source/librpc/gen_ndr/ndr_lsa.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_lsa.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 _PUBLIC_ enum ndr_err_code ndr_push_lsa_String(struct ndr_push *ndr, int ndr_flags, const struct lsa_String *r)
   8 {
   9         if (ndr_flags & NDR_SCALARS) {
  10                 NDR_CHECK(ndr_push_align(ndr, 4));
  11                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  12                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  13                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
  14         }
  15         if (ndr_flags & NDR_BUFFERS) {
  16                 if (r->string) {
  17                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m(r->string) / 2));
  18                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  19                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m(r->string) / 2));
  20                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, 2 * strlen_m(r->string) / 2, sizeof(uint16_t), CH_UTF16));
  21                 }
  22         }
  23         return NDR_ERR_SUCCESS;
  24 }
  25
  26 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_String(struct ndr_pull *ndr, int ndr_flags, struct lsa_String *r)
  27 {
  28         uint32_t _ptr_string;
  29         TALLOC_CTX *_mem_save_string_0;
  30         if (ndr_flags & NDR_SCALARS) {
  31                 NDR_CHECK(ndr_pull_align(ndr, 4));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
  34                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
  35                 if (_ptr_string) {
  36                         NDR_PULL_ALLOC(ndr, r->string);
  37                 } else {
  38                         r->string = NULL;
  39                 }
  40         }
  41         if (ndr_flags & NDR_BUFFERS) {
  42                 if (r->string) {
  43                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
  44                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
  45                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
  46                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
  47                         if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
  48                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string), ndr_get_array_length(ndr, &r->string));
  49                         }
  50                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
  51                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
  52                 }
  53                 if (r->string) {
  54                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
  55                 }
  56                 if (r->string) {
  57                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->string, r->length / 2));
  58                 }
  59         }
  60         return NDR_ERR_SUCCESS;
  61 }
  62
  63 _PUBLIC_ void ndr_print_lsa_String(struct ndr_print *ndr, const char *name, const struct lsa_String *r)
  64 {
  65         ndr_print_struct(ndr, name, "lsa_String");
  66         ndr->depth++;
  67         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->length);
  68         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->size);
  69         ndr_print_ptr(ndr, "string", r->string);
  70         ndr->depth++;
  71         if (r->string) {
  72                 ndr_print_string(ndr, "string", r->string);
  73         }
  74         ndr->depth--;
  75         ndr->depth--;
  76 }
  77
  78 _PUBLIC_ enum ndr_err_code ndr_push_lsa_StringLarge(struct ndr_push *ndr, int ndr_flags, const struct lsa_StringLarge *r)
  79 {
  80         if (ndr_flags & NDR_SCALARS) {
  81                 NDR_CHECK(ndr_push_align(ndr, 4));
  82                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  83                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m_term(r->string)));
  84                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
  85         }
  86         if (ndr_flags & NDR_BUFFERS) {
  87                 if (r->string) {
  88                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->string) / 2));
  89                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  90                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m(r->string) / 2));
  91                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, 2 * strlen_m(r->string) / 2, sizeof(uint16_t), CH_UTF16));
  92                 }
  93         }
  94         return NDR_ERR_SUCCESS;
  95 }
  96
  97 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_StringLarge(struct ndr_pull *ndr, int ndr_flags, struct lsa_StringLarge *r)
  98 {
  99         uint32_t _ptr_string;
 100         TALLOC_CTX *_mem_save_string_0;
 101         if (ndr_flags & NDR_SCALARS) {
 102                 NDR_CHECK(ndr_pull_align(ndr, 4));
 103                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 104                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
 106                 if (_ptr_string) {
 107                         NDR_PULL_ALLOC(ndr, r->string);
 108                 } else {
 109                         r->string = NULL;
 110                 }
 111         }
 112         if (ndr_flags & NDR_BUFFERS) {
 113                 if (r->string) {
 114                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
 115                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
 116                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
 117                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
 118                         if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
 119                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string), ndr_get_array_length(ndr, &r->string));
 120                         }
 121                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
 122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
 123                 }
 124                 if (r->string) {
 125                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
 126                 }
 127                 if (r->string) {
 128                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->string, r->length / 2));
 129                 }
 130         }
 131         return NDR_ERR_SUCCESS;
 132 }
 133
 134 _PUBLIC_ void ndr_print_lsa_StringLarge(struct ndr_print *ndr, const char *name, const struct lsa_StringLarge *r)
 135 {
 136         ndr_print_struct(ndr, name, "lsa_StringLarge");
 137         ndr->depth++;
 138         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->length);
 139         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->string):r->size);
 140         ndr_print_ptr(ndr, "string", r->string);
 141         ndr->depth++;
 142         if (r->string) {
 143                 ndr_print_string(ndr, "string", r->string);
 144         }
 145         ndr->depth--;
 146         ndr->depth--;
 147 }
 148
 149 _PUBLIC_ enum ndr_err_code ndr_push_lsa_Strings(struct ndr_push *ndr, int ndr_flags, const struct lsa_Strings *r)
 150 {
 151         uint32_t cntr_names_1;
 152         if (ndr_flags & NDR_SCALARS) {
 153                 NDR_CHECK(ndr_push_align(ndr, 4));
 154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
 156         }
 157         if (ndr_flags & NDR_BUFFERS) {
 158                 if (r->names) {
 159                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 160                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 161                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
 162                         }
 163                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 164                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
 165                         }
 166                 }
 167         }
 168         return NDR_ERR_SUCCESS;
 169 }
 170
 171 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_Strings(struct ndr_pull *ndr, int ndr_flags, struct lsa_Strings *r)
 172 {
 173         uint32_t _ptr_names;
 174         uint32_t cntr_names_1;
 175         TALLOC_CTX *_mem_save_names_0;
 176         TALLOC_CTX *_mem_save_names_1;
 177         if (ndr_flags & NDR_SCALARS) {
 178                 NDR_CHECK(ndr_pull_align(ndr, 4));
 179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
 181                 if (_ptr_names) {
 182                         NDR_PULL_ALLOC(ndr, r->names);
 183                 } else {
 184                         r->names = NULL;
 185                 }
 186         }
 187         if (ndr_flags & NDR_BUFFERS) {
 188                 if (r->names) {
 189                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 190                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
 191                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
 192                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
 193                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
 194                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
 195                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 196                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
 197                         }
 198                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 199                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
 200                         }
 201                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
 202                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
 203                 }
 204                 if (r->names) {
 205                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
 206                 }
 207         }
 208         return NDR_ERR_SUCCESS;
 209 }
 210
 211 _PUBLIC_ void ndr_print_lsa_Strings(struct ndr_print *ndr, const char *name, const struct lsa_Strings *r)
 212 {
 213         uint32_t cntr_names_1;
 214         ndr_print_struct(ndr, name, "lsa_Strings");
 215         ndr->depth++;
 216         ndr_print_uint32(ndr, "count", r->count);
 217         ndr_print_ptr(ndr, "names", r->names);
 218         ndr->depth++;
 219         if (r->names) {
 220                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->count);
 221                 ndr->depth++;
 222                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
 223                         char *idx_1=NULL;
 224                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
 225                                 ndr_print_lsa_String(ndr, "names", &r->names[cntr_names_1]);
 226                                 free(idx_1);
 227                         }
 228                 }
 229                 ndr->depth--;
 230         }
 231         ndr->depth--;
 232         ndr->depth--;
 233 }
 234
 235 _PUBLIC_ enum ndr_err_code ndr_push_lsa_AsciiString(struct ndr_push *ndr, int ndr_flags, const struct lsa_AsciiString *r)
 236 {
 237         if (ndr_flags & NDR_SCALARS) {
 238                 NDR_CHECK(ndr_push_align(ndr, 4));
 239                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->string)));
 240                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->string)));
 241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
 242         }
 243         if (ndr_flags & NDR_BUFFERS) {
 244                 if (r->string) {
 245                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->string)));
 246                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->string)));
 248                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, strlen_m(r->string), sizeof(uint8_t), CH_DOS));
 249                 }
 250         }
 251         return NDR_ERR_SUCCESS;
 252 }
 253
 254 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_AsciiString(struct ndr_pull *ndr, int ndr_flags, struct lsa_AsciiString *r)
 255 {
 256         uint32_t _ptr_string;
 257         TALLOC_CTX *_mem_save_string_0;
 258         if (ndr_flags & NDR_SCALARS) {
 259                 NDR_CHECK(ndr_pull_align(ndr, 4));
 260                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 261                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
 263                 if (_ptr_string) {
 264                         NDR_PULL_ALLOC(ndr, r->string);
 265                 } else {
 266                         r->string = NULL;
 267                 }
 268         }
 269         if (ndr_flags & NDR_BUFFERS) {
 270                 if (r->string) {
 271                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
 272                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
 273                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
 274                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
 275                         if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
 276                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string), ndr_get_array_length(ndr, &r->string));
 277                         }
 278                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint8_t), CH_DOS));
 279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
 280                 }
 281                 if (r->string) {
 282                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size));
 283                 }
 284                 if (r->string) {
 285                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->string, r->length));
 286                 }
 287         }
 288         return NDR_ERR_SUCCESS;
 289 }
 290
 291 _PUBLIC_ void ndr_print_lsa_AsciiString(struct ndr_print *ndr, const char *name, const struct lsa_AsciiString *r)
 292 {
 293         ndr_print_struct(ndr, name, "lsa_AsciiString");
 294         ndr->depth++;
 295         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->length);
 296         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->size);
 297         ndr_print_ptr(ndr, "string", r->string);
 298         ndr->depth++;
 299         if (r->string) {
 300                 ndr_print_string(ndr, "string", r->string);
 301         }
 302         ndr->depth--;
 303         ndr->depth--;
 304 }
 305
 306 _PUBLIC_ enum ndr_err_code ndr_push_lsa_AsciiStringLarge(struct ndr_push *ndr, int ndr_flags, const struct lsa_AsciiStringLarge *r)
 307 {
 308         if (ndr_flags & NDR_SCALARS) {
 309                 NDR_CHECK(ndr_push_align(ndr, 4));
 310                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->string)));
 311                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->string)));
 312                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
 313         }
 314         if (ndr_flags & NDR_BUFFERS) {
 315                 if (r->string) {
 316                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m_term(r->string)));
 317                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 318                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->string)));
 319                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, strlen_m(r->string), sizeof(uint8_t), CH_DOS));
 320                 }
 321         }
 322         return NDR_ERR_SUCCESS;
 323 }
 324
 325 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_AsciiStringLarge(struct ndr_pull *ndr, int ndr_flags, struct lsa_AsciiStringLarge *r)
 326 {
 327         uint32_t _ptr_string;
 328         TALLOC_CTX *_mem_save_string_0;
 329         if (ndr_flags & NDR_SCALARS) {
 330                 NDR_CHECK(ndr_pull_align(ndr, 4));
 331                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 332                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 333                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
 334                 if (_ptr_string) {
 335                         NDR_PULL_ALLOC(ndr, r->string);
 336                 } else {
 337                         r->string = NULL;
 338                 }
 339         }
 340         if (ndr_flags & NDR_BUFFERS) {
 341                 if (r->string) {
 342                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
 343                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
 344                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
 345                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
 346                         if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
 347                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string), ndr_get_array_length(ndr, &r->string));
 348                         }
 349                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint8_t), CH_DOS));
 350                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
 351                 }
 352                 if (r->string) {
 353                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size));
 354                 }
 355                 if (r->string) {
 356                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->string, r->length));
 357                 }
 358         }
 359         return NDR_ERR_SUCCESS;
 360 }
 361
 362 _PUBLIC_ void ndr_print_lsa_AsciiStringLarge(struct ndr_print *ndr, const char *name, const struct lsa_AsciiStringLarge *r)
 363 {
 364         ndr_print_struct(ndr, name, "lsa_AsciiStringLarge");
 365         ndr->depth++;
 366         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->length);
 367         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->string):r->size);
 368         ndr_print_ptr(ndr, "string", r->string);
 369         ndr->depth++;
 370         if (r->string) {
 371                 ndr_print_string(ndr, "string", r->string);
 372         }
 373         ndr->depth--;
 374         ndr->depth--;
 375 }
 376
 377 _PUBLIC_ enum ndr_err_code ndr_push_lsa_BinaryString(struct ndr_push *ndr, int ndr_flags, const struct lsa_BinaryString *r)
 378 {
 379         uint32_t cntr_array_1;
 380         if (ndr_flags & NDR_SCALARS) {
 381                 NDR_CHECK(ndr_push_align(ndr, 4));
 382                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
 383                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 384                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
 385         }
 386         if (ndr_flags & NDR_BUFFERS) {
 387                 if (r->array) {
 388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
 389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length / 2));
 391                         for (cntr_array_1 = 0; cntr_array_1 < r->length / 2; cntr_array_1++) {
 392                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->array[cntr_array_1]));
 393                         }
 394                 }
 395         }
 396         return NDR_ERR_SUCCESS;
 397 }
 398
 399 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_BinaryString(struct ndr_pull *ndr, int ndr_flags, struct lsa_BinaryString *r)
 400 {
 401         uint32_t _ptr_array;
 402         uint32_t cntr_array_1;
 403         TALLOC_CTX *_mem_save_array_0;
 404         TALLOC_CTX *_mem_save_array_1;
 405         if (ndr_flags & NDR_SCALARS) {
 406                 NDR_CHECK(ndr_pull_align(ndr, 4));
 407                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 408                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 409                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
 410                 if (_ptr_array) {
 411                         NDR_PULL_ALLOC(ndr, r->array);
 412                 } else {
 413                         r->array = NULL;
 414                 }
 415         }
 416         if (ndr_flags & NDR_BUFFERS) {
 417                 if (r->array) {
 418                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 419                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 420                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
 421                         NDR_CHECK(ndr_pull_array_length(ndr, &r->array));
 422                         if (ndr_get_array_length(ndr, &r->array) > ndr_get_array_size(ndr, &r->array)) {
 423                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->array), ndr_get_array_length(ndr, &r->array));
 424                         }
 425                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
 426                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
 427                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 428                         for (cntr_array_1 = 0; cntr_array_1 < r->length / 2; cntr_array_1++) {
 429                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 430                         }
 431                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
 432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 433                 }
 434                 if (r->array) {
 435                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->size / 2));
 436                 }
 437                 if (r->array) {
 438                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->array, r->length / 2));
 439                 }
 440         }
 441         return NDR_ERR_SUCCESS;
 442 }
 443
 444 _PUBLIC_ void ndr_print_lsa_BinaryString(struct ndr_print *ndr, const char *name, const struct lsa_BinaryString *r)
 445 {
 446         uint32_t cntr_array_1;
 447         ndr_print_struct(ndr, name, "lsa_BinaryString");
 448         ndr->depth++;
 449         ndr_print_uint16(ndr, "length", r->length);
 450         ndr_print_uint16(ndr, "size", r->size);
 451         ndr_print_ptr(ndr, "array", r->array);
 452         ndr->depth++;
 453         if (r->array) {
 454                 ndr->print(ndr, "%s: ARRAY(%d)", "array", r->length / 2);
 455                 ndr->depth++;
 456                 for (cntr_array_1=0;cntr_array_1<r->length / 2;cntr_array_1++) {
 457                         char *idx_1=NULL;
 458                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
 459                                 ndr_print_uint16(ndr, "array", r->array[cntr_array_1]);
 460                                 free(idx_1);
 461                         }
 462                 }
 463                 ndr->depth--;
 464         }
 465         ndr->depth--;
 466         ndr->depth--;
 467 }
 468
 469 static enum ndr_err_code ndr_push_lsa_LUID(struct ndr_push *ndr, int ndr_flags, const struct lsa_LUID *r)
 470 {
 471         if (ndr_flags & NDR_SCALARS) {
 472                 NDR_CHECK(ndr_push_align(ndr, 4));
 473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->low));
 474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high));
 475         }
 476         if (ndr_flags & NDR_BUFFERS) {
 477         }
 478         return NDR_ERR_SUCCESS;
 479 }
 480
 481 static enum ndr_err_code ndr_pull_lsa_LUID(struct ndr_pull *ndr, int ndr_flags, struct lsa_LUID *r)
 482 {
 483         if (ndr_flags & NDR_SCALARS) {
 484                 NDR_CHECK(ndr_pull_align(ndr, 4));
 485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->low));
 486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high));
 487         }
 488         if (ndr_flags & NDR_BUFFERS) {
 489         }
 490         return NDR_ERR_SUCCESS;
 491 }
 492
 493 _PUBLIC_ void ndr_print_lsa_LUID(struct ndr_print *ndr, const char *name, const struct lsa_LUID *r)
 494 {
 495         ndr_print_struct(ndr, name, "lsa_LUID");
 496         ndr->depth++;
 497         ndr_print_uint32(ndr, "low", r->low);
 498         ndr_print_uint32(ndr, "high", r->high);
 499         ndr->depth--;
 500 }
 501
 502 static enum ndr_err_code ndr_push_lsa_PrivEntry(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivEntry *r)
 503 {
 504         if (ndr_flags & NDR_SCALARS) {
 505                 NDR_CHECK(ndr_push_align(ndr, 4));
 506                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 507                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
 508         }
 509         if (ndr_flags & NDR_BUFFERS) {
 510                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 511         }
 512         return NDR_ERR_SUCCESS;
 513 }
 514
 515 static enum ndr_err_code ndr_pull_lsa_PrivEntry(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivEntry *r)
 516 {
 517         if (ndr_flags & NDR_SCALARS) {
 518                 NDR_CHECK(ndr_pull_align(ndr, 4));
 519                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 520                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
 521         }
 522         if (ndr_flags & NDR_BUFFERS) {
 523                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 524         }
 525         return NDR_ERR_SUCCESS;
 526 }
 527
 528 _PUBLIC_ void ndr_print_lsa_PrivEntry(struct ndr_print *ndr, const char *name, const struct lsa_PrivEntry *r)
 529 {
 530         ndr_print_struct(ndr, name, "lsa_PrivEntry");
 531         ndr->depth++;
 532         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
 533         ndr_print_lsa_LUID(ndr, "luid", &r->luid);
 534         ndr->depth--;
 535 }
 536
 537 static enum ndr_err_code ndr_push_lsa_PrivArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivArray *r)
 538 {
 539         uint32_t cntr_privs_1;
 540         if (ndr_flags & NDR_SCALARS) {
 541                 NDR_CHECK(ndr_push_align(ndr, 4));
 542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 543                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->privs));
 544         }
 545         if (ndr_flags & NDR_BUFFERS) {
 546                 if (r->privs) {
 547                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 548                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 549                                 NDR_CHECK(ndr_push_lsa_PrivEntry(ndr, NDR_SCALARS, &r->privs[cntr_privs_1]));
 550                         }
 551                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 552                                 NDR_CHECK(ndr_push_lsa_PrivEntry(ndr, NDR_BUFFERS, &r->privs[cntr_privs_1]));
 553                         }
 554                 }
 555         }
 556         return NDR_ERR_SUCCESS;
 557 }
 558
 559 static enum ndr_err_code ndr_pull_lsa_PrivArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivArray *r)
 560 {
 561         uint32_t _ptr_privs;
 562         uint32_t cntr_privs_1;
 563         TALLOC_CTX *_mem_save_privs_0;
 564         TALLOC_CTX *_mem_save_privs_1;
 565         if (ndr_flags & NDR_SCALARS) {
 566                 NDR_CHECK(ndr_pull_align(ndr, 4));
 567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 568                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
 569                 if (_ptr_privs) {
 570                         NDR_PULL_ALLOC(ndr, r->privs);
 571                 } else {
 572                         r->privs = NULL;
 573                 }
 574         }
 575         if (ndr_flags & NDR_BUFFERS) {
 576                 if (r->privs) {
 577                         _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
 578                         NDR_PULL_SET_MEM_CTX(ndr, r->privs, 0);
 579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->privs));
 580                         NDR_PULL_ALLOC_N(ndr, r->privs, ndr_get_array_size(ndr, &r->privs));
 581                         _mem_save_privs_1 = NDR_PULL_GET_MEM_CTX(ndr);
 582                         NDR_PULL_SET_MEM_CTX(ndr, r->privs, 0);
 583                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 584                                 NDR_CHECK(ndr_pull_lsa_PrivEntry(ndr, NDR_SCALARS, &r->privs[cntr_privs_1]));
 585                         }
 586                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 587                                 NDR_CHECK(ndr_pull_lsa_PrivEntry(ndr, NDR_BUFFERS, &r->privs[cntr_privs_1]));
 588                         }
 589                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_1, 0);
 590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, 0);
 591                 }
 592                 if (r->privs) {
 593                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->privs, r->count));
 594                 }
 595         }
 596         return NDR_ERR_SUCCESS;
 597 }
 598
 599 _PUBLIC_ void ndr_print_lsa_PrivArray(struct ndr_print *ndr, const char *name, const struct lsa_PrivArray *r)
 600 {
 601         uint32_t cntr_privs_1;
 602         ndr_print_struct(ndr, name, "lsa_PrivArray");
 603         ndr->depth++;
 604         ndr_print_uint32(ndr, "count", r->count);
 605         ndr_print_ptr(ndr, "privs", r->privs);
 606         ndr->depth++;
 607         if (r->privs) {
 608                 ndr->print(ndr, "%s: ARRAY(%d)", "privs", r->count);
 609                 ndr->depth++;
 610                 for (cntr_privs_1=0;cntr_privs_1<r->count;cntr_privs_1++) {
 611                         char *idx_1=NULL;
 612                         if (asprintf(&idx_1, "[%d]", cntr_privs_1) != -1) {
 613                                 ndr_print_lsa_PrivEntry(ndr, "privs", &r->privs[cntr_privs_1]);
 614                                 free(idx_1);
 615                         }
 616                 }
 617                 ndr->depth--;
 618         }
 619         ndr->depth--;
 620         ndr->depth--;
 621 }
 622
 623 static enum ndr_err_code ndr_push_lsa_QosInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_QosInfo *r)
 624 {
 625         if (ndr_flags & NDR_SCALARS) {
 626                 NDR_CHECK(ndr_push_align(ndr, 4));
 627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
 628                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->impersonation_level));
 629                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->context_mode));
 630                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->effective_only));
 631         }
 632         if (ndr_flags & NDR_BUFFERS) {
 633         }
 634         return NDR_ERR_SUCCESS;
 635 }
 636
 637 static enum ndr_err_code ndr_pull_lsa_QosInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_QosInfo *r)
 638 {
 639         if (ndr_flags & NDR_SCALARS) {
 640                 NDR_CHECK(ndr_pull_align(ndr, 4));
 641                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
 642                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->impersonation_level));
 643                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->context_mode));
 644                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->effective_only));
 645         }
 646         if (ndr_flags & NDR_BUFFERS) {
 647         }
 648         return NDR_ERR_SUCCESS;
 649 }
 650
 651 _PUBLIC_ void ndr_print_lsa_QosInfo(struct ndr_print *ndr, const char *name, const struct lsa_QosInfo *r)
 652 {
 653         ndr_print_struct(ndr, name, "lsa_QosInfo");
 654         ndr->depth++;
 655         ndr_print_uint32(ndr, "len", r->len);
 656         ndr_print_uint16(ndr, "impersonation_level", r->impersonation_level);
 657         ndr_print_uint8(ndr, "context_mode", r->context_mode);
 658         ndr_print_uint8(ndr, "effective_only", r->effective_only);
 659         ndr->depth--;
 660 }
 661
 662 static enum ndr_err_code ndr_push_lsa_ObjectAttribute(struct ndr_push *ndr, int ndr_flags, const struct lsa_ObjectAttribute *r)
 663 {
 664         if (ndr_flags & NDR_SCALARS) {
 665                 NDR_CHECK(ndr_push_align(ndr, 4));
 666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
 667                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->root_dir));
 668                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_name));
 669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attributes));
 670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sec_desc));
 671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sec_qos));
 672         }
 673         if (ndr_flags & NDR_BUFFERS) {
 674                 if (r->root_dir) {
 675                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->root_dir));
 676                 }
 677                 if (r->object_name) {
 678                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_name, CH_UTF16)));
 679                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 680                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_name, CH_UTF16)));
 681                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_name, ndr_charset_length(r->object_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 682                 }
 683                 if (r->sec_desc) {
 684                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sec_desc));
 685                 }
 686                 if (r->sec_qos) {
 687                         NDR_CHECK(ndr_push_lsa_QosInfo(ndr, NDR_SCALARS, r->sec_qos));
 688                 }
 689         }
 690         return NDR_ERR_SUCCESS;
 691 }
 692
 693 static enum ndr_err_code ndr_pull_lsa_ObjectAttribute(struct ndr_pull *ndr, int ndr_flags, struct lsa_ObjectAttribute *r)
 694 {
 695         uint32_t _ptr_root_dir;
 696         TALLOC_CTX *_mem_save_root_dir_0;
 697         uint32_t _ptr_object_name;
 698         TALLOC_CTX *_mem_save_object_name_0;
 699         uint32_t _ptr_sec_desc;
 700         TALLOC_CTX *_mem_save_sec_desc_0;
 701         uint32_t _ptr_sec_qos;
 702         TALLOC_CTX *_mem_save_sec_qos_0;
 703         if (ndr_flags & NDR_SCALARS) {
 704                 NDR_CHECK(ndr_pull_align(ndr, 4));
 705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
 706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_root_dir));
 707                 if (_ptr_root_dir) {
 708                         NDR_PULL_ALLOC(ndr, r->root_dir);
 709                 } else {
 710                         r->root_dir = NULL;
 711                 }
 712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_name));
 713                 if (_ptr_object_name) {
 714                         NDR_PULL_ALLOC(ndr, r->object_name);
 715                 } else {
 716                         r->object_name = NULL;
 717                 }
 718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attributes));
 719                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_desc));
 720                 if (_ptr_sec_desc) {
 721                         NDR_PULL_ALLOC(ndr, r->sec_desc);
 722                 } else {
 723                         r->sec_desc = NULL;
 724                 }
 725                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_qos));
 726                 if (_ptr_sec_qos) {
 727                         NDR_PULL_ALLOC(ndr, r->sec_qos);
 728                 } else {
 729                         r->sec_qos = NULL;
 730                 }
 731         }
 732         if (ndr_flags & NDR_BUFFERS) {
 733                 if (r->root_dir) {
 734                         _mem_save_root_dir_0 = NDR_PULL_GET_MEM_CTX(ndr);
 735                         NDR_PULL_SET_MEM_CTX(ndr, r->root_dir, 0);
 736                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->root_dir));
 737                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_root_dir_0, 0);
 738                 }
 739                 if (r->object_name) {
 740                         _mem_save_object_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 741                         NDR_PULL_SET_MEM_CTX(ndr, r->object_name, 0);
 742                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_name));
 743                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_name));
 744                         if (ndr_get_array_length(ndr, &r->object_name) > ndr_get_array_size(ndr, &r->object_name)) {
 745                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_name), ndr_get_array_length(ndr, &r->object_name));
 746                         }
 747                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_name), sizeof(uint16_t)));
 748                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_name, ndr_get_array_length(ndr, &r->object_name), sizeof(uint16_t), CH_UTF16));
 749                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_name_0, 0);
 750                 }
 751                 if (r->sec_desc) {
 752                         _mem_save_sec_desc_0 = NDR_PULL_GET_MEM_CTX(ndr);
 753                         NDR_PULL_SET_MEM_CTX(ndr, r->sec_desc, 0);
 754                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sec_desc));
 755                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_desc_0, 0);
 756                 }
 757                 if (r->sec_qos) {
 758                         _mem_save_sec_qos_0 = NDR_PULL_GET_MEM_CTX(ndr);
 759                         NDR_PULL_SET_MEM_CTX(ndr, r->sec_qos, 0);
 760                         NDR_CHECK(ndr_pull_lsa_QosInfo(ndr, NDR_SCALARS, r->sec_qos));
 761                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_qos_0, 0);
 762                 }
 763         }
 764         return NDR_ERR_SUCCESS;
 765 }
 766
 767 _PUBLIC_ void ndr_print_lsa_ObjectAttribute(struct ndr_print *ndr, const char *name, const struct lsa_ObjectAttribute *r)
 768 {
 769         ndr_print_struct(ndr, name, "lsa_ObjectAttribute");
 770         ndr->depth++;
 771         ndr_print_uint32(ndr, "len", r->len);
 772         ndr_print_ptr(ndr, "root_dir", r->root_dir);
 773         ndr->depth++;
 774         if (r->root_dir) {
 775                 ndr_print_uint8(ndr, "root_dir", *r->root_dir);
 776         }
 777         ndr->depth--;
 778         ndr_print_ptr(ndr, "object_name", r->object_name);
 779         ndr->depth++;
 780         if (r->object_name) {
 781                 ndr_print_string(ndr, "object_name", r->object_name);
 782         }
 783         ndr->depth--;
 784         ndr_print_uint32(ndr, "attributes", r->attributes);
 785         ndr_print_ptr(ndr, "sec_desc", r->sec_desc);
 786         ndr->depth++;
 787         if (r->sec_desc) {
 788                 ndr_print_security_descriptor(ndr, "sec_desc", r->sec_desc);
 789         }
 790         ndr->depth--;
 791         ndr_print_ptr(ndr, "sec_qos", r->sec_qos);
 792         ndr->depth++;
 793         if (r->sec_qos) {
 794                 ndr_print_lsa_QosInfo(ndr, "sec_qos", r->sec_qos);
 795         }
 796         ndr->depth--;
 797         ndr->depth--;
 798 }
 799
 800 _PUBLIC_ enum ndr_err_code ndr_push_lsa_PolicyAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 801 {
 802         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 803         return NDR_ERR_SUCCESS;
 804 }
 805
 806 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_PolicyAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 807 {
 808         uint32_t v;
 809         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 810         *r = v;
 811         return NDR_ERR_SUCCESS;
 812 }
 813
 814 _PUBLIC_ void ndr_print_lsa_PolicyAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 815 {
 816         ndr_print_uint32(ndr, name, r);
 817         ndr->depth++;
 818         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_VIEW_LOCAL_INFORMATION", LSA_POLICY_VIEW_LOCAL_INFORMATION, r);
 819         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_VIEW_AUDIT_INFORMATION", LSA_POLICY_VIEW_AUDIT_INFORMATION, r);
 820         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_GET_PRIVATE_INFORMATION", LSA_POLICY_GET_PRIVATE_INFORMATION, r);
 821         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_TRUST_ADMIN", LSA_POLICY_TRUST_ADMIN, r);
 822         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_CREATE_ACCOUNT", LSA_POLICY_CREATE_ACCOUNT, r);
 823         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_CREATE_SECRET", LSA_POLICY_CREATE_SECRET, r);
 824         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_CREATE_PRIVILEGE", LSA_POLICY_CREATE_PRIVILEGE, r);
 825         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_SET_DEFAULT_QUOTA_LIMITS", LSA_POLICY_SET_DEFAULT_QUOTA_LIMITS, r);
 826         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_SET_AUDIT_REQUIREMENTS", LSA_POLICY_SET_AUDIT_REQUIREMENTS, r);
 827         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_AUDIT_LOG_ADMIN", LSA_POLICY_AUDIT_LOG_ADMIN, r);
 828         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_SERVER_ADMIN", LSA_POLICY_SERVER_ADMIN, r);
 829         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_LOOKUP_NAMES", LSA_POLICY_LOOKUP_NAMES, r);
 830         ndr->depth--;
 831 }
 832
 833 static enum ndr_err_code ndr_push_lsa_AuditLogInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditLogInfo *r)
 834 {
 835         if (ndr_flags & NDR_SCALARS) {
 836                 NDR_CHECK(ndr_push_align(ndr, 4));
 837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->percent_full));
 838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->log_size));
 839                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->retention_time));
 840                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_in_progress));
 841                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time_to_shutdown));
 842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_audit_record));
 843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
 844         }
 845         if (ndr_flags & NDR_BUFFERS) {
 846         }
 847         return NDR_ERR_SUCCESS;
 848 }
 849
 850 static enum ndr_err_code ndr_pull_lsa_AuditLogInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditLogInfo *r)
 851 {
 852         if (ndr_flags & NDR_SCALARS) {
 853                 NDR_CHECK(ndr_pull_align(ndr, 4));
 854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->percent_full));
 855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->log_size));
 856                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->retention_time));
 857                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_in_progress));
 858                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time_to_shutdown));
 859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_audit_record));
 860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
 861         }
 862         if (ndr_flags & NDR_BUFFERS) {
 863         }
 864         return NDR_ERR_SUCCESS;
 865 }
 866
 867 _PUBLIC_ void ndr_print_lsa_AuditLogInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditLogInfo *r)
 868 {
 869         ndr_print_struct(ndr, name, "lsa_AuditLogInfo");
 870         ndr->depth++;
 871         ndr_print_uint32(ndr, "percent_full", r->percent_full);
 872         ndr_print_uint32(ndr, "log_size", r->log_size);
 873         ndr_print_NTTIME(ndr, "retention_time", r->retention_time);
 874         ndr_print_uint8(ndr, "shutdown_in_progress", r->shutdown_in_progress);
 875         ndr_print_NTTIME(ndr, "time_to_shutdown", r->time_to_shutdown);
 876         ndr_print_uint32(ndr, "next_audit_record", r->next_audit_record);
 877         ndr_print_uint32(ndr, "unknown", r->unknown);
 878         ndr->depth--;
 879 }
 880
 881 static enum ndr_err_code ndr_push_lsa_PolicyAuditPolicy(struct ndr_push *ndr, int ndr_flags, enum lsa_PolicyAuditPolicy r)
 882 {
 883         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 884         return NDR_ERR_SUCCESS;
 885 }
 886
 887 static enum ndr_err_code ndr_pull_lsa_PolicyAuditPolicy(struct ndr_pull *ndr, int ndr_flags, enum lsa_PolicyAuditPolicy *r)
 888 {
 889         uint32_t v;
 890         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 891         *r = v;
 892         return NDR_ERR_SUCCESS;
 893 }
 894
 895 _PUBLIC_ void ndr_print_lsa_PolicyAuditPolicy(struct ndr_print *ndr, const char *name, enum lsa_PolicyAuditPolicy r)
 896 {
 897         const char *val = NULL;
 898
 899         switch (r) {
 900                 case LSA_AUDIT_POLICY_NONE: val = "LSA_AUDIT_POLICY_NONE"; break;
 901                 case LSA_AUDIT_POLICY_SUCCESS: val = "LSA_AUDIT_POLICY_SUCCESS"; break;
 902                 case LSA_AUDIT_POLICY_FAILURE: val = "LSA_AUDIT_POLICY_FAILURE"; break;
 903                 case LSA_AUDIT_POLICY_ALL: val = "LSA_AUDIT_POLICY_ALL"; break;
 904                 case LSA_AUDIT_POLICY_CLEAR: val = "LSA_AUDIT_POLICY_CLEAR"; break;
 905         }
 906         ndr_print_enum(ndr, name, "ENUM", val, r);
 907 }
 908
 909 static enum ndr_err_code ndr_push_lsa_AuditEventsInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditEventsInfo *r)
 910 {
 911         uint32_t cntr_settings_1;
 912         if (ndr_flags & NDR_SCALARS) {
 913                 NDR_CHECK(ndr_push_align(ndr, 4));
 914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditing_mode));
 915                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->settings));
 916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 917         }
 918         if (ndr_flags & NDR_BUFFERS) {
 919                 if (r->settings) {
 920                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 921                         for (cntr_settings_1 = 0; cntr_settings_1 < r->count; cntr_settings_1++) {
 922                                 NDR_CHECK(ndr_push_lsa_PolicyAuditPolicy(ndr, NDR_SCALARS, r->settings[cntr_settings_1]));
 923                         }
 924                 }
 925         }
 926         return NDR_ERR_SUCCESS;
 927 }
 928
 929 static enum ndr_err_code ndr_pull_lsa_AuditEventsInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditEventsInfo *r)
 930 {
 931         uint32_t _ptr_settings;
 932         uint32_t cntr_settings_1;
 933         TALLOC_CTX *_mem_save_settings_0;
 934         TALLOC_CTX *_mem_save_settings_1;
 935         if (ndr_flags & NDR_SCALARS) {
 936                 NDR_CHECK(ndr_pull_align(ndr, 4));
 937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditing_mode));
 938                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_settings));
 939                 if (_ptr_settings) {
 940                         NDR_PULL_ALLOC(ndr, r->settings);
 941                 } else {
 942                         r->settings = NULL;
 943                 }
 944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 945         }
 946         if (ndr_flags & NDR_BUFFERS) {
 947                 if (r->settings) {
 948                         _mem_save_settings_0 = NDR_PULL_GET_MEM_CTX(ndr);
 949                         NDR_PULL_SET_MEM_CTX(ndr, r->settings, 0);
 950                         NDR_CHECK(ndr_pull_array_size(ndr, &r->settings));
 951                         NDR_PULL_ALLOC_N(ndr, r->settings, ndr_get_array_size(ndr, &r->settings));
 952                         _mem_save_settings_1 = NDR_PULL_GET_MEM_CTX(ndr);
 953                         NDR_PULL_SET_MEM_CTX(ndr, r->settings, 0);
 954                         for (cntr_settings_1 = 0; cntr_settings_1 < r->count; cntr_settings_1++) {
 955                                 NDR_CHECK(ndr_pull_lsa_PolicyAuditPolicy(ndr, NDR_SCALARS, &r->settings[cntr_settings_1]));
 956                         }
 957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_settings_1, 0);
 958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_settings_0, 0);
 959                 }
 960                 if (r->settings) {
 961                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->settings, r->count));
 962                 }
 963         }
 964         return NDR_ERR_SUCCESS;
 965 }
 966
 967 _PUBLIC_ void ndr_print_lsa_AuditEventsInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditEventsInfo *r)
 968 {
 969         uint32_t cntr_settings_1;
 970         ndr_print_struct(ndr, name, "lsa_AuditEventsInfo");
 971         ndr->depth++;
 972         ndr_print_uint32(ndr, "auditing_mode", r->auditing_mode);
 973         ndr_print_ptr(ndr, "settings", r->settings);
 974         ndr->depth++;
 975         if (r->settings) {
 976                 ndr->print(ndr, "%s: ARRAY(%d)", "settings", r->count);
 977                 ndr->depth++;
 978                 for (cntr_settings_1=0;cntr_settings_1<r->count;cntr_settings_1++) {
 979                         char *idx_1=NULL;
 980                         if (asprintf(&idx_1, "[%d]", cntr_settings_1) != -1) {
 981                                 ndr_print_lsa_PolicyAuditPolicy(ndr, "settings", r->settings[cntr_settings_1]);
 982                                 free(idx_1);
 983                         }
 984                 }
 985                 ndr->depth--;
 986         }
 987         ndr->depth--;
 988         ndr_print_uint32(ndr, "count", r->count);
 989         ndr->depth--;
 990 }
 991
 992 static enum ndr_err_code ndr_push_lsa_DomainInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfo *r)
 993 {
 994         if (ndr_flags & NDR_SCALARS) {
 995                 NDR_CHECK(ndr_push_align(ndr, 4));
 996                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
 998         }
 999         if (ndr_flags & NDR_BUFFERS) {
1000                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1001                 if (r->sid) {
1002                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1003                 }
1004         }
1005         return NDR_ERR_SUCCESS;
1006 }
1007
1008 static enum ndr_err_code ndr_pull_lsa_DomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfo *r)
1009 {
1010         uint32_t _ptr_sid;
1011         TALLOC_CTX *_mem_save_sid_0;
1012         if (ndr_flags & NDR_SCALARS) {
1013                 NDR_CHECK(ndr_pull_align(ndr, 4));
1014                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
1015                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
1016                 if (_ptr_sid) {
1017                         NDR_PULL_ALLOC(ndr, r->sid);
1018                 } else {
1019                         r->sid = NULL;
1020                 }
1021         }
1022         if (ndr_flags & NDR_BUFFERS) {
1023                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1024                 if (r->sid) {
1025                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1026                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1027                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1029                 }
1030         }
1031         return NDR_ERR_SUCCESS;
1032 }
1033
1034 _PUBLIC_ void ndr_print_lsa_DomainInfo(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfo *r)
1035 {
1036         ndr_print_struct(ndr, name, "lsa_DomainInfo");
1037         ndr->depth++;
1038         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
1039         ndr_print_ptr(ndr, "sid", r->sid);
1040         ndr->depth++;
1041         if (r->sid) {
1042                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1043         }
1044         ndr->depth--;
1045         ndr->depth--;
1046 }
1047
1048 static enum ndr_err_code ndr_push_lsa_PDAccountInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_PDAccountInfo *r)
1049 {
1050         if (ndr_flags & NDR_SCALARS) {
1051                 NDR_CHECK(ndr_push_align(ndr, 4));
1052                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1053         }
1054         if (ndr_flags & NDR_BUFFERS) {
1055                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1056         }
1057         return NDR_ERR_SUCCESS;
1058 }
1059
1060 static enum ndr_err_code ndr_pull_lsa_PDAccountInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_PDAccountInfo *r)
1061 {
1062         if (ndr_flags & NDR_SCALARS) {
1063                 NDR_CHECK(ndr_pull_align(ndr, 4));
1064                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1065         }
1066         if (ndr_flags & NDR_BUFFERS) {
1067                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1068         }
1069         return NDR_ERR_SUCCESS;
1070 }
1071
1072 _PUBLIC_ void ndr_print_lsa_PDAccountInfo(struct ndr_print *ndr, const char *name, const struct lsa_PDAccountInfo *r)
1073 {
1074         ndr_print_struct(ndr, name, "lsa_PDAccountInfo");
1075         ndr->depth++;
1076         ndr_print_lsa_String(ndr, "name", &r->name);
1077         ndr->depth--;
1078 }
1079
1080 static enum ndr_err_code ndr_push_lsa_ServerRole(struct ndr_push *ndr, int ndr_flags, const struct lsa_ServerRole *r)
1081 {
1082         if (ndr_flags & NDR_SCALARS) {
1083                 NDR_CHECK(ndr_push_align(ndr, 2));
1084                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown));
1085                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->role));
1086         }
1087         if (ndr_flags & NDR_BUFFERS) {
1088         }
1089         return NDR_ERR_SUCCESS;
1090 }
1091
1092 static enum ndr_err_code ndr_pull_lsa_ServerRole(struct ndr_pull *ndr, int ndr_flags, struct lsa_ServerRole *r)
1093 {
1094         if (ndr_flags & NDR_SCALARS) {
1095                 NDR_CHECK(ndr_pull_align(ndr, 2));
1096                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown));
1097                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->role));
1098         }
1099         if (ndr_flags & NDR_BUFFERS) {
1100         }
1101         return NDR_ERR_SUCCESS;
1102 }
1103
1104 _PUBLIC_ void ndr_print_lsa_ServerRole(struct ndr_print *ndr, const char *name, const struct lsa_ServerRole *r)
1105 {
1106         ndr_print_struct(ndr, name, "lsa_ServerRole");
1107         ndr->depth++;
1108         ndr_print_uint16(ndr, "unknown", r->unknown);
1109         ndr_print_uint16(ndr, "role", r->role);
1110         ndr->depth--;
1111 }
1112
1113 static enum ndr_err_code ndr_push_lsa_ReplicaSourceInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_ReplicaSourceInfo *r)
1114 {
1115         if (ndr_flags & NDR_SCALARS) {
1116                 NDR_CHECK(ndr_push_align(ndr, 4));
1117                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->source));
1118                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account));
1119         }
1120         if (ndr_flags & NDR_BUFFERS) {
1121                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->source));
1122                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account));
1123         }
1124         return NDR_ERR_SUCCESS;
1125 }
1126
1127 static enum ndr_err_code ndr_pull_lsa_ReplicaSourceInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ReplicaSourceInfo *r)
1128 {
1129         if (ndr_flags & NDR_SCALARS) {
1130                 NDR_CHECK(ndr_pull_align(ndr, 4));
1131                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->source));
1132                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account));
1133         }
1134         if (ndr_flags & NDR_BUFFERS) {
1135                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->source));
1136                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account));
1137         }
1138         return NDR_ERR_SUCCESS;
1139 }
1140
1141 _PUBLIC_ void ndr_print_lsa_ReplicaSourceInfo(struct ndr_print *ndr, const char *name, const struct lsa_ReplicaSourceInfo *r)
1142 {
1143         ndr_print_struct(ndr, name, "lsa_ReplicaSourceInfo");
1144         ndr->depth++;
1145         ndr_print_lsa_String(ndr, "source", &r->source);
1146         ndr_print_lsa_String(ndr, "account", &r->account);
1147         ndr->depth--;
1148 }
1149
1150 static enum ndr_err_code ndr_push_lsa_DefaultQuotaInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DefaultQuotaInfo *r)
1151 {
1152         if (ndr_flags & NDR_SCALARS) {
1153                 NDR_CHECK(ndr_push_align(ndr, 8));
1154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->paged_pool));
1155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->non_paged_pool));
1156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->min_wss));
1157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_wss));
1158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pagefile));
1159                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown));
1160         }
1161         if (ndr_flags & NDR_BUFFERS) {
1162         }
1163         return NDR_ERR_SUCCESS;
1164 }
1165
1166 static enum ndr_err_code ndr_pull_lsa_DefaultQuotaInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DefaultQuotaInfo *r)
1167 {
1168         if (ndr_flags & NDR_SCALARS) {
1169                 NDR_CHECK(ndr_pull_align(ndr, 8));
1170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->paged_pool));
1171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->non_paged_pool));
1172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->min_wss));
1173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_wss));
1174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pagefile));
1175                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown));
1176         }
1177         if (ndr_flags & NDR_BUFFERS) {
1178         }
1179         return NDR_ERR_SUCCESS;
1180 }
1181
1182 _PUBLIC_ void ndr_print_lsa_DefaultQuotaInfo(struct ndr_print *ndr, const char *name, const struct lsa_DefaultQuotaInfo *r)
1183 {
1184         ndr_print_struct(ndr, name, "lsa_DefaultQuotaInfo");
1185         ndr->depth++;
1186         ndr_print_uint32(ndr, "paged_pool", r->paged_pool);
1187         ndr_print_uint32(ndr, "non_paged_pool", r->non_paged_pool);
1188         ndr_print_uint32(ndr, "min_wss", r->min_wss);
1189         ndr_print_uint32(ndr, "max_wss", r->max_wss);
1190         ndr_print_uint32(ndr, "pagefile", r->pagefile);
1191         ndr_print_hyper(ndr, "unknown", r->unknown);
1192         ndr->depth--;
1193 }
1194
1195 static enum ndr_err_code ndr_push_lsa_ModificationInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_ModificationInfo *r)
1196 {
1197         if (ndr_flags & NDR_SCALARS) {
1198                 NDR_CHECK(ndr_push_align(ndr, 8));
1199                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_id));
1200                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->db_create_time));
1201         }
1202         if (ndr_flags & NDR_BUFFERS) {
1203         }
1204         return NDR_ERR_SUCCESS;
1205 }
1206
1207 static enum ndr_err_code ndr_pull_lsa_ModificationInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ModificationInfo *r)
1208 {
1209         if (ndr_flags & NDR_SCALARS) {
1210                 NDR_CHECK(ndr_pull_align(ndr, 8));
1211                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_id));
1212                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->db_create_time));
1213         }
1214         if (ndr_flags & NDR_BUFFERS) {
1215         }
1216         return NDR_ERR_SUCCESS;
1217 }
1218
1219 _PUBLIC_ void ndr_print_lsa_ModificationInfo(struct ndr_print *ndr, const char *name, const struct lsa_ModificationInfo *r)
1220 {
1221         ndr_print_struct(ndr, name, "lsa_ModificationInfo");
1222         ndr->depth++;
1223         ndr_print_hyper(ndr, "modified_id", r->modified_id);
1224         ndr_print_NTTIME(ndr, "db_create_time", r->db_create_time);
1225         ndr->depth--;
1226 }
1227
1228 static enum ndr_err_code ndr_push_lsa_AuditFullSetInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditFullSetInfo *r)
1229 {
1230         if (ndr_flags & NDR_SCALARS) {
1231                 NDR_CHECK(ndr_push_align(ndr, 1));
1232                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_on_full));
1233         }
1234         if (ndr_flags & NDR_BUFFERS) {
1235         }
1236         return NDR_ERR_SUCCESS;
1237 }
1238
1239 static enum ndr_err_code ndr_pull_lsa_AuditFullSetInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditFullSetInfo *r)
1240 {
1241         if (ndr_flags & NDR_SCALARS) {
1242                 NDR_CHECK(ndr_pull_align(ndr, 1));
1243                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_on_full));
1244         }
1245         if (ndr_flags & NDR_BUFFERS) {
1246         }
1247         return NDR_ERR_SUCCESS;
1248 }
1249
1250 _PUBLIC_ void ndr_print_lsa_AuditFullSetInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditFullSetInfo *r)
1251 {
1252         ndr_print_struct(ndr, name, "lsa_AuditFullSetInfo");
1253         ndr->depth++;
1254         ndr_print_uint8(ndr, "shutdown_on_full", r->shutdown_on_full);
1255         ndr->depth--;
1256 }
1257
1258 static enum ndr_err_code ndr_push_lsa_AuditFullQueryInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditFullQueryInfo *r)
1259 {
1260         if (ndr_flags & NDR_SCALARS) {
1261                 NDR_CHECK(ndr_push_align(ndr, 2));
1262                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown));
1263                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_on_full));
1264                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->log_is_full));
1265         }
1266         if (ndr_flags & NDR_BUFFERS) {
1267         }
1268         return NDR_ERR_SUCCESS;
1269 }
1270
1271 static enum ndr_err_code ndr_pull_lsa_AuditFullQueryInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditFullQueryInfo *r)
1272 {
1273         if (ndr_flags & NDR_SCALARS) {
1274                 NDR_CHECK(ndr_pull_align(ndr, 2));
1275                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown));
1276                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_on_full));
1277                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->log_is_full));
1278         }
1279         if (ndr_flags & NDR_BUFFERS) {
1280         }
1281         return NDR_ERR_SUCCESS;
1282 }
1283
1284 _PUBLIC_ void ndr_print_lsa_AuditFullQueryInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditFullQueryInfo *r)
1285 {
1286         ndr_print_struct(ndr, name, "lsa_AuditFullQueryInfo");
1287         ndr->depth++;
1288         ndr_print_uint16(ndr, "unknown", r->unknown);
1289         ndr_print_uint8(ndr, "shutdown_on_full", r->shutdown_on_full);
1290         ndr_print_uint8(ndr, "log_is_full", r->log_is_full);
1291         ndr->depth--;
1292 }
1293
1294 static enum ndr_err_code ndr_push_lsa_DnsDomainInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DnsDomainInfo *r)
1295 {
1296         if (ndr_flags & NDR_SCALARS) {
1297                 NDR_CHECK(ndr_push_align(ndr, 4));
1298                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
1299                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain));
1300                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_forest));
1301                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_guid));
1302                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
1303         }
1304         if (ndr_flags & NDR_BUFFERS) {
1305                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1306                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain));
1307                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_forest));
1308                 NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->domain_guid));
1309                 if (r->sid) {
1310                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1311                 }
1312         }
1313         return NDR_ERR_SUCCESS;
1314 }
1315
1316 static enum ndr_err_code ndr_pull_lsa_DnsDomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DnsDomainInfo *r)
1317 {
1318         uint32_t _ptr_sid;
1319         TALLOC_CTX *_mem_save_sid_0;
1320         if (ndr_flags & NDR_SCALARS) {
1321                 NDR_CHECK(ndr_pull_align(ndr, 4));
1322                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
1323                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain));
1324                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_forest));
1325                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_guid));
1326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
1327                 if (_ptr_sid) {
1328                         NDR_PULL_ALLOC(ndr, r->sid);
1329                 } else {
1330                         r->sid = NULL;
1331                 }
1332         }
1333         if (ndr_flags & NDR_BUFFERS) {
1334                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1335                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain));
1336                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_forest));
1337                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->domain_guid));
1338                 if (r->sid) {
1339                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1340                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1341                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1342                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1343                 }
1344         }
1345         return NDR_ERR_SUCCESS;
1346 }
1347
1348 _PUBLIC_ void ndr_print_lsa_DnsDomainInfo(struct ndr_print *ndr, const char *name, const struct lsa_DnsDomainInfo *r)
1349 {
1350         ndr_print_struct(ndr, name, "lsa_DnsDomainInfo");
1351         ndr->depth++;
1352         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
1353         ndr_print_lsa_StringLarge(ndr, "dns_domain", &r->dns_domain);
1354         ndr_print_lsa_StringLarge(ndr, "dns_forest", &r->dns_forest);
1355         ndr_print_GUID(ndr, "domain_guid", &r->domain_guid);
1356         ndr_print_ptr(ndr, "sid", r->sid);
1357         ndr->depth++;
1358         if (r->sid) {
1359                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1360         }
1361         ndr->depth--;
1362         ndr->depth--;
1363 }
1364
1365 static enum ndr_err_code ndr_push_lsa_PolicyInfo(struct ndr_push *ndr, int ndr_flags, enum lsa_PolicyInfo r)
1366 {
1367         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1368         return NDR_ERR_SUCCESS;
1369 }
1370
1371 static enum ndr_err_code ndr_pull_lsa_PolicyInfo(struct ndr_pull *ndr, int ndr_flags, enum lsa_PolicyInfo *r)
1372 {
1373         uint16_t v;
1374         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1375         *r = v;
1376         return NDR_ERR_SUCCESS;
1377 }
1378
1379 _PUBLIC_ void ndr_print_lsa_PolicyInfo(struct ndr_print *ndr, const char *name, enum lsa_PolicyInfo r)
1380 {
1381         const char *val = NULL;
1382
1383         switch (r) {
1384                 case LSA_POLICY_INFO_AUDIT_LOG: val = "LSA_POLICY_INFO_AUDIT_LOG"; break;
1385                 case LSA_POLICY_INFO_AUDIT_EVENTS: val = "LSA_POLICY_INFO_AUDIT_EVENTS"; break;
1386                 case LSA_POLICY_INFO_DOMAIN: val = "LSA_POLICY_INFO_DOMAIN"; break;
1387                 case LSA_POLICY_INFO_PD: val = "LSA_POLICY_INFO_PD"; break;
1388                 case LSA_POLICY_INFO_ACCOUNT_DOMAIN: val = "LSA_POLICY_INFO_ACCOUNT_DOMAIN"; break;
1389                 case LSA_POLICY_INFO_ROLE: val = "LSA_POLICY_INFO_ROLE"; break;
1390                 case LSA_POLICY_INFO_REPLICA: val = "LSA_POLICY_INFO_REPLICA"; break;
1391                 case LSA_POLICY_INFO_QUOTA: val = "LSA_POLICY_INFO_QUOTA"; break;
1392                 case LSA_POLICY_INFO_DB: val = "LSA_POLICY_INFO_DB"; break;
1393                 case LSA_POLICY_INFO_AUDIT_FULL_SET: val = "LSA_POLICY_INFO_AUDIT_FULL_SET"; break;
1394                 case LSA_POLICY_INFO_AUDIT_FULL_QUERY: val = "LSA_POLICY_INFO_AUDIT_FULL_QUERY"; break;
1395                 case LSA_POLICY_INFO_DNS: val = "LSA_POLICY_INFO_DNS"; break;
1396         }
1397         ndr_print_enum(ndr, name, "ENUM", val, r);
1398 }
1399
1400 static enum ndr_err_code ndr_push_lsa_PolicyInformation(struct ndr_push *ndr, int ndr_flags, const union lsa_PolicyInformation *r)
1401 {
1402         if (ndr_flags & NDR_SCALARS) {
1403                 int level = ndr_push_get_switch_value(ndr, r);
1404                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
1405                 switch (level) {
1406                         case LSA_POLICY_INFO_AUDIT_LOG: {
1407                                 NDR_CHECK(ndr_push_lsa_AuditLogInfo(ndr, NDR_SCALARS, &r->audit_log));
1408                         break; }
1409
1410                         case LSA_POLICY_INFO_AUDIT_EVENTS: {
1411                                 NDR_CHECK(ndr_push_lsa_AuditEventsInfo(ndr, NDR_SCALARS, &r->audit_events));
1412                         break; }
1413
1414                         case LSA_POLICY_INFO_DOMAIN: {
1415                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domain));
1416                         break; }
1417
1418                         case LSA_POLICY_INFO_PD: {
1419                                 NDR_CHECK(ndr_push_lsa_PDAccountInfo(ndr, NDR_SCALARS, &r->pd));
1420                         break; }
1421
1422                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN: {
1423                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->account_domain));
1424                         break; }
1425
1426                         case LSA_POLICY_INFO_ROLE: {
1427                                 NDR_CHECK(ndr_push_lsa_ServerRole(ndr, NDR_SCALARS, &r->role));
1428                         break; }
1429
1430                         case LSA_POLICY_INFO_REPLICA: {
1431                                 NDR_CHECK(ndr_push_lsa_ReplicaSourceInfo(ndr, NDR_SCALARS, &r->replica));
1432                         break; }
1433
1434                         case LSA_POLICY_INFO_QUOTA: {
1435                                 NDR_CHECK(ndr_push_lsa_DefaultQuotaInfo(ndr, NDR_SCALARS, &r->quota));
1436                         break; }
1437
1438                         case LSA_POLICY_INFO_DB: {
1439                                 NDR_CHECK(ndr_push_lsa_ModificationInfo(ndr, NDR_SCALARS, &r->db));
1440                         break; }
1441
1442                         case LSA_POLICY_INFO_AUDIT_FULL_SET: {
1443                                 NDR_CHECK(ndr_push_lsa_AuditFullSetInfo(ndr, NDR_SCALARS, &r->auditfullset));
1444                         break; }
1445
1446                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY: {
1447                                 NDR_CHECK(ndr_push_lsa_AuditFullQueryInfo(ndr, NDR_SCALARS, &r->auditfullquery));
1448                         break; }
1449
1450                         case LSA_POLICY_INFO_DNS: {
1451                                 NDR_CHECK(ndr_push_lsa_DnsDomainInfo(ndr, NDR_SCALARS, &r->dns));
1452                         break; }
1453
1454                         default:
1455                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1456                 }
1457         }
1458         if (ndr_flags & NDR_BUFFERS) {
1459                 int level = ndr_push_get_switch_value(ndr, r);
1460                 switch (level) {
1461                         case LSA_POLICY_INFO_AUDIT_LOG:
1462                         break;
1463
1464                         case LSA_POLICY_INFO_AUDIT_EVENTS:
1465                                 NDR_CHECK(ndr_push_lsa_AuditEventsInfo(ndr, NDR_BUFFERS, &r->audit_events));
1466                         break;
1467
1468                         case LSA_POLICY_INFO_DOMAIN:
1469                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domain));
1470                         break;
1471
1472                         case LSA_POLICY_INFO_PD:
1473                                 NDR_CHECK(ndr_push_lsa_PDAccountInfo(ndr, NDR_BUFFERS, &r->pd));
1474                         break;
1475
1476                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1477                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->account_domain));
1478                         break;
1479
1480                         case LSA_POLICY_INFO_ROLE:
1481                         break;
1482
1483                         case LSA_POLICY_INFO_REPLICA:
1484                                 NDR_CHECK(ndr_push_lsa_ReplicaSourceInfo(ndr, NDR_BUFFERS, &r->replica));
1485                         break;
1486
1487                         case LSA_POLICY_INFO_QUOTA:
1488                         break;
1489
1490                         case LSA_POLICY_INFO_DB:
1491                         break;
1492
1493                         case LSA_POLICY_INFO_AUDIT_FULL_SET:
1494                         break;
1495
1496                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1497                         break;
1498
1499                         case LSA_POLICY_INFO_DNS:
1500                                 NDR_CHECK(ndr_push_lsa_DnsDomainInfo(ndr, NDR_BUFFERS, &r->dns));
1501                         break;
1502
1503                         default:
1504                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1505                 }
1506         }
1507         return NDR_ERR_SUCCESS;
1508 }
1509
1510 static enum ndr_err_code ndr_pull_lsa_PolicyInformation(struct ndr_pull *ndr, int ndr_flags, union lsa_PolicyInformation *r)
1511 {
1512         int level;
1513         uint16_t _level;
1514         level = ndr_pull_get_switch_value(ndr, r);
1515         if (ndr_flags & NDR_SCALARS) {
1516                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1517                 if (_level != level) {
1518                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1519                 }
1520                 switch (level) {
1521                         case LSA_POLICY_INFO_AUDIT_LOG: {
1522                                 NDR_CHECK(ndr_pull_lsa_AuditLogInfo(ndr, NDR_SCALARS, &r->audit_log));
1523                         break; }
1524
1525                         case LSA_POLICY_INFO_AUDIT_EVENTS: {
1526                                 NDR_CHECK(ndr_pull_lsa_AuditEventsInfo(ndr, NDR_SCALARS, &r->audit_events));
1527                         break; }
1528
1529                         case LSA_POLICY_INFO_DOMAIN: {
1530                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domain));
1531                         break; }
1532
1533                         case LSA_POLICY_INFO_PD: {
1534                                 NDR_CHECK(ndr_pull_lsa_PDAccountInfo(ndr, NDR_SCALARS, &r->pd));
1535                         break; }
1536
1537                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN: {
1538                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->account_domain));
1539                         break; }
1540
1541                         case LSA_POLICY_INFO_ROLE: {
1542                                 NDR_CHECK(ndr_pull_lsa_ServerRole(ndr, NDR_SCALARS, &r->role));
1543                         break; }
1544
1545                         case LSA_POLICY_INFO_REPLICA: {
1546                                 NDR_CHECK(ndr_pull_lsa_ReplicaSourceInfo(ndr, NDR_SCALARS, &r->replica));
1547                         break; }
1548
1549                         case LSA_POLICY_INFO_QUOTA: {
1550                                 NDR_CHECK(ndr_pull_lsa_DefaultQuotaInfo(ndr, NDR_SCALARS, &r->quota));
1551                         break; }
1552
1553                         case LSA_POLICY_INFO_DB: {
1554                                 NDR_CHECK(ndr_pull_lsa_ModificationInfo(ndr, NDR_SCALARS, &r->db));
1555                         break; }
1556
1557                         case LSA_POLICY_INFO_AUDIT_FULL_SET: {
1558                                 NDR_CHECK(ndr_pull_lsa_AuditFullSetInfo(ndr, NDR_SCALARS, &r->auditfullset));
1559                         break; }
1560
1561                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY: {
1562                                 NDR_CHECK(ndr_pull_lsa_AuditFullQueryInfo(ndr, NDR_SCALARS, &r->auditfullquery));
1563                         break; }
1564
1565                         case LSA_POLICY_INFO_DNS: {
1566                                 NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_SCALARS, &r->dns));
1567                         break; }
1568
1569                         default:
1570                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1571                 }
1572         }
1573         if (ndr_flags & NDR_BUFFERS) {
1574                 switch (level) {
1575                         case LSA_POLICY_INFO_AUDIT_LOG:
1576                         break;
1577
1578                         case LSA_POLICY_INFO_AUDIT_EVENTS:
1579                                 NDR_CHECK(ndr_pull_lsa_AuditEventsInfo(ndr, NDR_BUFFERS, &r->audit_events));
1580                         break;
1581
1582                         case LSA_POLICY_INFO_DOMAIN:
1583                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domain));
1584                         break;
1585
1586                         case LSA_POLICY_INFO_PD:
1587                                 NDR_CHECK(ndr_pull_lsa_PDAccountInfo(ndr, NDR_BUFFERS, &r->pd));
1588                         break;
1589
1590                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1591                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->account_domain));
1592                         break;
1593
1594                         case LSA_POLICY_INFO_ROLE:
1595                         break;
1596
1597                         case LSA_POLICY_INFO_REPLICA:
1598                                 NDR_CHECK(ndr_pull_lsa_ReplicaSourceInfo(ndr, NDR_BUFFERS, &r->replica));
1599                         break;
1600
1601                         case LSA_POLICY_INFO_QUOTA:
1602                         break;
1603
1604                         case LSA_POLICY_INFO_DB:
1605                         break;
1606
1607                         case LSA_POLICY_INFO_AUDIT_FULL_SET:
1608                         break;
1609
1610                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1611                         break;
1612
1613                         case LSA_POLICY_INFO_DNS:
1614                                 NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_BUFFERS, &r->dns));
1615                         break;
1616
1617                         default:
1618                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1619                 }
1620         }
1621         return NDR_ERR_SUCCESS;
1622 }
1623
1624 _PUBLIC_ void ndr_print_lsa_PolicyInformation(struct ndr_print *ndr, const char *name, const union lsa_PolicyInformation *r)
1625 {
1626         int level;
1627         level = ndr_print_get_switch_value(ndr, r);
1628         ndr_print_union(ndr, name, level, "lsa_PolicyInformation");
1629         switch (level) {
1630                 case LSA_POLICY_INFO_AUDIT_LOG:
1631                         ndr_print_lsa_AuditLogInfo(ndr, "audit_log", &r->audit_log);
1632                 break;
1633
1634                 case LSA_POLICY_INFO_AUDIT_EVENTS:
1635                         ndr_print_lsa_AuditEventsInfo(ndr, "audit_events", &r->audit_events);
1636                 break;
1637
1638                 case LSA_POLICY_INFO_DOMAIN:
1639                         ndr_print_lsa_DomainInfo(ndr, "domain", &r->domain);
1640                 break;
1641
1642                 case LSA_POLICY_INFO_PD:
1643                         ndr_print_lsa_PDAccountInfo(ndr, "pd", &r->pd);
1644                 break;
1645
1646                 case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1647                         ndr_print_lsa_DomainInfo(ndr, "account_domain", &r->account_domain);
1648                 break;
1649
1650                 case LSA_POLICY_INFO_ROLE:
1651                         ndr_print_lsa_ServerRole(ndr, "role", &r->role);
1652                 break;
1653
1654                 case LSA_POLICY_INFO_REPLICA:
1655                         ndr_print_lsa_ReplicaSourceInfo(ndr, "replica", &r->replica);
1656                 break;
1657
1658                 case LSA_POLICY_INFO_QUOTA:
1659                         ndr_print_lsa_DefaultQuotaInfo(ndr, "quota", &r->quota);
1660                 break;
1661
1662                 case LSA_POLICY_INFO_DB:
1663                         ndr_print_lsa_ModificationInfo(ndr, "db", &r->db);
1664                 break;
1665
1666                 case LSA_POLICY_INFO_AUDIT_FULL_SET:
1667                         ndr_print_lsa_AuditFullSetInfo(ndr, "auditfullset", &r->auditfullset);
1668                 break;
1669
1670                 case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1671                         ndr_print_lsa_AuditFullQueryInfo(ndr, "auditfullquery", &r->auditfullquery);
1672                 break;
1673
1674                 case LSA_POLICY_INFO_DNS:
1675                         ndr_print_lsa_DnsDomainInfo(ndr, "dns", &r->dns);
1676                 break;
1677
1678                 default:
1679                         ndr_print_bad_level(ndr, name, level);
1680         }
1681 }
1682
1683 static enum ndr_err_code ndr_push_lsa_SidPtr(struct ndr_push *ndr, int ndr_flags, const struct lsa_SidPtr *r)
1684 {
1685         if (ndr_flags & NDR_SCALARS) {
1686                 NDR_CHECK(ndr_push_align(ndr, 4));
1687                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
1688         }
1689         if (ndr_flags & NDR_BUFFERS) {
1690                 if (r->sid) {
1691                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1692                 }
1693         }
1694         return NDR_ERR_SUCCESS;
1695 }
1696
1697 static enum ndr_err_code ndr_pull_lsa_SidPtr(struct ndr_pull *ndr, int ndr_flags, struct lsa_SidPtr *r)
1698 {
1699         uint32_t _ptr_sid;
1700         TALLOC_CTX *_mem_save_sid_0;
1701         if (ndr_flags & NDR_SCALARS) {
1702                 NDR_CHECK(ndr_pull_align(ndr, 4));
1703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
1704                 if (_ptr_sid) {
1705                         NDR_PULL_ALLOC(ndr, r->sid);
1706                 } else {
1707                         r->sid = NULL;
1708                 }
1709         }
1710         if (ndr_flags & NDR_BUFFERS) {
1711                 if (r->sid) {
1712                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1713                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1714                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1715                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1716                 }
1717         }
1718         return NDR_ERR_SUCCESS;
1719 }
1720
1721 _PUBLIC_ void ndr_print_lsa_SidPtr(struct ndr_print *ndr, const char *name, const struct lsa_SidPtr *r)
1722 {
1723         ndr_print_struct(ndr, name, "lsa_SidPtr");
1724         ndr->depth++;
1725         ndr_print_ptr(ndr, "sid", r->sid);
1726         ndr->depth++;
1727         if (r->sid) {
1728                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1729         }
1730         ndr->depth--;
1731         ndr->depth--;
1732 }
1733
1734 _PUBLIC_ enum ndr_err_code ndr_push_lsa_SidArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_SidArray *r)
1735 {
1736         uint32_t cntr_sids_1;
1737         if (ndr_flags & NDR_SCALARS) {
1738                 NDR_CHECK(ndr_push_align(ndr, 4));
1739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
1740                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
1741         }
1742         if (ndr_flags & NDR_BUFFERS) {
1743                 if (r->sids) {
1744                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
1745                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1746                                 NDR_CHECK(ndr_push_lsa_SidPtr(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1747                         }
1748                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1749                                 NDR_CHECK(ndr_push_lsa_SidPtr(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
1750                         }
1751                 }
1752         }
1753         return NDR_ERR_SUCCESS;
1754 }
1755
1756 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_SidArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_SidArray *r)
1757 {
1758         uint32_t _ptr_sids;
1759         uint32_t cntr_sids_1;
1760         TALLOC_CTX *_mem_save_sids_0;
1761         TALLOC_CTX *_mem_save_sids_1;
1762         if (ndr_flags & NDR_SCALARS) {
1763                 NDR_CHECK(ndr_pull_align(ndr, 4));
1764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
1765                 if (r->num_sids < 0 || r->num_sids > 1000) {
1766                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1767                 }
1768                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
1769                 if (_ptr_sids) {
1770                         NDR_PULL_ALLOC(ndr, r->sids);
1771                 } else {
1772                         r->sids = NULL;
1773                 }
1774         }
1775         if (ndr_flags & NDR_BUFFERS) {
1776                 if (r->sids) {
1777                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1778                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1779                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
1780                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
1781                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1782                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1783                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1784                                 NDR_CHECK(ndr_pull_lsa_SidPtr(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1785                         }
1786                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1787                                 NDR_CHECK(ndr_pull_lsa_SidPtr(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
1788                         }
1789                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
1790                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
1791                 }
1792                 if (r->sids) {
1793                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
1794                 }
1795         }
1796         return NDR_ERR_SUCCESS;
1797 }
1798
1799 _PUBLIC_ void ndr_print_lsa_SidArray(struct ndr_print *ndr, const char *name, const struct lsa_SidArray *r)
1800 {
1801         uint32_t cntr_sids_1;
1802         ndr_print_struct(ndr, name, "lsa_SidArray");
1803         ndr->depth++;
1804         ndr_print_uint32(ndr, "num_sids", r->num_sids);
1805         ndr_print_ptr(ndr, "sids", r->sids);
1806         ndr->depth++;
1807         if (r->sids) {
1808                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->num_sids);
1809                 ndr->depth++;
1810                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
1811                         char *idx_1=NULL;
1812                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
1813                                 ndr_print_lsa_SidPtr(ndr, "sids", &r->sids[cntr_sids_1]);
1814                                 free(idx_1);
1815                         }
1816                 }
1817                 ndr->depth--;
1818         }
1819         ndr->depth--;
1820         ndr->depth--;
1821 }
1822
1823 static enum ndr_err_code ndr_push_lsa_DomainList(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainList *r)
1824 {
1825         uint32_t cntr_domains_1;
1826         if (ndr_flags & NDR_SCALARS) {
1827                 NDR_CHECK(ndr_push_align(ndr, 4));
1828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1829                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
1830         }
1831         if (ndr_flags & NDR_BUFFERS) {
1832                 if (r->domains) {
1833                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1834                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1835                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
1836                         }
1837                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1838                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
1839                         }
1840                 }
1841         }
1842         return NDR_ERR_SUCCESS;
1843 }
1844
1845 static enum ndr_err_code ndr_pull_lsa_DomainList(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainList *r)
1846 {
1847         uint32_t _ptr_domains;
1848         uint32_t cntr_domains_1;
1849         TALLOC_CTX *_mem_save_domains_0;
1850         TALLOC_CTX *_mem_save_domains_1;
1851         if (ndr_flags & NDR_SCALARS) {
1852                 NDR_CHECK(ndr_pull_align(ndr, 4));
1853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
1855                 if (_ptr_domains) {
1856                         NDR_PULL_ALLOC(ndr, r->domains);
1857                 } else {
1858                         r->domains = NULL;
1859                 }
1860         }
1861         if (ndr_flags & NDR_BUFFERS) {
1862                 if (r->domains) {
1863                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
1864                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1865                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
1866                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
1867                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
1868                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1869                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1870                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
1871                         }
1872                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1873                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
1874                         }
1875                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
1876                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
1877                 }
1878                 if (r->domains) {
1879                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
1880                 }
1881         }
1882         return NDR_ERR_SUCCESS;
1883 }
1884
1885 _PUBLIC_ void ndr_print_lsa_DomainList(struct ndr_print *ndr, const char *name, const struct lsa_DomainList *r)
1886 {
1887         uint32_t cntr_domains_1;
1888         ndr_print_struct(ndr, name, "lsa_DomainList");
1889         ndr->depth++;
1890         ndr_print_uint32(ndr, "count", r->count);
1891         ndr_print_ptr(ndr, "domains", r->domains);
1892         ndr->depth++;
1893         if (r->domains) {
1894                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", r->count);
1895                 ndr->depth++;
1896                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
1897                         char *idx_1=NULL;
1898                         if (asprintf(&idx_1, "[%d]", cntr_domains_1) != -1) {
1899                                 ndr_print_lsa_DomainInfo(ndr, "domains", &r->domains[cntr_domains_1]);
1900                                 free(idx_1);
1901                         }
1902                 }
1903                 ndr->depth--;
1904         }
1905         ndr->depth--;
1906         ndr->depth--;
1907 }
1908
1909 _PUBLIC_ enum ndr_err_code ndr_push_lsa_SidType(struct ndr_push *ndr, int ndr_flags, enum lsa_SidType r)
1910 {
1911         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1912         return NDR_ERR_SUCCESS;
1913 }
1914
1915 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_SidType(struct ndr_pull *ndr, int ndr_flags, enum lsa_SidType *r)
1916 {
1917         uint16_t v;
1918         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1919         *r = v;
1920         return NDR_ERR_SUCCESS;
1921 }
1922
1923 _PUBLIC_ void ndr_print_lsa_SidType(struct ndr_print *ndr, const char *name, enum lsa_SidType r)
1924 {
1925         const char *val = NULL;
1926
1927         switch (r) {
1928                 case SID_NAME_USE_NONE: val = "SID_NAME_USE_NONE"; break;
1929                 case SID_NAME_USER: val = "SID_NAME_USER"; break;
1930                 case SID_NAME_DOM_GRP: val = "SID_NAME_DOM_GRP"; break;
1931                 case SID_NAME_DOMAIN: val = "SID_NAME_DOMAIN"; break;
1932                 case SID_NAME_ALIAS: val = "SID_NAME_ALIAS"; break;
1933                 case SID_NAME_WKN_GRP: val = "SID_NAME_WKN_GRP"; break;
1934                 case SID_NAME_DELETED: val = "SID_NAME_DELETED"; break;
1935                 case SID_NAME_INVALID: val = "SID_NAME_INVALID"; break;
1936                 case SID_NAME_UNKNOWN: val = "SID_NAME_UNKNOWN"; break;
1937                 case SID_NAME_COMPUTER: val = "SID_NAME_COMPUTER"; break;
1938         }
1939         ndr_print_enum(ndr, name, "ENUM", val, r);
1940 }
1941
1942 static enum ndr_err_code ndr_push_lsa_TranslatedSid(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid *r)
1943 {
1944         if (ndr_flags & NDR_SCALARS) {
1945                 NDR_CHECK(ndr_push_align(ndr, 4));
1946                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
1947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
1948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
1949         }
1950         if (ndr_flags & NDR_BUFFERS) {
1951         }
1952         return NDR_ERR_SUCCESS;
1953 }
1954
1955 static enum ndr_err_code ndr_pull_lsa_TranslatedSid(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid *r)
1956 {
1957         if (ndr_flags & NDR_SCALARS) {
1958                 NDR_CHECK(ndr_pull_align(ndr, 4));
1959                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
1960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
1961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
1962         }
1963         if (ndr_flags & NDR_BUFFERS) {
1964         }
1965         return NDR_ERR_SUCCESS;
1966 }
1967
1968 _PUBLIC_ void ndr_print_lsa_TranslatedSid(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid *r)
1969 {
1970         ndr_print_struct(ndr, name, "lsa_TranslatedSid");
1971         ndr->depth++;
1972         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
1973         ndr_print_uint32(ndr, "rid", r->rid);
1974         ndr_print_uint32(ndr, "sid_index", r->sid_index);
1975         ndr->depth--;
1976 }
1977
1978 static enum ndr_err_code ndr_push_lsa_TransSidArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray *r)
1979 {
1980         uint32_t cntr_sids_1;
1981         if (ndr_flags & NDR_SCALARS) {
1982                 NDR_CHECK(ndr_push_align(ndr, 4));
1983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1984                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
1985         }
1986         if (ndr_flags & NDR_BUFFERS) {
1987                 if (r->sids) {
1988                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1989                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
1990                                 NDR_CHECK(ndr_push_lsa_TranslatedSid(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1991                         }
1992                 }
1993         }
1994         return NDR_ERR_SUCCESS;
1995 }
1996
1997 static enum ndr_err_code ndr_pull_lsa_TransSidArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray *r)
1998 {
1999         uint32_t _ptr_sids;
2000         uint32_t cntr_sids_1;
2001         TALLOC_CTX *_mem_save_sids_0;
2002         TALLOC_CTX *_mem_save_sids_1;
2003         if (ndr_flags & NDR_SCALARS) {
2004                 NDR_CHECK(ndr_pull_align(ndr, 4));
2005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2006                 if (r->count < 0 || r->count > 1000) {
2007                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2008                 }
2009                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
2010                 if (_ptr_sids) {
2011                         NDR_PULL_ALLOC(ndr, r->sids);
2012                 } else {
2013                         r->sids = NULL;
2014                 }
2015         }
2016         if (ndr_flags & NDR_BUFFERS) {
2017                 if (r->sids) {
2018                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
2019                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
2020                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
2021                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
2022                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
2023                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
2024                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
2025                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
2026                         }
2027                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
2028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
2029                 }
2030                 if (r->sids) {
2031                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
2032                 }
2033         }
2034         return NDR_ERR_SUCCESS;
2035 }
2036
2037 _PUBLIC_ void ndr_print_lsa_TransSidArray(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray *r)
2038 {
2039         uint32_t cntr_sids_1;
2040         ndr_print_struct(ndr, name, "lsa_TransSidArray");
2041         ndr->depth++;
2042         ndr_print_uint32(ndr, "count", r->count);
2043         ndr_print_ptr(ndr, "sids", r->sids);
2044         ndr->depth++;
2045         if (r->sids) {
2046                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->count);
2047                 ndr->depth++;
2048                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
2049                         char *idx_1=NULL;
2050                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
2051                                 ndr_print_lsa_TranslatedSid(ndr, "sids", &r->sids[cntr_sids_1]);
2052                                 free(idx_1);
2053                         }
2054                 }
2055                 ndr->depth--;
2056         }
2057         ndr->depth--;
2058         ndr->depth--;
2059 }
2060
2061 static enum ndr_err_code ndr_push_lsa_RefDomainList(struct ndr_push *ndr, int ndr_flags, const struct lsa_RefDomainList *r)
2062 {
2063         uint32_t cntr_domains_1;
2064         if (ndr_flags & NDR_SCALARS) {
2065                 NDR_CHECK(ndr_push_align(ndr, 4));
2066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2067                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
2068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_size));
2069         }
2070         if (ndr_flags & NDR_BUFFERS) {
2071                 if (r->domains) {
2072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2073                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
2074                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
2075                         }
2076                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
2077                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
2078                         }
2079                 }
2080         }
2081         return NDR_ERR_SUCCESS;
2082 }
2083
2084 static enum ndr_err_code ndr_pull_lsa_RefDomainList(struct ndr_pull *ndr, int ndr_flags, struct lsa_RefDomainList *r)
2085 {
2086         uint32_t _ptr_domains;
2087         uint32_t cntr_domains_1;
2088         TALLOC_CTX *_mem_save_domains_0;
2089         TALLOC_CTX *_mem_save_domains_1;
2090         if (ndr_flags & NDR_SCALARS) {
2091                 NDR_CHECK(ndr_pull_align(ndr, 4));
2092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2093                 if (r->count < 0 || r->count > 1000) {
2094                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2095                 }
2096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
2097                 if (_ptr_domains) {
2098                         NDR_PULL_ALLOC(ndr, r->domains);
2099                 } else {
2100                         r->domains = NULL;
2101                 }
2102                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_size));
2103         }
2104         if (ndr_flags & NDR_BUFFERS) {
2105                 if (r->domains) {
2106                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
2107                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
2108                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
2109                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
2110                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
2111                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
2112                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
2113                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
2114                         }
2115                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
2116                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
2117                         }
2118                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
2119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
2120                 }
2121                 if (r->domains) {
2122                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
2123                 }
2124         }
2125         return NDR_ERR_SUCCESS;
2126 }
2127
2128 _PUBLIC_ void ndr_print_lsa_RefDomainList(struct ndr_print *ndr, const char *name, const struct lsa_RefDomainList *r)
2129 {
2130         uint32_t cntr_domains_1;
2131         ndr_print_struct(ndr, name, "lsa_RefDomainList");
2132         ndr->depth++;
2133         ndr_print_uint32(ndr, "count", r->count);
2134         ndr_print_ptr(ndr, "domains", r->domains);
2135         ndr->depth++;
2136         if (r->domains) {
2137                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", r->count);
2138                 ndr->depth++;
2139                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
2140                         char *idx_1=NULL;
2141                         if (asprintf(&idx_1, "[%d]", cntr_domains_1) != -1) {
2142                                 ndr_print_lsa_DomainInfo(ndr, "domains", &r->domains[cntr_domains_1]);
2143                                 free(idx_1);
2144                         }
2145                 }
2146                 ndr->depth--;
2147         }
2148         ndr->depth--;
2149         ndr_print_uint32(ndr, "max_size", r->max_size);
2150         ndr->depth--;
2151 }
2152
2153 static enum ndr_err_code ndr_push_lsa_LookupNamesLevel(struct ndr_push *ndr, int ndr_flags, enum lsa_LookupNamesLevel r)
2154 {
2155         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
2156         return NDR_ERR_SUCCESS;
2157 }
2158
2159 static enum ndr_err_code ndr_pull_lsa_LookupNamesLevel(struct ndr_pull *ndr, int ndr_flags, enum lsa_LookupNamesLevel *r)
2160 {
2161         uint16_t v;
2162         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
2163         *r = v;
2164         return NDR_ERR_SUCCESS;
2165 }
2166
2167 _PUBLIC_ void ndr_print_lsa_LookupNamesLevel(struct ndr_print *ndr, const char *name, enum lsa_LookupNamesLevel r)
2168 {
2169         const char *val = NULL;
2170
2171         switch (r) {
2172                 case LSA_LOOKUP_NAMES_ALL: val = "LSA_LOOKUP_NAMES_ALL"; break;
2173                 case LSA_LOOKUP_NAMES_DOMAINS_ONLY: val = "LSA_LOOKUP_NAMES_DOMAINS_ONLY"; break;
2174                 case LSA_LOOKUP_NAMES_PRIMARY_DOMAIN_ONLY: val = "LSA_LOOKUP_NAMES_PRIMARY_DOMAIN_ONLY"; break;
2175                 case LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY: val = "LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY"; break;
2176                 case LSA_LOOKUP_NAMES_FOREST_TRUSTS_ONLY: val = "LSA_LOOKUP_NAMES_FOREST_TRUSTS_ONLY"; break;
2177                 case LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY2: val = "LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY2"; break;
2178         }
2179         ndr_print_enum(ndr, name, "ENUM", val, r);
2180 }
2181
2182 static enum ndr_err_code ndr_push_lsa_TranslatedName(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedName *r)
2183 {
2184         if (ndr_flags & NDR_SCALARS) {
2185                 NDR_CHECK(ndr_push_align(ndr, 4));
2186                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
2187                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
2188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
2189         }
2190         if (ndr_flags & NDR_BUFFERS) {
2191                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
2192         }
2193         return NDR_ERR_SUCCESS;
2194 }
2195
2196 static enum ndr_err_code ndr_pull_lsa_TranslatedName(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedName *r)
2197 {
2198         if (ndr_flags & NDR_SCALARS) {
2199                 NDR_CHECK(ndr_pull_align(ndr, 4));
2200                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
2201                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
2202                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
2203         }
2204         if (ndr_flags & NDR_BUFFERS) {
2205                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
2206         }
2207         return NDR_ERR_SUCCESS;
2208 }
2209
2210 _PUBLIC_ void ndr_print_lsa_TranslatedName(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedName *r)
2211 {
2212         ndr_print_struct(ndr, name, "lsa_TranslatedName");
2213         ndr->depth++;
2214         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
2215         ndr_print_lsa_String(ndr, "name", &r->name);
2216         ndr_print_uint32(ndr, "sid_index", r->sid_index);
2217         ndr->depth--;
2218 }
2219
2220 static enum ndr_err_code ndr_push_lsa_TransNameArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransNameArray *r)
2221 {
2222         uint32_t cntr_names_1;
2223         if (ndr_flags & NDR_SCALARS) {
2224                 NDR_CHECK(ndr_push_align(ndr, 4));
2225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2226                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
2227         }
2228         if (ndr_flags & NDR_BUFFERS) {
2229                 if (r->names) {
2230                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2231                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2232                                 NDR_CHECK(ndr_push_lsa_TranslatedName(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
2233                         }
2234                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2235                                 NDR_CHECK(ndr_push_lsa_TranslatedName(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
2236                         }
2237                 }
2238         }
2239         return NDR_ERR_SUCCESS;
2240 }
2241
2242 static enum ndr_err_code ndr_pull_lsa_TransNameArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransNameArray *r)
2243 {
2244         uint32_t _ptr_names;
2245         uint32_t cntr_names_1;
2246         TALLOC_CTX *_mem_save_names_0;
2247         TALLOC_CTX *_mem_save_names_1;
2248         if (ndr_flags & NDR_SCALARS) {
2249                 NDR_CHECK(ndr_pull_align(ndr, 4));
2250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2251                 if (r->count < 0 || r->count > 1000) {
2252                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2253                 }
2254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
2255                 if (_ptr_names) {
2256                         NDR_PULL_ALLOC(ndr, r->names);
2257                 } else {
2258                         r->names = NULL;
2259                 }
2260         }
2261         if (ndr_flags & NDR_BUFFERS) {
2262                 if (r->names) {
2263                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
2264                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
2265                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
2266                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
2267                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
2268                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
2269                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2270                                 NDR_CHECK(ndr_pull_lsa_TranslatedName(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
2271                         }
2272                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2273                                 NDR_CHECK(ndr_pull_lsa_TranslatedName(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
2274                         }
2275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
2276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
2277                 }
2278                 if (r->names) {
2279                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
2280                 }
2281         }
2282         return NDR_ERR_SUCCESS;
2283 }
2284
2285 _PUBLIC_ void ndr_print_lsa_TransNameArray(struct ndr_print *ndr, const char *name, const struct lsa_TransNameArray *r)
2286 {
2287         uint32_t cntr_names_1;
2288         ndr_print_struct(ndr, name, "lsa_TransNameArray");
2289         ndr->depth++;
2290         ndr_print_uint32(ndr, "count", r->count);
2291         ndr_print_ptr(ndr, "names", r->names);
2292         ndr->depth++;
2293         if (r->names) {
2294                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->count);
2295                 ndr->depth++;
2296                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
2297                         char *idx_1=NULL;
2298                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
2299                                 ndr_print_lsa_TranslatedName(ndr, "names", &r->names[cntr_names_1]);
2300                                 free(idx_1);
2301                         }
2302                 }
2303                 ndr->depth--;
2304         }
2305         ndr->depth--;
2306         ndr->depth--;
2307 }
2308
2309 static enum ndr_err_code ndr_push_lsa_LUIDAttribute(struct ndr_push *ndr, int ndr_flags, const struct lsa_LUIDAttribute *r)
2310 {
2311         if (ndr_flags & NDR_SCALARS) {
2312                 NDR_CHECK(ndr_push_align(ndr, 4));
2313                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
2314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attribute));
2315         }
2316         if (ndr_flags & NDR_BUFFERS) {
2317         }
2318         return NDR_ERR_SUCCESS;
2319 }
2320
2321 static enum ndr_err_code ndr_pull_lsa_LUIDAttribute(struct ndr_pull *ndr, int ndr_flags, struct lsa_LUIDAttribute *r)
2322 {
2323         if (ndr_flags & NDR_SCALARS) {
2324                 NDR_CHECK(ndr_pull_align(ndr, 4));
2325                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
2326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attribute));
2327         }
2328         if (ndr_flags & NDR_BUFFERS) {
2329         }
2330         return NDR_ERR_SUCCESS;
2331 }
2332
2333 _PUBLIC_ void ndr_print_lsa_LUIDAttribute(struct ndr_print *ndr, const char *name, const struct lsa_LUIDAttribute *r)
2334 {
2335         ndr_print_struct(ndr, name, "lsa_LUIDAttribute");
2336         ndr->depth++;
2337         ndr_print_lsa_LUID(ndr, "luid", &r->luid);
2338         ndr_print_uint32(ndr, "attribute", r->attribute);
2339         ndr->depth--;
2340 }
2341
2342 static enum ndr_err_code ndr_push_lsa_PrivilegeSet(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivilegeSet *r)
2343 {
2344         uint32_t cntr_set_0;
2345         if (ndr_flags & NDR_SCALARS) {
2346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2347                 NDR_CHECK(ndr_push_align(ndr, 4));
2348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
2350                 for (cntr_set_0 = 0; cntr_set_0 < r->count; cntr_set_0++) {
2351                         NDR_CHECK(ndr_push_lsa_LUIDAttribute(ndr, NDR_SCALARS, &r->set[cntr_set_0]));
2352                 }
2353         }
2354         if (ndr_flags & NDR_BUFFERS) {
2355         }
2356         return NDR_ERR_SUCCESS;
2357 }
2358
2359 static enum ndr_err_code ndr_pull_lsa_PrivilegeSet(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivilegeSet *r)
2360 {
2361         uint32_t cntr_set_0;
2362         TALLOC_CTX *_mem_save_set_0;
2363         if (ndr_flags & NDR_SCALARS) {
2364                 NDR_CHECK(ndr_pull_array_size(ndr, &r->set));
2365                 NDR_CHECK(ndr_pull_align(ndr, 4));
2366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2367                 if (r->count < 0 || r->count > 1000) {
2368                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2369                 }
2370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
2371                 NDR_PULL_ALLOC_N(ndr, r->set, ndr_get_array_size(ndr, &r->set));
2372                 _mem_save_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
2373                 NDR_PULL_SET_MEM_CTX(ndr, r->set, 0);
2374                 for (cntr_set_0 = 0; cntr_set_0 < r->count; cntr_set_0++) {
2375                         NDR_CHECK(ndr_pull_lsa_LUIDAttribute(ndr, NDR_SCALARS, &r->set[cntr_set_0]));
2376                 }
2377                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_set_0, 0);
2378                 if (r->set) {
2379                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->set, r->count));
2380                 }
2381         }
2382         if (ndr_flags & NDR_BUFFERS) {
2383         }
2384         return NDR_ERR_SUCCESS;
2385 }
2386
2387 _PUBLIC_ void ndr_print_lsa_PrivilegeSet(struct ndr_print *ndr, const char *name, const struct lsa_PrivilegeSet *r)
2388 {
2389         uint32_t cntr_set_0;
2390         ndr_print_struct(ndr, name, "lsa_PrivilegeSet");
2391         ndr->depth++;
2392         ndr_print_uint32(ndr, "count", r->count);
2393         ndr_print_uint32(ndr, "unknown", r->unknown);
2394         ndr->print(ndr, "%s: ARRAY(%d)", "set", r->count);
2395         ndr->depth++;
2396         for (cntr_set_0=0;cntr_set_0<r->count;cntr_set_0++) {
2397                 char *idx_0=NULL;
2398                 if (asprintf(&idx_0, "[%d]", cntr_set_0) != -1) {
2399                         ndr_print_lsa_LUIDAttribute(ndr, "set", &r->set[cntr_set_0]);
2400                         free(idx_0);
2401                 }
2402         }
2403         ndr->depth--;
2404         ndr->depth--;
2405 }
2406
2407 static enum ndr_err_code ndr_push_lsa_DATA_BUF(struct ndr_push *ndr, int ndr_flags, const struct lsa_DATA_BUF *r)
2408 {
2409         {
2410                 uint32_t _flags_save_STRUCT = ndr->flags;
2411                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2412                 if (ndr_flags & NDR_SCALARS) {
2413                         NDR_CHECK(ndr_push_align(ndr, 4));
2414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
2415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2416                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
2417                 }
2418                 if (ndr_flags & NDR_BUFFERS) {
2419                         if (r->data) {
2420                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2421                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2422                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
2423                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
2424                         }
2425                 }
2426                 ndr->flags = _flags_save_STRUCT;
2427         }
2428         return NDR_ERR_SUCCESS;
2429 }
2430
2431 static enum ndr_err_code ndr_pull_lsa_DATA_BUF(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF *r)
2432 {
2433         uint32_t _ptr_data;
2434         TALLOC_CTX *_mem_save_data_0;
2435         {
2436                 uint32_t _flags_save_STRUCT = ndr->flags;
2437                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2438                 if (ndr_flags & NDR_SCALARS) {
2439                         NDR_CHECK(ndr_pull_align(ndr, 4));
2440                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
2441                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2442                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2443                         if (_ptr_data) {
2444                                 NDR_PULL_ALLOC(ndr, r->data);
2445                         } else {
2446                                 r->data = NULL;
2447                         }
2448                 }
2449                 if (ndr_flags & NDR_BUFFERS) {
2450                         if (r->data) {
2451                                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2452                                 NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
2453                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
2454                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->data));
2455                                 if (ndr_get_array_length(ndr, &r->data) > ndr_get_array_size(ndr, &r->data)) {
2456                                         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));
2457                                 }
2458                                 NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
2459                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_length(ndr, &r->data)));
2460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2461                         }
2462                         if (r->data) {
2463                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
2464                         }
2465                         if (r->data) {
2466                                 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->data, r->length));
2467                         }
2468                 }
2469                 ndr->flags = _flags_save_STRUCT;
2470         }
2471         return NDR_ERR_SUCCESS;
2472 }
2473
2474 _PUBLIC_ void ndr_print_lsa_DATA_BUF(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF *r)
2475 {
2476         ndr_print_struct(ndr, name, "lsa_DATA_BUF");
2477         {
2478                 uint32_t _flags_save_STRUCT = ndr->flags;
2479                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2480                 ndr->depth++;
2481                 ndr_print_uint32(ndr, "length", r->length);
2482                 ndr_print_uint32(ndr, "size", r->size);
2483                 ndr_print_ptr(ndr, "data", r->data);
2484                 ndr->depth++;
2485                 if (r->data) {
2486                         ndr_print_array_uint8(ndr, "data", r->data, r->length);
2487                 }
2488                 ndr->depth--;
2489                 ndr->depth--;
2490                 ndr->flags = _flags_save_STRUCT;
2491         }
2492 }
2493
2494 static enum ndr_err_code ndr_push_lsa_DATA_BUF2(struct ndr_push *ndr, int ndr_flags, const struct lsa_DATA_BUF2 *r)
2495 {
2496         {
2497                 uint32_t _flags_save_STRUCT = ndr->flags;
2498                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2499                 if (ndr_flags & NDR_SCALARS) {
2500                         NDR_CHECK(ndr_push_align(ndr, 4));
2501                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2502                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
2503                 }
2504                 if (ndr_flags & NDR_BUFFERS) {
2505                         if (r->data) {
2506                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2507                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
2508                         }
2509                 }
2510                 ndr->flags = _flags_save_STRUCT;
2511         }
2512         return NDR_ERR_SUCCESS;
2513 }
2514
2515 static enum ndr_err_code ndr_pull_lsa_DATA_BUF2(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF2 *r)
2516 {
2517         uint32_t _ptr_data;
2518         TALLOC_CTX *_mem_save_data_0;
2519         {
2520                 uint32_t _flags_save_STRUCT = ndr->flags;
2521                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2522                 if (ndr_flags & NDR_SCALARS) {
2523                         NDR_CHECK(ndr_pull_align(ndr, 4));
2524                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2525                         if (r->size < 0 || r->size > 65536) {
2526                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2527                         }
2528                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2529                         if (_ptr_data) {
2530                                 NDR_PULL_ALLOC(ndr, r->data);
2531                         } else {
2532                                 r->data = NULL;
2533                         }
2534                 }
2535                 if (ndr_flags & NDR_BUFFERS) {
2536                         if (r->data) {
2537                                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2538                                 NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
2539                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
2540                                 NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
2541                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
2542                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2543                         }
2544                         if (r->data) {
2545                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
2546                         }
2547                 }
2548                 ndr->flags = _flags_save_STRUCT;
2549         }
2550         return NDR_ERR_SUCCESS;
2551 }
2552
2553 _PUBLIC_ void ndr_print_lsa_DATA_BUF2(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF2 *r)
2554 {
2555         ndr_print_struct(ndr, name, "lsa_DATA_BUF2");
2556         {
2557                 uint32_t _flags_save_STRUCT = ndr->flags;
2558                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2559                 ndr->depth++;
2560                 ndr_print_uint32(ndr, "size", r->size);
2561                 ndr_print_ptr(ndr, "data", r->data);
2562                 ndr->depth++;
2563                 if (r->data) {
2564                         ndr_print_array_uint8(ndr, "data", r->data, r->size);
2565                 }
2566                 ndr->depth--;
2567                 ndr->depth--;
2568                 ndr->flags = _flags_save_STRUCT;
2569         }
2570 }
2571
2572 static enum ndr_err_code ndr_push_lsa_TrustDomInfoEnum(struct ndr_push *ndr, int ndr_flags, enum lsa_TrustDomInfoEnum r)
2573 {
2574         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
2575         return NDR_ERR_SUCCESS;
2576 }
2577
2578 static enum ndr_err_code ndr_pull_lsa_TrustDomInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum lsa_TrustDomInfoEnum *r)
2579 {
2580         uint16_t v;
2581         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
2582         *r = v;
2583         return NDR_ERR_SUCCESS;
2584 }
2585
2586 _PUBLIC_ void ndr_print_lsa_TrustDomInfoEnum(struct ndr_print *ndr, const char *name, enum lsa_TrustDomInfoEnum r)
2587 {
2588         const char *val = NULL;
2589
2590         switch (r) {
2591                 case LSA_TRUSTED_DOMAIN_INFO_NAME: val = "LSA_TRUSTED_DOMAIN_INFO_NAME"; break;
2592                 case LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS_INFO: val = "LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS_INFO"; break;
2593                 case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET: val = "LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET"; break;
2594                 case LSA_TRUSTED_DOMAIN_INFO_PASSWORD: val = "LSA_TRUSTED_DOMAIN_INFO_PASSWORD"; break;
2595                 case LSA_TRUSTED_DOMAIN_INFO_BASIC: val = "LSA_TRUSTED_DOMAIN_INFO_BASIC"; break;
2596                 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX: val = "LSA_TRUSTED_DOMAIN_INFO_INFO_EX"; break;
2597                 case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO: val = "LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO"; break;
2598                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO: val = "LSA_TRUSTED_DOMAIN_INFO_FULL_INFO"; break;
2599                 case LSA_TRUSTED_DOMAIN_INFO_11: val = "LSA_TRUSTED_DOMAIN_INFO_11"; break;
2600                 case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL: val = "LSA_TRUSTED_DOMAIN_INFO_INFO_ALL"; break;
2601         }
2602         ndr_print_enum(ndr, name, "ENUM", val, r);
2603 }
2604
2605 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoName(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoName *r)
2606 {
2607         if (ndr_flags & NDR_SCALARS) {
2608                 NDR_CHECK(ndr_push_align(ndr, 4));
2609                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2610         }
2611         if (ndr_flags & NDR_BUFFERS) {
2612                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2613         }
2614         return NDR_ERR_SUCCESS;
2615 }
2616
2617 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoName(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoName *r)
2618 {
2619         if (ndr_flags & NDR_SCALARS) {
2620                 NDR_CHECK(ndr_pull_align(ndr, 4));
2621                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2622         }
2623         if (ndr_flags & NDR_BUFFERS) {
2624                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2625         }
2626         return NDR_ERR_SUCCESS;
2627 }
2628
2629 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoName(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoName *r)
2630 {
2631         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoName");
2632         ndr->depth++;
2633         ndr_print_lsa_StringLarge(ndr, "netbios_name", &r->netbios_name);
2634         ndr->depth--;
2635 }
2636
2637 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoPosixOffset(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoPosixOffset *r)
2638 {
2639         if (ndr_flags & NDR_SCALARS) {
2640                 NDR_CHECK(ndr_push_align(ndr, 4));
2641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->posix_offset));
2642         }
2643         if (ndr_flags & NDR_BUFFERS) {
2644         }
2645         return NDR_ERR_SUCCESS;
2646 }
2647
2648 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoPosixOffset(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoPosixOffset *r)
2649 {
2650         if (ndr_flags & NDR_SCALARS) {
2651                 NDR_CHECK(ndr_pull_align(ndr, 4));
2652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->posix_offset));
2653         }
2654         if (ndr_flags & NDR_BUFFERS) {
2655         }
2656         return NDR_ERR_SUCCESS;
2657 }
2658
2659 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoPosixOffset(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoPosixOffset *r)
2660 {
2661         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoPosixOffset");
2662         ndr->depth++;
2663         ndr_print_uint32(ndr, "posix_offset", r->posix_offset);
2664         ndr->depth--;
2665 }
2666
2667 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoPassword(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoPassword *r)
2668 {
2669         if (ndr_flags & NDR_SCALARS) {
2670                 NDR_CHECK(ndr_push_align(ndr, 4));
2671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
2672                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->old_password));
2673         }
2674         if (ndr_flags & NDR_BUFFERS) {
2675                 if (r->password) {
2676                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->password));
2677                 }
2678                 if (r->old_password) {
2679                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->old_password));
2680                 }
2681         }
2682         return NDR_ERR_SUCCESS;
2683 }
2684
2685 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoPassword(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoPassword *r)
2686 {
2687         uint32_t _ptr_password;
2688         TALLOC_CTX *_mem_save_password_0;
2689         uint32_t _ptr_old_password;
2690         TALLOC_CTX *_mem_save_old_password_0;
2691         if (ndr_flags & NDR_SCALARS) {
2692                 NDR_CHECK(ndr_pull_align(ndr, 4));
2693                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
2694                 if (_ptr_password) {
2695                         NDR_PULL_ALLOC(ndr, r->password);
2696                 } else {
2697                         r->password = NULL;
2698                 }
2699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_password));
2700                 if (_ptr_old_password) {
2701                         NDR_PULL_ALLOC(ndr, r->old_password);
2702                 } else {
2703                         r->old_password = NULL;
2704                 }
2705         }
2706         if (ndr_flags & NDR_BUFFERS) {
2707                 if (r->password) {
2708                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
2709                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
2710                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->password));
2711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
2712                 }
2713                 if (r->old_password) {
2714                         _mem_save_old_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
2715                         NDR_PULL_SET_MEM_CTX(ndr, r->old_password, 0);
2716                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->old_password));
2717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_password_0, 0);
2718                 }
2719         }
2720         return NDR_ERR_SUCCESS;
2721 }
2722
2723 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoPassword(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoPassword *r)
2724 {
2725         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoPassword");
2726         ndr->depth++;
2727         ndr_print_ptr(ndr, "password", r->password);
2728         ndr->depth++;
2729         if (r->password) {
2730                 ndr_print_lsa_DATA_BUF(ndr, "password", r->password);
2731         }
2732         ndr->depth--;
2733         ndr_print_ptr(ndr, "old_password", r->old_password);
2734         ndr->depth++;
2735         if (r->old_password) {
2736                 ndr_print_lsa_DATA_BUF(ndr, "old_password", r->old_password);
2737         }
2738         ndr->depth--;
2739         ndr->depth--;
2740 }
2741
2742 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoBasic(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoBasic *r)
2743 {
2744         if (ndr_flags & NDR_SCALARS) {
2745                 NDR_CHECK(ndr_push_align(ndr, 4));
2746                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->netbios_name));
2747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2748         }
2749         if (ndr_flags & NDR_BUFFERS) {
2750                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->netbios_name));
2751                 if (r->sid) {
2752                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2753                 }
2754         }
2755         return NDR_ERR_SUCCESS;
2756 }
2757
2758 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoBasic(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoBasic *r)
2759 {
2760         uint32_t _ptr_sid;
2761         TALLOC_CTX *_mem_save_sid_0;
2762         if (ndr_flags & NDR_SCALARS) {
2763                 NDR_CHECK(ndr_pull_align(ndr, 4));
2764                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->netbios_name));
2765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2766                 if (_ptr_sid) {
2767                         NDR_PULL_ALLOC(ndr, r->sid);
2768                 } else {
2769                         r->sid = NULL;
2770                 }
2771         }
2772         if (ndr_flags & NDR_BUFFERS) {
2773                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->netbios_name));
2774                 if (r->sid) {
2775                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2776                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2777                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2778                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2779                 }
2780         }
2781         return NDR_ERR_SUCCESS;
2782 }
2783
2784 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoBasic(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoBasic *r)
2785 {
2786         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoBasic");
2787         ndr->depth++;
2788         ndr_print_lsa_String(ndr, "netbios_name", &r->netbios_name);
2789         ndr_print_ptr(ndr, "sid", r->sid);
2790         ndr->depth++;
2791         if (r->sid) {
2792                 ndr_print_dom_sid2(ndr, "sid", r->sid);
2793         }
2794         ndr->depth--;
2795         ndr->depth--;
2796 }
2797
2798 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoInfoEx(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoInfoEx *r)
2799 {
2800         if (ndr_flags & NDR_SCALARS) {
2801                 NDR_CHECK(ndr_push_align(ndr, 4));
2802                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->domain_name));
2803                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->trust_direction));
2806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->trust_type));
2807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->trust_attributes));
2808         }
2809         if (ndr_flags & NDR_BUFFERS) {
2810                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domain_name));
2811                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2812                 if (r->sid) {
2813                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2814                 }
2815         }
2816         return NDR_ERR_SUCCESS;
2817 }
2818
2819 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoInfoEx(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoInfoEx *r)
2820 {
2821         uint32_t _ptr_sid;
2822         TALLOC_CTX *_mem_save_sid_0;
2823         if (ndr_flags & NDR_SCALARS) {
2824                 NDR_CHECK(ndr_pull_align(ndr, 4));
2825                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->domain_name));
2826                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2828                 if (_ptr_sid) {
2829                         NDR_PULL_ALLOC(ndr, r->sid);
2830                 } else {
2831                         r->sid = NULL;
2832                 }
2833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->trust_direction));
2834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->trust_type));
2835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->trust_attributes));
2836         }
2837         if (ndr_flags & NDR_BUFFERS) {
2838                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domain_name));
2839                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2840                 if (r->sid) {
2841                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2842                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2843                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2845                 }
2846         }
2847         return NDR_ERR_SUCCESS;
2848 }
2849
2850 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoInfoEx(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoInfoEx *r)
2851 {
2852         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoInfoEx");
2853         ndr->depth++;
2854         ndr_print_lsa_StringLarge(ndr, "domain_name", &r->domain_name);
2855         ndr_print_lsa_StringLarge(ndr, "netbios_name", &r->netbios_name);
2856         ndr_print_ptr(ndr, "sid", r->sid);
2857         ndr->depth++;
2858         if (r->sid) {
2859                 ndr_print_dom_sid2(ndr, "sid", r->sid);
2860         }
2861         ndr->depth--;
2862         ndr_print_uint32(ndr, "trust_direction", r->trust_direction);
2863         ndr_print_uint32(ndr, "trust_type", r->trust_type);
2864         ndr_print_uint32(ndr, "trust_attributes", r->trust_attributes);
2865         ndr->depth--;
2866 }
2867
2868 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoBuffer(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoBuffer *r)
2869 {
2870         if (ndr_flags & NDR_SCALARS) {
2871                 NDR_CHECK(ndr_push_align(ndr, 8));
2872                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_update_time));
2873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secret_type));
2874                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data));
2875         }
2876         if (ndr_flags & NDR_BUFFERS) {
2877                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data));
2878         }
2879         return NDR_ERR_SUCCESS;
2880 }
2881
2882 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoBuffer(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoBuffer *r)
2883 {
2884         if (ndr_flags & NDR_SCALARS) {
2885                 NDR_CHECK(ndr_pull_align(ndr, 8));
2886                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_update_time));
2887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secret_type));
2888                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data));
2889         }
2890         if (ndr_flags & NDR_BUFFERS) {
2891                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data));
2892         }
2893         return NDR_ERR_SUCCESS;
2894 }
2895
2896 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoBuffer(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoBuffer *r)
2897 {
2898         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoBuffer");
2899         ndr->depth++;
2900         ndr_print_NTTIME_hyper(ndr, "last_update_time", r->last_update_time);
2901         ndr_print_uint32(ndr, "secret_type", r->secret_type);
2902         ndr_print_lsa_DATA_BUF2(ndr, "data", &r->data);
2903         ndr->depth--;
2904 }
2905
2906 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoAuthInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoAuthInfo *r)
2907 {
2908         if (ndr_flags & NDR_SCALARS) {
2909                 NDR_CHECK(ndr_push_align(ndr, 4));
2910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->incoming_count));
2911                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->incoming_current_auth_info));
2912                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->incoming_previous_auth_info));
2913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->outgoing_count));
2914                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->outgoing_current_auth_info));
2915                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->outgoing_previous_auth_info));
2916         }
2917         if (ndr_flags & NDR_BUFFERS) {
2918                 if (r->incoming_current_auth_info) {
2919                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_current_auth_info));
2920                 }
2921                 if (r->incoming_previous_auth_info) {
2922                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_previous_auth_info));
2923                 }
2924                 if (r->outgoing_current_auth_info) {
2925                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_current_auth_info));
2926                 }
2927                 if (r->outgoing_previous_auth_info) {
2928                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_previous_auth_info));
2929                 }
2930         }
2931         return NDR_ERR_SUCCESS;
2932 }
2933
2934 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoAuthInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoAuthInfo *r)
2935 {
2936         uint32_t _ptr_incoming_current_auth_info;
2937         TALLOC_CTX *_mem_save_incoming_current_auth_info_0;
2938         uint32_t _ptr_incoming_previous_auth_info;
2939         TALLOC_CTX *_mem_save_incoming_previous_auth_info_0;
2940         uint32_t _ptr_outgoing_current_auth_info;
2941         TALLOC_CTX *_mem_save_outgoing_current_auth_info_0;
2942         uint32_t _ptr_outgoing_previous_auth_info;
2943         TALLOC_CTX *_mem_save_outgoing_previous_auth_info_0;
2944         if (ndr_flags & NDR_SCALARS) {
2945                 NDR_CHECK(ndr_pull_align(ndr, 4));
2946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->incoming_count));
2947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_incoming_current_auth_info));
2948                 if (_ptr_incoming_current_auth_info) {
2949                         NDR_PULL_ALLOC(ndr, r->incoming_current_auth_info);
2950                 } else {
2951                         r->incoming_current_auth_info = NULL;
2952                 }
2953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_incoming_previous_auth_info));
2954                 if (_ptr_incoming_previous_auth_info) {
2955                         NDR_PULL_ALLOC(ndr, r->incoming_previous_auth_info);
2956                 } else {
2957                         r->incoming_previous_auth_info = NULL;
2958                 }
2959                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->outgoing_count));
2960                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_outgoing_current_auth_info));
2961                 if (_ptr_outgoing_current_auth_info) {
2962                         NDR_PULL_ALLOC(ndr, r->outgoing_current_auth_info);
2963                 } else {
2964                         r->outgoing_current_auth_info = NULL;
2965                 }
2966                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_outgoing_previous_auth_info));
2967                 if (_ptr_outgoing_previous_auth_info) {
2968                         NDR_PULL_ALLOC(ndr, r->outgoing_previous_auth_info);
2969                 } else {
2970                         r->outgoing_previous_auth_info = NULL;
2971                 }
2972         }
2973         if (ndr_flags & NDR_BUFFERS) {
2974                 if (r->incoming_current_auth_info) {
2975                         _mem_save_incoming_current_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2976                         NDR_PULL_SET_MEM_CTX(ndr, r->incoming_current_auth_info, 0);
2977                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_current_auth_info));
2978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_incoming_current_auth_info_0, 0);
2979                 }
2980                 if (r->incoming_previous_auth_info) {
2981                         _mem_save_incoming_previous_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2982                         NDR_PULL_SET_MEM_CTX(ndr, r->incoming_previous_auth_info, 0);
2983                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_previous_auth_info));
2984                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_incoming_previous_auth_info_0, 0);
2985                 }
2986                 if (r->outgoing_current_auth_info) {
2987                         _mem_save_outgoing_current_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2988                         NDR_PULL_SET_MEM_CTX(ndr, r->outgoing_current_auth_info, 0);
2989                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_current_auth_info));
2990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_outgoing_current_auth_info_0, 0);
2991                 }
2992                 if (r->outgoing_previous_auth_info) {
2993                         _mem_save_outgoing_previous_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2994                         NDR_PULL_SET_MEM_CTX(ndr, r->outgoing_previous_auth_info, 0);
2995                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_previous_auth_info));
2996                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_outgoing_previous_auth_info_0, 0);
2997                 }
2998         }
2999         return NDR_ERR_SUCCESS;
3000 }
3001
3002 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoAuthInfo(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoAuthInfo *r)
3003 {
3004         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoAuthInfo");
3005         ndr->depth++;
3006         ndr_print_uint32(ndr, "incoming_count", r->incoming_count);
3007         ndr_print_ptr(ndr, "incoming_current_auth_info", r->incoming_current_auth_info);
3008         ndr->depth++;
3009         if (r->incoming_current_auth_info) {
3010                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "incoming_current_auth_info", r->incoming_current_auth_info);
3011         }
3012         ndr->depth--;
3013         ndr_print_ptr(ndr, "incoming_previous_auth_info", r->incoming_previous_auth_info);
3014         ndr->depth++;
3015         if (r->incoming_previous_auth_info) {
3016                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "incoming_previous_auth_info", r->incoming_previous_auth_info);
3017         }
3018         ndr->depth--;
3019         ndr_print_uint32(ndr, "outgoing_count", r->outgoing_count);
3020         ndr_print_ptr(ndr, "outgoing_current_auth_info", r->outgoing_current_auth_info);
3021         ndr->depth++;
3022         if (r->outgoing_current_auth_info) {
3023                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "outgoing_current_auth_info", r->outgoing_current_auth_info);
3024         }
3025         ndr->depth--;
3026         ndr_print_ptr(ndr, "outgoing_previous_auth_info", r->outgoing_previous_auth_info);
3027         ndr->depth++;
3028         if (r->outgoing_previous_auth_info) {
3029                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "outgoing_previous_auth_info", r->outgoing_previous_auth_info);
3030         }
3031         ndr->depth--;
3032         ndr->depth--;
3033 }
3034
3035 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoFullInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoFullInfo *r)
3036 {
3037         if (ndr_flags & NDR_SCALARS) {
3038                 NDR_CHECK(ndr_push_align(ndr, 4));
3039                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3040                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3041                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3042         }
3043         if (ndr_flags & NDR_BUFFERS) {
3044                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3045                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3046         }
3047         return NDR_ERR_SUCCESS;
3048 }
3049
3050 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoFullInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoFullInfo *r)
3051 {
3052         if (ndr_flags & NDR_SCALARS) {
3053                 NDR_CHECK(ndr_pull_align(ndr, 4));
3054                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3055                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3056                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3057         }
3058         if (ndr_flags & NDR_BUFFERS) {
3059                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3060                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3061         }
3062         return NDR_ERR_SUCCESS;
3063 }
3064
3065 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoFullInfo(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoFullInfo *r)
3066 {
3067         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoFullInfo");
3068         ndr->depth++;
3069         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
3070         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
3071         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
3072         ndr->depth--;
3073 }
3074
3075 static enum ndr_err_code ndr_push_lsa_TrustDomainInfo11(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfo11 *r)
3076 {
3077         if (ndr_flags & NDR_SCALARS) {
3078                 NDR_CHECK(ndr_push_align(ndr, 4));
3079                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3080                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
3081         }
3082         if (ndr_flags & NDR_BUFFERS) {
3083                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3084                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
3085         }
3086         return NDR_ERR_SUCCESS;
3087 }
3088
3089 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfo11(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfo11 *r)
3090 {
3091         if (ndr_flags & NDR_SCALARS) {
3092                 NDR_CHECK(ndr_pull_align(ndr, 4));
3093                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3094                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
3095         }
3096         if (ndr_flags & NDR_BUFFERS) {
3097                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3098                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
3099         }
3100         return NDR_ERR_SUCCESS;
3101 }
3102
3103 _PUBLIC_ void ndr_print_lsa_TrustDomainInfo11(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfo11 *r)
3104 {
3105         ndr_print_struct(ndr, name, "lsa_TrustDomainInfo11");
3106         ndr->depth++;
3107         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
3108         ndr_print_lsa_DATA_BUF2(ndr, "data1", &r->data1);
3109         ndr->depth--;
3110 }
3111
3112 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoInfoAll(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoInfoAll *r)
3113 {
3114         if (ndr_flags & NDR_SCALARS) {
3115                 NDR_CHECK(ndr_push_align(ndr, 4));
3116                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3117                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
3118                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3119                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3120         }
3121         if (ndr_flags & NDR_BUFFERS) {
3122                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3123                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
3124                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3125         }
3126         return NDR_ERR_SUCCESS;
3127 }
3128
3129 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoInfoAll(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoInfoAll *r)
3130 {
3131         if (ndr_flags & NDR_SCALARS) {
3132                 NDR_CHECK(ndr_pull_align(ndr, 4));
3133                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3134                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
3135                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3136                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3137         }
3138         if (ndr_flags & NDR_BUFFERS) {
3139                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3140                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
3141                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3142         }
3143         return NDR_ERR_SUCCESS;
3144 }
3145
3146 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoInfoAll(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoInfoAll *r)
3147 {
3148         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoInfoAll");
3149         ndr->depth++;
3150         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
3151         ndr_print_lsa_DATA_BUF2(ndr, "data1", &r->data1);
3152         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
3153         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
3154         ndr->depth--;
3155 }
3156
3157 static enum ndr_err_code ndr_push_lsa_TrustedDomainInfo(struct ndr_push *ndr, int ndr_flags, const union lsa_TrustedDomainInfo *r)
3158 {
3159         if (ndr_flags & NDR_SCALARS) {
3160                 int level = ndr_push_get_switch_value(ndr, r);
3161                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, level));
3162                 switch (level) {
3163                         case LSA_TRUSTED_DOMAIN_INFO_NAME: {
3164                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoName(ndr, NDR_SCALARS, &r->name));
3165                         break; }
3166
3167                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET: {
3168                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3169                         break; }
3170
3171                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD: {
3172                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPassword(ndr, NDR_SCALARS, &r->password));
3173                         break; }
3174
3175                         case LSA_TRUSTED_DOMAIN_INFO_BASIC: {
3176                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoBasic(ndr, NDR_SCALARS, &r->info_basic));
3177                         break; }
3178
3179                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX: {
3180                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3181                         break; }
3182
3183                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO: {
3184                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3185                         break; }
3186
3187                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO: {
3188                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfo(ndr, NDR_SCALARS, &r->full_info));
3189                         break; }
3190
3191                         case LSA_TRUSTED_DOMAIN_INFO_11: {
3192                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfo11(ndr, NDR_SCALARS, &r->info11));
3193                         break; }
3194
3195                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL: {
3196                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoAll(ndr, NDR_SCALARS, &r->info_all));
3197                         break; }
3198
3199                         default:
3200                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3201                 }
3202         }
3203         if (ndr_flags & NDR_BUFFERS) {
3204                 int level = ndr_push_get_switch_value(ndr, r);
3205                 switch (level) {
3206                         case LSA_TRUSTED_DOMAIN_INFO_NAME:
3207                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoName(ndr, NDR_BUFFERS, &r->name));
3208                         break;
3209
3210                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
3211                         break;
3212
3213                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
3214                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPassword(ndr, NDR_BUFFERS, &r->password));
3215                         break;
3216
3217                         case LSA_TRUSTED_DOMAIN_INFO_BASIC:
3218                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoBasic(ndr, NDR_BUFFERS, &r->info_basic));
3219                         break;
3220
3221                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
3222                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3223                         break;
3224
3225                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
3226                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3227                         break;
3228
3229                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
3230                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfo(ndr, NDR_BUFFERS, &r->full_info));
3231                         break;
3232
3233                         case LSA_TRUSTED_DOMAIN_INFO_11:
3234                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfo11(ndr, NDR_BUFFERS, &r->info11));
3235                         break;
3236
3237                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL:
3238                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoAll(ndr, NDR_BUFFERS, &r->info_all));
3239                         break;
3240
3241                         default:
3242                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3243                 }
3244         }
3245         return NDR_ERR_SUCCESS;
3246 }
3247
3248 static enum ndr_err_code ndr_pull_lsa_TrustedDomainInfo(struct ndr_pull *ndr, int ndr_flags, union lsa_TrustedDomainInfo *r)
3249 {
3250         int level;
3251         uint16_t _level;
3252         level = ndr_pull_get_switch_value(ndr, r);
3253         if (ndr_flags & NDR_SCALARS) {
3254                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3255                 if (_level != level) {
3256                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3257                 }
3258                 switch (level) {
3259                         case LSA_TRUSTED_DOMAIN_INFO_NAME: {
3260                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoName(ndr, NDR_SCALARS, &r->name));
3261                         break; }
3262
3263                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET: {
3264                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3265                         break; }
3266
3267                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD: {
3268                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPassword(ndr, NDR_SCALARS, &r->password));
3269                         break; }
3270
3271                         case LSA_TRUSTED_DOMAIN_INFO_BASIC: {
3272                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBasic(ndr, NDR_SCALARS, &r->info_basic));
3273                         break; }
3274
3275                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX: {
3276                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3277                         break; }
3278
3279                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO: {
3280                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3281                         break; }
3282
3283                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO: {
3284                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfo(ndr, NDR_SCALARS, &r->full_info));
3285                         break; }
3286
3287                         case LSA_TRUSTED_DOMAIN_INFO_11: {
3288                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfo11(ndr, NDR_SCALARS, &r->info11));
3289                         break; }
3290
3291                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL: {
3292                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoAll(ndr, NDR_SCALARS, &r->info_all));
3293                         break; }
3294
3295                         default:
3296                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3297                 }
3298         }
3299         if (ndr_flags & NDR_BUFFERS) {
3300                 switch (level) {
3301                         case LSA_TRUSTED_DOMAIN_INFO_NAME:
3302                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoName(ndr, NDR_BUFFERS, &r->name));
3303                         break;
3304
3305                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
3306                         break;
3307
3308                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
3309                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPassword(ndr, NDR_BUFFERS, &r->password));
3310                         break;
3311
3312                         case LSA_TRUSTED_DOMAIN_INFO_BASIC:
3313                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBasic(ndr, NDR_BUFFERS, &r->info_basic));
3314                         break;
3315
3316                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
3317                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3318                         break;
3319
3320                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
3321                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3322                         break;
3323
3324                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
3325                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfo(ndr, NDR_BUFFERS, &r->full_info));
3326                         break;
3327
3328                         case LSA_TRUSTED_DOMAIN_INFO_11:
3329                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfo11(ndr, NDR_BUFFERS, &r->info11));
3330                         break;
3331
3332                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL:
3333                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoAll(ndr, NDR_BUFFERS, &r->info_all));
3334                         break;
3335
3336                         default:
3337                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3338                 }
3339         }
3340         return NDR_ERR_SUCCESS;
3341 }
3342
3343 _PUBLIC_ void ndr_print_lsa_TrustedDomainInfo(struct ndr_print *ndr, const char *name, const union lsa_TrustedDomainInfo *r)
3344 {
3345         int level;
3346         level = ndr_print_get_switch_value(ndr, r);
3347         ndr_print_union(ndr, name, level, "lsa_TrustedDomainInfo");
3348         switch (level) {
3349                 case LSA_TRUSTED_DOMAIN_INFO_NAME:
3350                         ndr_print_lsa_TrustDomainInfoName(ndr, "name", &r->name);
3351                 break;
3352
3353                 case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
3354                         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
3355                 break;
3356
3357                 case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
3358                         ndr_print_lsa_TrustDomainInfoPassword(ndr, "password", &r->password);
3359                 break;
3360
3361                 case LSA_TRUSTED_DOMAIN_INFO_BASIC:
3362                         ndr_print_lsa_TrustDomainInfoBasic(ndr, "info_basic", &r->info_basic);
3363                 break;
3364
3365                 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
3366                         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
3367                 break;
3368
3369                 case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
3370                         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
3371                 break;
3372
3373                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
3374                         ndr_print_lsa_TrustDomainInfoFullInfo(ndr, "full_info", &r->full_info);
3375                 break;
3376
3377                 case LSA_TRUSTED_DOMAIN_INFO_11:
3378                         ndr_print_lsa_TrustDomainInfo11(ndr, "info11", &r->info11);
3379                 break;
3380
3381                 case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL:
3382                         ndr_print_lsa_TrustDomainInfoInfoAll(ndr, "info_all", &r->info_all);
3383                 break;
3384
3385                 default:
3386                         ndr_print_bad_level(ndr, name, level);
3387         }
3388 }
3389
3390 static enum ndr_err_code ndr_push_lsa_DATA_BUF_PTR(struct ndr_push *ndr, int ndr_flags, const struct lsa_DATA_BUF_PTR *r)
3391 {
3392         if (ndr_flags & NDR_SCALARS) {
3393                 NDR_CHECK(ndr_push_align(ndr, 4));
3394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->buf));
3395         }
3396         if (ndr_flags & NDR_BUFFERS) {
3397                 if (r->buf) {
3398                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->buf));
3399                 }
3400         }
3401         return NDR_ERR_SUCCESS;
3402 }
3403
3404 static enum ndr_err_code ndr_pull_lsa_DATA_BUF_PTR(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF_PTR *r)
3405 {
3406         uint32_t _ptr_buf;
3407         TALLOC_CTX *_mem_save_buf_0;
3408         if (ndr_flags & NDR_SCALARS) {
3409                 NDR_CHECK(ndr_pull_align(ndr, 4));
3410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buf));
3411                 if (_ptr_buf) {
3412                         NDR_PULL_ALLOC(ndr, r->buf);
3413                 } else {
3414                         r->buf = NULL;
3415                 }
3416         }
3417         if (ndr_flags & NDR_BUFFERS) {
3418                 if (r->buf) {
3419                         _mem_save_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);
3420                         NDR_PULL_SET_MEM_CTX(ndr, r->buf, 0);
3421                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->buf));
3422                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buf_0, 0);
3423                 }
3424         }
3425         return NDR_ERR_SUCCESS;
3426 }
3427
3428 _PUBLIC_ void ndr_print_lsa_DATA_BUF_PTR(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF_PTR *r)
3429 {
3430         ndr_print_struct(ndr, name, "lsa_DATA_BUF_PTR");
3431         ndr->depth++;
3432         ndr_print_ptr(ndr, "buf", r->buf);
3433         ndr->depth++;
3434         if (r->buf) {
3435                 ndr_print_lsa_DATA_BUF(ndr, "buf", r->buf);
3436         }
3437         ndr->depth--;
3438         ndr->depth--;
3439 }
3440
3441 static enum ndr_err_code ndr_push_lsa_RightSet(struct ndr_push *ndr, int ndr_flags, const struct lsa_RightSet *r)
3442 {
3443         uint32_t cntr_names_1;
3444         if (ndr_flags & NDR_SCALARS) {
3445                 NDR_CHECK(ndr_push_align(ndr, 4));
3446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3447                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
3448         }
3449         if (ndr_flags & NDR_BUFFERS) {
3450                 if (r->names) {
3451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3452                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3453                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3454                         }
3455                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3456                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3457                         }
3458                 }
3459         }
3460         return NDR_ERR_SUCCESS;
3461 }
3462
3463 static enum ndr_err_code ndr_pull_lsa_RightSet(struct ndr_pull *ndr, int ndr_flags, struct lsa_RightSet *r)
3464 {
3465         uint32_t _ptr_names;
3466         uint32_t cntr_names_1;
3467         TALLOC_CTX *_mem_save_names_0;
3468         TALLOC_CTX *_mem_save_names_1;
3469         if (ndr_flags & NDR_SCALARS) {
3470                 NDR_CHECK(ndr_pull_align(ndr, 4));
3471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3472                 if (r->count < 0 || r->count > 256) {
3473                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3474                 }
3475                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
3476                 if (_ptr_names) {
3477                         NDR_PULL_ALLOC(ndr, r->names);
3478                 } else {
3479                         r->names = NULL;
3480                 }
3481         }
3482         if (ndr_flags & NDR_BUFFERS) {
3483                 if (r->names) {
3484                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
3485                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
3487                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
3488                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
3489                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3490                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3491                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3492                         }
3493                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3494                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3495                         }
3496                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
3497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
3498                 }
3499                 if (r->names) {
3500                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
3501                 }
3502         }
3503         return NDR_ERR_SUCCESS;
3504 }
3505
3506 _PUBLIC_ void ndr_print_lsa_RightSet(struct ndr_print *ndr, const char *name, const struct lsa_RightSet *r)
3507 {
3508         uint32_t cntr_names_1;
3509         ndr_print_struct(ndr, name, "lsa_RightSet");
3510         ndr->depth++;
3511         ndr_print_uint32(ndr, "count", r->count);
3512         ndr_print_ptr(ndr, "names", r->names);
3513         ndr->depth++;
3514         if (r->names) {
3515                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->count);
3516                 ndr->depth++;
3517                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
3518                         char *idx_1=NULL;
3519                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
3520                                 ndr_print_lsa_StringLarge(ndr, "names", &r->names[cntr_names_1]);
3521                                 free(idx_1);
3522                         }
3523                 }
3524                 ndr->depth--;
3525         }
3526         ndr->depth--;
3527         ndr->depth--;
3528 }
3529
3530 static enum ndr_err_code ndr_push_lsa_DomainListEx(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainListEx *r)
3531 {
3532         uint32_t cntr_domains_1;
3533         if (ndr_flags & NDR_SCALARS) {
3534                 NDR_CHECK(ndr_push_align(ndr, 4));
3535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3536                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
3537         }
3538         if (ndr_flags & NDR_BUFFERS) {
3539                 if (r->domains) {
3540                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3541                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3542                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
3543                         }
3544                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3545                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
3546                         }
3547                 }
3548         }
3549         return NDR_ERR_SUCCESS;
3550 }
3551
3552 static enum ndr_err_code ndr_pull_lsa_DomainListEx(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainListEx *r)
3553 {
3554         uint32_t _ptr_domains;
3555         uint32_t cntr_domains_1;
3556         TALLOC_CTX *_mem_save_domains_0;
3557         TALLOC_CTX *_mem_save_domains_1;
3558         if (ndr_flags & NDR_SCALARS) {
3559                 NDR_CHECK(ndr_pull_align(ndr, 4));
3560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
3562                 if (_ptr_domains) {
3563                         NDR_PULL_ALLOC(ndr, r->domains);
3564                 } else {
3565                         r->domains = NULL;
3566                 }
3567         }
3568         if (ndr_flags & NDR_BUFFERS) {
3569                 if (r->domains) {
3570                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3571                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
3572                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
3573                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
3574                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
3575                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
3576                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3577                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
3578                         }
3579                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3580                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
3581                         }
3582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
3583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
3584                 }
3585                 if (r->domains) {
3586                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
3587                 }
3588         }
3589         return NDR_ERR_SUCCESS;
3590 }
3591
3592 _PUBLIC_ void ndr_print_lsa_DomainListEx(struct ndr_print *ndr, const char *name, const struct lsa_DomainListEx *r)
3593 {
3594         uint32_t cntr_domains_1;
3595         ndr_print_struct(ndr, name, "lsa_DomainListEx");
3596         ndr->depth++;
3597         ndr_print_uint32(ndr, "count", r->count);
3598         ndr_print_ptr(ndr, "domains", r->domains);
3599         ndr->depth++;
3600         if (r->domains) {
3601                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", r->count);
3602                 ndr->depth++;
3603                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
3604                         char *idx_1=NULL;
3605                         if (asprintf(&idx_1, "[%d]", cntr_domains_1) != -1) {
3606                                 ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "domains", &r->domains[cntr_domains_1]);
3607                                 free(idx_1);
3608                         }
3609                 }
3610                 ndr->depth--;
3611         }
3612         ndr->depth--;
3613         ndr->depth--;
3614 }
3615
3616 static enum ndr_err_code ndr_push_lsa_DomainInfoKerberos(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfoKerberos *r)
3617 {
3618         if (ndr_flags & NDR_SCALARS) {
3619                 NDR_CHECK(ndr_push_align(ndr, 8));
3620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enforce_restrictions));
3621                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->service_tkt_lifetime));
3622                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->user_tkt_lifetime));
3623                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->user_tkt_renewaltime));
3624                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->clock_skew));
3625                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown6));
3626         }
3627         if (ndr_flags & NDR_BUFFERS) {
3628         }
3629         return NDR_ERR_SUCCESS;
3630 }
3631
3632 static enum ndr_err_code ndr_pull_lsa_DomainInfoKerberos(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfoKerberos *r)
3633 {
3634         if (ndr_flags & NDR_SCALARS) {
3635                 NDR_CHECK(ndr_pull_align(ndr, 8));
3636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enforce_restrictions));
3637                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->service_tkt_lifetime));
3638                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->user_tkt_lifetime));
3639                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->user_tkt_renewaltime));
3640                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->clock_skew));
3641                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown6));
3642         }
3643         if (ndr_flags & NDR_BUFFERS) {
3644         }
3645         return NDR_ERR_SUCCESS;
3646 }
3647
3648 _PUBLIC_ void ndr_print_lsa_DomainInfoKerberos(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfoKerberos *r)
3649 {
3650         ndr_print_struct(ndr, name, "lsa_DomainInfoKerberos");
3651         ndr->depth++;
3652         ndr_print_uint32(ndr, "enforce_restrictions", r->enforce_restrictions);
3653         ndr_print_hyper(ndr, "service_tkt_lifetime", r->service_tkt_lifetime);
3654         ndr_print_hyper(ndr, "user_tkt_lifetime", r->user_tkt_lifetime);
3655         ndr_print_hyper(ndr, "user_tkt_renewaltime", r->user_tkt_renewaltime);
3656         ndr_print_hyper(ndr, "clock_skew", r->clock_skew);
3657         ndr_print_hyper(ndr, "unknown6", r->unknown6);
3658         ndr->depth--;
3659 }
3660
3661 static enum ndr_err_code ndr_push_lsa_DomainInfoEfs(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfoEfs *r)
3662 {
3663         if (ndr_flags & NDR_SCALARS) {
3664                 NDR_CHECK(ndr_push_align(ndr, 4));
3665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->blob_size));
3666                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->efs_blob));
3667         }
3668         if (ndr_flags & NDR_BUFFERS) {
3669                 if (r->efs_blob) {
3670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->blob_size));
3671                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->efs_blob, r->blob_size));
3672                 }
3673         }
3674         return NDR_ERR_SUCCESS;
3675 }
3676
3677 static enum ndr_err_code ndr_pull_lsa_DomainInfoEfs(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfoEfs *r)
3678 {
3679         uint32_t _ptr_efs_blob;
3680         TALLOC_CTX *_mem_save_efs_blob_0;
3681         if (ndr_flags & NDR_SCALARS) {
3682                 NDR_CHECK(ndr_pull_align(ndr, 4));
3683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->blob_size));
3684                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_efs_blob));
3685                 if (_ptr_efs_blob) {
3686                         NDR_PULL_ALLOC(ndr, r->efs_blob);
3687                 } else {
3688                         r->efs_blob = NULL;
3689                 }
3690         }
3691         if (ndr_flags & NDR_BUFFERS) {
3692                 if (r->efs_blob) {
3693                         _mem_save_efs_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
3694                         NDR_PULL_SET_MEM_CTX(ndr, r->efs_blob, 0);
3695                         NDR_CHECK(ndr_pull_array_size(ndr, &r->efs_blob));
3696                         NDR_PULL_ALLOC_N(ndr, r->efs_blob, ndr_get_array_size(ndr, &r->efs_blob));
3697                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->efs_blob, ndr_get_array_size(ndr, &r->efs_blob)));
3698                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_efs_blob_0, 0);
3699                 }
3700                 if (r->efs_blob) {
3701                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->efs_blob, r->blob_size));
3702                 }
3703         }
3704         return NDR_ERR_SUCCESS;
3705 }
3706
3707 _PUBLIC_ void ndr_print_lsa_DomainInfoEfs(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfoEfs *r)
3708 {
3709         ndr_print_struct(ndr, name, "lsa_DomainInfoEfs");
3710         ndr->depth++;
3711         ndr_print_uint32(ndr, "blob_size", r->blob_size);
3712         ndr_print_ptr(ndr, "efs_blob", r->efs_blob);
3713         ndr->depth++;
3714         if (r->efs_blob) {
3715                 ndr_print_array_uint8(ndr, "efs_blob", r->efs_blob, r->blob_size);
3716         }
3717         ndr->depth--;
3718         ndr->depth--;
3719 }
3720
3721 static enum ndr_err_code ndr_push_lsa_DomainInformationPolicy(struct ndr_push *ndr, int ndr_flags, const union lsa_DomainInformationPolicy *r)
3722 {
3723         if (ndr_flags & NDR_SCALARS) {
3724                 int level = ndr_push_get_switch_value(ndr, r);
3725                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
3726                 switch (level) {
3727                         case LSA_DOMAIN_INFO_POLICY_EFS: {
3728                                 NDR_CHECK(ndr_push_lsa_DomainInfoEfs(ndr, NDR_SCALARS, &r->efs_info));
3729                         break; }
3730
3731                         case LSA_DOMAIN_INFO_POLICY_KERBEROS: {
3732                                 NDR_CHECK(ndr_push_lsa_DomainInfoKerberos(ndr, NDR_SCALARS, &r->kerberos_info));
3733                         break; }
3734
3735                         default:
3736                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3737                 }
3738         }
3739         if (ndr_flags & NDR_BUFFERS) {
3740                 int level = ndr_push_get_switch_value(ndr, r);
3741                 switch (level) {
3742                         case LSA_DOMAIN_INFO_POLICY_EFS:
3743                                 NDR_CHECK(ndr_push_lsa_DomainInfoEfs(ndr, NDR_BUFFERS, &r->efs_info));
3744                         break;
3745
3746                         case LSA_DOMAIN_INFO_POLICY_KERBEROS:
3747                         break;
3748
3749                         default:
3750                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3751                 }
3752         }
3753         return NDR_ERR_SUCCESS;
3754 }
3755
3756 static enum ndr_err_code ndr_pull_lsa_DomainInformationPolicy(struct ndr_pull *ndr, int ndr_flags, union lsa_DomainInformationPolicy *r)
3757 {
3758         int level;
3759         uint16_t _level;
3760         level = ndr_pull_get_switch_value(ndr, r);
3761         if (ndr_flags & NDR_SCALARS) {
3762                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3763                 if (_level != level) {
3764                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3765                 }
3766                 switch (level) {
3767                         case LSA_DOMAIN_INFO_POLICY_EFS: {
3768                                 NDR_CHECK(ndr_pull_lsa_DomainInfoEfs(ndr, NDR_SCALARS, &r->efs_info));
3769                         break; }
3770
3771                         case LSA_DOMAIN_INFO_POLICY_KERBEROS: {
3772                                 NDR_CHECK(ndr_pull_lsa_DomainInfoKerberos(ndr, NDR_SCALARS, &r->kerberos_info));
3773                         break; }
3774
3775                         default:
3776                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3777                 }
3778         }
3779         if (ndr_flags & NDR_BUFFERS) {
3780                 switch (level) {
3781                         case LSA_DOMAIN_INFO_POLICY_EFS:
3782                                 NDR_CHECK(ndr_pull_lsa_DomainInfoEfs(ndr, NDR_BUFFERS, &r->efs_info));
3783                         break;
3784
3785                         case LSA_DOMAIN_INFO_POLICY_KERBEROS:
3786                         break;
3787
3788                         default:
3789                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3790                 }
3791         }
3792         return NDR_ERR_SUCCESS;
3793 }
3794
3795 _PUBLIC_ void ndr_print_lsa_DomainInformationPolicy(struct ndr_print *ndr, const char *name, const union lsa_DomainInformationPolicy *r)
3796 {
3797         int level;
3798         level = ndr_print_get_switch_value(ndr, r);
3799         ndr_print_union(ndr, name, level, "lsa_DomainInformationPolicy");
3800         switch (level) {
3801                 case LSA_DOMAIN_INFO_POLICY_EFS:
3802                         ndr_print_lsa_DomainInfoEfs(ndr, "efs_info", &r->efs_info);
3803                 break;
3804
3805                 case LSA_DOMAIN_INFO_POLICY_KERBEROS:
3806                         ndr_print_lsa_DomainInfoKerberos(ndr, "kerberos_info", &r->kerberos_info);
3807                 break;
3808
3809                 default:
3810                         ndr_print_bad_level(ndr, name, level);
3811         }
3812 }
3813
3814 static enum ndr_err_code ndr_push_lsa_TranslatedName2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedName2 *r)
3815 {
3816         if (ndr_flags & NDR_SCALARS) {
3817                 NDR_CHECK(ndr_push_align(ndr, 4));
3818                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
3819                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
3820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
3821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
3822         }
3823         if (ndr_flags & NDR_BUFFERS) {
3824                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
3825         }
3826         return NDR_ERR_SUCCESS;
3827 }
3828
3829 static enum ndr_err_code ndr_pull_lsa_TranslatedName2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedName2 *r)
3830 {
3831         if (ndr_flags & NDR_SCALARS) {
3832                 NDR_CHECK(ndr_pull_align(ndr, 4));
3833                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
3834                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
3835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
3836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
3837         }
3838         if (ndr_flags & NDR_BUFFERS) {
3839                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
3840         }
3841         return NDR_ERR_SUCCESS;
3842 }
3843
3844 _PUBLIC_ void ndr_print_lsa_TranslatedName2(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedName2 *r)
3845 {
3846         ndr_print_struct(ndr, name, "lsa_TranslatedName2");
3847         ndr->depth++;
3848         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
3849         ndr_print_lsa_String(ndr, "name", &r->name);
3850         ndr_print_uint32(ndr, "sid_index", r->sid_index);
3851         ndr_print_uint32(ndr, "unknown", r->unknown);
3852         ndr->depth--;
3853 }
3854
3855 static enum ndr_err_code ndr_push_lsa_TransNameArray2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransNameArray2 *r)
3856 {
3857         uint32_t cntr_names_1;
3858         if (ndr_flags & NDR_SCALARS) {
3859                 NDR_CHECK(ndr_push_align(ndr, 4));
3860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3861                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
3862         }
3863         if (ndr_flags & NDR_BUFFERS) {
3864                 if (r->names) {
3865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3866                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3867                                 NDR_CHECK(ndr_push_lsa_TranslatedName2(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3868                         }
3869                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3870                                 NDR_CHECK(ndr_push_lsa_TranslatedName2(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3871                         }
3872                 }
3873         }
3874         return NDR_ERR_SUCCESS;
3875 }
3876
3877 static enum ndr_err_code ndr_pull_lsa_TransNameArray2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransNameArray2 *r)
3878 {
3879         uint32_t _ptr_names;
3880         uint32_t cntr_names_1;
3881         TALLOC_CTX *_mem_save_names_0;
3882         TALLOC_CTX *_mem_save_names_1;
3883         if (ndr_flags & NDR_SCALARS) {
3884                 NDR_CHECK(ndr_pull_align(ndr, 4));
3885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3886                 if (r->count < 0 || r->count > 1000) {
3887                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3888                 }
3889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
3890                 if (_ptr_names) {
3891                         NDR_PULL_ALLOC(ndr, r->names);
3892                 } else {
3893                         r->names = NULL;
3894                 }
3895         }
3896         if (ndr_flags & NDR_BUFFERS) {
3897                 if (r->names) {
3898                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
3899                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3900                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
3901                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
3902                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
3903                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3904                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3905                                 NDR_CHECK(ndr_pull_lsa_TranslatedName2(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3906                         }
3907                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3908                                 NDR_CHECK(ndr_pull_lsa_TranslatedName2(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3909                         }
3910                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
3911                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
3912                 }
3913                 if (r->names) {
3914                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
3915                 }
3916         }
3917         return NDR_ERR_SUCCESS;
3918 }
3919
3920 _PUBLIC_ void ndr_print_lsa_TransNameArray2(struct ndr_print *ndr, const char *name, const struct lsa_TransNameArray2 *r)
3921 {
3922         uint32_t cntr_names_1;
3923         ndr_print_struct(ndr, name, "lsa_TransNameArray2");
3924         ndr->depth++;
3925         ndr_print_uint32(ndr, "count", r->count);
3926         ndr_print_ptr(ndr, "names", r->names);
3927         ndr->depth++;
3928         if (r->names) {
3929                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->count);
3930                 ndr->depth++;
3931                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
3932                         char *idx_1=NULL;
3933                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
3934                                 ndr_print_lsa_TranslatedName2(ndr, "names", &r->names[cntr_names_1]);
3935                                 free(idx_1);
3936                         }
3937                 }
3938                 ndr->depth--;
3939         }
3940         ndr->depth--;
3941         ndr->depth--;
3942 }
3943
3944 static enum ndr_err_code ndr_push_lsa_TranslatedSid2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid2 *r)
3945 {
3946         if (ndr_flags & NDR_SCALARS) {
3947                 NDR_CHECK(ndr_push_align(ndr, 4));
3948                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
3949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
3951                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
3952         }
3953         if (ndr_flags & NDR_BUFFERS) {
3954         }
3955         return NDR_ERR_SUCCESS;
3956 }
3957
3958 static enum ndr_err_code ndr_pull_lsa_TranslatedSid2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid2 *r)
3959 {
3960         if (ndr_flags & NDR_SCALARS) {
3961                 NDR_CHECK(ndr_pull_align(ndr, 4));
3962                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
3963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3964                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
3965                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
3966         }
3967         if (ndr_flags & NDR_BUFFERS) {
3968         }
3969         return NDR_ERR_SUCCESS;
3970 }
3971
3972 _PUBLIC_ void ndr_print_lsa_TranslatedSid2(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid2 *r)
3973 {
3974         ndr_print_struct(ndr, name, "lsa_TranslatedSid2");
3975         ndr->depth++;
3976         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
3977         ndr_print_uint32(ndr, "rid", r->rid);
3978         ndr_print_uint32(ndr, "sid_index", r->sid_index);
3979         ndr_print_uint32(ndr, "unknown", r->unknown);
3980         ndr->depth--;
3981 }
3982
3983 static enum ndr_err_code ndr_push_lsa_TransSidArray2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray2 *r)
3984 {
3985         uint32_t cntr_sids_1;
3986         if (ndr_flags & NDR_SCALARS) {
3987                 NDR_CHECK(ndr_push_align(ndr, 4));
3988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3989                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
3990         }
3991         if (ndr_flags & NDR_BUFFERS) {
3992                 if (r->sids) {
3993                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3994                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3995                                 NDR_CHECK(ndr_push_lsa_TranslatedSid2(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
3996                         }
3997                 }
3998         }
3999         return NDR_ERR_SUCCESS;
4000 }
4001
4002 static enum ndr_err_code ndr_pull_lsa_TransSidArray2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray2 *r)
4003 {
4004         uint32_t _ptr_sids;
4005         uint32_t cntr_sids_1;
4006         TALLOC_CTX *_mem_save_sids_0;
4007         TALLOC_CTX *_mem_save_sids_1;
4008         if (ndr_flags & NDR_SCALARS) {
4009                 NDR_CHECK(ndr_pull_align(ndr, 4));
4010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4011                 if (r->count < 0 || r->count > 1000) {
4012                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4013                 }
4014                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4015                 if (_ptr_sids) {
4016                         NDR_PULL_ALLOC(ndr, r->sids);
4017                 } else {
4018                         r->sids = NULL;
4019                 }
4020         }
4021         if (ndr_flags & NDR_BUFFERS) {
4022                 if (r->sids) {
4023                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4024                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4025                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4026                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4027                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4028                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4029                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
4030                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid2(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
4031                         }
4032                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4033                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4034                 }
4035                 if (r->sids) {
4036                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
4037                 }
4038         }
4039         return NDR_ERR_SUCCESS;
4040 }
4041
4042 _PUBLIC_ void ndr_print_lsa_TransSidArray2(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray2 *r)
4043 {
4044         uint32_t cntr_sids_1;
4045         ndr_print_struct(ndr, name, "lsa_TransSidArray2");
4046         ndr->depth++;
4047         ndr_print_uint32(ndr, "count", r->count);
4048         ndr_print_ptr(ndr, "sids", r->sids);
4049         ndr->depth++;
4050         if (r->sids) {
4051                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->count);
4052                 ndr->depth++;
4053                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
4054                         char *idx_1=NULL;
4055                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4056                                 ndr_print_lsa_TranslatedSid2(ndr, "sids", &r->sids[cntr_sids_1]);
4057                                 free(idx_1);
4058                         }
4059                 }
4060                 ndr->depth--;
4061         }
4062         ndr->depth--;
4063         ndr->depth--;
4064 }
4065
4066 static enum ndr_err_code ndr_push_lsa_TranslatedSid3(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid3 *r)
4067 {
4068         if (ndr_flags & NDR_SCALARS) {
4069                 NDR_CHECK(ndr_push_align(ndr, 4));
4070                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
4071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
4072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
4073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
4074         }
4075         if (ndr_flags & NDR_BUFFERS) {
4076                 if (r->sid) {
4077                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
4078                 }
4079         }
4080         return NDR_ERR_SUCCESS;
4081 }
4082
4083 static enum ndr_err_code ndr_pull_lsa_TranslatedSid3(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid3 *r)
4084 {
4085         uint32_t _ptr_sid;
4086         TALLOC_CTX *_mem_save_sid_0;
4087         if (ndr_flags & NDR_SCALARS) {
4088                 NDR_CHECK(ndr_pull_align(ndr, 4));
4089                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
4090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
4091                 if (_ptr_sid) {
4092                         NDR_PULL_ALLOC(ndr, r->sid);
4093                 } else {
4094                         r->sid = NULL;
4095                 }
4096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
4097                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
4098         }
4099         if (ndr_flags & NDR_BUFFERS) {
4100                 if (r->sid) {
4101                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4102                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
4103                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
4104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
4105                 }
4106         }
4107         return NDR_ERR_SUCCESS;
4108 }
4109
4110 _PUBLIC_ void ndr_print_lsa_TranslatedSid3(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid3 *r)
4111 {
4112         ndr_print_struct(ndr, name, "lsa_TranslatedSid3");
4113         ndr->depth++;
4114         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
4115         ndr_print_ptr(ndr, "sid", r->sid);
4116         ndr->depth++;
4117         if (r->sid) {
4118                 ndr_print_dom_sid2(ndr, "sid", r->sid);
4119         }
4120         ndr->depth--;
4121         ndr_print_uint32(ndr, "sid_index", r->sid_index);
4122         ndr_print_uint32(ndr, "unknown", r->unknown);
4123         ndr->depth--;
4124 }
4125
4126 static enum ndr_err_code ndr_push_lsa_TransSidArray3(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray3 *r)
4127 {
4128         uint32_t cntr_sids_1;
4129         if (ndr_flags & NDR_SCALARS) {
4130                 NDR_CHECK(ndr_push_align(ndr, 4));
4131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4132                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4133         }
4134         if (ndr_flags & NDR_BUFFERS) {
4135                 if (r->sids) {
4136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4137                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
4138                                 NDR_CHECK(ndr_push_lsa_TranslatedSid3(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
4139                         }
4140                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
4141                                 NDR_CHECK(ndr_push_lsa_TranslatedSid3(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
4142                         }
4143                 }
4144         }
4145         return NDR_ERR_SUCCESS;
4146 }
4147
4148 static enum ndr_err_code ndr_pull_lsa_TransSidArray3(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray3 *r)
4149 {
4150         uint32_t _ptr_sids;
4151         uint32_t cntr_sids_1;
4152         TALLOC_CTX *_mem_save_sids_0;
4153         TALLOC_CTX *_mem_save_sids_1;
4154         if (ndr_flags & NDR_SCALARS) {
4155                 NDR_CHECK(ndr_pull_align(ndr, 4));
4156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4157                 if (r->count < 0 || r->count > 1000) {
4158                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4159                 }
4160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4161                 if (_ptr_sids) {
4162                         NDR_PULL_ALLOC(ndr, r->sids);
4163                 } else {
4164                         r->sids = NULL;
4165                 }
4166         }
4167         if (ndr_flags & NDR_BUFFERS) {
4168                 if (r->sids) {
4169                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4170                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4171                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4172                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4173                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4174                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4175                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
4176                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid3(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
4177                         }
4178                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
4179                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid3(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
4180                         }
4181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4183                 }
4184                 if (r->sids) {
4185                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
4186                 }
4187         }
4188         return NDR_ERR_SUCCESS;
4189 }
4190
4191 _PUBLIC_ void ndr_print_lsa_TransSidArray3(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray3 *r)
4192 {
4193         uint32_t cntr_sids_1;
4194         ndr_print_struct(ndr, name, "lsa_TransSidArray3");
4195         ndr->depth++;
4196         ndr_print_uint32(ndr, "count", r->count);
4197         ndr_print_ptr(ndr, "sids", r->sids);
4198         ndr->depth++;
4199         if (r->sids) {
4200                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->count);
4201                 ndr->depth++;
4202                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
4203                         char *idx_1=NULL;
4204                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4205                                 ndr_print_lsa_TranslatedSid3(ndr, "sids", &r->sids[cntr_sids_1]);
4206                                 free(idx_1);
4207                         }
4208                 }
4209                 ndr->depth--;
4210         }
4211         ndr->depth--;
4212         ndr->depth--;
4213 }
4214
4215 static enum ndr_err_code ndr_push_lsa_ForestTrustBinaryData(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustBinaryData *r)
4216 {
4217         if (ndr_flags & NDR_SCALARS) {
4218                 NDR_CHECK(ndr_push_align(ndr, 4));
4219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4220                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
4221         }
4222         if (ndr_flags & NDR_BUFFERS) {
4223                 if (r->data) {
4224                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4225                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
4226                 }
4227         }
4228         return NDR_ERR_SUCCESS;
4229 }
4230
4231 static enum ndr_err_code ndr_pull_lsa_ForestTrustBinaryData(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustBinaryData *r)
4232 {
4233         uint32_t _ptr_data;
4234         TALLOC_CTX *_mem_save_data_0;
4235         if (ndr_flags & NDR_SCALARS) {
4236                 NDR_CHECK(ndr_pull_align(ndr, 4));
4237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
4238                 if (r->length < 0 || r->length > 131072) {
4239                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4240                 }
4241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
4242                 if (_ptr_data) {
4243                         NDR_PULL_ALLOC(ndr, r->data);
4244                 } else {
4245                         r->data = NULL;
4246                 }
4247         }
4248         if (ndr_flags & NDR_BUFFERS) {
4249                 if (r->data) {
4250                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
4251                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
4252                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
4253                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
4254                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
4255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
4256                 }
4257                 if (r->data) {
4258                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
4259                 }
4260         }
4261         return NDR_ERR_SUCCESS;
4262 }
4263
4264 _PUBLIC_ void ndr_print_lsa_ForestTrustBinaryData(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustBinaryData *r)
4265 {
4266         ndr_print_struct(ndr, name, "lsa_ForestTrustBinaryData");
4267         ndr->depth++;
4268         ndr_print_uint32(ndr, "length", r->length);
4269         ndr_print_ptr(ndr, "data", r->data);
4270         ndr->depth++;
4271         if (r->data) {
4272                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
4273         }
4274         ndr->depth--;
4275         ndr->depth--;
4276 }
4277
4278 static enum ndr_err_code ndr_push_lsa_ForestTrustDomainInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustDomainInfo *r)
4279 {
4280         if (ndr_flags & NDR_SCALARS) {
4281                 NDR_CHECK(ndr_push_align(ndr, 4));
4282                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_sid));
4283                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain_name));
4284                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_domain_name));
4285         }
4286         if (ndr_flags & NDR_BUFFERS) {
4287                 if (r->domain_sid) {
4288                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
4289                 }
4290                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain_name));
4291                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_domain_name));
4292         }
4293         return NDR_ERR_SUCCESS;
4294 }
4295
4296 static enum ndr_err_code ndr_pull_lsa_ForestTrustDomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustDomainInfo *r)
4297 {
4298         uint32_t _ptr_domain_sid;
4299         TALLOC_CTX *_mem_save_domain_sid_0;
4300         if (ndr_flags & NDR_SCALARS) {
4301                 NDR_CHECK(ndr_pull_align(ndr, 4));
4302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_sid));
4303                 if (_ptr_domain_sid) {
4304                         NDR_PULL_ALLOC(ndr, r->domain_sid);
4305                 } else {
4306                         r->domain_sid = NULL;
4307                 }
4308                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain_name));
4309                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_domain_name));
4310         }
4311         if (ndr_flags & NDR_BUFFERS) {
4312                 if (r->domain_sid) {
4313                         _mem_save_domain_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4314                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_sid, 0);
4315                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
4316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_sid_0, 0);
4317                 }
4318                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain_name));
4319                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_domain_name));
4320         }
4321         return NDR_ERR_SUCCESS;
4322 }
4323
4324 _PUBLIC_ void ndr_print_lsa_ForestTrustDomainInfo(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustDomainInfo *r)
4325 {
4326         ndr_print_struct(ndr, name, "lsa_ForestTrustDomainInfo");
4327         ndr->depth++;
4328         ndr_print_ptr(ndr, "domain_sid", r->domain_sid);
4329         ndr->depth++;
4330         if (r->domain_sid) {
4331                 ndr_print_dom_sid2(ndr, "domain_sid", r->domain_sid);
4332         }
4333         ndr->depth--;
4334         ndr_print_lsa_StringLarge(ndr, "dns_domain_name", &r->dns_domain_name);
4335         ndr_print_lsa_StringLarge(ndr, "netbios_domain_name", &r->netbios_domain_name);
4336         ndr->depth--;
4337 }
4338
4339 static enum ndr_err_code ndr_push_lsa_ForestTrustData(struct ndr_push *ndr, int ndr_flags, const union lsa_ForestTrustData *r)
4340 {
4341         if (ndr_flags & NDR_SCALARS) {
4342                 int level = ndr_push_get_switch_value(ndr, r);
4343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4344                 switch (level) {
4345                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME: {
4346                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->top_level_name));
4347                         break; }
4348
4349                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX: {
4350                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->top_level_name_ex));
4351                         break; }
4352
4353                         case LSA_FOREST_TRUST_DOMAIN_INFO: {
4354                                 NDR_CHECK(ndr_push_lsa_ForestTrustDomainInfo(ndr, NDR_SCALARS, &r->domain_info));
4355                         break; }
4356
4357                         default: {
4358                                 NDR_CHECK(ndr_push_lsa_ForestTrustBinaryData(ndr, NDR_SCALARS, &r->data));
4359                         break; }
4360
4361                 }
4362         }
4363         if (ndr_flags & NDR_BUFFERS) {
4364                 int level = ndr_push_get_switch_value(ndr, r);
4365                 switch (level) {
4366                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME:
4367                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->top_level_name));
4368                         break;
4369
4370                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX:
4371                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->top_level_name_ex));
4372                         break;
4373
4374                         case LSA_FOREST_TRUST_DOMAIN_INFO:
4375                                 NDR_CHECK(ndr_push_lsa_ForestTrustDomainInfo(ndr, NDR_BUFFERS, &r->domain_info));
4376                         break;
4377
4378                         default:
4379                                 NDR_CHECK(ndr_push_lsa_ForestTrustBinaryData(ndr, NDR_BUFFERS, &r->data));
4380                         break;
4381
4382                 }
4383         }
4384         return NDR_ERR_SUCCESS;
4385 }
4386
4387 static enum ndr_err_code ndr_pull_lsa_ForestTrustData(struct ndr_pull *ndr, int ndr_flags, union lsa_ForestTrustData *r)
4388 {
4389         int level;
4390         uint32_t _level;
4391         level = ndr_pull_get_switch_value(ndr, r);
4392         if (ndr_flags & NDR_SCALARS) {
4393                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4394                 if (_level != level) {
4395                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4396                 }
4397                 switch (level) {
4398                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME: {
4399                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->top_level_name));
4400                         break; }
4401
4402                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX: {
4403                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->top_level_name_ex));
4404                         break; }
4405
4406                         case LSA_FOREST_TRUST_DOMAIN_INFO: {
4407                                 NDR_CHECK(ndr_pull_lsa_ForestTrustDomainInfo(ndr, NDR_SCALARS, &r->domain_info));
4408                         break; }
4409
4410                         default: {
4411                                 NDR_CHECK(ndr_pull_lsa_ForestTrustBinaryData(ndr, NDR_SCALARS, &r->data));
4412                         break; }
4413
4414                 }
4415         }
4416         if (ndr_flags & NDR_BUFFERS) {
4417                 switch (level) {
4418                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME:
4419                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->top_level_name));
4420                         break;
4421
4422                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX:
4423                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->top_level_name_ex));
4424                         break;
4425
4426                         case LSA_FOREST_TRUST_DOMAIN_INFO:
4427                                 NDR_CHECK(ndr_pull_lsa_ForestTrustDomainInfo(ndr, NDR_BUFFERS, &r->domain_info));
4428                         break;
4429
4430                         default:
4431                                 NDR_CHECK(ndr_pull_lsa_ForestTrustBinaryData(ndr, NDR_BUFFERS, &r->data));
4432                         break;
4433
4434                 }
4435         }
4436         return NDR_ERR_SUCCESS;
4437 }
4438
4439 _PUBLIC_ void ndr_print_lsa_ForestTrustData(struct ndr_print *ndr, const char *name, const union lsa_ForestTrustData *r)
4440 {
4441         int level;
4442         level = ndr_print_get_switch_value(ndr, r);
4443         ndr_print_union(ndr, name, level, "lsa_ForestTrustData");
4444         switch (level) {
4445                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME:
4446                         ndr_print_lsa_String(ndr, "top_level_name", &r->top_level_name);
4447                 break;
4448
4449                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX:
4450                         ndr_print_lsa_StringLarge(ndr, "top_level_name_ex", &r->top_level_name_ex);
4451                 break;
4452
4453                 case LSA_FOREST_TRUST_DOMAIN_INFO:
4454                         ndr_print_lsa_ForestTrustDomainInfo(ndr, "domain_info", &r->domain_info);
4455                 break;
4456
4457                 default:
4458                         ndr_print_lsa_ForestTrustBinaryData(ndr, "data", &r->data);
4459                 break;
4460
4461         }
4462 }
4463
4464 static enum ndr_err_code ndr_push_lsa_ForestTrustRecordType(struct ndr_push *ndr, int ndr_flags, enum lsa_ForestTrustRecordType r)
4465 {
4466         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4467         return NDR_ERR_SUCCESS;
4468 }
4469
4470 static enum ndr_err_code ndr_pull_lsa_ForestTrustRecordType(struct ndr_pull *ndr, int ndr_flags, enum lsa_ForestTrustRecordType *r)
4471 {
4472         uint32_t v;
4473         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4474         *r = v;
4475         return NDR_ERR_SUCCESS;
4476 }
4477
4478 _PUBLIC_ void ndr_print_lsa_ForestTrustRecordType(struct ndr_print *ndr, const char *name, enum lsa_ForestTrustRecordType r)
4479 {
4480         const char *val = NULL;
4481
4482         switch (r) {
4483                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME: val = "LSA_FOREST_TRUST_TOP_LEVEL_NAME"; break;
4484                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX: val = "LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX"; break;
4485                 case LSA_FOREST_TRUST_DOMAIN_INFO: val = "LSA_FOREST_TRUST_DOMAIN_INFO"; break;
4486                 case LSA_FOREST_TRUST_RECORD_TYPE_LAST: val = "LSA_FOREST_TRUST_RECORD_TYPE_LAST"; break;
4487         }
4488         ndr_print_enum(ndr, name, "ENUM", val, r);
4489 }
4490
4491 static enum ndr_err_code ndr_push_lsa_ForestTrustRecord(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustRecord *r)
4492 {
4493         if (ndr_flags & NDR_SCALARS) {
4494                 NDR_CHECK(ndr_push_align(ndr, 8));
4495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4496                 NDR_CHECK(ndr_push_lsa_ForestTrustRecordType(ndr, NDR_SCALARS, r->level));
4497                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown));
4498                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->forest_trust_data, r->level));
4499                 NDR_CHECK(ndr_push_lsa_ForestTrustData(ndr, NDR_SCALARS, &r->forest_trust_data));
4500         }
4501         if (ndr_flags & NDR_BUFFERS) {
4502                 NDR_CHECK(ndr_push_lsa_ForestTrustData(ndr, NDR_BUFFERS, &r->forest_trust_data));
4503         }
4504         return NDR_ERR_SUCCESS;
4505 }
4506
4507 static enum ndr_err_code ndr_pull_lsa_ForestTrustRecord(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustRecord *r)
4508 {
4509         if (ndr_flags & NDR_SCALARS) {
4510                 NDR_CHECK(ndr_pull_align(ndr, 8));
4511                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
4512                 NDR_CHECK(ndr_pull_lsa_ForestTrustRecordType(ndr, NDR_SCALARS, &r->level));
4513                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown));
4514                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->forest_trust_data, r->level));
4515                 NDR_CHECK(ndr_pull_lsa_ForestTrustData(ndr, NDR_SCALARS, &r->forest_trust_data));
4516         }
4517         if (ndr_flags & NDR_BUFFERS) {
4518                 NDR_CHECK(ndr_pull_lsa_ForestTrustData(ndr, NDR_BUFFERS, &r->forest_trust_data));
4519         }
4520         return NDR_ERR_SUCCESS;
4521 }
4522
4523 _PUBLIC_ void ndr_print_lsa_ForestTrustRecord(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustRecord *r)
4524 {
4525         ndr_print_struct(ndr, name, "lsa_ForestTrustRecord");
4526         ndr->depth++;
4527         ndr_print_uint32(ndr, "flags", r->flags);
4528         ndr_print_lsa_ForestTrustRecordType(ndr, "level", r->level);
4529         ndr_print_hyper(ndr, "unknown", r->unknown);
4530         ndr_print_set_switch_value(ndr, &r->forest_trust_data, r->level);
4531         ndr_print_lsa_ForestTrustData(ndr, "forest_trust_data", &r->forest_trust_data);
4532         ndr->depth--;
4533 }
4534
4535 _PUBLIC_ enum ndr_err_code ndr_push_lsa_ForestTrustInformation(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustInformation *r)
4536 {
4537         uint32_t cntr_entries_1;
4538         if (ndr_flags & NDR_SCALARS) {
4539                 NDR_CHECK(ndr_push_align(ndr, 4));
4540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4541                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4542         }
4543         if (ndr_flags & NDR_BUFFERS) {
4544                 if (r->entries) {
4545                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4546                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4547                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries[cntr_entries_1]));
4548                         }
4549                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4550                                 if (r->entries[cntr_entries_1]) {
4551                                         NDR_CHECK(ndr_push_lsa_ForestTrustRecord(ndr, NDR_SCALARS|NDR_BUFFERS, r->entries[cntr_entries_1]));
4552                                 }
4553                         }
4554                 }
4555         }
4556         return NDR_ERR_SUCCESS;
4557 }
4558
4559 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_ForestTrustInformation(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustInformation *r)
4560 {
4561         uint32_t _ptr_entries;
4562         uint32_t cntr_entries_1;
4563         TALLOC_CTX *_mem_save_entries_0;
4564         TALLOC_CTX *_mem_save_entries_1;
4565         TALLOC_CTX *_mem_save_entries_2;
4566         if (ndr_flags & NDR_SCALARS) {
4567                 NDR_CHECK(ndr_pull_align(ndr, 4));
4568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4569                 if (r->count < 0 || r->count > 4000) {
4570                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4571                 }
4572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4573                 if (_ptr_entries) {
4574                         NDR_PULL_ALLOC(ndr, r->entries);
4575                 } else {
4576                         r->entries = NULL;
4577                 }
4578         }
4579         if (ndr_flags & NDR_BUFFERS) {
4580                 if (r->entries) {
4581                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4582                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4584                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
4585                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4586                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4587                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4588                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4589                                 if (_ptr_entries) {
4590                                         NDR_PULL_ALLOC(ndr, r->entries[cntr_entries_1]);
4591                                 } else {
4592                                         r->entries[cntr_entries_1] = NULL;
4593                                 }
4594                         }
4595                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4596                                 if (r->entries[cntr_entries_1]) {
4597                                         _mem_save_entries_2 = NDR_PULL_GET_MEM_CTX(ndr);
4598                                         NDR_PULL_SET_MEM_CTX(ndr, r->entries[cntr_entries_1], 0);
4599                                         NDR_CHECK(ndr_pull_lsa_ForestTrustRecord(ndr, NDR_SCALARS|NDR_BUFFERS, r->entries[cntr_entries_1]));
4600                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_2, 0);
4601                                 }
4602                         }
4603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4604                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4605                 }
4606                 if (r->entries) {
4607                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4608                 }
4609         }
4610         return NDR_ERR_SUCCESS;
4611 }
4612
4613 _PUBLIC_ void ndr_print_lsa_ForestTrustInformation(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustInformation *r)
4614 {
4615         uint32_t cntr_entries_1;
4616         ndr_print_struct(ndr, name, "lsa_ForestTrustInformation");
4617         ndr->depth++;
4618         ndr_print_uint32(ndr, "count", r->count);
4619         ndr_print_ptr(ndr, "entries", r->entries);
4620         ndr->depth++;
4621         if (r->entries) {
4622                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", r->count);
4623                 ndr->depth++;
4624                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4625                         char *idx_1=NULL;
4626                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4627                                 ndr_print_ptr(ndr, "entries", r->entries[cntr_entries_1]);
4628                                 ndr->depth++;
4629                                 if (r->entries[cntr_entries_1]) {
4630                                         ndr_print_lsa_ForestTrustRecord(ndr, "entries", r->entries[cntr_entries_1]);
4631                                 }
4632                                 ndr->depth--;
4633                                 free(idx_1);
4634                         }
4635                 }
4636                 ndr->depth--;
4637         }
4638         ndr->depth--;
4639         ndr->depth--;
4640 }
4641
4642 static enum ndr_err_code ndr_push_lsa_Close(struct ndr_push *ndr, int flags, const struct lsa_Close *r)
4643 {
4644         if (flags & NDR_IN) {
4645                 if (r->in.handle == NULL) {
4646                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4647                 }
4648                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4649         }
4650         if (flags & NDR_OUT) {
4651                 if (r->out.handle == NULL) {
4652                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4653                 }
4654                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
4655                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4656         }
4657         return NDR_ERR_SUCCESS;
4658 }
4659
4660 static enum ndr_err_code ndr_pull_lsa_Close(struct ndr_pull *ndr, int flags, struct lsa_Close *r)
4661 {
4662         TALLOC_CTX *_mem_save_handle_0;
4663         if (flags & NDR_IN) {
4664                 ZERO_STRUCT(r->out);
4665
4666                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4667                         NDR_PULL_ALLOC(ndr, r->in.handle);
4668                 }
4669                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4670                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4671                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4672                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4673                 NDR_PULL_ALLOC(ndr, r->out.handle);
4674                 *r->out.handle = *r->in.handle;
4675         }
4676         if (flags & NDR_OUT) {
4677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4678                         NDR_PULL_ALLOC(ndr, r->out.handle);
4679                 }
4680                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4681                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
4682                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
4683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4684                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4685         }
4686         return NDR_ERR_SUCCESS;
4687 }
4688
4689 _PUBLIC_ void ndr_print_lsa_Close(struct ndr_print *ndr, const char *name, int flags, const struct lsa_Close *r)
4690 {
4691         ndr_print_struct(ndr, name, "lsa_Close");
4692         ndr->depth++;
4693         if (flags & NDR_SET_VALUES) {
4694                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4695         }
4696         if (flags & NDR_IN) {
4697                 ndr_print_struct(ndr, "in", "lsa_Close");
4698                 ndr->depth++;
4699                 ndr_print_ptr(ndr, "handle", r->in.handle);
4700                 ndr->depth++;
4701                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4702                 ndr->depth--;
4703                 ndr->depth--;
4704         }
4705         if (flags & NDR_OUT) {
4706                 ndr_print_struct(ndr, "out", "lsa_Close");
4707                 ndr->depth++;
4708                 ndr_print_ptr(ndr, "handle", r->out.handle);
4709                 ndr->depth++;
4710                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
4711                 ndr->depth--;
4712                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4713                 ndr->depth--;
4714         }
4715         ndr->depth--;
4716 }
4717
4718 _PUBLIC_ enum ndr_err_code ndr_push_lsa_Delete(struct ndr_push *ndr, int flags, const struct lsa_Delete *r)
4719 {
4720         if (flags & NDR_IN) {
4721                 if (r->in.handle == NULL) {
4722                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4723                 }
4724                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4725         }
4726         if (flags & NDR_OUT) {
4727                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4728         }
4729         return NDR_ERR_SUCCESS;
4730 }
4731
4732 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_Delete(struct ndr_pull *ndr, int flags, struct lsa_Delete *r)
4733 {
4734         TALLOC_CTX *_mem_save_handle_0;
4735         if (flags & NDR_IN) {
4736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4737                         NDR_PULL_ALLOC(ndr, r->in.handle);
4738                 }
4739                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4740                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4741                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4743         }
4744         if (flags & NDR_OUT) {
4745                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4746         }
4747         return NDR_ERR_SUCCESS;
4748 }
4749
4750 _PUBLIC_ void ndr_print_lsa_Delete(struct ndr_print *ndr, const char *name, int flags, const struct lsa_Delete *r)
4751 {
4752         ndr_print_struct(ndr, name, "lsa_Delete");
4753         ndr->depth++;
4754         if (flags & NDR_SET_VALUES) {
4755                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4756         }
4757         if (flags & NDR_IN) {
4758                 ndr_print_struct(ndr, "in", "lsa_Delete");
4759                 ndr->depth++;
4760                 ndr_print_ptr(ndr, "handle", r->in.handle);
4761                 ndr->depth++;
4762                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4763                 ndr->depth--;
4764                 ndr->depth--;
4765         }
4766         if (flags & NDR_OUT) {
4767                 ndr_print_struct(ndr, "out", "lsa_Delete");
4768                 ndr->depth++;
4769                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4770                 ndr->depth--;
4771         }
4772         ndr->depth--;
4773 }
4774
4775 _PUBLIC_ enum ndr_err_code ndr_push_lsa_EnumPrivs(struct ndr_push *ndr, int flags, const struct lsa_EnumPrivs *r)
4776 {
4777         if (flags & NDR_IN) {
4778                 if (r->in.handle == NULL) {
4779                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4780                 }
4781                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4782                 if (r->in.resume_handle == NULL) {
4783                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4784                 }
4785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
4786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_count));
4787         }
4788         if (flags & NDR_OUT) {
4789                 if (r->out.resume_handle == NULL) {
4790                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4791                 }
4792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
4793                 if (r->out.privs == NULL) {
4794                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4795                 }
4796                 NDR_CHECK(ndr_push_lsa_PrivArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.privs));
4797                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4798         }
4799         return NDR_ERR_SUCCESS;
4800 }
4801
4802 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_EnumPrivs(struct ndr_pull *ndr, int flags, struct lsa_EnumPrivs *r)
4803 {
4804         TALLOC_CTX *_mem_save_handle_0;
4805         TALLOC_CTX *_mem_save_resume_handle_0;
4806         TALLOC_CTX *_mem_save_privs_0;
4807         if (flags & NDR_IN) {
4808                 ZERO_STRUCT(r->out);
4809
4810                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4811                         NDR_PULL_ALLOC(ndr, r->in.handle);
4812                 }
4813                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4814                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4815                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4816                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4817                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4818                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
4819                 }
4820                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4821                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
4822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
4823                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
4824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_count));
4825                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
4826                 *r->out.resume_handle = *r->in.resume_handle;
4827                 NDR_PULL_ALLOC(ndr, r->out.privs);
4828                 ZERO_STRUCTP(r->out.privs);
4829         }
4830         if (flags & NDR_OUT) {
4831                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4832                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
4833                 }
4834                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4835                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
4836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
4837                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
4838                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4839                         NDR_PULL_ALLOC(ndr, r->out.privs);
4840                 }
4841                 _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4842                 NDR_PULL_SET_MEM_CTX(ndr, r->out.privs, LIBNDR_FLAG_REF_ALLOC);
4843                 NDR_CHECK(ndr_pull_lsa_PrivArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.privs));
4844                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, LIBNDR_FLAG_REF_ALLOC);
4845                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4846         }
4847         return NDR_ERR_SUCCESS;
4848 }
4849
4850 _PUBLIC_ void ndr_print_lsa_EnumPrivs(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumPrivs *r)
4851 {
4852         ndr_print_struct(ndr, name, "lsa_EnumPrivs");
4853         ndr->depth++;
4854         if (flags & NDR_SET_VALUES) {
4855                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4856         }
4857         if (flags & NDR_IN) {
4858                 ndr_print_struct(ndr, "in", "lsa_EnumPrivs");
4859                 ndr->depth++;
4860                 ndr_print_ptr(ndr, "handle", r->in.handle);
4861                 ndr->depth++;
4862                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4863                 ndr->depth--;
4864                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
4865                 ndr->depth++;
4866                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
4867                 ndr->depth--;
4868                 ndr_print_uint32(ndr, "max_count", r->in.max_count);
4869                 ndr->depth--;
4870         }
4871         if (flags & NDR_OUT) {
4872                 ndr_print_struct(ndr, "out", "lsa_EnumPrivs");
4873                 ndr->depth++;
4874                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
4875                 ndr->depth++;
4876                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
4877                 ndr->depth--;
4878                 ndr_print_ptr(ndr, "privs", r->out.privs);
4879                 ndr->depth++;
4880                 ndr_print_lsa_PrivArray(ndr, "privs", r->out.privs);
4881                 ndr->depth--;
4882                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4883                 ndr->depth--;
4884         }
4885         ndr->depth--;
4886 }
4887
4888 static enum ndr_err_code ndr_push_lsa_QuerySecurity(struct ndr_push *ndr, int flags, const struct lsa_QuerySecurity *r)
4889 {
4890         if (flags & NDR_IN) {
4891                 if (r->in.handle == NULL) {
4892                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4893                 }
4894                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4895                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
4896         }
4897         if (flags & NDR_OUT) {
4898                 if (r->out.sdbuf == NULL) {
4899                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4900                 }
4901                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));
4902                 if (*r->out.sdbuf) {
4903                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
4904                 }
4905                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4906         }
4907         return NDR_ERR_SUCCESS;
4908 }
4909
4910 static enum ndr_err_code ndr_pull_lsa_QuerySecurity(struct ndr_pull *ndr, int flags, struct lsa_QuerySecurity *r)
4911 {
4912         uint32_t _ptr_sdbuf;
4913         TALLOC_CTX *_mem_save_handle_0;
4914         TALLOC_CTX *_mem_save_sdbuf_0;
4915         TALLOC_CTX *_mem_save_sdbuf_1;
4916         if (flags & NDR_IN) {
4917                 ZERO_STRUCT(r->out);
4918
4919                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4920                         NDR_PULL_ALLOC(ndr, r->in.handle);
4921                 }
4922                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4923                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4924                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4925                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4926                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
4927                 NDR_PULL_ALLOC(ndr, r->out.sdbuf);
4928                 ZERO_STRUCTP(r->out.sdbuf);
4929         }
4930         if (flags & NDR_OUT) {
4931                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4932                         NDR_PULL_ALLOC(ndr, r->out.sdbuf);
4933                 }
4934                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
4935                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);
4936                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
4937                 if (_ptr_sdbuf) {
4938                         NDR_PULL_ALLOC(ndr, *r->out.sdbuf);
4939                 } else {
4940                         *r->out.sdbuf = NULL;
4941                 }
4942                 if (*r->out.sdbuf) {
4943                         _mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);
4944                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);
4945                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
4946                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);
4947                 }
4948                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
4949                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4950         }
4951         return NDR_ERR_SUCCESS;
4952 }
4953
4954 _PUBLIC_ void ndr_print_lsa_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QuerySecurity *r)
4955 {
4956         ndr_print_struct(ndr, name, "lsa_QuerySecurity");
4957         ndr->depth++;
4958         if (flags & NDR_SET_VALUES) {
4959                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4960         }
4961         if (flags & NDR_IN) {
4962                 ndr_print_struct(ndr, "in", "lsa_QuerySecurity");
4963                 ndr->depth++;
4964                 ndr_print_ptr(ndr, "handle", r->in.handle);
4965                 ndr->depth++;
4966                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4967                 ndr->depth--;
4968                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
4969                 ndr->depth--;
4970         }
4971         if (flags & NDR_OUT) {
4972                 ndr_print_struct(ndr, "out", "lsa_QuerySecurity");
4973                 ndr->depth++;
4974                 ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
4975                 ndr->depth++;
4976                 ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);
4977                 ndr->depth++;
4978                 if (*r->out.sdbuf) {
4979                         ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);
4980                 }
4981                 ndr->depth--;
4982                 ndr->depth--;
4983                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4984                 ndr->depth--;
4985         }
4986         ndr->depth--;
4987 }
4988
4989 static enum ndr_err_code ndr_push_lsa_SetSecObj(struct ndr_push *ndr, int flags, const struct lsa_SetSecObj *r)
4990 {
4991         if (flags & NDR_IN) {
4992                 if (r->in.handle == NULL) {
4993                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4994                 }
4995                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4996                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
4997                 if (r->in.sdbuf == NULL) {
4998                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4999                 }
5000                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5001         }
5002         if (flags & NDR_OUT) {
5003                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5004         }
5005         return NDR_ERR_SUCCESS;
5006 }
5007
5008 static enum ndr_err_code ndr_pull_lsa_SetSecObj(struct ndr_pull *ndr, int flags, struct lsa_SetSecObj *r)
5009 {
5010         TALLOC_CTX *_mem_save_handle_0;
5011         TALLOC_CTX *_mem_save_sdbuf_0;
5012         if (flags & NDR_IN) {
5013                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5014                         NDR_PULL_ALLOC(ndr, r->in.handle);
5015                 }
5016                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5017                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5018                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5019                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5020                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5021                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5022                         NDR_PULL_ALLOC(ndr, r->in.sdbuf);
5023                 }
5024                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5025                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5026                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5027                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5028         }
5029         if (flags & NDR_OUT) {
5030                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5031         }
5032         return NDR_ERR_SUCCESS;
5033 }
5034
5035 _PUBLIC_ void ndr_print_lsa_SetSecObj(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSecObj *r)
5036 {
5037         ndr_print_struct(ndr, name, "lsa_SetSecObj");
5038         ndr->depth++;
5039         if (flags & NDR_SET_VALUES) {
5040                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5041         }
5042         if (flags & NDR_IN) {
5043                 ndr_print_struct(ndr, "in", "lsa_SetSecObj");
5044                 ndr->depth++;
5045                 ndr_print_ptr(ndr, "handle", r->in.handle);
5046                 ndr->depth++;
5047                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5048                 ndr->depth--;
5049                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5050                 ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);
5051                 ndr->depth++;
5052                 ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);
5053                 ndr->depth--;
5054                 ndr->depth--;
5055         }
5056         if (flags & NDR_OUT) {
5057                 ndr_print_struct(ndr, "out", "lsa_SetSecObj");
5058                 ndr->depth++;
5059                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5060                 ndr->depth--;
5061         }
5062         ndr->depth--;
5063 }
5064
5065 static enum ndr_err_code ndr_push_lsa_ChangePassword(struct ndr_push *ndr, int flags, const struct lsa_ChangePassword *r)
5066 {
5067         if (flags & NDR_IN) {
5068         }
5069         if (flags & NDR_OUT) {
5070                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5071         }
5072         return NDR_ERR_SUCCESS;
5073 }
5074
5075 static enum ndr_err_code ndr_pull_lsa_ChangePassword(struct ndr_pull *ndr, int flags, struct lsa_ChangePassword *r)
5076 {
5077         if (flags & NDR_IN) {
5078         }
5079         if (flags & NDR_OUT) {
5080                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5081         }
5082         return NDR_ERR_SUCCESS;
5083 }
5084
5085 _PUBLIC_ void ndr_print_lsa_ChangePassword(struct ndr_print *ndr, const char *name, int flags, const struct lsa_ChangePassword *r)
5086 {
5087         ndr_print_struct(ndr, name, "lsa_ChangePassword");
5088         ndr->depth++;
5089         if (flags & NDR_SET_VALUES) {
5090                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5091         }
5092         if (flags & NDR_IN) {
5093                 ndr_print_struct(ndr, "in", "lsa_ChangePassword");
5094                 ndr->depth++;
5095                 ndr->depth--;
5096         }
5097         if (flags & NDR_OUT) {
5098                 ndr_print_struct(ndr, "out", "lsa_ChangePassword");
5099                 ndr->depth++;
5100                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5101                 ndr->depth--;
5102         }
5103         ndr->depth--;
5104 }
5105
5106 _PUBLIC_ enum ndr_err_code ndr_push_lsa_OpenPolicy(struct ndr_push *ndr, int flags, const struct lsa_OpenPolicy *r)
5107 {
5108         if (flags & NDR_IN) {
5109                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
5110                 if (r->in.system_name) {
5111                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
5112                 }
5113                 if (r->in.attr == NULL) {
5114                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5115                 }
5116                 NDR_CHECK(ndr_push_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
5117                 NDR_CHECK(ndr_push_lsa_PolicyAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5118         }
5119         if (flags & NDR_OUT) {
5120                 if (r->out.handle == NULL) {
5121                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5122                 }
5123                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
5124                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5125         }
5126         return NDR_ERR_SUCCESS;
5127 }
5128
5129 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_OpenPolicy(struct ndr_pull *ndr, int flags, struct lsa_OpenPolicy *r)
5130 {
5131         uint32_t _ptr_system_name;
5132         TALLOC_CTX *_mem_save_system_name_0;
5133         TALLOC_CTX *_mem_save_attr_0;
5134         TALLOC_CTX *_mem_save_handle_0;
5135         if (flags & NDR_IN) {
5136                 ZERO_STRUCT(r->out);
5137
5138                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
5139                 if (_ptr_system_name) {
5140                         NDR_PULL_ALLOC(ndr, r->in.system_name);
5141                 } else {
5142                         r->in.system_name = NULL;
5143                 }
5144                 if (r->in.system_name) {
5145                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5146                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
5147                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
5148                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
5149                 }
5150                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5151                         NDR_PULL_ALLOC(ndr, r->in.attr);
5152                 }
5153                 _mem_save_attr_0 = NDR_PULL_GET_MEM_CTX(ndr);
5154                 NDR_PULL_SET_MEM_CTX(ndr, r->in.attr, LIBNDR_FLAG_REF_ALLOC);
5155                 NDR_CHECK(ndr_pull_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
5156                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attr_0, LIBNDR_FLAG_REF_ALLOC);
5157                 NDR_CHECK(ndr_pull_lsa_PolicyAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
5158                 NDR_PULL_ALLOC(ndr, r->out.handle);
5159                 ZERO_STRUCTP(r->out.handle);
5160         }
5161         if (flags & NDR_OUT) {
5162                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5163                         NDR_PULL_ALLOC(ndr, r->out.handle);
5164                 }
5165                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5166                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5167                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
5168                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5169                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5170         }
5171         return NDR_ERR_SUCCESS;
5172 }
5173
5174 _PUBLIC_ void ndr_print_lsa_OpenPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenPolicy *r)
5175 {
5176         ndr_print_struct(ndr, name, "lsa_OpenPolicy");
5177         ndr->depth++;
5178         if (flags & NDR_SET_VALUES) {
5179                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5180         }
5181         if (flags & NDR_IN) {
5182                 ndr_print_struct(ndr, "in", "lsa_OpenPolicy");
5183                 ndr->depth++;
5184                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
5185                 ndr->depth++;
5186                 if (r->in.system_name) {
5187                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
5188                 }
5189                 ndr->depth--;
5190                 ndr_print_ptr(ndr, "attr", r->in.attr);
5191                 ndr->depth++;
5192                 ndr_print_lsa_ObjectAttribute(ndr, "attr", r->in.attr);
5193                 ndr->depth--;
5194                 ndr_print_lsa_PolicyAccessMask(ndr, "access_mask", r->in.access_mask);
5195                 ndr->depth--;
5196         }
5197         if (flags & NDR_OUT) {
5198                 ndr_print_struct(ndr, "out", "lsa_OpenPolicy");
5199                 ndr->depth++;
5200                 ndr_print_ptr(ndr, "handle", r->out.handle);
5201                 ndr->depth++;
5202                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
5203                 ndr->depth--;
5204                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5205                 ndr->depth--;
5206         }
5207         ndr->depth--;
5208 }
5209
5210 static enum ndr_err_code ndr_push_lsa_QueryInfoPolicy(struct ndr_push *ndr, int flags, const struct lsa_QueryInfoPolicy *r)
5211 {
5212         if (flags & NDR_IN) {
5213                 if (r->in.handle == NULL) {
5214                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5215                 }
5216                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5217                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
5218         }
5219         if (flags & NDR_OUT) {
5220                 if (r->out.info == NULL) {
5221                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5222                 }
5223                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
5224                 if (*r->out.info) {
5225                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
5226                         NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
5227                 }
5228                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5229         }
5230         return NDR_ERR_SUCCESS;
5231 }
5232
5233 static enum ndr_err_code ndr_pull_lsa_QueryInfoPolicy(struct ndr_pull *ndr, int flags, struct lsa_QueryInfoPolicy *r)
5234 {
5235         uint32_t _ptr_info;
5236         TALLOC_CTX *_mem_save_handle_0;
5237         TALLOC_CTX *_mem_save_info_0;
5238         TALLOC_CTX *_mem_save_info_1;
5239         if (flags & NDR_IN) {
5240                 ZERO_STRUCT(r->out);
5241
5242                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5243                         NDR_PULL_ALLOC(ndr, r->in.handle);
5244                 }
5245                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5246                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5247                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5248                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5249                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
5250                 NDR_PULL_ALLOC(ndr, r->out.info);
5251                 ZERO_STRUCTP(r->out.info);
5252         }
5253         if (flags & NDR_OUT) {
5254                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5255                         NDR_PULL_ALLOC(ndr, r->out.info);
5256                 }
5257                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5258                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
5259                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
5260                 if (_ptr_info) {
5261                         NDR_PULL_ALLOC(ndr, *r->out.info);
5262                 } else {
5263                         *r->out.info = NULL;
5264                 }
5265                 if (*r->out.info) {
5266                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
5267                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
5268                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
5269                         NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
5270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
5271                 }
5272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5273                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5274         }
5275         return NDR_ERR_SUCCESS;
5276 }
5277
5278 _PUBLIC_ void ndr_print_lsa_QueryInfoPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryInfoPolicy *r)
5279 {
5280         ndr_print_struct(ndr, name, "lsa_QueryInfoPolicy");
5281         ndr->depth++;
5282         if (flags & NDR_SET_VALUES) {
5283                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5284         }
5285         if (flags & NDR_IN) {
5286                 ndr_print_struct(ndr, "in", "lsa_QueryInfoPolicy");
5287                 ndr->depth++;
5288                 ndr_print_ptr(ndr, "handle", r->in.handle);
5289                 ndr->depth++;
5290                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5291                 ndr->depth--;
5292                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
5293                 ndr->depth--;
5294         }
5295         if (flags & NDR_OUT) {
5296                 ndr_print_struct(ndr, "out", "lsa_QueryInfoPolicy");
5297                 ndr->depth++;
5298                 ndr_print_ptr(ndr, "info", r->out.info);
5299                 ndr->depth++;
5300                 ndr_print_ptr(ndr, "info", *r->out.info);
5301                 ndr->depth++;
5302                 if (*r->out.info) {
5303                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
5304                         ndr_print_lsa_PolicyInformation(ndr, "info", *r->out.info);
5305                 }
5306                 ndr->depth--;
5307                 ndr->depth--;
5308                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5309                 ndr->depth--;
5310         }
5311         ndr->depth--;
5312 }
5313
5314 static enum ndr_err_code ndr_push_lsa_SetInfoPolicy(struct ndr_push *ndr, int flags, const struct lsa_SetInfoPolicy *r)
5315 {
5316         if (flags & NDR_IN) {
5317                 if (r->in.handle == NULL) {
5318                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5319                 }
5320                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5321                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
5322                 if (r->in.info == NULL) {
5323                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5324                 }
5325                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
5326                 NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5327         }
5328         if (flags & NDR_OUT) {
5329                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5330         }
5331         return NDR_ERR_SUCCESS;
5332 }
5333
5334 static enum ndr_err_code ndr_pull_lsa_SetInfoPolicy(struct ndr_pull *ndr, int flags, struct lsa_SetInfoPolicy *r)
5335 {
5336         TALLOC_CTX *_mem_save_handle_0;
5337         TALLOC_CTX *_mem_save_info_0;
5338         if (flags & NDR_IN) {
5339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5340                         NDR_PULL_ALLOC(ndr, r->in.handle);
5341                 }
5342                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5343                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5344                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5346                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
5347                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5348                         NDR_PULL_ALLOC(ndr, r->in.info);
5349                 }
5350                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5351                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5352                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
5353                 NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5354                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5355         }
5356         if (flags & NDR_OUT) {
5357                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5358         }
5359         return NDR_ERR_SUCCESS;
5360 }
5361
5362 _PUBLIC_ void ndr_print_lsa_SetInfoPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInfoPolicy *r)
5363 {
5364         ndr_print_struct(ndr, name, "lsa_SetInfoPolicy");
5365         ndr->depth++;
5366         if (flags & NDR_SET_VALUES) {
5367                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5368         }
5369         if (flags & NDR_IN) {
5370                 ndr_print_struct(ndr, "in", "lsa_SetInfoPolicy");
5371                 ndr->depth++;
5372                 ndr_print_ptr(ndr, "handle", r->in.handle);
5373                 ndr->depth++;
5374                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5375                 ndr->depth--;
5376                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
5377                 ndr_print_ptr(ndr, "info", r->in.info);
5378                 ndr->depth++;
5379                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
5380                 ndr_print_lsa_PolicyInformation(ndr, "info", r->in.info);
5381                 ndr->depth--;
5382                 ndr->depth--;
5383         }
5384         if (flags & NDR_OUT) {
5385                 ndr_print_struct(ndr, "out", "lsa_SetInfoPolicy");
5386                 ndr->depth++;
5387                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5388                 ndr->depth--;
5389         }
5390         ndr->depth--;
5391 }
5392
5393 static enum ndr_err_code ndr_push_lsa_ClearAuditLog(struct ndr_push *ndr, int flags, const struct lsa_ClearAuditLog *r)
5394 {
5395         if (flags & NDR_IN) {
5396         }
5397         if (flags & NDR_OUT) {
5398                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5399         }
5400         return NDR_ERR_SUCCESS;
5401 }
5402
5403 static enum ndr_err_code ndr_pull_lsa_ClearAuditLog(struct ndr_pull *ndr, int flags, struct lsa_ClearAuditLog *r)
5404 {
5405         if (flags & NDR_IN) {
5406         }
5407         if (flags & NDR_OUT) {
5408                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5409         }
5410         return NDR_ERR_SUCCESS;
5411 }
5412
5413 _PUBLIC_ void ndr_print_lsa_ClearAuditLog(struct ndr_print *ndr, const char *name, int flags, const struct lsa_ClearAuditLog *r)
5414 {
5415         ndr_print_struct(ndr, name, "lsa_ClearAuditLog");
5416         ndr->depth++;
5417         if (flags & NDR_SET_VALUES) {
5418                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5419         }
5420         if (flags & NDR_IN) {
5421                 ndr_print_struct(ndr, "in", "lsa_ClearAuditLog");
5422                 ndr->depth++;
5423                 ndr->depth--;
5424         }
5425         if (flags & NDR_OUT) {
5426                 ndr_print_struct(ndr, "out", "lsa_ClearAuditLog");
5427                 ndr->depth++;
5428                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5429                 ndr->depth--;
5430         }
5431         ndr->depth--;
5432 }
5433
5434 _PUBLIC_ enum ndr_err_code ndr_push_lsa_CreateAccount(struct ndr_push *ndr, int flags, const struct lsa_CreateAccount *r)
5435 {
5436         if (flags & NDR_IN) {
5437                 if (r->in.handle == NULL) {
5438                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5439                 }
5440                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5441                 if (r->in.sid == NULL) {
5442                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5443                 }
5444                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
5445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
5446         }
5447         if (flags & NDR_OUT) {
5448                 if (r->out.acct_handle == NULL) {
5449                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5450                 }
5451                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
5452                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5453         }
5454         return NDR_ERR_SUCCESS;
5455 }
5456
5457 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_CreateAccount(struct ndr_pull *ndr, int flags, struct lsa_CreateAccount *r)
5458 {
5459         TALLOC_CTX *_mem_save_handle_0;
5460         TALLOC_CTX *_mem_save_sid_0;
5461         TALLOC_CTX *_mem_save_acct_handle_0;
5462         if (flags & NDR_IN) {
5463                 ZERO_STRUCT(r->out);
5464
5465                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5466                         NDR_PULL_ALLOC(ndr, r->in.handle);
5467                 }
5468                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5469                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5470                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5473                         NDR_PULL_ALLOC(ndr, r->in.sid);
5474                 }
5475                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
5476                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
5477                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
5478                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
5479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
5480                 NDR_PULL_ALLOC(ndr, r->out.acct_handle);
5481                 ZERO_STRUCTP(r->out.acct_handle);
5482         }
5483         if (flags & NDR_OUT) {
5484                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5485                         NDR_PULL_ALLOC(ndr, r->out.acct_handle);
5486                 }
5487                 _mem_save_acct_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5488                 NDR_PULL_SET_MEM_CTX(ndr, r->out.acct_handle, LIBNDR_FLAG_REF_ALLOC);
5489                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
5490                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_handle_0, LIBNDR_FLAG_REF_ALLOC);
5491                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5492         }
5493         return NDR_ERR_SUCCESS;
5494 }
5495
5496 _PUBLIC_ void ndr_print_lsa_CreateAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateAccount *r)
5497 {
5498         ndr_print_struct(ndr, name, "lsa_CreateAccount");
5499         ndr->depth++;
5500         if (flags & NDR_SET_VALUES) {
5501                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5502         }
5503         if (flags & NDR_IN) {
5504                 ndr_print_struct(ndr, "in", "lsa_CreateAccount");
5505                 ndr->depth++;
5506                 ndr_print_ptr(ndr, "handle", r->in.handle);
5507                 ndr->depth++;
5508                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5509                 ndr->depth--;
5510                 ndr_print_ptr(ndr, "sid", r->in.sid);
5511                 ndr->depth++;
5512                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
5513                 ndr->depth--;
5514                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
5515                 ndr->depth--;
5516         }
5517         if (flags & NDR_OUT) {
5518                 ndr_print_struct(ndr, "out", "lsa_CreateAccount");
5519                 ndr->depth++;
5520                 ndr_print_ptr(ndr, "acct_handle", r->out.acct_handle);
5521                 ndr->depth++;
5522                 ndr_print_policy_handle(ndr, "acct_handle", r->out.acct_handle);
5523                 ndr->depth--;
5524                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5525                 ndr->depth--;
5526         }
5527         ndr->depth--;
5528 }
5529
5530 _PUBLIC_ enum ndr_err_code ndr_push_lsa_EnumAccounts(struct ndr_push *ndr, int flags, const struct lsa_EnumAccounts *r)
5531 {
5532         if (flags & NDR_IN) {
5533                 if (r->in.handle == NULL) {
5534                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5535                 }
5536                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5537                 if (r->in.resume_handle == NULL) {
5538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5539                 }
5540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_entries));
5542         }
5543         if (flags & NDR_OUT) {
5544                 if (r->out.resume_handle == NULL) {
5545                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5546                 }
5547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5548                 if (r->out.sids == NULL) {
5549                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5550                 }
5551                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
5552                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5553         }
5554         return NDR_ERR_SUCCESS;
5555 }
5556
5557 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_EnumAccounts(struct ndr_pull *ndr, int flags, struct lsa_EnumAccounts *r)
5558 {
5559         TALLOC_CTX *_mem_save_handle_0;
5560         TALLOC_CTX *_mem_save_resume_handle_0;
5561         TALLOC_CTX *_mem_save_sids_0;
5562         if (flags & NDR_IN) {
5563                 ZERO_STRUCT(r->out);
5564
5565                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5566                         NDR_PULL_ALLOC(ndr, r->in.handle);
5567                 }
5568                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5569                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5570                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5571                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5573                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5574                 }
5575                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5576                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_entries));
5580                 if (r->in.num_entries < 0 || r->in.num_entries > 8192) {
5581                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5582                 }
5583                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5584                 *r->out.resume_handle = *r->in.resume_handle;
5585                 NDR_PULL_ALLOC(ndr, r->out.sids);
5586                 ZERO_STRUCTP(r->out.sids);
5587         }
5588         if (flags & NDR_OUT) {
5589                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5590                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5591                 }
5592                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5593                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5595                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5596                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5597                         NDR_PULL_ALLOC(ndr, r->out.sids);
5598                 }
5599                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
5600                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
5601                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
5602                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
5603                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5604         }
5605         return NDR_ERR_SUCCESS;
5606 }
5607
5608 _PUBLIC_ void ndr_print_lsa_EnumAccounts(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccounts *r)
5609 {
5610         ndr_print_struct(ndr, name, "lsa_EnumAccounts");
5611         ndr->depth++;
5612         if (flags & NDR_SET_VALUES) {
5613                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5614         }
5615         if (flags & NDR_IN) {
5616                 ndr_print_struct(ndr, "in", "lsa_EnumAccounts");
5617                 ndr->depth++;
5618                 ndr_print_ptr(ndr, "handle", r->in.handle);
5619                 ndr->depth++;
5620                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5621                 ndr->depth--;
5622                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5623                 ndr->depth++;
5624                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5625                 ndr->depth--;
5626                 ndr_print_uint32(ndr, "num_entries", r->in.num_entries);
5627                 ndr->depth--;
5628         }
5629         if (flags & NDR_OUT) {
5630                 ndr_print_struct(ndr, "out", "lsa_EnumAccounts");
5631                 ndr->depth++;
5632                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5633                 ndr->depth++;
5634                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5635                 ndr->depth--;
5636                 ndr_print_ptr(ndr, "sids", r->out.sids);
5637                 ndr->depth++;
5638                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
5639                 ndr->depth--;
5640                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5641                 ndr->depth--;
5642         }
5643         ndr->depth--;
5644 }
5645
5646 _PUBLIC_ enum ndr_err_code ndr_push_lsa_CreateTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomain *r)
5647 {
5648         if (flags & NDR_IN) {
5649                 if (r->in.handle == NULL) {
5650                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5651                 }
5652                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5653                 if (r->in.info == NULL) {
5654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5655                 }
5656                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
5658         }
5659         if (flags & NDR_OUT) {
5660                 if (r->out.trustdom_handle == NULL) {
5661                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5662                 }
5663                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
5664                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5665         }
5666         return NDR_ERR_SUCCESS;
5667 }
5668
5669 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_CreateTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomain *r)
5670 {
5671         TALLOC_CTX *_mem_save_handle_0;
5672         TALLOC_CTX *_mem_save_info_0;
5673         TALLOC_CTX *_mem_save_trustdom_handle_0;
5674         if (flags & NDR_IN) {
5675                 ZERO_STRUCT(r->out);
5676
5677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5678                         NDR_PULL_ALLOC(ndr, r->in.handle);
5679                 }
5680                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5681                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5682                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5684                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5685                         NDR_PULL_ALLOC(ndr, r->in.info);
5686                 }
5687                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5688                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5689                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5690                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
5692                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
5693                 ZERO_STRUCTP(r->out.trustdom_handle);
5694         }
5695         if (flags & NDR_OUT) {
5696                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5697                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
5698                 }
5699                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5700                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
5701                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
5702                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
5703                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5704         }
5705         return NDR_ERR_SUCCESS;
5706 }
5707
5708 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomain *r)
5709 {
5710         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomain");
5711         ndr->depth++;
5712         if (flags & NDR_SET_VALUES) {
5713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5714         }
5715         if (flags & NDR_IN) {
5716                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomain");
5717                 ndr->depth++;
5718                 ndr_print_ptr(ndr, "handle", r->in.handle);
5719                 ndr->depth++;
5720                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5721                 ndr->depth--;
5722                 ndr_print_ptr(ndr, "info", r->in.info);
5723                 ndr->depth++;
5724                 ndr_print_lsa_DomainInfo(ndr, "info", r->in.info);
5725                 ndr->depth--;
5726                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
5727                 ndr->depth--;
5728         }
5729         if (flags & NDR_OUT) {
5730                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomain");
5731                 ndr->depth++;
5732                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
5733                 ndr->depth++;
5734                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
5735                 ndr->depth--;
5736                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5737                 ndr->depth--;
5738         }
5739         ndr->depth--;
5740 }
5741
5742 static enum ndr_err_code ndr_push_lsa_EnumTrustDom(struct ndr_push *ndr, int flags, const struct lsa_EnumTrustDom *r)
5743 {
5744         if (flags & NDR_IN) {
5745                 if (r->in.handle == NULL) {
5746                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5747                 }
5748                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5749                 if (r->in.resume_handle == NULL) {
5750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5751                 }
5752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
5754         }
5755         if (flags & NDR_OUT) {
5756                 if (r->out.resume_handle == NULL) {
5757                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5758                 }
5759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5760                 if (r->out.domains == NULL) {
5761                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5762                 }
5763                 NDR_CHECK(ndr_push_lsa_DomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
5764                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5765         }
5766         return NDR_ERR_SUCCESS;
5767 }
5768
5769 static enum ndr_err_code ndr_pull_lsa_EnumTrustDom(struct ndr_pull *ndr, int flags, struct lsa_EnumTrustDom *r)
5770 {
5771         TALLOC_CTX *_mem_save_handle_0;
5772         TALLOC_CTX *_mem_save_resume_handle_0;
5773         TALLOC_CTX *_mem_save_domains_0;
5774         if (flags & NDR_IN) {
5775                 ZERO_STRUCT(r->out);
5776
5777                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5778                         NDR_PULL_ALLOC(ndr, r->in.handle);
5779                 }
5780                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5781                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5782                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5783                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5784                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5785                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5786                 }
5787                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5788                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5790                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
5792                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5793                 *r->out.resume_handle = *r->in.resume_handle;
5794                 NDR_PULL_ALLOC(ndr, r->out.domains);
5795                 ZERO_STRUCTP(r->out.domains);
5796         }
5797         if (flags & NDR_OUT) {
5798                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5799                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5800                 }
5801                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5802                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5804                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5805                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5806                         NDR_PULL_ALLOC(ndr, r->out.domains);
5807                 }
5808                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
5809                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
5810                 NDR_CHECK(ndr_pull_lsa_DomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
5811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
5812                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5813         }
5814         return NDR_ERR_SUCCESS;
5815 }
5816
5817 _PUBLIC_ void ndr_print_lsa_EnumTrustDom(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumTrustDom *r)
5818 {
5819         ndr_print_struct(ndr, name, "lsa_EnumTrustDom");
5820         ndr->depth++;
5821         if (flags & NDR_SET_VALUES) {
5822                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5823         }
5824         if (flags & NDR_IN) {
5825                 ndr_print_struct(ndr, "in", "lsa_EnumTrustDom");
5826                 ndr->depth++;
5827                 ndr_print_ptr(ndr, "handle", r->in.handle);
5828                 ndr->depth++;
5829                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5830                 ndr->depth--;
5831                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5832                 ndr->depth++;
5833                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5834                 ndr->depth--;
5835                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
5836                 ndr->depth--;
5837         }
5838         if (flags & NDR_OUT) {
5839                 ndr_print_struct(ndr, "out", "lsa_EnumTrustDom");
5840                 ndr->depth++;
5841                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5842                 ndr->depth++;
5843                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5844                 ndr->depth--;
5845                 ndr_print_ptr(ndr, "domains", r->out.domains);
5846                 ndr->depth++;
5847                 ndr_print_lsa_DomainList(ndr, "domains", r->out.domains);
5848                 ndr->depth--;
5849                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5850                 ndr->depth--;
5851         }
5852         ndr->depth--;
5853 }
5854
5855 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupNames(struct ndr_push *ndr, int flags, const struct lsa_LookupNames *r)
5856 {
5857         uint32_t cntr_names_0;
5858         if (flags & NDR_IN) {
5859                 if (r->in.handle == NULL) {
5860                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5861                 }
5862                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
5864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
5865                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5866                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
5867                 }
5868                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5869                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
5870                 }
5871                 if (r->in.sids == NULL) {
5872                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5873                 }
5874                 NDR_CHECK(ndr_push_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
5875                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
5876                 if (r->in.count == NULL) {
5877                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5878                 }
5879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
5880         }
5881         if (flags & NDR_OUT) {
5882                 if (r->out.domains == NULL) {
5883                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5884                 }
5885                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
5886                 if (*r->out.domains) {
5887                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
5888                 }
5889                 if (r->out.sids == NULL) {
5890                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5891                 }
5892                 NDR_CHECK(ndr_push_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
5893                 if (r->out.count == NULL) {
5894                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5895                 }
5896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
5897                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5898         }
5899         return NDR_ERR_SUCCESS;
5900 }
5901
5902 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupNames(struct ndr_pull *ndr, int flags, struct lsa_LookupNames *r)
5903 {
5904         uint32_t cntr_names_0;
5905         uint32_t _ptr_domains;
5906         TALLOC_CTX *_mem_save_handle_0;
5907         TALLOC_CTX *_mem_save_names_0;
5908         TALLOC_CTX *_mem_save_domains_0;
5909         TALLOC_CTX *_mem_save_domains_1;
5910         TALLOC_CTX *_mem_save_sids_0;
5911         TALLOC_CTX *_mem_save_count_0;
5912         if (flags & NDR_IN) {
5913                 ZERO_STRUCT(r->out);
5914
5915                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5916                         NDR_PULL_ALLOC(ndr, r->in.handle);
5917                 }
5918                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5919                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5920                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5921                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
5923                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
5924                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5925                 }
5926                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
5927                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
5928                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5929                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
5930                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5931                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
5932                 }
5933                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5934                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
5935                 }
5936                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5938                         NDR_PULL_ALLOC(ndr, r->in.sids);
5939                 }
5940                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
5941                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
5942                 NDR_CHECK(ndr_pull_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
5943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
5944                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
5945                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5946                         NDR_PULL_ALLOC(ndr, r->in.count);
5947                 }
5948                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
5949                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
5950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
5951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
5952                 NDR_PULL_ALLOC(ndr, r->out.domains);
5953                 ZERO_STRUCTP(r->out.domains);
5954                 NDR_PULL_ALLOC(ndr, r->out.sids);
5955                 *r->out.sids = *r->in.sids;
5956                 NDR_PULL_ALLOC(ndr, r->out.count);
5957                 *r->out.count = *r->in.count;
5958                 if (r->in.names) {
5959                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
5960                 }
5961         }
5962         if (flags & NDR_OUT) {
5963                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5964                         NDR_PULL_ALLOC(ndr, r->out.domains);
5965                 }
5966                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
5967                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
5968                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
5969                 if (_ptr_domains) {
5970                         NDR_PULL_ALLOC(ndr, *r->out.domains);
5971                 } else {
5972                         *r->out.domains = NULL;
5973                 }
5974                 if (*r->out.domains) {
5975                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
5976                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
5977                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
5978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
5979                 }
5980                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
5981                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5982                         NDR_PULL_ALLOC(ndr, r->out.sids);
5983                 }
5984                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
5985                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
5986                 NDR_CHECK(ndr_pull_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
5987                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
5988                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5989                         NDR_PULL_ALLOC(ndr, r->out.count);
5990                 }
5991                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
5992                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
5993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
5994                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
5995                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5996         }
5997         return NDR_ERR_SUCCESS;
5998 }
5999
6000 _PUBLIC_ void ndr_print_lsa_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames *r)
6001 {
6002         uint32_t cntr_names_0;
6003         ndr_print_struct(ndr, name, "lsa_LookupNames");
6004         ndr->depth++;
6005         if (flags & NDR_SET_VALUES) {
6006                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6007         }
6008         if (flags & NDR_IN) {
6009                 ndr_print_struct(ndr, "in", "lsa_LookupNames");
6010                 ndr->depth++;
6011                 ndr_print_ptr(ndr, "handle", r->in.handle);
6012                 ndr->depth++;
6013                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6014                 ndr->depth--;
6015                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
6016                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
6017                 ndr->depth++;
6018                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
6019                         char *idx_0=NULL;
6020                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
6021                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
6022                                 free(idx_0);
6023                         }
6024                 }
6025                 ndr->depth--;
6026                 ndr_print_ptr(ndr, "sids", r->in.sids);
6027                 ndr->depth++;
6028                 ndr_print_lsa_TransSidArray(ndr, "sids", r->in.sids);
6029                 ndr->depth--;
6030                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
6031                 ndr_print_ptr(ndr, "count", r->in.count);
6032                 ndr->depth++;
6033                 ndr_print_uint32(ndr, "count", *r->in.count);
6034                 ndr->depth--;
6035                 ndr->depth--;
6036         }
6037         if (flags & NDR_OUT) {
6038                 ndr_print_struct(ndr, "out", "lsa_LookupNames");
6039                 ndr->depth++;
6040                 ndr_print_ptr(ndr, "domains", r->out.domains);
6041                 ndr->depth++;
6042                 ndr_print_ptr(ndr, "domains", *r->out.domains);
6043                 ndr->depth++;
6044                 if (*r->out.domains) {
6045                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
6046                 }
6047                 ndr->depth--;
6048                 ndr->depth--;
6049                 ndr_print_ptr(ndr, "sids", r->out.sids);
6050                 ndr->depth++;
6051                 ndr_print_lsa_TransSidArray(ndr, "sids", r->out.sids);
6052                 ndr->depth--;
6053                 ndr_print_ptr(ndr, "count", r->out.count);
6054                 ndr->depth++;
6055                 ndr_print_uint32(ndr, "count", *r->out.count);
6056                 ndr->depth--;
6057                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6058                 ndr->depth--;
6059         }
6060         ndr->depth--;
6061 }
6062
6063 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupSids(struct ndr_push *ndr, int flags, const struct lsa_LookupSids *r)
6064 {
6065         if (flags & NDR_IN) {
6066                 if (r->in.handle == NULL) {
6067                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6068                 }
6069                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6070                 if (r->in.sids == NULL) {
6071                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6072                 }
6073                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
6074                 if (r->in.names == NULL) {
6075                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6076                 }
6077                 NDR_CHECK(ndr_push_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
6078                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
6079                 if (r->in.count == NULL) {
6080                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6081                 }
6082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
6083         }
6084         if (flags & NDR_OUT) {
6085                 if (r->out.domains == NULL) {
6086                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6087                 }
6088                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
6089                 if (*r->out.domains) {
6090                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
6091                 }
6092                 if (r->out.names == NULL) {
6093                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6094                 }
6095                 NDR_CHECK(ndr_push_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
6096                 if (r->out.count == NULL) {
6097                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6098                 }
6099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
6100                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6101         }
6102         return NDR_ERR_SUCCESS;
6103 }
6104
6105 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupSids(struct ndr_pull *ndr, int flags, struct lsa_LookupSids *r)
6106 {
6107         uint32_t _ptr_domains;
6108         TALLOC_CTX *_mem_save_handle_0;
6109         TALLOC_CTX *_mem_save_sids_0;
6110         TALLOC_CTX *_mem_save_domains_0;
6111         TALLOC_CTX *_mem_save_domains_1;
6112         TALLOC_CTX *_mem_save_names_0;
6113         TALLOC_CTX *_mem_save_count_0;
6114         if (flags & NDR_IN) {
6115                 ZERO_STRUCT(r->out);
6116
6117                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6118                         NDR_PULL_ALLOC(ndr, r->in.handle);
6119                 }
6120                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6121                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6122                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6123                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6124                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6125                         NDR_PULL_ALLOC(ndr, r->in.sids);
6126                 }
6127                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
6128                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
6129                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
6130                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
6131                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6132                         NDR_PULL_ALLOC(ndr, r->in.names);
6133                 }
6134                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6135                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
6136                 NDR_CHECK(ndr_pull_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
6137                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
6138                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
6139                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6140                         NDR_PULL_ALLOC(ndr, r->in.count);
6141                 }
6142                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
6143                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
6144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
6145                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
6146                 NDR_PULL_ALLOC(ndr, r->out.domains);
6147                 ZERO_STRUCTP(r->out.domains);
6148                 NDR_PULL_ALLOC(ndr, r->out.names);
6149                 *r->out.names = *r->in.names;
6150                 NDR_PULL_ALLOC(ndr, r->out.count);
6151                 *r->out.count = *r->in.count;
6152         }
6153         if (flags & NDR_OUT) {
6154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6155                         NDR_PULL_ALLOC(ndr, r->out.domains);
6156                 }
6157                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
6158                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
6159                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
6160                 if (_ptr_domains) {
6161                         NDR_PULL_ALLOC(ndr, *r->out.domains);
6162                 } else {
6163                         *r->out.domains = NULL;
6164                 }
6165                 if (*r->out.domains) {
6166                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
6167                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
6168                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
6169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
6170                 }
6171                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
6172                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6173                         NDR_PULL_ALLOC(ndr, r->out.names);
6174                 }
6175                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6176                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
6177                 NDR_CHECK(ndr_pull_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
6178                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
6179                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6180                         NDR_PULL_ALLOC(ndr, r->out.count);
6181                 }
6182                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
6183                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
6184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
6185                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
6186                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6187         }
6188         return NDR_ERR_SUCCESS;
6189 }
6190
6191 _PUBLIC_ void ndr_print_lsa_LookupSids(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids *r)
6192 {
6193         ndr_print_struct(ndr, name, "lsa_LookupSids");
6194         ndr->depth++;
6195         if (flags & NDR_SET_VALUES) {
6196                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6197         }
6198         if (flags & NDR_IN) {
6199                 ndr_print_struct(ndr, "in", "lsa_LookupSids");
6200                 ndr->depth++;
6201                 ndr_print_ptr(ndr, "handle", r->in.handle);
6202                 ndr->depth++;
6203                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6204                 ndr->depth--;
6205                 ndr_print_ptr(ndr, "sids", r->in.sids);
6206                 ndr->depth++;
6207                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
6208                 ndr->depth--;
6209                 ndr_print_ptr(ndr, "names", r->in.names);
6210                 ndr->depth++;
6211                 ndr_print_lsa_TransNameArray(ndr, "names", r->in.names);
6212                 ndr->depth--;
6213                 ndr_print_uint16(ndr, "level", r->in.level);
6214                 ndr_print_ptr(ndr, "count", r->in.count);
6215                 ndr->depth++;
6216                 ndr_print_uint32(ndr, "count", *r->in.count);
6217                 ndr->depth--;
6218                 ndr->depth--;
6219         }
6220         if (flags & NDR_OUT) {
6221                 ndr_print_struct(ndr, "out", "lsa_LookupSids");
6222                 ndr->depth++;
6223                 ndr_print_ptr(ndr, "domains", r->out.domains);
6224                 ndr->depth++;
6225                 ndr_print_ptr(ndr, "domains", *r->out.domains);
6226                 ndr->depth++;
6227                 if (*r->out.domains) {
6228                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
6229                 }
6230                 ndr->depth--;
6231                 ndr->depth--;
6232                 ndr_print_ptr(ndr, "names", r->out.names);
6233                 ndr->depth++;
6234                 ndr_print_lsa_TransNameArray(ndr, "names", r->out.names);
6235                 ndr->depth--;
6236                 ndr_print_ptr(ndr, "count", r->out.count);
6237                 ndr->depth++;
6238                 ndr_print_uint32(ndr, "count", *r->out.count);
6239                 ndr->depth--;
6240                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6241                 ndr->depth--;
6242         }
6243         ndr->depth--;
6244 }
6245
6246 _PUBLIC_ enum ndr_err_code ndr_push_lsa_CreateSecret(struct ndr_push *ndr, int flags, const struct lsa_CreateSecret *r)
6247 {
6248         if (flags & NDR_IN) {
6249                 if (r->in.handle == NULL) {
6250                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6251                 }
6252                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6253                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6255         }
6256         if (flags & NDR_OUT) {
6257                 if (r->out.sec_handle == NULL) {
6258                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6259                 }
6260                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
6261                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6262         }
6263         return NDR_ERR_SUCCESS;
6264 }
6265
6266 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_CreateSecret(struct ndr_pull *ndr, int flags, struct lsa_CreateSecret *r)
6267 {
6268         TALLOC_CTX *_mem_save_handle_0;
6269         TALLOC_CTX *_mem_save_sec_handle_0;
6270         if (flags & NDR_IN) {
6271                 ZERO_STRUCT(r->out);
6272
6273                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6274                         NDR_PULL_ALLOC(ndr, r->in.handle);
6275                 }
6276                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6277                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6278                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6279                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6280                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6282                 NDR_PULL_ALLOC(ndr, r->out.sec_handle);
6283                 ZERO_STRUCTP(r->out.sec_handle);
6284         }
6285         if (flags & NDR_OUT) {
6286                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6287                         NDR_PULL_ALLOC(ndr, r->out.sec_handle);
6288                 }
6289                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6290                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sec_handle, LIBNDR_FLAG_REF_ALLOC);
6291                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
6292                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
6293                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6294         }
6295         return NDR_ERR_SUCCESS;
6296 }
6297
6298 _PUBLIC_ void ndr_print_lsa_CreateSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateSecret *r)
6299 {
6300         ndr_print_struct(ndr, name, "lsa_CreateSecret");
6301         ndr->depth++;
6302         if (flags & NDR_SET_VALUES) {
6303                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6304         }
6305         if (flags & NDR_IN) {
6306                 ndr_print_struct(ndr, "in", "lsa_CreateSecret");
6307                 ndr->depth++;
6308                 ndr_print_ptr(ndr, "handle", r->in.handle);
6309                 ndr->depth++;
6310                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6311                 ndr->depth--;
6312                 ndr_print_lsa_String(ndr, "name", &r->in.name);
6313                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
6314                 ndr->depth--;
6315         }
6316         if (flags & NDR_OUT) {
6317                 ndr_print_struct(ndr, "out", "lsa_CreateSecret");
6318                 ndr->depth++;
6319                 ndr_print_ptr(ndr, "sec_handle", r->out.sec_handle);
6320                 ndr->depth++;
6321                 ndr_print_policy_handle(ndr, "sec_handle", r->out.sec_handle);
6322                 ndr->depth--;
6323                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6324                 ndr->depth--;
6325         }
6326         ndr->depth--;
6327 }
6328
6329 static enum ndr_err_code ndr_push_lsa_OpenAccount(struct ndr_push *ndr, int flags, const struct lsa_OpenAccount *r)
6330 {
6331         if (flags & NDR_IN) {
6332                 if (r->in.handle == NULL) {
6333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6334                 }
6335                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6336                 if (r->in.sid == NULL) {
6337                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6338                 }
6339                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6341         }
6342         if (flags & NDR_OUT) {
6343                 if (r->out.acct_handle == NULL) {
6344                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6345                 }
6346                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
6347                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6348         }
6349         return NDR_ERR_SUCCESS;
6350 }
6351
6352 static enum ndr_err_code ndr_pull_lsa_OpenAccount(struct ndr_pull *ndr, int flags, struct lsa_OpenAccount *r)
6353 {
6354         TALLOC_CTX *_mem_save_handle_0;
6355         TALLOC_CTX *_mem_save_sid_0;
6356         TALLOC_CTX *_mem_save_acct_handle_0;
6357         if (flags & NDR_IN) {
6358                 ZERO_STRUCT(r->out);
6359
6360                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6361                         NDR_PULL_ALLOC(ndr, r->in.handle);
6362                 }
6363                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6364                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6365                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6367                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6368                         NDR_PULL_ALLOC(ndr, r->in.sid);
6369                 }
6370                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6371                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6372                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6373                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6375                 NDR_PULL_ALLOC(ndr, r->out.acct_handle);
6376                 ZERO_STRUCTP(r->out.acct_handle);
6377         }
6378         if (flags & NDR_OUT) {
6379                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6380                         NDR_PULL_ALLOC(ndr, r->out.acct_handle);
6381                 }
6382                 _mem_save_acct_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6383                 NDR_PULL_SET_MEM_CTX(ndr, r->out.acct_handle, LIBNDR_FLAG_REF_ALLOC);
6384                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
6385                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_handle_0, LIBNDR_FLAG_REF_ALLOC);
6386                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6387         }
6388         return NDR_ERR_SUCCESS;
6389 }
6390
6391 _PUBLIC_ void ndr_print_lsa_OpenAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenAccount *r)
6392 {
6393         ndr_print_struct(ndr, name, "lsa_OpenAccount");
6394         ndr->depth++;
6395         if (flags & NDR_SET_VALUES) {
6396                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6397         }
6398         if (flags & NDR_IN) {
6399                 ndr_print_struct(ndr, "in", "lsa_OpenAccount");
6400                 ndr->depth++;
6401                 ndr_print_ptr(ndr, "handle", r->in.handle);
6402                 ndr->depth++;
6403                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6404                 ndr->depth--;
6405                 ndr_print_ptr(ndr, "sid", r->in.sid);
6406                 ndr->depth++;
6407                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6408                 ndr->depth--;
6409                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
6410                 ndr->depth--;
6411         }
6412         if (flags & NDR_OUT) {
6413                 ndr_print_struct(ndr, "out", "lsa_OpenAccount");
6414                 ndr->depth++;
6415                 ndr_print_ptr(ndr, "acct_handle", r->out.acct_handle);
6416                 ndr->depth++;
6417                 ndr_print_policy_handle(ndr, "acct_handle", r->out.acct_handle);
6418                 ndr->depth--;
6419                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6420                 ndr->depth--;
6421         }
6422         ndr->depth--;
6423 }
6424
6425 static enum ndr_err_code ndr_push_lsa_EnumPrivsAccount(struct ndr_push *ndr, int flags, const struct lsa_EnumPrivsAccount *r)
6426 {
6427         if (flags & NDR_IN) {
6428                 if (r->in.handle == NULL) {
6429                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6430                 }
6431                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6432         }
6433         if (flags & NDR_OUT) {
6434                 if (r->out.privs == NULL) {
6435                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6436                 }
6437                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.privs));
6438                 if (*r->out.privs) {
6439                         NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, *r->out.privs));
6440                 }
6441                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6442         }
6443         return NDR_ERR_SUCCESS;
6444 }
6445
6446 static enum ndr_err_code ndr_pull_lsa_EnumPrivsAccount(struct ndr_pull *ndr, int flags, struct lsa_EnumPrivsAccount *r)
6447 {
6448         uint32_t _ptr_privs;
6449         TALLOC_CTX *_mem_save_handle_0;
6450         TALLOC_CTX *_mem_save_privs_0;
6451         TALLOC_CTX *_mem_save_privs_1;
6452         if (flags & NDR_IN) {
6453                 ZERO_STRUCT(r->out);
6454
6455                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6456                         NDR_PULL_ALLOC(ndr, r->in.handle);
6457                 }
6458                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6459                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6460                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6461                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6462                 NDR_PULL_ALLOC(ndr, r->out.privs);
6463                 ZERO_STRUCTP(r->out.privs);
6464         }
6465         if (flags & NDR_OUT) {
6466                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6467                         NDR_PULL_ALLOC(ndr, r->out.privs);
6468                 }
6469                 _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
6470                 NDR_PULL_SET_MEM_CTX(ndr, r->out.privs, LIBNDR_FLAG_REF_ALLOC);
6471                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
6472                 if (_ptr_privs) {
6473                         NDR_PULL_ALLOC(ndr, *r->out.privs);
6474                 } else {
6475                         *r->out.privs = NULL;
6476                 }
6477                 if (*r->out.privs) {
6478                         _mem_save_privs_1 = NDR_PULL_GET_MEM_CTX(ndr);
6479                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.privs, 0);
6480                         NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, *r->out.privs));
6481                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_1, 0);
6482                 }
6483                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, LIBNDR_FLAG_REF_ALLOC);
6484                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6485         }
6486         return NDR_ERR_SUCCESS;
6487 }
6488
6489 _PUBLIC_ void ndr_print_lsa_EnumPrivsAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumPrivsAccount *r)
6490 {
6491         ndr_print_struct(ndr, name, "lsa_EnumPrivsAccount");
6492         ndr->depth++;
6493         if (flags & NDR_SET_VALUES) {
6494                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6495         }
6496         if (flags & NDR_IN) {
6497                 ndr_print_struct(ndr, "in", "lsa_EnumPrivsAccount");
6498                 ndr->depth++;
6499                 ndr_print_ptr(ndr, "handle", r->in.handle);
6500                 ndr->depth++;
6501                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6502                 ndr->depth--;
6503                 ndr->depth--;
6504         }
6505         if (flags & NDR_OUT) {
6506                 ndr_print_struct(ndr, "out", "lsa_EnumPrivsAccount");
6507                 ndr->depth++;
6508                 ndr_print_ptr(ndr, "privs", r->out.privs);
6509                 ndr->depth++;
6510                 ndr_print_ptr(ndr, "privs", *r->out.privs);
6511                 ndr->depth++;
6512                 if (*r->out.privs) {
6513                         ndr_print_lsa_PrivilegeSet(ndr, "privs", *r->out.privs);
6514                 }
6515                 ndr->depth--;
6516                 ndr->depth--;
6517                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6518                 ndr->depth--;
6519         }
6520         ndr->depth--;
6521 }
6522
6523 static enum ndr_err_code ndr_push_lsa_AddPrivilegesToAccount(struct ndr_push *ndr, int flags, const struct lsa_AddPrivilegesToAccount *r)
6524 {
6525         if (flags & NDR_IN) {
6526                 if (r->in.handle == NULL) {
6527                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6528                 }
6529                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6530                 if (r->in.privs == NULL) {
6531                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6532                 }
6533                 NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
6534         }
6535         if (flags & NDR_OUT) {
6536                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6537         }
6538         return NDR_ERR_SUCCESS;
6539 }
6540
6541 static enum ndr_err_code ndr_pull_lsa_AddPrivilegesToAccount(struct ndr_pull *ndr, int flags, struct lsa_AddPrivilegesToAccount *r)
6542 {
6543         TALLOC_CTX *_mem_save_handle_0;
6544         TALLOC_CTX *_mem_save_privs_0;
6545         if (flags & NDR_IN) {
6546                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6547                         NDR_PULL_ALLOC(ndr, r->in.handle);
6548                 }
6549                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6550                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6551                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6552                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6554                         NDR_PULL_ALLOC(ndr, r->in.privs);
6555                 }
6556                 _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
6557                 NDR_PULL_SET_MEM_CTX(ndr, r->in.privs, LIBNDR_FLAG_REF_ALLOC);
6558                 NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
6559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, LIBNDR_FLAG_REF_ALLOC);
6560         }
6561         if (flags & NDR_OUT) {
6562                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6563         }
6564         return NDR_ERR_SUCCESS;
6565 }
6566
6567 _PUBLIC_ void ndr_print_lsa_AddPrivilegesToAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_AddPrivilegesToAccount *r)
6568 {
6569         ndr_print_struct(ndr, name, "lsa_AddPrivilegesToAccount");
6570         ndr->depth++;
6571         if (flags & NDR_SET_VALUES) {
6572                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6573         }
6574         if (flags & NDR_IN) {
6575                 ndr_print_struct(ndr, "in", "lsa_AddPrivilegesToAccount");
6576                 ndr->depth++;
6577                 ndr_print_ptr(ndr, "handle", r->in.handle);
6578                 ndr->depth++;
6579                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6580                 ndr->depth--;
6581                 ndr_print_ptr(ndr, "privs", r->in.privs);
6582                 ndr->depth++;
6583                 ndr_print_lsa_PrivilegeSet(ndr, "privs", r->in.privs);
6584                 ndr->depth--;
6585                 ndr->depth--;
6586         }
6587         if (flags & NDR_OUT) {
6588                 ndr_print_struct(ndr, "out", "lsa_AddPrivilegesToAccount");
6589                 ndr->depth++;
6590                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6591                 ndr->depth--;
6592         }
6593         ndr->depth--;
6594 }
6595
6596 static enum ndr_err_code ndr_push_lsa_RemovePrivilegesFromAccount(struct ndr_push *ndr, int flags, const struct lsa_RemovePrivilegesFromAccount *r)
6597 {
6598         if (flags & NDR_IN) {
6599                 if (r->in.handle == NULL) {
6600                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6601                 }
6602                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6603                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.remove_all));
6604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.privs));
6605                 if (r->in.privs) {
6606                         NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
6607                 }
6608         }
6609         if (flags & NDR_OUT) {
6610                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6611         }
6612         return NDR_ERR_SUCCESS;
6613 }
6614
6615 static enum ndr_err_code ndr_pull_lsa_RemovePrivilegesFromAccount(struct ndr_pull *ndr, int flags, struct lsa_RemovePrivilegesFromAccount *r)
6616 {
6617         uint32_t _ptr_privs;
6618         TALLOC_CTX *_mem_save_handle_0;
6619         TALLOC_CTX *_mem_save_privs_0;
6620         if (flags & NDR_IN) {
6621                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6622                         NDR_PULL_ALLOC(ndr, r->in.handle);
6623                 }
6624                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6625                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6626                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6627                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6628                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.remove_all));
6629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
6630                 if (_ptr_privs) {
6631                         NDR_PULL_ALLOC(ndr, r->in.privs);
6632                 } else {
6633                         r->in.privs = NULL;
6634                 }
6635                 if (r->in.privs) {
6636                         _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
6637                         NDR_PULL_SET_MEM_CTX(ndr, r->in.privs, 0);
6638                         NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
6639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, 0);
6640                 }
6641         }
6642         if (flags & NDR_OUT) {
6643                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6644         }
6645         return NDR_ERR_SUCCESS;
6646 }
6647
6648 _PUBLIC_ void ndr_print_lsa_RemovePrivilegesFromAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RemovePrivilegesFromAccount *r)
6649 {
6650         ndr_print_struct(ndr, name, "lsa_RemovePrivilegesFromAccount");
6651         ndr->depth++;
6652         if (flags & NDR_SET_VALUES) {
6653                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6654         }
6655         if (flags & NDR_IN) {
6656                 ndr_print_struct(ndr, "in", "lsa_RemovePrivilegesFromAccount");
6657                 ndr->depth++;
6658                 ndr_print_ptr(ndr, "handle", r->in.handle);
6659                 ndr->depth++;
6660                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6661                 ndr->depth--;
6662                 ndr_print_uint8(ndr, "remove_all", r->in.remove_all);
6663                 ndr_print_ptr(ndr, "privs", r->in.privs);
6664                 ndr->depth++;
6665                 if (r->in.privs) {
6666                         ndr_print_lsa_PrivilegeSet(ndr, "privs", r->in.privs);
6667                 }
6668                 ndr->depth--;
6669                 ndr->depth--;
6670         }
6671         if (flags & NDR_OUT) {
6672                 ndr_print_struct(ndr, "out", "lsa_RemovePrivilegesFromAccount");
6673                 ndr->depth++;
6674                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6675                 ndr->depth--;
6676         }
6677         ndr->depth--;
6678 }
6679
6680 static enum ndr_err_code ndr_push_lsa_GetQuotasForAccount(struct ndr_push *ndr, int flags, const struct lsa_GetQuotasForAccount *r)
6681 {
6682         if (flags & NDR_IN) {
6683         }
6684         if (flags & NDR_OUT) {
6685                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6686         }
6687         return NDR_ERR_SUCCESS;
6688 }
6689
6690 static enum ndr_err_code ndr_pull_lsa_GetQuotasForAccount(struct ndr_pull *ndr, int flags, struct lsa_GetQuotasForAccount *r)
6691 {
6692         if (flags & NDR_IN) {
6693         }
6694         if (flags & NDR_OUT) {
6695                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6696         }
6697         return NDR_ERR_SUCCESS;
6698 }
6699
6700 _PUBLIC_ void ndr_print_lsa_GetQuotasForAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetQuotasForAccount *r)
6701 {
6702         ndr_print_struct(ndr, name, "lsa_GetQuotasForAccount");
6703         ndr->depth++;
6704         if (flags & NDR_SET_VALUES) {
6705                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6706         }
6707         if (flags & NDR_IN) {
6708                 ndr_print_struct(ndr, "in", "lsa_GetQuotasForAccount");
6709                 ndr->depth++;
6710                 ndr->depth--;
6711         }
6712         if (flags & NDR_OUT) {
6713                 ndr_print_struct(ndr, "out", "lsa_GetQuotasForAccount");
6714                 ndr->depth++;
6715                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6716                 ndr->depth--;
6717         }
6718         ndr->depth--;
6719 }
6720
6721 static enum ndr_err_code ndr_push_lsa_SetQuotasForAccount(struct ndr_push *ndr, int flags, const struct lsa_SetQuotasForAccount *r)
6722 {
6723         if (flags & NDR_IN) {
6724         }
6725         if (flags & NDR_OUT) {
6726                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6727         }
6728         return NDR_ERR_SUCCESS;
6729 }
6730
6731 static enum ndr_err_code ndr_pull_lsa_SetQuotasForAccount(struct ndr_pull *ndr, int flags, struct lsa_SetQuotasForAccount *r)
6732 {
6733         if (flags & NDR_IN) {
6734         }
6735         if (flags & NDR_OUT) {
6736                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6737         }
6738         return NDR_ERR_SUCCESS;
6739 }
6740
6741 _PUBLIC_ void ndr_print_lsa_SetQuotasForAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetQuotasForAccount *r)
6742 {
6743         ndr_print_struct(ndr, name, "lsa_SetQuotasForAccount");
6744         ndr->depth++;
6745         if (flags & NDR_SET_VALUES) {
6746                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6747         }
6748         if (flags & NDR_IN) {
6749                 ndr_print_struct(ndr, "in", "lsa_SetQuotasForAccount");
6750                 ndr->depth++;
6751                 ndr->depth--;
6752         }
6753         if (flags & NDR_OUT) {
6754                 ndr_print_struct(ndr, "out", "lsa_SetQuotasForAccount");
6755                 ndr->depth++;
6756                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6757                 ndr->depth--;
6758         }
6759         ndr->depth--;
6760 }
6761
6762 static enum ndr_err_code ndr_push_lsa_GetSystemAccessAccount(struct ndr_push *ndr, int flags, const struct lsa_GetSystemAccessAccount *r)
6763 {
6764         if (flags & NDR_IN) {
6765                 if (r->in.handle == NULL) {
6766                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6767                 }
6768                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6769         }
6770         if (flags & NDR_OUT) {
6771                 if (r->out.access_mask == NULL) {
6772                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6773                 }
6774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.access_mask));
6775                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6776         }
6777         return NDR_ERR_SUCCESS;
6778 }
6779
6780 static enum ndr_err_code ndr_pull_lsa_GetSystemAccessAccount(struct ndr_pull *ndr, int flags, struct lsa_GetSystemAccessAccount *r)
6781 {
6782         TALLOC_CTX *_mem_save_handle_0;
6783         TALLOC_CTX *_mem_save_access_mask_0;
6784         if (flags & NDR_IN) {
6785                 ZERO_STRUCT(r->out);
6786
6787                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6788                         NDR_PULL_ALLOC(ndr, r->in.handle);
6789                 }
6790                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6791                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6792                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6793                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6794                 NDR_PULL_ALLOC(ndr, r->out.access_mask);
6795                 ZERO_STRUCTP(r->out.access_mask);
6796         }
6797         if (flags & NDR_OUT) {
6798                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6799                         NDR_PULL_ALLOC(ndr, r->out.access_mask);
6800                 }
6801                 _mem_save_access_mask_0 = NDR_PULL_GET_MEM_CTX(ndr);
6802                 NDR_PULL_SET_MEM_CTX(ndr, r->out.access_mask, LIBNDR_FLAG_REF_ALLOC);
6803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.access_mask));
6804                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_mask_0, LIBNDR_FLAG_REF_ALLOC);
6805                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6806         }
6807         return NDR_ERR_SUCCESS;
6808 }
6809
6810 _PUBLIC_ void ndr_print_lsa_GetSystemAccessAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetSystemAccessAccount *r)
6811 {
6812         ndr_print_struct(ndr, name, "lsa_GetSystemAccessAccount");
6813         ndr->depth++;
6814         if (flags & NDR_SET_VALUES) {
6815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6816         }
6817         if (flags & NDR_IN) {
6818                 ndr_print_struct(ndr, "in", "lsa_GetSystemAccessAccount");
6819                 ndr->depth++;
6820                 ndr_print_ptr(ndr, "handle", r->in.handle);
6821                 ndr->depth++;
6822                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6823                 ndr->depth--;
6824                 ndr->depth--;
6825         }
6826         if (flags & NDR_OUT) {
6827                 ndr_print_struct(ndr, "out", "lsa_GetSystemAccessAccount");
6828                 ndr->depth++;
6829                 ndr_print_ptr(ndr, "access_mask", r->out.access_mask);
6830                 ndr->depth++;
6831                 ndr_print_uint32(ndr, "access_mask", *r->out.access_mask);
6832                 ndr->depth--;
6833                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6834                 ndr->depth--;
6835         }
6836         ndr->depth--;
6837 }
6838
6839 static enum ndr_err_code ndr_push_lsa_SetSystemAccessAccount(struct ndr_push *ndr, int flags, const struct lsa_SetSystemAccessAccount *r)
6840 {
6841         if (flags & NDR_IN) {
6842                 if (r->in.handle == NULL) {
6843                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6844                 }
6845                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6847         }
6848         if (flags & NDR_OUT) {
6849                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6850         }
6851         return NDR_ERR_SUCCESS;
6852 }
6853
6854 static enum ndr_err_code ndr_pull_lsa_SetSystemAccessAccount(struct ndr_pull *ndr, int flags, struct lsa_SetSystemAccessAccount *r)
6855 {
6856         TALLOC_CTX *_mem_save_handle_0;
6857         if (flags & NDR_IN) {
6858                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6859                         NDR_PULL_ALLOC(ndr, r->in.handle);
6860                 }
6861                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6862                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6863                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6864                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6866         }
6867         if (flags & NDR_OUT) {
6868                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6869         }
6870         return NDR_ERR_SUCCESS;
6871 }
6872
6873 _PUBLIC_ void ndr_print_lsa_SetSystemAccessAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSystemAccessAccount *r)
6874 {
6875         ndr_print_struct(ndr, name, "lsa_SetSystemAccessAccount");
6876         ndr->depth++;
6877         if (flags & NDR_SET_VALUES) {
6878                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6879         }
6880         if (flags & NDR_IN) {
6881                 ndr_print_struct(ndr, "in", "lsa_SetSystemAccessAccount");
6882                 ndr->depth++;
6883                 ndr_print_ptr(ndr, "handle", r->in.handle);
6884                 ndr->depth++;
6885                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6886                 ndr->depth--;
6887                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
6888                 ndr->depth--;
6889         }
6890         if (flags & NDR_OUT) {
6891                 ndr_print_struct(ndr, "out", "lsa_SetSystemAccessAccount");
6892                 ndr->depth++;
6893                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6894                 ndr->depth--;
6895         }
6896         ndr->depth--;
6897 }
6898
6899 static enum ndr_err_code ndr_push_lsa_OpenTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_OpenTrustedDomain *r)
6900 {
6901         if (flags & NDR_IN) {
6902                 if (r->in.handle == NULL) {
6903                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6904                 }
6905                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6906                 if (r->in.sid == NULL) {
6907                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6908                 }
6909                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6911         }
6912         if (flags & NDR_OUT) {
6913                 if (r->out.trustdom_handle == NULL) {
6914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6915                 }
6916                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
6917                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6918         }
6919         return NDR_ERR_SUCCESS;
6920 }
6921
6922 static enum ndr_err_code ndr_pull_lsa_OpenTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_OpenTrustedDomain *r)
6923 {
6924         TALLOC_CTX *_mem_save_handle_0;
6925         TALLOC_CTX *_mem_save_sid_0;
6926         TALLOC_CTX *_mem_save_trustdom_handle_0;
6927         if (flags & NDR_IN) {
6928                 ZERO_STRUCT(r->out);
6929
6930                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6931                         NDR_PULL_ALLOC(ndr, r->in.handle);
6932                 }
6933                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6934                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6935                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6936                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6938                         NDR_PULL_ALLOC(ndr, r->in.sid);
6939                 }
6940                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6941                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6942                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6945                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
6946                 ZERO_STRUCTP(r->out.trustdom_handle);
6947         }
6948         if (flags & NDR_OUT) {
6949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6950                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
6951                 }
6952                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6953                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
6954                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
6955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
6956                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6957         }
6958         return NDR_ERR_SUCCESS;
6959 }
6960
6961 _PUBLIC_ void ndr_print_lsa_OpenTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenTrustedDomain *r)
6962 {
6963         ndr_print_struct(ndr, name, "lsa_OpenTrustedDomain");
6964         ndr->depth++;
6965         if (flags & NDR_SET_VALUES) {
6966                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6967         }
6968         if (flags & NDR_IN) {
6969                 ndr_print_struct(ndr, "in", "lsa_OpenTrustedDomain");
6970                 ndr->depth++;
6971                 ndr_print_ptr(ndr, "handle", r->in.handle);
6972                 ndr->depth++;
6973                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6974                 ndr->depth--;
6975                 ndr_print_ptr(ndr, "sid", r->in.sid);
6976                 ndr->depth++;
6977                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6978                 ndr->depth--;
6979                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
6980                 ndr->depth--;
6981         }
6982         if (flags & NDR_OUT) {
6983                 ndr_print_struct(ndr, "out", "lsa_OpenTrustedDomain");
6984                 ndr->depth++;
6985                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
6986                 ndr->depth++;
6987                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
6988                 ndr->depth--;
6989                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6990                 ndr->depth--;
6991         }
6992         ndr->depth--;
6993 }
6994
6995 static enum ndr_err_code ndr_push_lsa_QueryTrustedDomainInfo(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfo *r)
6996 {
6997         if (flags & NDR_IN) {
6998                 if (r->in.trustdom_handle == NULL) {
6999                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7000                 }
7001                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trustdom_handle));
7002                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
7003         }
7004         if (flags & NDR_OUT) {
7005                 if (r->out.info == NULL) {
7006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7007                 }
7008                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
7009                 if (*r->out.info) {
7010                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
7011                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7012                 }
7013                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7014         }
7015         return NDR_ERR_SUCCESS;
7016 }
7017
7018 static enum ndr_err_code ndr_pull_lsa_QueryTrustedDomainInfo(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfo *r)
7019 {
7020         uint32_t _ptr_info;
7021         TALLOC_CTX *_mem_save_trustdom_handle_0;
7022         TALLOC_CTX *_mem_save_info_0;
7023         TALLOC_CTX *_mem_save_info_1;
7024         if (flags & NDR_IN) {
7025                 ZERO_STRUCT(r->out);
7026
7027                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7028                         NDR_PULL_ALLOC(ndr, r->in.trustdom_handle);
7029                 }
7030                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7031                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
7032                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trustdom_handle));
7033                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
7034                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7035                 NDR_PULL_ALLOC(ndr, r->out.info);
7036                 ZERO_STRUCTP(r->out.info);
7037         }
7038         if (flags & NDR_OUT) {
7039                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7040                         NDR_PULL_ALLOC(ndr, r->out.info);
7041                 }
7042                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7043                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7044                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7045                 if (_ptr_info) {
7046                         NDR_PULL_ALLOC(ndr, *r->out.info);
7047                 } else {
7048                         *r->out.info = NULL;
7049                 }
7050                 if (*r->out.info) {
7051                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7052                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
7053                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
7054                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
7056                 }
7057                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7058                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7059         }
7060         return NDR_ERR_SUCCESS;
7061 }
7062
7063 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfo *r)
7064 {
7065         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfo");
7066         ndr->depth++;
7067         if (flags & NDR_SET_VALUES) {
7068                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7069         }
7070         if (flags & NDR_IN) {
7071                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfo");
7072                 ndr->depth++;
7073                 ndr_print_ptr(ndr, "trustdom_handle", r->in.trustdom_handle);
7074                 ndr->depth++;
7075                 ndr_print_policy_handle(ndr, "trustdom_handle", r->in.trustdom_handle);
7076                 ndr->depth--;
7077                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
7078                 ndr->depth--;
7079         }
7080         if (flags & NDR_OUT) {
7081                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfo");
7082                 ndr->depth++;
7083                 ndr_print_ptr(ndr, "info", r->out.info);
7084                 ndr->depth++;
7085                 ndr_print_ptr(ndr, "info", *r->out.info);
7086                 ndr->depth++;
7087                 if (*r->out.info) {
7088                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
7089                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", *r->out.info);
7090                 }
7091                 ndr->depth--;
7092                 ndr->depth--;
7093                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7094                 ndr->depth--;
7095         }
7096         ndr->depth--;
7097 }
7098
7099 static enum ndr_err_code ndr_push_lsa_SetInformationTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_SetInformationTrustedDomain *r)
7100 {
7101         if (flags & NDR_IN) {
7102         }
7103         if (flags & NDR_OUT) {
7104                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7105         }
7106         return NDR_ERR_SUCCESS;
7107 }
7108
7109 static enum ndr_err_code ndr_pull_lsa_SetInformationTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_SetInformationTrustedDomain *r)
7110 {
7111         if (flags & NDR_IN) {
7112         }
7113         if (flags & NDR_OUT) {
7114                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7115         }
7116         return NDR_ERR_SUCCESS;
7117 }
7118
7119 _PUBLIC_ void ndr_print_lsa_SetInformationTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInformationTrustedDomain *r)
7120 {
7121         ndr_print_struct(ndr, name, "lsa_SetInformationTrustedDomain");
7122         ndr->depth++;
7123         if (flags & NDR_SET_VALUES) {
7124                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7125         }
7126         if (flags & NDR_IN) {
7127                 ndr_print_struct(ndr, "in", "lsa_SetInformationTrustedDomain");
7128                 ndr->depth++;
7129                 ndr->depth--;
7130         }
7131         if (flags & NDR_OUT) {
7132                 ndr_print_struct(ndr, "out", "lsa_SetInformationTrustedDomain");
7133                 ndr->depth++;
7134                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7135                 ndr->depth--;
7136         }
7137         ndr->depth--;
7138 }
7139
7140 _PUBLIC_ enum ndr_err_code ndr_push_lsa_OpenSecret(struct ndr_push *ndr, int flags, const struct lsa_OpenSecret *r)
7141 {
7142         if (flags & NDR_IN) {
7143                 if (r->in.handle == NULL) {
7144                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7145                 }
7146                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7147                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
7148                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
7149         }
7150         if (flags & NDR_OUT) {
7151                 if (r->out.sec_handle == NULL) {
7152                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7153                 }
7154                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
7155                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7156         }
7157         return NDR_ERR_SUCCESS;
7158 }
7159
7160 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_OpenSecret(struct ndr_pull *ndr, int flags, struct lsa_OpenSecret *r)
7161 {
7162         TALLOC_CTX *_mem_save_handle_0;
7163         TALLOC_CTX *_mem_save_sec_handle_0;
7164         if (flags & NDR_IN) {
7165                 ZERO_STRUCT(r->out);
7166
7167                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7168                         NDR_PULL_ALLOC(ndr, r->in.handle);
7169                 }
7170                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7171                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7172                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7173                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7174                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
7175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
7176                 NDR_PULL_ALLOC(ndr, r->out.sec_handle);
7177                 ZERO_STRUCTP(r->out.sec_handle);
7178         }
7179         if (flags & NDR_OUT) {
7180                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7181                         NDR_PULL_ALLOC(ndr, r->out.sec_handle);
7182                 }
7183                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7184                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sec_handle, LIBNDR_FLAG_REF_ALLOC);
7185                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
7186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
7187                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7188         }
7189         return NDR_ERR_SUCCESS;
7190 }
7191
7192 _PUBLIC_ void ndr_print_lsa_OpenSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenSecret *r)
7193 {
7194         ndr_print_struct(ndr, name, "lsa_OpenSecret");
7195         ndr->depth++;
7196         if (flags & NDR_SET_VALUES) {
7197                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7198         }
7199         if (flags & NDR_IN) {
7200                 ndr_print_struct(ndr, "in", "lsa_OpenSecret");
7201                 ndr->depth++;
7202                 ndr_print_ptr(ndr, "handle", r->in.handle);
7203                 ndr->depth++;
7204                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7205                 ndr->depth--;
7206                 ndr_print_lsa_String(ndr, "name", &r->in.name);
7207                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
7208                 ndr->depth--;
7209         }
7210         if (flags & NDR_OUT) {
7211                 ndr_print_struct(ndr, "out", "lsa_OpenSecret");
7212                 ndr->depth++;
7213                 ndr_print_ptr(ndr, "sec_handle", r->out.sec_handle);
7214                 ndr->depth++;
7215                 ndr_print_policy_handle(ndr, "sec_handle", r->out.sec_handle);
7216                 ndr->depth--;
7217                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7218                 ndr->depth--;
7219         }
7220         ndr->depth--;
7221 }
7222
7223 _PUBLIC_ enum ndr_err_code ndr_push_lsa_SetSecret(struct ndr_push *ndr, int flags, const struct lsa_SetSecret *r)
7224 {
7225         if (flags & NDR_IN) {
7226                 if (r->in.sec_handle == NULL) {
7227                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7228                 }
7229                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
7230                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_val));
7231                 if (r->in.new_val) {
7232                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7233                 }
7234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_val));
7235                 if (r->in.old_val) {
7236                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7237                 }
7238         }
7239         if (flags & NDR_OUT) {
7240                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7241         }
7242         return NDR_ERR_SUCCESS;
7243 }
7244
7245 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_SetSecret(struct ndr_pull *ndr, int flags, struct lsa_SetSecret *r)
7246 {
7247         uint32_t _ptr_new_val;
7248         uint32_t _ptr_old_val;
7249         TALLOC_CTX *_mem_save_sec_handle_0;
7250         TALLOC_CTX *_mem_save_new_val_0;
7251         TALLOC_CTX *_mem_save_old_val_0;
7252         if (flags & NDR_IN) {
7253                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7254                         NDR_PULL_ALLOC(ndr, r->in.sec_handle);
7255                 }
7256                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7257                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_handle, LIBNDR_FLAG_REF_ALLOC);
7258                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
7259                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
7260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
7261                 if (_ptr_new_val) {
7262                         NDR_PULL_ALLOC(ndr, r->in.new_val);
7263                 } else {
7264                         r->in.new_val = NULL;
7265                 }
7266                 if (r->in.new_val) {
7267                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7268                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_val, 0);
7269                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
7271                 }
7272                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
7273                 if (_ptr_old_val) {
7274                         NDR_PULL_ALLOC(ndr, r->in.old_val);
7275                 } else {
7276                         r->in.old_val = NULL;
7277                 }
7278                 if (r->in.old_val) {
7279                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7280                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_val, 0);
7281                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7282                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
7283                 }
7284         }
7285         if (flags & NDR_OUT) {
7286                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7287         }
7288         return NDR_ERR_SUCCESS;
7289 }
7290
7291 _PUBLIC_ void ndr_print_lsa_SetSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSecret *r)
7292 {
7293         ndr_print_struct(ndr, name, "lsa_SetSecret");
7294         ndr->depth++;
7295         if (flags & NDR_SET_VALUES) {
7296                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7297         }
7298         if (flags & NDR_IN) {
7299                 ndr_print_struct(ndr, "in", "lsa_SetSecret");
7300                 ndr->depth++;
7301                 ndr_print_ptr(ndr, "sec_handle", r->in.sec_handle);
7302                 ndr->depth++;
7303                 ndr_print_policy_handle(ndr, "sec_handle", r->in.sec_handle);
7304                 ndr->depth--;
7305                 ndr_print_ptr(ndr, "new_val", r->in.new_val);
7306                 ndr->depth++;
7307                 if (r->in.new_val) {
7308                         ndr_print_lsa_DATA_BUF(ndr, "new_val", r->in.new_val);
7309                 }
7310                 ndr->depth--;
7311                 ndr_print_ptr(ndr, "old_val", r->in.old_val);
7312                 ndr->depth++;
7313                 if (r->in.old_val) {
7314                         ndr_print_lsa_DATA_BUF(ndr, "old_val", r->in.old_val);
7315                 }
7316                 ndr->depth--;
7317                 ndr->depth--;
7318         }
7319         if (flags & NDR_OUT) {
7320                 ndr_print_struct(ndr, "out", "lsa_SetSecret");
7321                 ndr->depth++;
7322                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7323                 ndr->depth--;
7324         }
7325         ndr->depth--;
7326 }
7327
7328 _PUBLIC_ enum ndr_err_code ndr_push_lsa_QuerySecret(struct ndr_push *ndr, int flags, const struct lsa_QuerySecret *r)
7329 {
7330         if (flags & NDR_IN) {
7331                 if (r->in.sec_handle == NULL) {
7332                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7333                 }
7334                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
7335                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_val));
7336                 if (r->in.new_val) {
7337                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7338                 }
7339                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_mtime));
7340                 if (r->in.new_mtime) {
7341                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->in.new_mtime));
7342                 }
7343                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_val));
7344                 if (r->in.old_val) {
7345                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7346                 }
7347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_mtime));
7348                 if (r->in.old_mtime) {
7349                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->in.old_mtime));
7350                 }
7351         }
7352         if (flags & NDR_OUT) {
7353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.new_val));
7354                 if (r->out.new_val) {
7355                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.new_val));
7356                 }
7357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.new_mtime));
7358                 if (r->out.new_mtime) {
7359                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->out.new_mtime));
7360                 }
7361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.old_val));
7362                 if (r->out.old_val) {
7363                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.old_val));
7364                 }
7365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.old_mtime));
7366                 if (r->out.old_mtime) {
7367                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->out.old_mtime));
7368                 }
7369                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7370         }
7371         return NDR_ERR_SUCCESS;
7372 }
7373
7374 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_QuerySecret(struct ndr_pull *ndr, int flags, struct lsa_QuerySecret *r)
7375 {
7376         uint32_t _ptr_new_val;
7377         uint32_t _ptr_new_mtime;
7378         uint32_t _ptr_old_val;
7379         uint32_t _ptr_old_mtime;
7380         TALLOC_CTX *_mem_save_sec_handle_0;
7381         TALLOC_CTX *_mem_save_new_val_0;
7382         TALLOC_CTX *_mem_save_new_mtime_0;
7383         TALLOC_CTX *_mem_save_old_val_0;
7384         TALLOC_CTX *_mem_save_old_mtime_0;
7385         if (flags & NDR_IN) {
7386                 ZERO_STRUCT(r->out);
7387
7388                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7389                         NDR_PULL_ALLOC(ndr, r->in.sec_handle);
7390                 }
7391                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7392                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_handle, LIBNDR_FLAG_REF_ALLOC);
7393                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
7394                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
7395                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
7396                 if (_ptr_new_val) {
7397                         NDR_PULL_ALLOC(ndr, r->in.new_val);
7398                 } else {
7399                         r->in.new_val = NULL;
7400                 }
7401                 if (r->in.new_val) {
7402                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7403                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_val, 0);
7404                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7405                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
7406                 }
7407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_mtime));
7408                 if (_ptr_new_mtime) {
7409                         NDR_PULL_ALLOC(ndr, r->in.new_mtime);
7410                 } else {
7411                         r->in.new_mtime = NULL;
7412                 }
7413                 if (r->in.new_mtime) {
7414                         _mem_save_new_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
7415                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_mtime, 0);
7416                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->in.new_mtime));
7417                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_mtime_0, 0);
7418                 }
7419                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
7420                 if (_ptr_old_val) {
7421                         NDR_PULL_ALLOC(ndr, r->in.old_val);
7422                 } else {
7423                         r->in.old_val = NULL;
7424                 }
7425                 if (r->in.old_val) {
7426                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7427                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_val, 0);
7428                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7429                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
7430                 }
7431                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_mtime));
7432                 if (_ptr_old_mtime) {
7433                         NDR_PULL_ALLOC(ndr, r->in.old_mtime);
7434                 } else {
7435                         r->in.old_mtime = NULL;
7436                 }
7437                 if (r->in.old_mtime) {
7438                         _mem_save_old_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
7439                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_mtime, 0);
7440                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->in.old_mtime));
7441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_mtime_0, 0);
7442                 }
7443         }
7444         if (flags & NDR_OUT) {
7445                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
7446                 if (_ptr_new_val) {
7447                         NDR_PULL_ALLOC(ndr, r->out.new_val);
7448                 } else {
7449                         r->out.new_val = NULL;
7450                 }
7451                 if (r->out.new_val) {
7452                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7453                         NDR_PULL_SET_MEM_CTX(ndr, r->out.new_val, 0);
7454                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.new_val));
7455                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
7456                 }
7457                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_mtime));
7458                 if (_ptr_new_mtime) {
7459                         NDR_PULL_ALLOC(ndr, r->out.new_mtime);
7460                 } else {
7461                         r->out.new_mtime = NULL;
7462                 }
7463                 if (r->out.new_mtime) {
7464                         _mem_save_new_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
7465                         NDR_PULL_SET_MEM_CTX(ndr, r->out.new_mtime, 0);
7466                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->out.new_mtime));
7467                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_mtime_0, 0);
7468                 }
7469                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
7470                 if (_ptr_old_val) {
7471                         NDR_PULL_ALLOC(ndr, r->out.old_val);
7472                 } else {
7473                         r->out.old_val = NULL;
7474                 }
7475                 if (r->out.old_val) {
7476                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7477                         NDR_PULL_SET_MEM_CTX(ndr, r->out.old_val, 0);
7478                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.old_val));
7479                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
7480                 }
7481                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_mtime));
7482                 if (_ptr_old_mtime) {
7483                         NDR_PULL_ALLOC(ndr, r->out.old_mtime);
7484                 } else {
7485                         r->out.old_mtime = NULL;
7486                 }
7487                 if (r->out.old_mtime) {
7488                         _mem_save_old_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
7489                         NDR_PULL_SET_MEM_CTX(ndr, r->out.old_mtime, 0);
7490                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->out.old_mtime));
7491                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_mtime_0, 0);
7492                 }
7493                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7494         }
7495         return NDR_ERR_SUCCESS;
7496 }
7497
7498 _PUBLIC_ void ndr_print_lsa_QuerySecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QuerySecret *r)
7499 {
7500         ndr_print_struct(ndr, name, "lsa_QuerySecret");
7501         ndr->depth++;
7502         if (flags & NDR_SET_VALUES) {
7503                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7504         }
7505         if (flags & NDR_IN) {
7506                 ndr_print_struct(ndr, "in", "lsa_QuerySecret");
7507                 ndr->depth++;
7508                 ndr_print_ptr(ndr, "sec_handle", r->in.sec_handle);
7509                 ndr->depth++;
7510                 ndr_print_policy_handle(ndr, "sec_handle", r->in.sec_handle);
7511                 ndr->depth--;
7512                 ndr_print_ptr(ndr, "new_val", r->in.new_val);
7513                 ndr->depth++;
7514                 if (r->in.new_val) {
7515                         ndr_print_lsa_DATA_BUF_PTR(ndr, "new_val", r->in.new_val);
7516                 }
7517                 ndr->depth--;
7518                 ndr_print_ptr(ndr, "new_mtime", r->in.new_mtime);
7519                 ndr->depth++;
7520                 if (r->in.new_mtime) {
7521                         ndr_print_NTTIME_hyper(ndr, "new_mtime", *r->in.new_mtime);
7522                 }
7523                 ndr->depth--;
7524                 ndr_print_ptr(ndr, "old_val", r->in.old_val);
7525                 ndr->depth++;
7526                 if (r->in.old_val) {
7527                         ndr_print_lsa_DATA_BUF_PTR(ndr, "old_val", r->in.old_val);
7528                 }
7529                 ndr->depth--;
7530                 ndr_print_ptr(ndr, "old_mtime", r->in.old_mtime);
7531                 ndr->depth++;
7532                 if (r->in.old_mtime) {
7533                         ndr_print_NTTIME_hyper(ndr, "old_mtime", *r->in.old_mtime);
7534                 }
7535                 ndr->depth--;
7536                 ndr->depth--;
7537         }
7538         if (flags & NDR_OUT) {
7539                 ndr_print_struct(ndr, "out", "lsa_QuerySecret");
7540                 ndr->depth++;
7541                 ndr_print_ptr(ndr, "new_val", r->out.new_val);
7542                 ndr->depth++;
7543                 if (r->out.new_val) {
7544                         ndr_print_lsa_DATA_BUF_PTR(ndr, "new_val", r->out.new_val);
7545                 }
7546                 ndr->depth--;
7547                 ndr_print_ptr(ndr, "new_mtime", r->out.new_mtime);
7548                 ndr->depth++;
7549                 if (r->out.new_mtime) {
7550                         ndr_print_NTTIME_hyper(ndr, "new_mtime", *r->out.new_mtime);
7551                 }
7552                 ndr->depth--;
7553                 ndr_print_ptr(ndr, "old_val", r->out.old_val);
7554                 ndr->depth++;
7555                 if (r->out.old_val) {
7556                         ndr_print_lsa_DATA_BUF_PTR(ndr, "old_val", r->out.old_val);
7557                 }
7558                 ndr->depth--;
7559                 ndr_print_ptr(ndr, "old_mtime", r->out.old_mtime);
7560                 ndr->depth++;
7561                 if (r->out.old_mtime) {
7562                         ndr_print_NTTIME_hyper(ndr, "old_mtime", *r->out.old_mtime);
7563                 }
7564                 ndr->depth--;
7565                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7566                 ndr->depth--;
7567         }
7568         ndr->depth--;
7569 }
7570
7571 static enum ndr_err_code ndr_push_lsa_LookupPrivValue(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivValue *r)
7572 {
7573         if (flags & NDR_IN) {
7574                 if (r->in.handle == NULL) {
7575                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7576                 }
7577                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7578                 if (r->in.name == NULL) {
7579                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7580                 }
7581                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
7582         }
7583         if (flags & NDR_OUT) {
7584                 if (r->out.luid == NULL) {
7585                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7586                 }
7587                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, r->out.luid));
7588                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7589         }
7590         return NDR_ERR_SUCCESS;
7591 }
7592
7593 static enum ndr_err_code ndr_pull_lsa_LookupPrivValue(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivValue *r)
7594 {
7595         TALLOC_CTX *_mem_save_handle_0;
7596         TALLOC_CTX *_mem_save_name_0;
7597         TALLOC_CTX *_mem_save_luid_0;
7598         if (flags & NDR_IN) {
7599                 ZERO_STRUCT(r->out);
7600
7601                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7602                         NDR_PULL_ALLOC(ndr, r->in.handle);
7603                 }
7604                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7605                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7606                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7607                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7609                         NDR_PULL_ALLOC(ndr, r->in.name);
7610                 }
7611                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7612                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
7613                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
7614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
7615                 NDR_PULL_ALLOC(ndr, r->out.luid);
7616                 ZERO_STRUCTP(r->out.luid);
7617         }
7618         if (flags & NDR_OUT) {
7619                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7620                         NDR_PULL_ALLOC(ndr, r->out.luid);
7621                 }
7622                 _mem_save_luid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7623                 NDR_PULL_SET_MEM_CTX(ndr, r->out.luid, LIBNDR_FLAG_REF_ALLOC);
7624                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, r->out.luid));
7625                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_luid_0, LIBNDR_FLAG_REF_ALLOC);
7626                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7627         }
7628         return NDR_ERR_SUCCESS;
7629 }
7630
7631 _PUBLIC_ void ndr_print_lsa_LookupPrivValue(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivValue *r)
7632 {
7633         ndr_print_struct(ndr, name, "lsa_LookupPrivValue");
7634         ndr->depth++;
7635         if (flags & NDR_SET_VALUES) {
7636                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7637         }
7638         if (flags & NDR_IN) {
7639                 ndr_print_struct(ndr, "in", "lsa_LookupPrivValue");
7640                 ndr->depth++;
7641                 ndr_print_ptr(ndr, "handle", r->in.handle);
7642                 ndr->depth++;
7643                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7644                 ndr->depth--;
7645                 ndr_print_ptr(ndr, "name", r->in.name);
7646                 ndr->depth++;
7647                 ndr_print_lsa_String(ndr, "name", r->in.name);
7648                 ndr->depth--;
7649                 ndr->depth--;
7650         }
7651         if (flags & NDR_OUT) {
7652                 ndr_print_struct(ndr, "out", "lsa_LookupPrivValue");
7653                 ndr->depth++;
7654                 ndr_print_ptr(ndr, "luid", r->out.luid);
7655                 ndr->depth++;
7656                 ndr_print_lsa_LUID(ndr, "luid", r->out.luid);
7657                 ndr->depth--;
7658                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7659                 ndr->depth--;
7660         }
7661         ndr->depth--;
7662 }
7663
7664 static enum ndr_err_code ndr_push_lsa_LookupPrivName(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivName *r)
7665 {
7666         if (flags & NDR_IN) {
7667                 if (r->in.handle == NULL) {
7668                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7669                 }
7670                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7671                 if (r->in.luid == NULL) {
7672                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7673                 }
7674                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, r->in.luid));
7675         }
7676         if (flags & NDR_OUT) {
7677                 if (r->out.name == NULL) {
7678                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7679                 }
7680                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.name));
7681                 if (*r->out.name) {
7682                         NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.name));
7683                 }
7684                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7685         }
7686         return NDR_ERR_SUCCESS;
7687 }
7688
7689 static enum ndr_err_code ndr_pull_lsa_LookupPrivName(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivName *r)
7690 {
7691         uint32_t _ptr_name;
7692         TALLOC_CTX *_mem_save_handle_0;
7693         TALLOC_CTX *_mem_save_luid_0;
7694         TALLOC_CTX *_mem_save_name_0;
7695         TALLOC_CTX *_mem_save_name_1;
7696         if (flags & NDR_IN) {
7697                 ZERO_STRUCT(r->out);
7698
7699                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7700                         NDR_PULL_ALLOC(ndr, r->in.handle);
7701                 }
7702                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7703                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7704                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7705                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7706                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7707                         NDR_PULL_ALLOC(ndr, r->in.luid);
7708                 }
7709                 _mem_save_luid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7710                 NDR_PULL_SET_MEM_CTX(ndr, r->in.luid, LIBNDR_FLAG_REF_ALLOC);
7711                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, r->in.luid));
7712                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_luid_0, LIBNDR_FLAG_REF_ALLOC);
7713                 NDR_PULL_ALLOC(ndr, r->out.name);
7714                 ZERO_STRUCTP(r->out.name);
7715         }
7716         if (flags & NDR_OUT) {
7717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7718                         NDR_PULL_ALLOC(ndr, r->out.name);
7719                 }
7720                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7721                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);
7722                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
7723                 if (_ptr_name) {
7724                         NDR_PULL_ALLOC(ndr, *r->out.name);
7725                 } else {
7726                         *r->out.name = NULL;
7727                 }
7728                 if (*r->out.name) {
7729                         _mem_save_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
7730                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.name, 0);
7731                         NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.name));
7732                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_1, 0);
7733                 }
7734                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
7735                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7736         }
7737         return NDR_ERR_SUCCESS;
7738 }
7739
7740 _PUBLIC_ void ndr_print_lsa_LookupPrivName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivName *r)
7741 {
7742         ndr_print_struct(ndr, name, "lsa_LookupPrivName");
7743         ndr->depth++;
7744         if (flags & NDR_SET_VALUES) {
7745                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7746         }
7747         if (flags & NDR_IN) {
7748                 ndr_print_struct(ndr, "in", "lsa_LookupPrivName");
7749                 ndr->depth++;
7750                 ndr_print_ptr(ndr, "handle", r->in.handle);
7751                 ndr->depth++;
7752                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7753                 ndr->depth--;
7754                 ndr_print_ptr(ndr, "luid", r->in.luid);
7755                 ndr->depth++;
7756                 ndr_print_lsa_LUID(ndr, "luid", r->in.luid);
7757                 ndr->depth--;
7758                 ndr->depth--;
7759         }
7760         if (flags & NDR_OUT) {
7761                 ndr_print_struct(ndr, "out", "lsa_LookupPrivName");
7762                 ndr->depth++;
7763                 ndr_print_ptr(ndr, "name", r->out.name);
7764                 ndr->depth++;
7765                 ndr_print_ptr(ndr, "name", *r->out.name);
7766                 ndr->depth++;
7767                 if (*r->out.name) {
7768                         ndr_print_lsa_StringLarge(ndr, "name", *r->out.name);
7769                 }
7770                 ndr->depth--;
7771                 ndr->depth--;
7772                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7773                 ndr->depth--;
7774         }
7775         ndr->depth--;
7776 }
7777
7778 static enum ndr_err_code ndr_push_lsa_LookupPrivDisplayName(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivDisplayName *r)
7779 {
7780         if (flags & NDR_IN) {
7781                 if (r->in.handle == NULL) {
7782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7783                 }
7784                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7785                 if (r->in.name == NULL) {
7786                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7787                 }
7788                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
7789                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.language_id));
7790                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.language_id_sys));
7791         }
7792         if (flags & NDR_OUT) {
7793                 if (r->out.disp_name == NULL) {
7794                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7795                 }
7796                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.disp_name));
7797                 if (*r->out.disp_name) {
7798                         NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.disp_name));
7799                 }
7800                 if (r->out.returned_language_id == NULL) {
7801                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7802                 }
7803                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->out.returned_language_id));
7804                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7805         }
7806         return NDR_ERR_SUCCESS;
7807 }
7808
7809 static enum ndr_err_code ndr_pull_lsa_LookupPrivDisplayName(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivDisplayName *r)
7810 {
7811         uint32_t _ptr_disp_name;
7812         TALLOC_CTX *_mem_save_handle_0;
7813         TALLOC_CTX *_mem_save_name_0;
7814         TALLOC_CTX *_mem_save_disp_name_0;
7815         TALLOC_CTX *_mem_save_disp_name_1;
7816         TALLOC_CTX *_mem_save_returned_language_id_0;
7817         if (flags & NDR_IN) {
7818                 ZERO_STRUCT(r->out);
7819
7820                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7821                         NDR_PULL_ALLOC(ndr, r->in.handle);
7822                 }
7823                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7824                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7825                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7826                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7827                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7828                         NDR_PULL_ALLOC(ndr, r->in.name);
7829                 }
7830                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7831                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
7832                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
7833                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
7834                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.language_id));
7835                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.language_id_sys));
7836                 NDR_PULL_ALLOC(ndr, r->out.disp_name);
7837                 ZERO_STRUCTP(r->out.disp_name);
7838                 NDR_PULL_ALLOC(ndr, r->out.returned_language_id);
7839                 ZERO_STRUCTP(r->out.returned_language_id);
7840         }
7841         if (flags & NDR_OUT) {
7842                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7843                         NDR_PULL_ALLOC(ndr, r->out.disp_name);
7844                 }
7845                 _mem_save_disp_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7846                 NDR_PULL_SET_MEM_CTX(ndr, r->out.disp_name, LIBNDR_FLAG_REF_ALLOC);
7847                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_disp_name));
7848                 if (_ptr_disp_name) {
7849                         NDR_PULL_ALLOC(ndr, *r->out.disp_name);
7850                 } else {
7851                         *r->out.disp_name = NULL;
7852                 }
7853                 if (*r->out.disp_name) {
7854                         _mem_save_disp_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
7855                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.disp_name, 0);
7856                         NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.disp_name));
7857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disp_name_1, 0);
7858                 }
7859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disp_name_0, LIBNDR_FLAG_REF_ALLOC);
7860                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7861                         NDR_PULL_ALLOC(ndr, r->out.returned_language_id);
7862                 }
7863                 _mem_save_returned_language_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
7864                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_language_id, LIBNDR_FLAG_REF_ALLOC);
7865                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->out.returned_language_id));
7866                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_language_id_0, LIBNDR_FLAG_REF_ALLOC);
7867                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7868         }
7869         return NDR_ERR_SUCCESS;
7870 }
7871
7872 _PUBLIC_ void ndr_print_lsa_LookupPrivDisplayName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivDisplayName *r)
7873 {
7874         ndr_print_struct(ndr, name, "lsa_LookupPrivDisplayName");
7875         ndr->depth++;
7876         if (flags & NDR_SET_VALUES) {
7877                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7878         }
7879         if (flags & NDR_IN) {
7880                 ndr_print_struct(ndr, "in", "lsa_LookupPrivDisplayName");
7881                 ndr->depth++;
7882                 ndr_print_ptr(ndr, "handle", r->in.handle);
7883                 ndr->depth++;
7884                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7885                 ndr->depth--;
7886                 ndr_print_ptr(ndr, "name", r->in.name);
7887                 ndr->depth++;
7888                 ndr_print_lsa_String(ndr, "name", r->in.name);
7889                 ndr->depth--;
7890                 ndr_print_uint16(ndr, "language_id", r->in.language_id);
7891                 ndr_print_uint16(ndr, "language_id_sys", r->in.language_id_sys);
7892                 ndr->depth--;
7893         }
7894         if (flags & NDR_OUT) {
7895                 ndr_print_struct(ndr, "out", "lsa_LookupPrivDisplayName");
7896                 ndr->depth++;
7897                 ndr_print_ptr(ndr, "disp_name", r->out.disp_name);
7898                 ndr->depth++;
7899                 ndr_print_ptr(ndr, "disp_name", *r->out.disp_name);
7900                 ndr->depth++;
7901                 if (*r->out.disp_name) {
7902                         ndr_print_lsa_StringLarge(ndr, "disp_name", *r->out.disp_name);
7903                 }
7904                 ndr->depth--;
7905                 ndr->depth--;
7906                 ndr_print_ptr(ndr, "returned_language_id", r->out.returned_language_id);
7907                 ndr->depth++;
7908                 ndr_print_uint16(ndr, "returned_language_id", *r->out.returned_language_id);
7909                 ndr->depth--;
7910                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7911                 ndr->depth--;
7912         }
7913         ndr->depth--;
7914 }
7915
7916 static enum ndr_err_code ndr_push_lsa_DeleteObject(struct ndr_push *ndr, int flags, const struct lsa_DeleteObject *r)
7917 {
7918         if (flags & NDR_IN) {
7919                 if (r->in.handle == NULL) {
7920                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7921                 }
7922                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7923         }
7924         if (flags & NDR_OUT) {
7925                 if (r->out.handle == NULL) {
7926                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7927                 }
7928                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
7929                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7930         }
7931         return NDR_ERR_SUCCESS;
7932 }
7933
7934 static enum ndr_err_code ndr_pull_lsa_DeleteObject(struct ndr_pull *ndr, int flags, struct lsa_DeleteObject *r)
7935 {
7936         TALLOC_CTX *_mem_save_handle_0;
7937         if (flags & NDR_IN) {
7938                 ZERO_STRUCT(r->out);
7939
7940                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7941                         NDR_PULL_ALLOC(ndr, r->in.handle);
7942                 }
7943                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7944                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7945                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7946                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7947                 NDR_PULL_ALLOC(ndr, r->out.handle);
7948                 *r->out.handle = *r->in.handle;
7949         }
7950         if (flags & NDR_OUT) {
7951                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7952                         NDR_PULL_ALLOC(ndr, r->out.handle);
7953                 }
7954                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7955                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
7956                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
7957                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7958                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7959         }
7960         return NDR_ERR_SUCCESS;
7961 }
7962
7963 _PUBLIC_ void ndr_print_lsa_DeleteObject(struct ndr_print *ndr, const char *name, int flags, const struct lsa_DeleteObject *r)
7964 {
7965         ndr_print_struct(ndr, name, "lsa_DeleteObject");
7966         ndr->depth++;
7967         if (flags & NDR_SET_VALUES) {
7968                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7969         }
7970         if (flags & NDR_IN) {
7971                 ndr_print_struct(ndr, "in", "lsa_DeleteObject");
7972                 ndr->depth++;
7973                 ndr_print_ptr(ndr, "handle", r->in.handle);
7974                 ndr->depth++;
7975                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7976                 ndr->depth--;
7977                 ndr->depth--;
7978         }
7979         if (flags & NDR_OUT) {
7980                 ndr_print_struct(ndr, "out", "lsa_DeleteObject");
7981                 ndr->depth++;
7982                 ndr_print_ptr(ndr, "handle", r->out.handle);
7983                 ndr->depth++;
7984                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
7985                 ndr->depth--;
7986                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7987                 ndr->depth--;
7988         }
7989         ndr->depth--;
7990 }
7991
7992 static enum ndr_err_code ndr_push_lsa_EnumAccountsWithUserRight(struct ndr_push *ndr, int flags, const struct lsa_EnumAccountsWithUserRight *r)
7993 {
7994         if (flags & NDR_IN) {
7995                 if (r->in.handle == NULL) {
7996                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7997                 }
7998                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7999                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
8000                 if (r->in.name) {
8001                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
8002                 }
8003         }
8004         if (flags & NDR_OUT) {
8005                 if (r->out.sids == NULL) {
8006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8007                 }
8008                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8009                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8010         }
8011         return NDR_ERR_SUCCESS;
8012 }
8013
8014 static enum ndr_err_code ndr_pull_lsa_EnumAccountsWithUserRight(struct ndr_pull *ndr, int flags, struct lsa_EnumAccountsWithUserRight *r)
8015 {
8016         uint32_t _ptr_name;
8017         TALLOC_CTX *_mem_save_handle_0;
8018         TALLOC_CTX *_mem_save_name_0;
8019         TALLOC_CTX *_mem_save_sids_0;
8020         if (flags & NDR_IN) {
8021                 ZERO_STRUCT(r->out);
8022
8023                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8024                         NDR_PULL_ALLOC(ndr, r->in.handle);
8025                 }
8026                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8027                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8028                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
8031                 if (_ptr_name) {
8032                         NDR_PULL_ALLOC(ndr, r->in.name);
8033                 } else {
8034                         r->in.name = NULL;
8035                 }
8036                 if (r->in.name) {
8037                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8038                         NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
8039                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
8040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
8041                 }
8042                 NDR_PULL_ALLOC(ndr, r->out.sids);
8043                 ZERO_STRUCTP(r->out.sids);
8044         }
8045         if (flags & NDR_OUT) {
8046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8047                         NDR_PULL_ALLOC(ndr, r->out.sids);
8048                 }
8049                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8050                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
8051                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
8053                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8054         }
8055         return NDR_ERR_SUCCESS;
8056 }
8057
8058 _PUBLIC_ void ndr_print_lsa_EnumAccountsWithUserRight(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccountsWithUserRight *r)
8059 {
8060         ndr_print_struct(ndr, name, "lsa_EnumAccountsWithUserRight");
8061         ndr->depth++;
8062         if (flags & NDR_SET_VALUES) {
8063                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8064         }
8065         if (flags & NDR_IN) {
8066                 ndr_print_struct(ndr, "in", "lsa_EnumAccountsWithUserRight");
8067                 ndr->depth++;
8068                 ndr_print_ptr(ndr, "handle", r->in.handle);
8069                 ndr->depth++;
8070                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8071                 ndr->depth--;
8072                 ndr_print_ptr(ndr, "name", r->in.name);
8073                 ndr->depth++;
8074                 if (r->in.name) {
8075                         ndr_print_lsa_String(ndr, "name", r->in.name);
8076                 }
8077                 ndr->depth--;
8078                 ndr->depth--;
8079         }
8080         if (flags & NDR_OUT) {
8081                 ndr_print_struct(ndr, "out", "lsa_EnumAccountsWithUserRight");
8082                 ndr->depth++;
8083                 ndr_print_ptr(ndr, "sids", r->out.sids);
8084                 ndr->depth++;
8085                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
8086                 ndr->depth--;
8087                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8088                 ndr->depth--;
8089         }
8090         ndr->depth--;
8091 }
8092
8093 static enum ndr_err_code ndr_push_lsa_EnumAccountRights(struct ndr_push *ndr, int flags, const struct lsa_EnumAccountRights *r)
8094 {
8095         if (flags & NDR_IN) {
8096                 if (r->in.handle == NULL) {
8097                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8098                 }
8099                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8100                 if (r->in.sid == NULL) {
8101                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8102                 }
8103                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8104         }
8105         if (flags & NDR_OUT) {
8106                 if (r->out.rights == NULL) {
8107                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8108                 }
8109                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rights));
8110                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8111         }
8112         return NDR_ERR_SUCCESS;
8113 }
8114
8115 static enum ndr_err_code ndr_pull_lsa_EnumAccountRights(struct ndr_pull *ndr, int flags, struct lsa_EnumAccountRights *r)
8116 {
8117         TALLOC_CTX *_mem_save_handle_0;
8118         TALLOC_CTX *_mem_save_sid_0;
8119         TALLOC_CTX *_mem_save_rights_0;
8120         if (flags & NDR_IN) {
8121                 ZERO_STRUCT(r->out);
8122
8123                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8124                         NDR_PULL_ALLOC(ndr, r->in.handle);
8125                 }
8126                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8127                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8128                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8129                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8130                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8131                         NDR_PULL_ALLOC(ndr, r->in.sid);
8132                 }
8133                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8134                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8135                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8137                 NDR_PULL_ALLOC(ndr, r->out.rights);
8138                 ZERO_STRUCTP(r->out.rights);
8139         }
8140         if (flags & NDR_OUT) {
8141                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8142                         NDR_PULL_ALLOC(ndr, r->out.rights);
8143                 }
8144                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
8145                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rights, LIBNDR_FLAG_REF_ALLOC);
8146                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rights));
8147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
8148                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8149         }
8150         return NDR_ERR_SUCCESS;
8151 }
8152
8153 _PUBLIC_ void ndr_print_lsa_EnumAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccountRights *r)
8154 {
8155         ndr_print_struct(ndr, name, "lsa_EnumAccountRights");
8156         ndr->depth++;
8157         if (flags & NDR_SET_VALUES) {
8158                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8159         }
8160         if (flags & NDR_IN) {
8161                 ndr_print_struct(ndr, "in", "lsa_EnumAccountRights");
8162                 ndr->depth++;
8163                 ndr_print_ptr(ndr, "handle", r->in.handle);
8164                 ndr->depth++;
8165                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8166                 ndr->depth--;
8167                 ndr_print_ptr(ndr, "sid", r->in.sid);
8168                 ndr->depth++;
8169                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8170                 ndr->depth--;
8171                 ndr->depth--;
8172         }
8173         if (flags & NDR_OUT) {
8174                 ndr_print_struct(ndr, "out", "lsa_EnumAccountRights");
8175                 ndr->depth++;
8176                 ndr_print_ptr(ndr, "rights", r->out.rights);
8177                 ndr->depth++;
8178                 ndr_print_lsa_RightSet(ndr, "rights", r->out.rights);
8179                 ndr->depth--;
8180                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8181                 ndr->depth--;
8182         }
8183         ndr->depth--;
8184 }
8185
8186 static enum ndr_err_code ndr_push_lsa_AddAccountRights(struct ndr_push *ndr, int flags, const struct lsa_AddAccountRights *r)
8187 {
8188         if (flags & NDR_IN) {
8189                 if (r->in.handle == NULL) {
8190                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8191                 }
8192                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8193                 if (r->in.sid == NULL) {
8194                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8195                 }
8196                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8197                 if (r->in.rights == NULL) {
8198                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8199                 }
8200                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
8201         }
8202         if (flags & NDR_OUT) {
8203                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8204         }
8205         return NDR_ERR_SUCCESS;
8206 }
8207
8208 static enum ndr_err_code ndr_pull_lsa_AddAccountRights(struct ndr_pull *ndr, int flags, struct lsa_AddAccountRights *r)
8209 {
8210         TALLOC_CTX *_mem_save_handle_0;
8211         TALLOC_CTX *_mem_save_sid_0;
8212         TALLOC_CTX *_mem_save_rights_0;
8213         if (flags & NDR_IN) {
8214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8215                         NDR_PULL_ALLOC(ndr, r->in.handle);
8216                 }
8217                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8218                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8219                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8221                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8222                         NDR_PULL_ALLOC(ndr, r->in.sid);
8223                 }
8224                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8225                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8226                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8227                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8228                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8229                         NDR_PULL_ALLOC(ndr, r->in.rights);
8230                 }
8231                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
8232                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rights, LIBNDR_FLAG_REF_ALLOC);
8233                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
8234                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
8235         }
8236         if (flags & NDR_OUT) {
8237                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8238         }
8239         return NDR_ERR_SUCCESS;
8240 }
8241
8242 _PUBLIC_ void ndr_print_lsa_AddAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_AddAccountRights *r)
8243 {
8244         ndr_print_struct(ndr, name, "lsa_AddAccountRights");
8245         ndr->depth++;
8246         if (flags & NDR_SET_VALUES) {
8247                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8248         }
8249         if (flags & NDR_IN) {
8250                 ndr_print_struct(ndr, "in", "lsa_AddAccountRights");
8251                 ndr->depth++;
8252                 ndr_print_ptr(ndr, "handle", r->in.handle);
8253                 ndr->depth++;
8254                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8255                 ndr->depth--;
8256                 ndr_print_ptr(ndr, "sid", r->in.sid);
8257                 ndr->depth++;
8258                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8259                 ndr->depth--;
8260                 ndr_print_ptr(ndr, "rights", r->in.rights);
8261                 ndr->depth++;
8262                 ndr_print_lsa_RightSet(ndr, "rights", r->in.rights);
8263                 ndr->depth--;
8264                 ndr->depth--;
8265         }
8266         if (flags & NDR_OUT) {
8267                 ndr_print_struct(ndr, "out", "lsa_AddAccountRights");
8268                 ndr->depth++;
8269                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8270                 ndr->depth--;
8271         }
8272         ndr->depth--;
8273 }
8274
8275 static enum ndr_err_code ndr_push_lsa_RemoveAccountRights(struct ndr_push *ndr, int flags, const struct lsa_RemoveAccountRights *r)
8276 {
8277         if (flags & NDR_IN) {
8278                 if (r->in.handle == NULL) {
8279                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8280                 }
8281                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8282                 if (r->in.sid == NULL) {
8283                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8284                 }
8285                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8286                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.remove_all));
8287                 if (r->in.rights == NULL) {
8288                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8289                 }
8290                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
8291         }
8292         if (flags & NDR_OUT) {
8293                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8294         }
8295         return NDR_ERR_SUCCESS;
8296 }
8297
8298 static enum ndr_err_code ndr_pull_lsa_RemoveAccountRights(struct ndr_pull *ndr, int flags, struct lsa_RemoveAccountRights *r)
8299 {
8300         TALLOC_CTX *_mem_save_handle_0;
8301         TALLOC_CTX *_mem_save_sid_0;
8302         TALLOC_CTX *_mem_save_rights_0;
8303         if (flags & NDR_IN) {
8304                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8305                         NDR_PULL_ALLOC(ndr, r->in.handle);
8306                 }
8307                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8308                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8309                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8310                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8311                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8312                         NDR_PULL_ALLOC(ndr, r->in.sid);
8313                 }
8314                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8315                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8316                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8317                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8318                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.remove_all));
8319                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8320                         NDR_PULL_ALLOC(ndr, r->in.rights);
8321                 }
8322                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
8323                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rights, LIBNDR_FLAG_REF_ALLOC);
8324                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
8325                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
8326         }
8327         if (flags & NDR_OUT) {
8328                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8329         }
8330         return NDR_ERR_SUCCESS;
8331 }
8332
8333 _PUBLIC_ void ndr_print_lsa_RemoveAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RemoveAccountRights *r)
8334 {
8335         ndr_print_struct(ndr, name, "lsa_RemoveAccountRights");
8336         ndr->depth++;
8337         if (flags & NDR_SET_VALUES) {
8338                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8339         }
8340         if (flags & NDR_IN) {
8341                 ndr_print_struct(ndr, "in", "lsa_RemoveAccountRights");
8342                 ndr->depth++;
8343                 ndr_print_ptr(ndr, "handle", r->in.handle);
8344                 ndr->depth++;
8345                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8346                 ndr->depth--;
8347                 ndr_print_ptr(ndr, "sid", r->in.sid);
8348                 ndr->depth++;
8349                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8350                 ndr->depth--;
8351                 ndr_print_uint8(ndr, "remove_all", r->in.remove_all);
8352                 ndr_print_ptr(ndr, "rights", r->in.rights);
8353                 ndr->depth++;
8354                 ndr_print_lsa_RightSet(ndr, "rights", r->in.rights);
8355                 ndr->depth--;
8356                 ndr->depth--;
8357         }
8358         if (flags & NDR_OUT) {
8359                 ndr_print_struct(ndr, "out", "lsa_RemoveAccountRights");
8360                 ndr->depth++;
8361                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8362                 ndr->depth--;
8363         }
8364         ndr->depth--;
8365 }
8366
8367 static enum ndr_err_code ndr_push_lsa_QueryTrustedDomainInfoBySid(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfoBySid *r)
8368 {
8369         if (flags & NDR_IN) {
8370                 if (r->in.handle == NULL) {
8371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8372                 }
8373                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8374                 if (r->in.dom_sid == NULL) {
8375                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8376                 }
8377                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
8378                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
8379         }
8380         if (flags & NDR_OUT) {
8381                 if (r->out.info == NULL) {
8382                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8383                 }
8384                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8385                 if (*r->out.info) {
8386                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8387                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8388                 }
8389                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8390         }
8391         return NDR_ERR_SUCCESS;
8392 }
8393
8394 static enum ndr_err_code ndr_pull_lsa_QueryTrustedDomainInfoBySid(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfoBySid *r)
8395 {
8396         uint32_t _ptr_info;
8397         TALLOC_CTX *_mem_save_handle_0;
8398         TALLOC_CTX *_mem_save_dom_sid_0;
8399         TALLOC_CTX *_mem_save_info_0;
8400         TALLOC_CTX *_mem_save_info_1;
8401         if (flags & NDR_IN) {
8402                 ZERO_STRUCT(r->out);
8403
8404                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8405                         NDR_PULL_ALLOC(ndr, r->in.handle);
8406                 }
8407                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8408                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8409                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8410                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8411                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8412                         NDR_PULL_ALLOC(ndr, r->in.dom_sid);
8413                 }
8414                 _mem_save_dom_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8415                 NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_sid, LIBNDR_FLAG_REF_ALLOC);
8416                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
8417                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_sid_0, LIBNDR_FLAG_REF_ALLOC);
8418                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8419                 NDR_PULL_ALLOC(ndr, r->out.info);
8420                 ZERO_STRUCTP(r->out.info);
8421         }
8422         if (flags & NDR_OUT) {
8423                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8424                         NDR_PULL_ALLOC(ndr, r->out.info);
8425                 }
8426                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8427                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8428                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8429                 if (_ptr_info) {
8430                         NDR_PULL_ALLOC(ndr, *r->out.info);
8431                 } else {
8432                         *r->out.info = NULL;
8433                 }
8434                 if (*r->out.info) {
8435                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8436                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8437                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8438                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8439                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8440                 }
8441                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8442                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8443         }
8444         return NDR_ERR_SUCCESS;
8445 }
8446
8447 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfoBySid(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfoBySid *r)
8448 {
8449         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfoBySid");
8450         ndr->depth++;
8451         if (flags & NDR_SET_VALUES) {
8452                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8453         }
8454         if (flags & NDR_IN) {
8455                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfoBySid");
8456                 ndr->depth++;
8457                 ndr_print_ptr(ndr, "handle", r->in.handle);
8458                 ndr->depth++;
8459                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8460                 ndr->depth--;
8461                 ndr_print_ptr(ndr, "dom_sid", r->in.dom_sid);
8462                 ndr->depth++;
8463                 ndr_print_dom_sid2(ndr, "dom_sid", r->in.dom_sid);
8464                 ndr->depth--;
8465                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
8466                 ndr->depth--;
8467         }
8468         if (flags & NDR_OUT) {
8469                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfoBySid");
8470                 ndr->depth++;
8471                 ndr_print_ptr(ndr, "info", r->out.info);
8472                 ndr->depth++;
8473                 ndr_print_ptr(ndr, "info", *r->out.info);
8474                 ndr->depth++;
8475                 if (*r->out.info) {
8476                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8477                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", *r->out.info);
8478                 }
8479                 ndr->depth--;
8480                 ndr->depth--;
8481                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8482                 ndr->depth--;
8483         }
8484         ndr->depth--;
8485 }
8486
8487 static enum ndr_err_code ndr_push_lsa_SetTrustedDomainInfo(struct ndr_push *ndr, int flags, const struct lsa_SetTrustedDomainInfo *r)
8488 {
8489         if (flags & NDR_IN) {
8490         }
8491         if (flags & NDR_OUT) {
8492                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8493         }
8494         return NDR_ERR_SUCCESS;
8495 }
8496
8497 static enum ndr_err_code ndr_pull_lsa_SetTrustedDomainInfo(struct ndr_pull *ndr, int flags, struct lsa_SetTrustedDomainInfo *r)
8498 {
8499         if (flags & NDR_IN) {
8500         }
8501         if (flags & NDR_OUT) {
8502                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8503         }
8504         return NDR_ERR_SUCCESS;
8505 }
8506
8507 _PUBLIC_ void ndr_print_lsa_SetTrustedDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetTrustedDomainInfo *r)
8508 {
8509         ndr_print_struct(ndr, name, "lsa_SetTrustedDomainInfo");
8510         ndr->depth++;
8511         if (flags & NDR_SET_VALUES) {
8512                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8513         }
8514         if (flags & NDR_IN) {
8515                 ndr_print_struct(ndr, "in", "lsa_SetTrustedDomainInfo");
8516                 ndr->depth++;
8517                 ndr->depth--;
8518         }
8519         if (flags & NDR_OUT) {
8520                 ndr_print_struct(ndr, "out", "lsa_SetTrustedDomainInfo");
8521                 ndr->depth++;
8522                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8523                 ndr->depth--;
8524         }
8525         ndr->depth--;
8526 }
8527
8528 static enum ndr_err_code ndr_push_lsa_DeleteTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_DeleteTrustedDomain *r)
8529 {
8530         if (flags & NDR_IN) {
8531                 if (r->in.handle == NULL) {
8532                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8533                 }
8534                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8535                 if (r->in.dom_sid == NULL) {
8536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8537                 }
8538                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
8539         }
8540         if (flags & NDR_OUT) {
8541                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8542         }
8543         return NDR_ERR_SUCCESS;
8544 }
8545
8546 static enum ndr_err_code ndr_pull_lsa_DeleteTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_DeleteTrustedDomain *r)
8547 {
8548         TALLOC_CTX *_mem_save_handle_0;
8549         TALLOC_CTX *_mem_save_dom_sid_0;
8550         if (flags & NDR_IN) {
8551                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8552                         NDR_PULL_ALLOC(ndr, r->in.handle);
8553                 }
8554                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8555                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8556                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8559                         NDR_PULL_ALLOC(ndr, r->in.dom_sid);
8560                 }
8561                 _mem_save_dom_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8562                 NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_sid, LIBNDR_FLAG_REF_ALLOC);
8563                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
8564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_sid_0, LIBNDR_FLAG_REF_ALLOC);
8565         }
8566         if (flags & NDR_OUT) {
8567                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8568         }
8569         return NDR_ERR_SUCCESS;
8570 }
8571
8572 _PUBLIC_ void ndr_print_lsa_DeleteTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_DeleteTrustedDomain *r)
8573 {
8574         ndr_print_struct(ndr, name, "lsa_DeleteTrustedDomain");
8575         ndr->depth++;
8576         if (flags & NDR_SET_VALUES) {
8577                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8578         }
8579         if (flags & NDR_IN) {
8580                 ndr_print_struct(ndr, "in", "lsa_DeleteTrustedDomain");
8581                 ndr->depth++;
8582                 ndr_print_ptr(ndr, "handle", r->in.handle);
8583                 ndr->depth++;
8584                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8585                 ndr->depth--;
8586                 ndr_print_ptr(ndr, "dom_sid", r->in.dom_sid);
8587                 ndr->depth++;
8588                 ndr_print_dom_sid2(ndr, "dom_sid", r->in.dom_sid);
8589                 ndr->depth--;
8590                 ndr->depth--;
8591         }
8592         if (flags & NDR_OUT) {
8593                 ndr_print_struct(ndr, "out", "lsa_DeleteTrustedDomain");
8594                 ndr->depth++;
8595                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8596                 ndr->depth--;
8597         }
8598         ndr->depth--;
8599 }
8600
8601 static enum ndr_err_code ndr_push_lsa_StorePrivateData(struct ndr_push *ndr, int flags, const struct lsa_StorePrivateData *r)
8602 {
8603         if (flags & NDR_IN) {
8604         }
8605         if (flags & NDR_OUT) {
8606                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8607         }
8608         return NDR_ERR_SUCCESS;
8609 }
8610
8611 static enum ndr_err_code ndr_pull_lsa_StorePrivateData(struct ndr_pull *ndr, int flags, struct lsa_StorePrivateData *r)
8612 {
8613         if (flags & NDR_IN) {
8614         }
8615         if (flags & NDR_OUT) {
8616                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8617         }
8618         return NDR_ERR_SUCCESS;
8619 }
8620
8621 _PUBLIC_ void ndr_print_lsa_StorePrivateData(struct ndr_print *ndr, const char *name, int flags, const struct lsa_StorePrivateData *r)
8622 {
8623         ndr_print_struct(ndr, name, "lsa_StorePrivateData");
8624         ndr->depth++;
8625         if (flags & NDR_SET_VALUES) {
8626                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8627         }
8628         if (flags & NDR_IN) {
8629                 ndr_print_struct(ndr, "in", "lsa_StorePrivateData");
8630                 ndr->depth++;
8631                 ndr->depth--;
8632         }
8633         if (flags & NDR_OUT) {
8634                 ndr_print_struct(ndr, "out", "lsa_StorePrivateData");
8635                 ndr->depth++;
8636                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8637                 ndr->depth--;
8638         }
8639         ndr->depth--;
8640 }
8641
8642 static enum ndr_err_code ndr_push_lsa_RetrievePrivateData(struct ndr_push *ndr, int flags, const struct lsa_RetrievePrivateData *r)
8643 {
8644         if (flags & NDR_IN) {
8645         }
8646         if (flags & NDR_OUT) {
8647                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8648         }
8649         return NDR_ERR_SUCCESS;
8650 }
8651
8652 static enum ndr_err_code ndr_pull_lsa_RetrievePrivateData(struct ndr_pull *ndr, int flags, struct lsa_RetrievePrivateData *r)
8653 {
8654         if (flags & NDR_IN) {
8655         }
8656         if (flags & NDR_OUT) {
8657                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8658         }
8659         return NDR_ERR_SUCCESS;
8660 }
8661
8662 _PUBLIC_ void ndr_print_lsa_RetrievePrivateData(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RetrievePrivateData *r)
8663 {
8664         ndr_print_struct(ndr, name, "lsa_RetrievePrivateData");
8665         ndr->depth++;
8666         if (flags & NDR_SET_VALUES) {
8667                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8668         }
8669         if (flags & NDR_IN) {
8670                 ndr_print_struct(ndr, "in", "lsa_RetrievePrivateData");
8671                 ndr->depth++;
8672                 ndr->depth--;
8673         }
8674         if (flags & NDR_OUT) {
8675                 ndr_print_struct(ndr, "out", "lsa_RetrievePrivateData");
8676                 ndr->depth++;
8677                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8678                 ndr->depth--;
8679         }
8680         ndr->depth--;
8681 }
8682
8683 _PUBLIC_ enum ndr_err_code ndr_push_lsa_OpenPolicy2(struct ndr_push *ndr, int flags, const struct lsa_OpenPolicy2 *r)
8684 {
8685         if (flags & NDR_IN) {
8686                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
8687                 if (r->in.system_name) {
8688                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
8689                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8690                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
8691                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8692                 }
8693                 if (r->in.attr == NULL) {
8694                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8695                 }
8696                 NDR_CHECK(ndr_push_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
8697                 NDR_CHECK(ndr_push_lsa_PolicyAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
8698         }
8699         if (flags & NDR_OUT) {
8700                 if (r->out.handle == NULL) {
8701                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8702                 }
8703                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
8704                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8705         }
8706         return NDR_ERR_SUCCESS;
8707 }
8708
8709 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_OpenPolicy2(struct ndr_pull *ndr, int flags, struct lsa_OpenPolicy2 *r)
8710 {
8711         uint32_t _ptr_system_name;
8712         TALLOC_CTX *_mem_save_system_name_0;
8713         TALLOC_CTX *_mem_save_attr_0;
8714         TALLOC_CTX *_mem_save_handle_0;
8715         if (flags & NDR_IN) {
8716                 ZERO_STRUCT(r->out);
8717
8718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
8719                 if (_ptr_system_name) {
8720                         NDR_PULL_ALLOC(ndr, r->in.system_name);
8721                 } else {
8722                         r->in.system_name = NULL;
8723                 }
8724                 if (r->in.system_name) {
8725                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8726                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
8727                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
8728                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
8729                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
8730                                 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.system_name), ndr_get_array_length(ndr, &r->in.system_name));
8731                         }
8732                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
8733                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
8734                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
8735                 }
8736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8737                         NDR_PULL_ALLOC(ndr, r->in.attr);
8738                 }
8739                 _mem_save_attr_0 = NDR_PULL_GET_MEM_CTX(ndr);
8740                 NDR_PULL_SET_MEM_CTX(ndr, r->in.attr, LIBNDR_FLAG_REF_ALLOC);
8741                 NDR_CHECK(ndr_pull_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
8742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attr_0, LIBNDR_FLAG_REF_ALLOC);
8743                 NDR_CHECK(ndr_pull_lsa_PolicyAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
8744                 NDR_PULL_ALLOC(ndr, r->out.handle);
8745                 ZERO_STRUCTP(r->out.handle);
8746         }
8747         if (flags & NDR_OUT) {
8748                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8749                         NDR_PULL_ALLOC(ndr, r->out.handle);
8750                 }
8751                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8752                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
8753                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
8754                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8755                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8756         }
8757         return NDR_ERR_SUCCESS;
8758 }
8759
8760 _PUBLIC_ void ndr_print_lsa_OpenPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenPolicy2 *r)
8761 {
8762         ndr_print_struct(ndr, name, "lsa_OpenPolicy2");
8763         ndr->depth++;
8764         if (flags & NDR_SET_VALUES) {
8765                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8766         }
8767         if (flags & NDR_IN) {
8768                 ndr_print_struct(ndr, "in", "lsa_OpenPolicy2");
8769                 ndr->depth++;
8770                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
8771                 ndr->depth++;
8772                 if (r->in.system_name) {
8773                         ndr_print_string(ndr, "system_name", r->in.system_name);
8774                 }
8775                 ndr->depth--;
8776                 ndr_print_ptr(ndr, "attr", r->in.attr);
8777                 ndr->depth++;
8778                 ndr_print_lsa_ObjectAttribute(ndr, "attr", r->in.attr);
8779                 ndr->depth--;
8780                 ndr_print_lsa_PolicyAccessMask(ndr, "access_mask", r->in.access_mask);
8781                 ndr->depth--;
8782         }
8783         if (flags & NDR_OUT) {
8784                 ndr_print_struct(ndr, "out", "lsa_OpenPolicy2");
8785                 ndr->depth++;
8786                 ndr_print_ptr(ndr, "handle", r->out.handle);
8787                 ndr->depth++;
8788                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
8789                 ndr->depth--;
8790                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8791                 ndr->depth--;
8792         }
8793         ndr->depth--;
8794 }
8795
8796 static enum ndr_err_code ndr_push_lsa_GetUserName(struct ndr_push *ndr, int flags, const struct lsa_GetUserName *r)
8797 {
8798         if (flags & NDR_IN) {
8799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
8800                 if (r->in.system_name) {
8801                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
8802                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8803                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
8804                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.system_name, ndr_charset_length(r->in.system_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8805                 }
8806                 if (r->in.account_name == NULL) {
8807                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8808                 }
8809                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.account_name));
8810                 if (*r->in.account_name) {
8811                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.account_name));
8812                 }
8813                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.authority_name));
8814                 if (r->in.authority_name) {
8815                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.authority_name));
8816                         if (*r->in.authority_name) {
8817                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.authority_name));
8818                         }
8819                 }
8820         }
8821         if (flags & NDR_OUT) {
8822                 if (r->out.account_name == NULL) {
8823                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8824                 }
8825                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.account_name));
8826                 if (*r->out.account_name) {
8827                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.account_name));
8828                 }
8829                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.authority_name));
8830                 if (r->out.authority_name) {
8831                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.authority_name));
8832                         if (*r->out.authority_name) {
8833                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.authority_name));
8834                         }
8835                 }
8836                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8837         }
8838         return NDR_ERR_SUCCESS;
8839 }
8840
8841 static enum ndr_err_code ndr_pull_lsa_GetUserName(struct ndr_pull *ndr, int flags, struct lsa_GetUserName *r)
8842 {
8843         uint32_t _ptr_system_name;
8844         uint32_t _ptr_account_name;
8845         uint32_t _ptr_authority_name;
8846         TALLOC_CTX *_mem_save_system_name_0;
8847         TALLOC_CTX *_mem_save_account_name_0;
8848         TALLOC_CTX *_mem_save_account_name_1;
8849         TALLOC_CTX *_mem_save_authority_name_0;
8850         TALLOC_CTX *_mem_save_authority_name_1;
8851         if (flags & NDR_IN) {
8852                 ZERO_STRUCT(r->out);
8853
8854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
8855                 if (_ptr_system_name) {
8856                         NDR_PULL_ALLOC(ndr, r->in.system_name);
8857                 } else {
8858                         r->in.system_name = NULL;
8859                 }
8860                 if (r->in.system_name) {
8861                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8862                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
8863                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
8864                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
8865                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
8866                                 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.system_name), ndr_get_array_length(ndr, &r->in.system_name));
8867                         }
8868                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
8869                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.system_name, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t), CH_UTF16));
8870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
8871                 }
8872                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8873                         NDR_PULL_ALLOC(ndr, r->in.account_name);
8874                 }
8875                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8876                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
8877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
8878                 if (_ptr_account_name) {
8879                         NDR_PULL_ALLOC(ndr, *r->in.account_name);
8880                 } else {
8881                         *r->in.account_name = NULL;
8882                 }
8883                 if (*r->in.account_name) {
8884                         _mem_save_account_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
8885                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.account_name, 0);
8886                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.account_name));
8887                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_1, 0);
8888                 }
8889                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
8890                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
8891                 if (_ptr_authority_name) {
8892                         NDR_PULL_ALLOC(ndr, r->in.authority_name);
8893                 } else {
8894                         r->in.authority_name = NULL;
8895                 }
8896                 if (r->in.authority_name) {
8897                         _mem_save_authority_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8898                         NDR_PULL_SET_MEM_CTX(ndr, r->in.authority_name, 0);
8899                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
8900                         if (_ptr_authority_name) {
8901                                 NDR_PULL_ALLOC(ndr, *r->in.authority_name);
8902                         } else {
8903                                 *r->in.authority_name = NULL;
8904                         }
8905                         if (*r->in.authority_name) {
8906                                 _mem_save_authority_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
8907                                 NDR_PULL_SET_MEM_CTX(ndr, *r->in.authority_name, 0);
8908                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.authority_name));
8909                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_1, 0);
8910                         }
8911                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_0, 0);
8912                 }
8913                 NDR_PULL_ALLOC(ndr, r->out.account_name);
8914                 *r->out.account_name = *r->in.account_name;
8915         }
8916         if (flags & NDR_OUT) {
8917                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8918                         NDR_PULL_ALLOC(ndr, r->out.account_name);
8919                 }
8920                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8921                 NDR_PULL_SET_MEM_CTX(ndr, r->out.account_name, LIBNDR_FLAG_REF_ALLOC);
8922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
8923                 if (_ptr_account_name) {
8924                         NDR_PULL_ALLOC(ndr, *r->out.account_name);
8925                 } else {
8926                         *r->out.account_name = NULL;
8927                 }
8928                 if (*r->out.account_name) {
8929                         _mem_save_account_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
8930                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.account_name, 0);
8931                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.account_name));
8932                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_1, 0);
8933                 }
8934                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
8935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
8936                 if (_ptr_authority_name) {
8937                         NDR_PULL_ALLOC(ndr, r->out.authority_name);
8938                 } else {
8939                         r->out.authority_name = NULL;
8940                 }
8941                 if (r->out.authority_name) {
8942                         _mem_save_authority_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8943                         NDR_PULL_SET_MEM_CTX(ndr, r->out.authority_name, 0);
8944                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
8945                         if (_ptr_authority_name) {
8946                                 NDR_PULL_ALLOC(ndr, *r->out.authority_name);
8947                         } else {
8948                                 *r->out.authority_name = NULL;
8949                         }
8950                         if (*r->out.authority_name) {
8951                                 _mem_save_authority_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
8952                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.authority_name, 0);
8953                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.authority_name));
8954                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_1, 0);
8955                         }
8956                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_0, 0);
8957                 }
8958                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8959         }
8960         return NDR_ERR_SUCCESS;
8961 }
8962
8963 _PUBLIC_ void ndr_print_lsa_GetUserName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetUserName *r)
8964 {
8965         ndr_print_struct(ndr, name, "lsa_GetUserName");
8966         ndr->depth++;
8967         if (flags & NDR_SET_VALUES) {
8968                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8969         }
8970         if (flags & NDR_IN) {
8971                 ndr_print_struct(ndr, "in", "lsa_GetUserName");
8972                 ndr->depth++;
8973                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
8974                 ndr->depth++;
8975                 if (r->in.system_name) {
8976                         ndr_print_string(ndr, "system_name", r->in.system_name);
8977                 }
8978                 ndr->depth--;
8979                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
8980                 ndr->depth++;
8981                 ndr_print_ptr(ndr, "account_name", *r->in.account_name);
8982                 ndr->depth++;
8983                 if (*r->in.account_name) {
8984                         ndr_print_lsa_String(ndr, "account_name", *r->in.account_name);
8985                 }
8986                 ndr->depth--;
8987                 ndr->depth--;
8988                 ndr_print_ptr(ndr, "authority_name", r->in.authority_name);
8989                 ndr->depth++;
8990                 if (r->in.authority_name) {
8991                         ndr_print_ptr(ndr, "authority_name", *r->in.authority_name);
8992                         ndr->depth++;
8993                         if (*r->in.authority_name) {
8994                                 ndr_print_lsa_String(ndr, "authority_name", *r->in.authority_name);
8995                         }
8996                         ndr->depth--;
8997                 }
8998                 ndr->depth--;
8999                 ndr->depth--;
9000         }
9001         if (flags & NDR_OUT) {
9002                 ndr_print_struct(ndr, "out", "lsa_GetUserName");
9003                 ndr->depth++;
9004                 ndr_print_ptr(ndr, "account_name", r->out.account_name);
9005                 ndr->depth++;
9006                 ndr_print_ptr(ndr, "account_name", *r->out.account_name);
9007                 ndr->depth++;
9008                 if (*r->out.account_name) {
9009                         ndr_print_lsa_String(ndr, "account_name", *r->out.account_name);
9010                 }
9011                 ndr->depth--;
9012                 ndr->depth--;
9013                 ndr_print_ptr(ndr, "authority_name", r->out.authority_name);
9014                 ndr->depth++;
9015                 if (r->out.authority_name) {
9016                         ndr_print_ptr(ndr, "authority_name", *r->out.authority_name);
9017                         ndr->depth++;
9018                         if (*r->out.authority_name) {
9019                                 ndr_print_lsa_String(ndr, "authority_name", *r->out.authority_name);
9020                         }
9021                         ndr->depth--;
9022                 }
9023                 ndr->depth--;
9024                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9025                 ndr->depth--;
9026         }
9027         ndr->depth--;
9028 }
9029
9030 static enum ndr_err_code ndr_push_lsa_QueryInfoPolicy2(struct ndr_push *ndr, int flags, const struct lsa_QueryInfoPolicy2 *r)
9031 {
9032         if (flags & NDR_IN) {
9033                 if (r->in.handle == NULL) {
9034                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9035                 }
9036                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9037                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
9038         }
9039         if (flags & NDR_OUT) {
9040                 if (r->out.info == NULL) {
9041                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9042                 }
9043                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9044                 if (*r->out.info) {
9045                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9046                         NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9047                 }
9048                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9049         }
9050         return NDR_ERR_SUCCESS;
9051 }
9052
9053 static enum ndr_err_code ndr_pull_lsa_QueryInfoPolicy2(struct ndr_pull *ndr, int flags, struct lsa_QueryInfoPolicy2 *r)
9054 {
9055         uint32_t _ptr_info;
9056         TALLOC_CTX *_mem_save_handle_0;
9057         TALLOC_CTX *_mem_save_info_0;
9058         TALLOC_CTX *_mem_save_info_1;
9059         if (flags & NDR_IN) {
9060                 ZERO_STRUCT(r->out);
9061
9062                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9063                         NDR_PULL_ALLOC(ndr, r->in.handle);
9064                 }
9065                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9066                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9067                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9068                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9069                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
9070                 NDR_PULL_ALLOC(ndr, r->out.info);
9071                 ZERO_STRUCTP(r->out.info);
9072         }
9073         if (flags & NDR_OUT) {
9074                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9075                         NDR_PULL_ALLOC(ndr, r->out.info);
9076                 }
9077                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9078                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9080                 if (_ptr_info) {
9081                         NDR_PULL_ALLOC(ndr, *r->out.info);
9082                 } else {
9083                         *r->out.info = NULL;
9084                 }
9085                 if (*r->out.info) {
9086                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9087                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9088                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9089                         NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9090                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9091                 }
9092                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9093                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9094         }
9095         return NDR_ERR_SUCCESS;
9096 }
9097
9098 _PUBLIC_ void ndr_print_lsa_QueryInfoPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryInfoPolicy2 *r)
9099 {
9100         ndr_print_struct(ndr, name, "lsa_QueryInfoPolicy2");
9101         ndr->depth++;
9102         if (flags & NDR_SET_VALUES) {
9103                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9104         }
9105         if (flags & NDR_IN) {
9106                 ndr_print_struct(ndr, "in", "lsa_QueryInfoPolicy2");
9107                 ndr->depth++;
9108                 ndr_print_ptr(ndr, "handle", r->in.handle);
9109                 ndr->depth++;
9110                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9111                 ndr->depth--;
9112                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
9113                 ndr->depth--;
9114         }
9115         if (flags & NDR_OUT) {
9116                 ndr_print_struct(ndr, "out", "lsa_QueryInfoPolicy2");
9117                 ndr->depth++;
9118                 ndr_print_ptr(ndr, "info", r->out.info);
9119                 ndr->depth++;
9120                 ndr_print_ptr(ndr, "info", *r->out.info);
9121                 ndr->depth++;
9122                 if (*r->out.info) {
9123                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9124                         ndr_print_lsa_PolicyInformation(ndr, "info", *r->out.info);
9125                 }
9126                 ndr->depth--;
9127                 ndr->depth--;
9128                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9129                 ndr->depth--;
9130         }
9131         ndr->depth--;
9132 }
9133
9134 static enum ndr_err_code ndr_push_lsa_SetInfoPolicy2(struct ndr_push *ndr, int flags, const struct lsa_SetInfoPolicy2 *r)
9135 {
9136         if (flags & NDR_IN) {
9137                 if (r->in.handle == NULL) {
9138                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9139                 }
9140                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9141                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
9142                 if (r->in.info == NULL) {
9143                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9144                 }
9145                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
9146                 NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9147         }
9148         if (flags & NDR_OUT) {
9149                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9150         }
9151         return NDR_ERR_SUCCESS;
9152 }
9153
9154 static enum ndr_err_code ndr_pull_lsa_SetInfoPolicy2(struct ndr_pull *ndr, int flags, struct lsa_SetInfoPolicy2 *r)
9155 {
9156         TALLOC_CTX *_mem_save_handle_0;
9157         TALLOC_CTX *_mem_save_info_0;
9158         if (flags & NDR_IN) {
9159                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9160                         NDR_PULL_ALLOC(ndr, r->in.handle);
9161                 }
9162                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9163                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9164                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9165                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9166                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
9167                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9168                         NDR_PULL_ALLOC(ndr, r->in.info);
9169                 }
9170                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9171                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
9172                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
9173                 NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9174                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9175         }
9176         if (flags & NDR_OUT) {
9177                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9178         }
9179         return NDR_ERR_SUCCESS;
9180 }
9181
9182 _PUBLIC_ void ndr_print_lsa_SetInfoPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInfoPolicy2 *r)
9183 {
9184         ndr_print_struct(ndr, name, "lsa_SetInfoPolicy2");
9185         ndr->depth++;
9186         if (flags & NDR_SET_VALUES) {
9187                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9188         }
9189         if (flags & NDR_IN) {
9190                 ndr_print_struct(ndr, "in", "lsa_SetInfoPolicy2");
9191                 ndr->depth++;
9192                 ndr_print_ptr(ndr, "handle", r->in.handle);
9193                 ndr->depth++;
9194                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9195                 ndr->depth--;
9196                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
9197                 ndr_print_ptr(ndr, "info", r->in.info);
9198                 ndr->depth++;
9199                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9200                 ndr_print_lsa_PolicyInformation(ndr, "info", r->in.info);
9201                 ndr->depth--;
9202                 ndr->depth--;
9203         }
9204         if (flags & NDR_OUT) {
9205                 ndr_print_struct(ndr, "out", "lsa_SetInfoPolicy2");
9206                 ndr->depth++;
9207                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9208                 ndr->depth--;
9209         }
9210         ndr->depth--;
9211 }
9212
9213 static enum ndr_err_code ndr_push_lsa_QueryTrustedDomainInfoByName(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfoByName *r)
9214 {
9215         if (flags & NDR_IN) {
9216                 if (r->in.handle == NULL) {
9217                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9218                 }
9219                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9220                 if (r->in.trusted_domain == NULL) {
9221                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9222                 }
9223                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain));
9224                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
9225         }
9226         if (flags & NDR_OUT) {
9227                 if (r->out.info == NULL) {
9228                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9229                 }
9230                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9231                 if (*r->out.info) {
9232                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9233                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9234                 }
9235                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9236         }
9237         return NDR_ERR_SUCCESS;
9238 }
9239
9240 static enum ndr_err_code ndr_pull_lsa_QueryTrustedDomainInfoByName(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfoByName *r)
9241 {
9242         uint32_t _ptr_info;
9243         TALLOC_CTX *_mem_save_handle_0;
9244         TALLOC_CTX *_mem_save_trusted_domain_0;
9245         TALLOC_CTX *_mem_save_info_0;
9246         TALLOC_CTX *_mem_save_info_1;
9247         if (flags & NDR_IN) {
9248                 ZERO_STRUCT(r->out);
9249
9250                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9251                         NDR_PULL_ALLOC(ndr, r->in.handle);
9252                 }
9253                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9254                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9255                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9256                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9258                         NDR_PULL_ALLOC(ndr, r->in.trusted_domain);
9259                 }
9260                 _mem_save_trusted_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
9261                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trusted_domain, LIBNDR_FLAG_REF_ALLOC);
9262                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain));
9263                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trusted_domain_0, LIBNDR_FLAG_REF_ALLOC);
9264                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
9265                 NDR_PULL_ALLOC(ndr, r->out.info);
9266                 ZERO_STRUCTP(r->out.info);
9267         }
9268         if (flags & NDR_OUT) {
9269                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9270                         NDR_PULL_ALLOC(ndr, r->out.info);
9271                 }
9272                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9273                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9275                 if (_ptr_info) {
9276                         NDR_PULL_ALLOC(ndr, *r->out.info);
9277                 } else {
9278                         *r->out.info = NULL;
9279                 }
9280                 if (*r->out.info) {
9281                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9282                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9283                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9284                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9286                 }
9287                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9288                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9289         }
9290         return NDR_ERR_SUCCESS;
9291 }
9292
9293 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfoByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfoByName *r)
9294 {
9295         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfoByName");
9296         ndr->depth++;
9297         if (flags & NDR_SET_VALUES) {
9298                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9299         }
9300         if (flags & NDR_IN) {
9301                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfoByName");
9302                 ndr->depth++;
9303                 ndr_print_ptr(ndr, "handle", r->in.handle);
9304                 ndr->depth++;
9305                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9306                 ndr->depth--;
9307                 ndr_print_ptr(ndr, "trusted_domain", r->in.trusted_domain);
9308                 ndr->depth++;
9309                 ndr_print_lsa_String(ndr, "trusted_domain", r->in.trusted_domain);
9310                 ndr->depth--;
9311                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
9312                 ndr->depth--;
9313         }
9314         if (flags & NDR_OUT) {
9315                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfoByName");
9316                 ndr->depth++;
9317                 ndr_print_ptr(ndr, "info", r->out.info);
9318                 ndr->depth++;
9319                 ndr_print_ptr(ndr, "info", *r->out.info);
9320                 ndr->depth++;
9321                 if (*r->out.info) {
9322                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9323                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", *r->out.info);
9324                 }
9325                 ndr->depth--;
9326                 ndr->depth--;
9327                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9328                 ndr->depth--;
9329         }
9330         ndr->depth--;
9331 }
9332
9333 static enum ndr_err_code ndr_push_lsa_SetTrustedDomainInfoByName(struct ndr_push *ndr, int flags, const struct lsa_SetTrustedDomainInfoByName *r)
9334 {
9335         if (flags & NDR_IN) {
9336                 if (r->in.handle == NULL) {
9337                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9338                 }
9339                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9340                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
9341                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
9342                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
9343                 if (r->in.info) {
9344                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
9345                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9346                 }
9347         }
9348         if (flags & NDR_OUT) {
9349                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9350         }
9351         return NDR_ERR_SUCCESS;
9352 }
9353
9354 static enum ndr_err_code ndr_pull_lsa_SetTrustedDomainInfoByName(struct ndr_pull *ndr, int flags, struct lsa_SetTrustedDomainInfoByName *r)
9355 {
9356         uint32_t _ptr_info;
9357         TALLOC_CTX *_mem_save_handle_0;
9358         TALLOC_CTX *_mem_save_info_0;
9359         if (flags & NDR_IN) {
9360                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9361                         NDR_PULL_ALLOC(ndr, r->in.handle);
9362                 }
9363                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9364                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9365                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9367                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
9368                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
9369                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9370                 if (_ptr_info) {
9371                         NDR_PULL_ALLOC(ndr, r->in.info);
9372                 } else {
9373                         r->in.info = NULL;
9374                 }
9375                 if (r->in.info) {
9376                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9377                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
9378                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
9379                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9380                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9381                 }
9382         }
9383         if (flags & NDR_OUT) {
9384                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9385         }
9386         return NDR_ERR_SUCCESS;
9387 }
9388
9389 _PUBLIC_ void ndr_print_lsa_SetTrustedDomainInfoByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetTrustedDomainInfoByName *r)
9390 {
9391         ndr_print_struct(ndr, name, "lsa_SetTrustedDomainInfoByName");
9392         ndr->depth++;
9393         if (flags & NDR_SET_VALUES) {
9394                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9395         }
9396         if (flags & NDR_IN) {
9397                 ndr_print_struct(ndr, "in", "lsa_SetTrustedDomainInfoByName");
9398                 ndr->depth++;
9399                 ndr_print_ptr(ndr, "handle", r->in.handle);
9400                 ndr->depth++;
9401                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9402                 ndr->depth--;
9403                 ndr_print_lsa_String(ndr, "trusted_domain", &r->in.trusted_domain);
9404                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
9405                 ndr_print_ptr(ndr, "info", r->in.info);
9406                 ndr->depth++;
9407                 if (r->in.info) {
9408                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9409                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->in.info);
9410                 }
9411                 ndr->depth--;
9412                 ndr->depth--;
9413         }
9414         if (flags & NDR_OUT) {
9415                 ndr_print_struct(ndr, "out", "lsa_SetTrustedDomainInfoByName");
9416                 ndr->depth++;
9417                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9418                 ndr->depth--;
9419         }
9420         ndr->depth--;
9421 }
9422
9423 static enum ndr_err_code ndr_push_lsa_EnumTrustedDomainsEx(struct ndr_push *ndr, int flags, const struct lsa_EnumTrustedDomainsEx *r)
9424 {
9425         if (flags & NDR_IN) {
9426                 if (r->in.handle == NULL) {
9427                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9428                 }
9429                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9430                 if (r->in.resume_handle == NULL) {
9431                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9432                 }
9433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
9434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
9435         }
9436         if (flags & NDR_OUT) {
9437                 if (r->out.resume_handle == NULL) {
9438                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9439                 }
9440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
9441                 if (r->out.domains == NULL) {
9442                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9443                 }
9444                 NDR_CHECK(ndr_push_lsa_DomainListEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
9445                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9446         }
9447         return NDR_ERR_SUCCESS;
9448 }
9449
9450 static enum ndr_err_code ndr_pull_lsa_EnumTrustedDomainsEx(struct ndr_pull *ndr, int flags, struct lsa_EnumTrustedDomainsEx *r)
9451 {
9452         TALLOC_CTX *_mem_save_handle_0;
9453         TALLOC_CTX *_mem_save_resume_handle_0;
9454         TALLOC_CTX *_mem_save_domains_0;
9455         if (flags & NDR_IN) {
9456                 ZERO_STRUCT(r->out);
9457
9458                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9459                         NDR_PULL_ALLOC(ndr, r->in.handle);
9460                 }
9461                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9462                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9463                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9464                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9465                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9466                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
9467                 }
9468                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9469                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
9470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
9471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
9472                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
9473                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
9474                 *r->out.resume_handle = *r->in.resume_handle;
9475                 NDR_PULL_ALLOC(ndr, r->out.domains);
9476                 ZERO_STRUCTP(r->out.domains);
9477         }
9478         if (flags & NDR_OUT) {
9479                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9480                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
9481                 }
9482                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9483                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
9484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
9485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
9486                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9487                         NDR_PULL_ALLOC(ndr, r->out.domains);
9488                 }
9489                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
9490                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
9491                 NDR_CHECK(ndr_pull_lsa_DomainListEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
9492                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
9493                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9494         }
9495         return NDR_ERR_SUCCESS;
9496 }
9497
9498 _PUBLIC_ void ndr_print_lsa_EnumTrustedDomainsEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumTrustedDomainsEx *r)
9499 {
9500         ndr_print_struct(ndr, name, "lsa_EnumTrustedDomainsEx");
9501         ndr->depth++;
9502         if (flags & NDR_SET_VALUES) {
9503                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9504         }
9505         if (flags & NDR_IN) {
9506                 ndr_print_struct(ndr, "in", "lsa_EnumTrustedDomainsEx");
9507                 ndr->depth++;
9508                 ndr_print_ptr(ndr, "handle", r->in.handle);
9509                 ndr->depth++;
9510                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9511                 ndr->depth--;
9512                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
9513                 ndr->depth++;
9514                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
9515                 ndr->depth--;
9516                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
9517                 ndr->depth--;
9518         }
9519         if (flags & NDR_OUT) {
9520                 ndr_print_struct(ndr, "out", "lsa_EnumTrustedDomainsEx");
9521                 ndr->depth++;
9522                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
9523                 ndr->depth++;
9524                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
9525                 ndr->depth--;
9526                 ndr_print_ptr(ndr, "domains", r->out.domains);
9527                 ndr->depth++;
9528                 ndr_print_lsa_DomainListEx(ndr, "domains", r->out.domains);
9529                 ndr->depth--;
9530                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9531                 ndr->depth--;
9532         }
9533         ndr->depth--;
9534 }
9535
9536 static enum ndr_err_code ndr_push_lsa_CreateTrustedDomainEx(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomainEx *r)
9537 {
9538         if (flags & NDR_IN) {
9539         }
9540         if (flags & NDR_OUT) {
9541                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9542         }
9543         return NDR_ERR_SUCCESS;
9544 }
9545
9546 static enum ndr_err_code ndr_pull_lsa_CreateTrustedDomainEx(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomainEx *r)
9547 {
9548         if (flags & NDR_IN) {
9549         }
9550         if (flags & NDR_OUT) {
9551                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9552         }
9553         return NDR_ERR_SUCCESS;
9554 }
9555
9556 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomainEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomainEx *r)
9557 {
9558         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomainEx");
9559         ndr->depth++;
9560         if (flags & NDR_SET_VALUES) {
9561                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9562         }
9563         if (flags & NDR_IN) {
9564                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomainEx");
9565                 ndr->depth++;
9566                 ndr->depth--;
9567         }
9568         if (flags & NDR_OUT) {
9569                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomainEx");
9570                 ndr->depth++;
9571                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9572                 ndr->depth--;
9573         }
9574         ndr->depth--;
9575 }
9576
9577 static enum ndr_err_code ndr_push_lsa_CloseTrustedDomainEx(struct ndr_push *ndr, int flags, const struct lsa_CloseTrustedDomainEx *r)
9578 {
9579         if (flags & NDR_IN) {
9580                 if (r->in.handle == NULL) {
9581                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9582                 }
9583                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9584         }
9585         if (flags & NDR_OUT) {
9586                 if (r->out.handle == NULL) {
9587                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9588                 }
9589                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
9590                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9591         }
9592         return NDR_ERR_SUCCESS;
9593 }
9594
9595 static enum ndr_err_code ndr_pull_lsa_CloseTrustedDomainEx(struct ndr_pull *ndr, int flags, struct lsa_CloseTrustedDomainEx *r)
9596 {
9597         TALLOC_CTX *_mem_save_handle_0;
9598         if (flags & NDR_IN) {
9599                 ZERO_STRUCT(r->out);
9600
9601                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9602                         NDR_PULL_ALLOC(ndr, r->in.handle);
9603                 }
9604                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9605                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9606                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9607                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9608                 NDR_PULL_ALLOC(ndr, r->out.handle);
9609                 *r->out.handle = *r->in.handle;
9610         }
9611         if (flags & NDR_OUT) {
9612                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9613                         NDR_PULL_ALLOC(ndr, r->out.handle);
9614                 }
9615                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9616                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
9617                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
9618                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9619                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9620         }
9621         return NDR_ERR_SUCCESS;
9622 }
9623
9624 _PUBLIC_ void ndr_print_lsa_CloseTrustedDomainEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CloseTrustedDomainEx *r)
9625 {
9626         ndr_print_struct(ndr, name, "lsa_CloseTrustedDomainEx");
9627         ndr->depth++;
9628         if (flags & NDR_SET_VALUES) {
9629                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9630         }
9631         if (flags & NDR_IN) {
9632                 ndr_print_struct(ndr, "in", "lsa_CloseTrustedDomainEx");
9633                 ndr->depth++;
9634                 ndr_print_ptr(ndr, "handle", r->in.handle);
9635                 ndr->depth++;
9636                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9637                 ndr->depth--;
9638                 ndr->depth--;
9639         }
9640         if (flags & NDR_OUT) {
9641                 ndr_print_struct(ndr, "out", "lsa_CloseTrustedDomainEx");
9642                 ndr->depth++;
9643                 ndr_print_ptr(ndr, "handle", r->out.handle);
9644                 ndr->depth++;
9645                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
9646                 ndr->depth--;
9647                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9648                 ndr->depth--;
9649         }
9650         ndr->depth--;
9651 }
9652
9653 static enum ndr_err_code ndr_push_lsa_QueryDomainInformationPolicy(struct ndr_push *ndr, int flags, const struct lsa_QueryDomainInformationPolicy *r)
9654 {
9655         if (flags & NDR_IN) {
9656                 if (r->in.handle == NULL) {
9657                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9658                 }
9659                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9660                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9661         }
9662         if (flags & NDR_OUT) {
9663                 if (r->out.info == NULL) {
9664                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9665                 }
9666                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9667                 if (*r->out.info) {
9668                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9669                         NDR_CHECK(ndr_push_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9670                 }
9671                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9672         }
9673         return NDR_ERR_SUCCESS;
9674 }
9675
9676 static enum ndr_err_code ndr_pull_lsa_QueryDomainInformationPolicy(struct ndr_pull *ndr, int flags, struct lsa_QueryDomainInformationPolicy *r)
9677 {
9678         uint32_t _ptr_info;
9679         TALLOC_CTX *_mem_save_handle_0;
9680         TALLOC_CTX *_mem_save_info_0;
9681         TALLOC_CTX *_mem_save_info_1;
9682         if (flags & NDR_IN) {
9683                 ZERO_STRUCT(r->out);
9684
9685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9686                         NDR_PULL_ALLOC(ndr, r->in.handle);
9687                 }
9688                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9689                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9690                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9692                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9693                 NDR_PULL_ALLOC(ndr, r->out.info);
9694                 ZERO_STRUCTP(r->out.info);
9695         }
9696         if (flags & NDR_OUT) {
9697                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9698                         NDR_PULL_ALLOC(ndr, r->out.info);
9699                 }
9700                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9701                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9702                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9703                 if (_ptr_info) {
9704                         NDR_PULL_ALLOC(ndr, *r->out.info);
9705                 } else {
9706                         *r->out.info = NULL;
9707                 }
9708                 if (*r->out.info) {
9709                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9710                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9711                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9712                         NDR_CHECK(ndr_pull_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9714                 }
9715                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9716                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9717         }
9718         return NDR_ERR_SUCCESS;
9719 }
9720
9721 _PUBLIC_ void ndr_print_lsa_QueryDomainInformationPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryDomainInformationPolicy *r)
9722 {
9723         ndr_print_struct(ndr, name, "lsa_QueryDomainInformationPolicy");
9724         ndr->depth++;
9725         if (flags & NDR_SET_VALUES) {
9726                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9727         }
9728         if (flags & NDR_IN) {
9729                 ndr_print_struct(ndr, "in", "lsa_QueryDomainInformationPolicy");
9730                 ndr->depth++;
9731                 ndr_print_ptr(ndr, "handle", r->in.handle);
9732                 ndr->depth++;
9733                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9734                 ndr->depth--;
9735                 ndr_print_uint16(ndr, "level", r->in.level);
9736                 ndr->depth--;
9737         }
9738         if (flags & NDR_OUT) {
9739                 ndr_print_struct(ndr, "out", "lsa_QueryDomainInformationPolicy");
9740                 ndr->depth++;
9741                 ndr_print_ptr(ndr, "info", r->out.info);
9742                 ndr->depth++;
9743                 ndr_print_ptr(ndr, "info", *r->out.info);
9744                 ndr->depth++;
9745                 if (*r->out.info) {
9746                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9747                         ndr_print_lsa_DomainInformationPolicy(ndr, "info", *r->out.info);
9748                 }
9749                 ndr->depth--;
9750                 ndr->depth--;
9751                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9752                 ndr->depth--;
9753         }
9754         ndr->depth--;
9755 }
9756
9757 static enum ndr_err_code ndr_push_lsa_SetDomainInformationPolicy(struct ndr_push *ndr, int flags, const struct lsa_SetDomainInformationPolicy *r)
9758 {
9759         if (flags & NDR_IN) {
9760                 if (r->in.handle == NULL) {
9761                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9762                 }
9763                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9764                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9765                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
9766                 if (r->in.info) {
9767                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
9768                         NDR_CHECK(ndr_push_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9769                 }
9770         }
9771         if (flags & NDR_OUT) {
9772                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9773         }
9774         return NDR_ERR_SUCCESS;
9775 }
9776
9777 static enum ndr_err_code ndr_pull_lsa_SetDomainInformationPolicy(struct ndr_pull *ndr, int flags, struct lsa_SetDomainInformationPolicy *r)
9778 {
9779         uint32_t _ptr_info;
9780         TALLOC_CTX *_mem_save_handle_0;
9781         TALLOC_CTX *_mem_save_info_0;
9782         if (flags & NDR_IN) {
9783                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9784                         NDR_PULL_ALLOC(ndr, r->in.handle);
9785                 }
9786                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9787                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9788                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9789                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9790                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9792                 if (_ptr_info) {
9793                         NDR_PULL_ALLOC(ndr, r->in.info);
9794                 } else {
9795                         r->in.info = NULL;
9796                 }
9797                 if (r->in.info) {
9798                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9799                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
9800                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
9801                         NDR_CHECK(ndr_pull_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9802                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9803                 }
9804         }
9805         if (flags & NDR_OUT) {
9806                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9807         }
9808         return NDR_ERR_SUCCESS;
9809 }
9810
9811 _PUBLIC_ void ndr_print_lsa_SetDomainInformationPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetDomainInformationPolicy *r)
9812 {
9813         ndr_print_struct(ndr, name, "lsa_SetDomainInformationPolicy");
9814         ndr->depth++;
9815         if (flags & NDR_SET_VALUES) {
9816                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9817         }
9818         if (flags & NDR_IN) {
9819                 ndr_print_struct(ndr, "in", "lsa_SetDomainInformationPolicy");
9820                 ndr->depth++;
9821                 ndr_print_ptr(ndr, "handle", r->in.handle);
9822                 ndr->depth++;
9823                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9824                 ndr->depth--;
9825                 ndr_print_uint16(ndr, "level", r->in.level);
9826                 ndr_print_ptr(ndr, "info", r->in.info);
9827                 ndr->depth++;
9828                 if (r->in.info) {
9829                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9830                         ndr_print_lsa_DomainInformationPolicy(ndr, "info", r->in.info);
9831                 }
9832                 ndr->depth--;
9833                 ndr->depth--;
9834         }
9835         if (flags & NDR_OUT) {
9836                 ndr_print_struct(ndr, "out", "lsa_SetDomainInformationPolicy");
9837                 ndr->depth++;
9838                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9839                 ndr->depth--;
9840         }
9841         ndr->depth--;
9842 }
9843
9844 static enum ndr_err_code ndr_push_lsa_OpenTrustedDomainByName(struct ndr_push *ndr, int flags, const struct lsa_OpenTrustedDomainByName *r)
9845 {
9846         if (flags & NDR_IN) {
9847                 if (r->in.handle == NULL) {
9848                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9849                 }
9850                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9851                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
9852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
9853         }
9854         if (flags & NDR_OUT) {
9855                 if (r->out.trustdom_handle == NULL) {
9856                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9857                 }
9858                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
9859                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9860         }
9861         return NDR_ERR_SUCCESS;
9862 }
9863
9864 static enum ndr_err_code ndr_pull_lsa_OpenTrustedDomainByName(struct ndr_pull *ndr, int flags, struct lsa_OpenTrustedDomainByName *r)
9865 {
9866         TALLOC_CTX *_mem_save_handle_0;
9867         TALLOC_CTX *_mem_save_trustdom_handle_0;
9868         if (flags & NDR_IN) {
9869                 ZERO_STRUCT(r->out);
9870
9871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9872                         NDR_PULL_ALLOC(ndr, r->in.handle);
9873                 }
9874                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9875                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9876                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9878                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
9879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
9880                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
9881                 ZERO_STRUCTP(r->out.trustdom_handle);
9882         }
9883         if (flags & NDR_OUT) {
9884                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9885                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
9886                 }
9887                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9888                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
9889                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
9890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
9891                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9892         }
9893         return NDR_ERR_SUCCESS;
9894 }
9895
9896 _PUBLIC_ void ndr_print_lsa_OpenTrustedDomainByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenTrustedDomainByName *r)
9897 {
9898         ndr_print_struct(ndr, name, "lsa_OpenTrustedDomainByName");
9899         ndr->depth++;
9900         if (flags & NDR_SET_VALUES) {
9901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9902         }
9903         if (flags & NDR_IN) {
9904                 ndr_print_struct(ndr, "in", "lsa_OpenTrustedDomainByName");
9905                 ndr->depth++;
9906                 ndr_print_ptr(ndr, "handle", r->in.handle);
9907                 ndr->depth++;
9908                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9909                 ndr->depth--;
9910                 ndr_print_lsa_String(ndr, "name", &r->in.name);
9911                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
9912                 ndr->depth--;
9913         }
9914         if (flags & NDR_OUT) {
9915                 ndr_print_struct(ndr, "out", "lsa_OpenTrustedDomainByName");
9916                 ndr->depth++;
9917                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
9918                 ndr->depth++;
9919                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
9920                 ndr->depth--;
9921                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9922                 ndr->depth--;
9923         }
9924         ndr->depth--;
9925 }
9926
9927 static enum ndr_err_code ndr_push_lsa_TestCall(struct ndr_push *ndr, int flags, const struct lsa_TestCall *r)
9928 {
9929         if (flags & NDR_IN) {
9930         }
9931         if (flags & NDR_OUT) {
9932                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9933         }
9934         return NDR_ERR_SUCCESS;
9935 }
9936
9937 static enum ndr_err_code ndr_pull_lsa_TestCall(struct ndr_pull *ndr, int flags, struct lsa_TestCall *r)
9938 {
9939         if (flags & NDR_IN) {
9940         }
9941         if (flags & NDR_OUT) {
9942                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9943         }
9944         return NDR_ERR_SUCCESS;
9945 }
9946
9947 _PUBLIC_ void ndr_print_lsa_TestCall(struct ndr_print *ndr, const char *name, int flags, const struct lsa_TestCall *r)
9948 {
9949         ndr_print_struct(ndr, name, "lsa_TestCall");
9950         ndr->depth++;
9951         if (flags & NDR_SET_VALUES) {
9952                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9953         }
9954         if (flags & NDR_IN) {
9955                 ndr_print_struct(ndr, "in", "lsa_TestCall");
9956                 ndr->depth++;
9957                 ndr->depth--;
9958         }
9959         if (flags & NDR_OUT) {
9960                 ndr_print_struct(ndr, "out", "lsa_TestCall");
9961                 ndr->depth++;
9962                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9963                 ndr->depth--;
9964         }
9965         ndr->depth--;
9966 }
9967
9968 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupSids2(struct ndr_push *ndr, int flags, const struct lsa_LookupSids2 *r)
9969 {
9970         if (flags & NDR_IN) {
9971                 if (r->in.handle == NULL) {
9972                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9973                 }
9974                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9975                 if (r->in.sids == NULL) {
9976                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9977                 }
9978                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
9979                 if (r->in.names == NULL) {
9980                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9981                 }
9982                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
9983                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9984                 if (r->in.count == NULL) {
9985                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9986                 }
9987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
9988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
9989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
9990         }
9991         if (flags & NDR_OUT) {
9992                 if (r->out.domains == NULL) {
9993                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9994                 }
9995                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
9996                 if (*r->out.domains) {
9997                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
9998                 }
9999                 if (r->out.names == NULL) {
10000                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10001                 }
10002                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
10003                 if (r->out.count == NULL) {
10004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10005                 }
10006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
10007                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10008         }
10009         return NDR_ERR_SUCCESS;
10010 }
10011
10012 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupSids2(struct ndr_pull *ndr, int flags, struct lsa_LookupSids2 *r)
10013 {
10014         uint32_t _ptr_domains;
10015         TALLOC_CTX *_mem_save_handle_0;
10016         TALLOC_CTX *_mem_save_sids_0;
10017         TALLOC_CTX *_mem_save_domains_0;
10018         TALLOC_CTX *_mem_save_domains_1;
10019         TALLOC_CTX *_mem_save_names_0;
10020         TALLOC_CTX *_mem_save_count_0;
10021         if (flags & NDR_IN) {
10022                 ZERO_STRUCT(r->out);
10023
10024                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10025                         NDR_PULL_ALLOC(ndr, r->in.handle);
10026                 }
10027                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10028                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10029                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
10030                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10031                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10032                         NDR_PULL_ALLOC(ndr, r->in.sids);
10033                 }
10034                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10035                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10036                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10037                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10038                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10039                         NDR_PULL_ALLOC(ndr, r->in.names);
10040                 }
10041                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10042                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
10043                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
10044                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
10045                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10047                         NDR_PULL_ALLOC(ndr, r->in.count);
10048                 }
10049                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10050                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
10051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
10052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
10054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
10055                 NDR_PULL_ALLOC(ndr, r->out.domains);
10056                 ZERO_STRUCTP(r->out.domains);
10057                 NDR_PULL_ALLOC(ndr, r->out.names);
10058                 *r->out.names = *r->in.names;
10059                 NDR_PULL_ALLOC(ndr, r->out.count);
10060                 *r->out.count = *r->in.count;
10061         }
10062         if (flags & NDR_OUT) {
10063                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10064                         NDR_PULL_ALLOC(ndr, r->out.domains);
10065                 }
10066                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
10067                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
10068                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
10069                 if (_ptr_domains) {
10070                         NDR_PULL_ALLOC(ndr, *r->out.domains);
10071                 } else {
10072                         *r->out.domains = NULL;
10073                 }
10074                 if (*r->out.domains) {
10075                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
10076                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
10077                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10078                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
10079                 }
10080                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
10081                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10082                         NDR_PULL_ALLOC(ndr, r->out.names);
10083                 }
10084                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10085                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
10086                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
10087                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
10088                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10089                         NDR_PULL_ALLOC(ndr, r->out.count);
10090                 }
10091                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10092                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
10093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
10094                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10095                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10096         }
10097         return NDR_ERR_SUCCESS;
10098 }
10099
10100 _PUBLIC_ void ndr_print_lsa_LookupSids2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids2 *r)
10101 {
10102         ndr_print_struct(ndr, name, "lsa_LookupSids2");
10103         ndr->depth++;
10104         if (flags & NDR_SET_VALUES) {
10105                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10106         }
10107         if (flags & NDR_IN) {
10108                 ndr_print_struct(ndr, "in", "lsa_LookupSids2");
10109                 ndr->depth++;
10110                 ndr_print_ptr(ndr, "handle", r->in.handle);
10111                 ndr->depth++;
10112                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10113                 ndr->depth--;
10114                 ndr_print_ptr(ndr, "sids", r->in.sids);
10115                 ndr->depth++;
10116                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10117                 ndr->depth--;
10118                 ndr_print_ptr(ndr, "names", r->in.names);
10119                 ndr->depth++;
10120                 ndr_print_lsa_TransNameArray2(ndr, "names", r->in.names);
10121                 ndr->depth--;
10122                 ndr_print_uint16(ndr, "level", r->in.level);
10123                 ndr_print_ptr(ndr, "count", r->in.count);
10124                 ndr->depth++;
10125                 ndr_print_uint32(ndr, "count", *r->in.count);
10126                 ndr->depth--;
10127                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
10128                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
10129                 ndr->depth--;
10130         }
10131         if (flags & NDR_OUT) {
10132                 ndr_print_struct(ndr, "out", "lsa_LookupSids2");
10133                 ndr->depth++;
10134                 ndr_print_ptr(ndr, "domains", r->out.domains);
10135                 ndr->depth++;
10136                 ndr_print_ptr(ndr, "domains", *r->out.domains);
10137                 ndr->depth++;
10138                 if (*r->out.domains) {
10139                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
10140                 }
10141                 ndr->depth--;
10142                 ndr->depth--;
10143                 ndr_print_ptr(ndr, "names", r->out.names);
10144                 ndr->depth++;
10145                 ndr_print_lsa_TransNameArray2(ndr, "names", r->out.names);
10146                 ndr->depth--;
10147                 ndr_print_ptr(ndr, "count", r->out.count);
10148                 ndr->depth++;
10149                 ndr_print_uint32(ndr, "count", *r->out.count);
10150                 ndr->depth--;
10151                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10152                 ndr->depth--;
10153         }
10154         ndr->depth--;
10155 }
10156
10157 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupNames2(struct ndr_push *ndr, int flags, const struct lsa_LookupNames2 *r)
10158 {
10159         uint32_t cntr_names_0;
10160         if (flags & NDR_IN) {
10161                 if (r->in.handle == NULL) {
10162                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10163                 }
10164                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
10165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10167                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10168                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
10169                 }
10170                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10171                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
10172                 }
10173                 if (r->in.sids == NULL) {
10174                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10175                 }
10176                 NDR_CHECK(ndr_push_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10177                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
10178                 if (r->in.count == NULL) {
10179                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10180                 }
10181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
10182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
10183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
10184         }
10185         if (flags & NDR_OUT) {
10186                 if (r->out.domains == NULL) {
10187                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10188                 }
10189                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
10190                 if (*r->out.domains) {
10191                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10192                 }
10193                 if (r->out.sids == NULL) {
10194                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10195                 }
10196                 NDR_CHECK(ndr_push_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
10197                 if (r->out.count == NULL) {
10198                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10199                 }
10200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
10201                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10202         }
10203         return NDR_ERR_SUCCESS;
10204 }
10205
10206 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupNames2(struct ndr_pull *ndr, int flags, struct lsa_LookupNames2 *r)
10207 {
10208         uint32_t cntr_names_0;
10209         uint32_t _ptr_domains;
10210         TALLOC_CTX *_mem_save_handle_0;
10211         TALLOC_CTX *_mem_save_names_0;
10212         TALLOC_CTX *_mem_save_domains_0;
10213         TALLOC_CTX *_mem_save_domains_1;
10214         TALLOC_CTX *_mem_save_sids_0;
10215         TALLOC_CTX *_mem_save_count_0;
10216         if (flags & NDR_IN) {
10217                 ZERO_STRUCT(r->out);
10218
10219                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10220                         NDR_PULL_ALLOC(ndr, r->in.handle);
10221                 }
10222                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10223                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10224                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
10225                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
10227                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
10228                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
10229                 }
10230                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
10231                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
10232                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10233                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
10234                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10235                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
10236                 }
10237                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10238                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
10239                 }
10240                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
10241                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10242                         NDR_PULL_ALLOC(ndr, r->in.sids);
10243                 }
10244                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10245                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10246                 NDR_CHECK(ndr_pull_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10247                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10248                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
10249                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10250                         NDR_PULL_ALLOC(ndr, r->in.count);
10251                 }
10252                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10253                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
10254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
10255                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
10257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
10258                 NDR_PULL_ALLOC(ndr, r->out.domains);
10259                 ZERO_STRUCTP(r->out.domains);
10260                 NDR_PULL_ALLOC(ndr, r->out.sids);
10261                 *r->out.sids = *r->in.sids;
10262                 NDR_PULL_ALLOC(ndr, r->out.count);
10263                 *r->out.count = *r->in.count;
10264                 if (r->in.names) {
10265                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
10266                 }
10267         }
10268         if (flags & NDR_OUT) {
10269                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10270                         NDR_PULL_ALLOC(ndr, r->out.domains);
10271                 }
10272                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
10273                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
10274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
10275                 if (_ptr_domains) {
10276                         NDR_PULL_ALLOC(ndr, *r->out.domains);
10277                 } else {
10278                         *r->out.domains = NULL;
10279                 }
10280                 if (*r->out.domains) {
10281                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
10282                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
10283                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
10285                 }
10286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
10287                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10288                         NDR_PULL_ALLOC(ndr, r->out.sids);
10289                 }
10290                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10291                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
10292                 NDR_CHECK(ndr_pull_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
10293                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10294                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10295                         NDR_PULL_ALLOC(ndr, r->out.count);
10296                 }
10297                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10298                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
10299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
10300                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10301                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10302         }
10303         return NDR_ERR_SUCCESS;
10304 }
10305
10306 _PUBLIC_ void ndr_print_lsa_LookupNames2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames2 *r)
10307 {
10308         uint32_t cntr_names_0;
10309         ndr_print_struct(ndr, name, "lsa_LookupNames2");
10310         ndr->depth++;
10311         if (flags & NDR_SET_VALUES) {
10312                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10313         }
10314         if (flags & NDR_IN) {
10315                 ndr_print_struct(ndr, "in", "lsa_LookupNames2");
10316                 ndr->depth++;
10317                 ndr_print_ptr(ndr, "handle", r->in.handle);
10318                 ndr->depth++;
10319                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10320                 ndr->depth--;
10321                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
10322                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
10323                 ndr->depth++;
10324                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
10325                         char *idx_0=NULL;
10326                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
10327                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
10328                                 free(idx_0);
10329                         }
10330                 }
10331                 ndr->depth--;
10332                 ndr_print_ptr(ndr, "sids", r->in.sids);
10333                 ndr->depth++;
10334                 ndr_print_lsa_TransSidArray2(ndr, "sids", r->in.sids);
10335                 ndr->depth--;
10336                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
10337                 ndr_print_ptr(ndr, "count", r->in.count);
10338                 ndr->depth++;
10339                 ndr_print_uint32(ndr, "count", *r->in.count);
10340                 ndr->depth--;
10341                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
10342                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
10343                 ndr->depth--;
10344         }
10345         if (flags & NDR_OUT) {
10346                 ndr_print_struct(ndr, "out", "lsa_LookupNames2");
10347                 ndr->depth++;
10348                 ndr_print_ptr(ndr, "domains", r->out.domains);
10349                 ndr->depth++;
10350                 ndr_print_ptr(ndr, "domains", *r->out.domains);
10351                 ndr->depth++;
10352                 if (*r->out.domains) {
10353                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
10354                 }
10355                 ndr->depth--;
10356                 ndr->depth--;
10357                 ndr_print_ptr(ndr, "sids", r->out.sids);
10358                 ndr->depth++;
10359                 ndr_print_lsa_TransSidArray2(ndr, "sids", r->out.sids);
10360                 ndr->depth--;
10361                 ndr_print_ptr(ndr, "count", r->out.count);
10362                 ndr->depth++;
10363                 ndr_print_uint32(ndr, "count", *r->out.count);
10364                 ndr->depth--;
10365                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10366                 ndr->depth--;
10367         }
10368         ndr->depth--;
10369 }
10370
10371 static enum ndr_err_code ndr_push_lsa_CreateTrustedDomainEx2(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomainEx2 *r)
10372 {
10373         if (flags & NDR_IN) {
10374         }
10375         if (flags & NDR_OUT) {
10376                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10377         }
10378         return NDR_ERR_SUCCESS;
10379 }
10380
10381 static enum ndr_err_code ndr_pull_lsa_CreateTrustedDomainEx2(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomainEx2 *r)
10382 {
10383         if (flags & NDR_IN) {
10384         }
10385         if (flags & NDR_OUT) {
10386                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10387         }
10388         return NDR_ERR_SUCCESS;
10389 }
10390
10391 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomainEx2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomainEx2 *r)
10392 {
10393         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomainEx2");
10394         ndr->depth++;
10395         if (flags & NDR_SET_VALUES) {
10396                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10397         }
10398         if (flags & NDR_IN) {
10399                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomainEx2");
10400                 ndr->depth++;
10401                 ndr->depth--;
10402         }
10403         if (flags & NDR_OUT) {
10404                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomainEx2");
10405                 ndr->depth++;
10406                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10407                 ndr->depth--;
10408         }
10409         ndr->depth--;
10410 }
10411
10412 static enum ndr_err_code ndr_push_lsa_CREDRWRITE(struct ndr_push *ndr, int flags, const struct lsa_CREDRWRITE *r)
10413 {
10414         if (flags & NDR_IN) {
10415         }
10416         if (flags & NDR_OUT) {
10417                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10418         }
10419         return NDR_ERR_SUCCESS;
10420 }
10421
10422 static enum ndr_err_code ndr_pull_lsa_CREDRWRITE(struct ndr_pull *ndr, int flags, struct lsa_CREDRWRITE *r)
10423 {
10424         if (flags & NDR_IN) {
10425         }
10426         if (flags & NDR_OUT) {
10427                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10428         }
10429         return NDR_ERR_SUCCESS;
10430 }
10431
10432 _PUBLIC_ void ndr_print_lsa_CREDRWRITE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRWRITE *r)
10433 {
10434         ndr_print_struct(ndr, name, "lsa_CREDRWRITE");
10435         ndr->depth++;
10436         if (flags & NDR_SET_VALUES) {
10437                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10438         }
10439         if (flags & NDR_IN) {
10440                 ndr_print_struct(ndr, "in", "lsa_CREDRWRITE");
10441                 ndr->depth++;
10442                 ndr->depth--;
10443         }
10444         if (flags & NDR_OUT) {
10445                 ndr_print_struct(ndr, "out", "lsa_CREDRWRITE");
10446                 ndr->depth++;
10447                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10448                 ndr->depth--;
10449         }
10450         ndr->depth--;
10451 }
10452
10453 static enum ndr_err_code ndr_push_lsa_CREDRREAD(struct ndr_push *ndr, int flags, const struct lsa_CREDRREAD *r)
10454 {
10455         if (flags & NDR_IN) {
10456         }
10457         if (flags & NDR_OUT) {
10458                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10459         }
10460         return NDR_ERR_SUCCESS;
10461 }
10462
10463 static enum ndr_err_code ndr_pull_lsa_CREDRREAD(struct ndr_pull *ndr, int flags, struct lsa_CREDRREAD *r)
10464 {
10465         if (flags & NDR_IN) {
10466         }
10467         if (flags & NDR_OUT) {
10468                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10469         }
10470         return NDR_ERR_SUCCESS;
10471 }
10472
10473 _PUBLIC_ void ndr_print_lsa_CREDRREAD(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRREAD *r)
10474 {
10475         ndr_print_struct(ndr, name, "lsa_CREDRREAD");
10476         ndr->depth++;
10477         if (flags & NDR_SET_VALUES) {
10478                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10479         }
10480         if (flags & NDR_IN) {
10481                 ndr_print_struct(ndr, "in", "lsa_CREDRREAD");
10482                 ndr->depth++;
10483                 ndr->depth--;
10484         }
10485         if (flags & NDR_OUT) {
10486                 ndr_print_struct(ndr, "out", "lsa_CREDRREAD");
10487                 ndr->depth++;
10488                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10489                 ndr->depth--;
10490         }
10491         ndr->depth--;
10492 }
10493
10494 static enum ndr_err_code ndr_push_lsa_CREDRENUMERATE(struct ndr_push *ndr, int flags, const struct lsa_CREDRENUMERATE *r)
10495 {
10496         if (flags & NDR_IN) {
10497         }
10498         if (flags & NDR_OUT) {
10499                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10500         }
10501         return NDR_ERR_SUCCESS;
10502 }
10503
10504 static enum ndr_err_code ndr_pull_lsa_CREDRENUMERATE(struct ndr_pull *ndr, int flags, struct lsa_CREDRENUMERATE *r)
10505 {
10506         if (flags & NDR_IN) {
10507         }
10508         if (flags & NDR_OUT) {
10509                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10510         }
10511         return NDR_ERR_SUCCESS;
10512 }
10513
10514 _PUBLIC_ void ndr_print_lsa_CREDRENUMERATE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRENUMERATE *r)
10515 {
10516         ndr_print_struct(ndr, name, "lsa_CREDRENUMERATE");
10517         ndr->depth++;
10518         if (flags & NDR_SET_VALUES) {
10519                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10520         }
10521         if (flags & NDR_IN) {
10522                 ndr_print_struct(ndr, "in", "lsa_CREDRENUMERATE");
10523                 ndr->depth++;
10524                 ndr->depth--;
10525         }
10526         if (flags & NDR_OUT) {
10527                 ndr_print_struct(ndr, "out", "lsa_CREDRENUMERATE");
10528                 ndr->depth++;
10529                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10530                 ndr->depth--;
10531         }
10532         ndr->depth--;
10533 }
10534
10535 static enum ndr_err_code ndr_push_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_push *ndr, int flags, const struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
10536 {
10537         if (flags & NDR_IN) {
10538         }
10539         if (flags & NDR_OUT) {
10540                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10541         }
10542         return NDR_ERR_SUCCESS;
10543 }
10544
10545 static enum ndr_err_code ndr_pull_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_pull *ndr, int flags, struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
10546 {
10547         if (flags & NDR_IN) {
10548         }
10549         if (flags & NDR_OUT) {
10550                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10551         }
10552         return NDR_ERR_SUCCESS;
10553 }
10554
10555 _PUBLIC_ void ndr_print_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
10556 {
10557         ndr_print_struct(ndr, name, "lsa_CREDRWRITEDOMAINCREDENTIALS");
10558         ndr->depth++;
10559         if (flags & NDR_SET_VALUES) {
10560                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10561         }
10562         if (flags & NDR_IN) {
10563                 ndr_print_struct(ndr, "in", "lsa_CREDRWRITEDOMAINCREDENTIALS");
10564                 ndr->depth++;
10565                 ndr->depth--;
10566         }
10567         if (flags & NDR_OUT) {
10568                 ndr_print_struct(ndr, "out", "lsa_CREDRWRITEDOMAINCREDENTIALS");
10569                 ndr->depth++;
10570                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10571                 ndr->depth--;
10572         }
10573         ndr->depth--;
10574 }
10575
10576 static enum ndr_err_code ndr_push_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_push *ndr, int flags, const struct lsa_CREDRREADDOMAINCREDENTIALS *r)
10577 {
10578         if (flags & NDR_IN) {
10579         }
10580         if (flags & NDR_OUT) {
10581                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10582         }
10583         return NDR_ERR_SUCCESS;
10584 }
10585
10586 static enum ndr_err_code ndr_pull_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_pull *ndr, int flags, struct lsa_CREDRREADDOMAINCREDENTIALS *r)
10587 {
10588         if (flags & NDR_IN) {
10589         }
10590         if (flags & NDR_OUT) {
10591                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10592         }
10593         return NDR_ERR_SUCCESS;
10594 }
10595
10596 _PUBLIC_ void ndr_print_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRREADDOMAINCREDENTIALS *r)
10597 {
10598         ndr_print_struct(ndr, name, "lsa_CREDRREADDOMAINCREDENTIALS");
10599         ndr->depth++;
10600         if (flags & NDR_SET_VALUES) {
10601                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10602         }
10603         if (flags & NDR_IN) {
10604                 ndr_print_struct(ndr, "in", "lsa_CREDRREADDOMAINCREDENTIALS");
10605                 ndr->depth++;
10606                 ndr->depth--;
10607         }
10608         if (flags & NDR_OUT) {
10609                 ndr_print_struct(ndr, "out", "lsa_CREDRREADDOMAINCREDENTIALS");
10610                 ndr->depth++;
10611                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10612                 ndr->depth--;
10613         }
10614         ndr->depth--;
10615 }
10616
10617 static enum ndr_err_code ndr_push_lsa_CREDRDELETE(struct ndr_push *ndr, int flags, const struct lsa_CREDRDELETE *r)
10618 {
10619         if (flags & NDR_IN) {
10620         }
10621         if (flags & NDR_OUT) {
10622                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10623         }
10624         return NDR_ERR_SUCCESS;
10625 }
10626
10627 static enum ndr_err_code ndr_pull_lsa_CREDRDELETE(struct ndr_pull *ndr, int flags, struct lsa_CREDRDELETE *r)
10628 {
10629         if (flags & NDR_IN) {
10630         }
10631         if (flags & NDR_OUT) {
10632                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10633         }
10634         return NDR_ERR_SUCCESS;
10635 }
10636
10637 _PUBLIC_ void ndr_print_lsa_CREDRDELETE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRDELETE *r)
10638 {
10639         ndr_print_struct(ndr, name, "lsa_CREDRDELETE");
10640         ndr->depth++;
10641         if (flags & NDR_SET_VALUES) {
10642                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10643         }
10644         if (flags & NDR_IN) {
10645                 ndr_print_struct(ndr, "in", "lsa_CREDRDELETE");
10646                 ndr->depth++;
10647                 ndr->depth--;
10648         }
10649         if (flags & NDR_OUT) {
10650                 ndr_print_struct(ndr, "out", "lsa_CREDRDELETE");
10651                 ndr->depth++;
10652                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10653                 ndr->depth--;
10654         }
10655         ndr->depth--;
10656 }
10657
10658 static enum ndr_err_code ndr_push_lsa_CREDRGETTARGETINFO(struct ndr_push *ndr, int flags, const struct lsa_CREDRGETTARGETINFO *r)
10659 {
10660         if (flags & NDR_IN) {
10661         }
10662         if (flags & NDR_OUT) {
10663                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10664         }
10665         return NDR_ERR_SUCCESS;
10666 }
10667
10668 static enum ndr_err_code ndr_pull_lsa_CREDRGETTARGETINFO(struct ndr_pull *ndr, int flags, struct lsa_CREDRGETTARGETINFO *r)
10669 {
10670         if (flags & NDR_IN) {
10671         }
10672         if (flags & NDR_OUT) {
10673                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10674         }
10675         return NDR_ERR_SUCCESS;
10676 }
10677
10678 _PUBLIC_ void ndr_print_lsa_CREDRGETTARGETINFO(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRGETTARGETINFO *r)
10679 {
10680         ndr_print_struct(ndr, name, "lsa_CREDRGETTARGETINFO");
10681         ndr->depth++;
10682         if (flags & NDR_SET_VALUES) {
10683                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10684         }
10685         if (flags & NDR_IN) {
10686                 ndr_print_struct(ndr, "in", "lsa_CREDRGETTARGETINFO");
10687                 ndr->depth++;
10688                 ndr->depth--;
10689         }
10690         if (flags & NDR_OUT) {
10691                 ndr_print_struct(ndr, "out", "lsa_CREDRGETTARGETINFO");
10692                 ndr->depth++;
10693                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10694                 ndr->depth--;
10695         }
10696         ndr->depth--;
10697 }
10698
10699 static enum ndr_err_code ndr_push_lsa_CREDRPROFILELOADED(struct ndr_push *ndr, int flags, const struct lsa_CREDRPROFILELOADED *r)
10700 {
10701         if (flags & NDR_IN) {
10702         }
10703         if (flags & NDR_OUT) {
10704                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10705         }
10706         return NDR_ERR_SUCCESS;
10707 }
10708
10709 static enum ndr_err_code ndr_pull_lsa_CREDRPROFILELOADED(struct ndr_pull *ndr, int flags, struct lsa_CREDRPROFILELOADED *r)
10710 {
10711         if (flags & NDR_IN) {
10712         }
10713         if (flags & NDR_OUT) {
10714                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10715         }
10716         return NDR_ERR_SUCCESS;
10717 }
10718
10719 _PUBLIC_ void ndr_print_lsa_CREDRPROFILELOADED(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRPROFILELOADED *r)
10720 {
10721         ndr_print_struct(ndr, name, "lsa_CREDRPROFILELOADED");
10722         ndr->depth++;
10723         if (flags & NDR_SET_VALUES) {
10724                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10725         }
10726         if (flags & NDR_IN) {
10727                 ndr_print_struct(ndr, "in", "lsa_CREDRPROFILELOADED");
10728                 ndr->depth++;
10729                 ndr->depth--;
10730         }
10731         if (flags & NDR_OUT) {
10732                 ndr_print_struct(ndr, "out", "lsa_CREDRPROFILELOADED");
10733                 ndr->depth++;
10734                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10735                 ndr->depth--;
10736         }
10737         ndr->depth--;
10738 }
10739
10740 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupNames3(struct ndr_push *ndr, int flags, const struct lsa_LookupNames3 *r)
10741 {
10742         uint32_t cntr_names_0;
10743         if (flags & NDR_IN) {
10744                 if (r->in.handle == NULL) {
10745                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10746                 }
10747                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
10748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10750                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10751                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
10752                 }
10753                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10754                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
10755                 }
10756                 if (r->in.sids == NULL) {
10757                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10758                 }
10759                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10760                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
10761                 if (r->in.count == NULL) {
10762                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10763                 }
10764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
10765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
10766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
10767         }
10768         if (flags & NDR_OUT) {
10769                 if (r->out.domains == NULL) {
10770                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10771                 }
10772                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
10773                 if (*r->out.domains) {
10774                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10775                 }
10776                 if (r->out.sids == NULL) {
10777                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10778                 }
10779                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
10780                 if (r->out.count == NULL) {
10781                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10782                 }
10783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
10784                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10785         }
10786         return NDR_ERR_SUCCESS;
10787 }
10788
10789 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupNames3(struct ndr_pull *ndr, int flags, struct lsa_LookupNames3 *r)
10790 {
10791         uint32_t cntr_names_0;
10792         uint32_t _ptr_domains;
10793         TALLOC_CTX *_mem_save_handle_0;
10794         TALLOC_CTX *_mem_save_names_0;
10795         TALLOC_CTX *_mem_save_domains_0;
10796         TALLOC_CTX *_mem_save_domains_1;
10797         TALLOC_CTX *_mem_save_sids_0;
10798         TALLOC_CTX *_mem_save_count_0;
10799         if (flags & NDR_IN) {
10800                 ZERO_STRUCT(r->out);
10801
10802                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10803                         NDR_PULL_ALLOC(ndr, r->in.handle);
10804                 }
10805                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10806                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10807                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
10808                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
10810                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
10811                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
10812                 }
10813                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
10814                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
10815                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10816                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
10817                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10818                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
10819                 }
10820                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10821                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
10822                 }
10823                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
10824                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10825                         NDR_PULL_ALLOC(ndr, r->in.sids);
10826                 }
10827                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10828                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10829                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10830                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10831                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
10832                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10833                         NDR_PULL_ALLOC(ndr, r->in.count);
10834                 }
10835                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10836                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
10837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
10838                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
10840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
10841                 NDR_PULL_ALLOC(ndr, r->out.domains);
10842                 ZERO_STRUCTP(r->out.domains);
10843                 NDR_PULL_ALLOC(ndr, r->out.sids);
10844                 *r->out.sids = *r->in.sids;
10845                 NDR_PULL_ALLOC(ndr, r->out.count);
10846                 *r->out.count = *r->in.count;
10847                 if (r->in.names) {
10848                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
10849                 }
10850         }
10851         if (flags & NDR_OUT) {
10852                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10853                         NDR_PULL_ALLOC(ndr, r->out.domains);
10854                 }
10855                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
10856                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
10857                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
10858                 if (_ptr_domains) {
10859                         NDR_PULL_ALLOC(ndr, *r->out.domains);
10860                 } else {
10861                         *r->out.domains = NULL;
10862                 }
10863                 if (*r->out.domains) {
10864                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
10865                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
10866                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10867                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
10868                 }
10869                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
10870                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10871                         NDR_PULL_ALLOC(ndr, r->out.sids);
10872                 }
10873                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10874                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
10875                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
10876                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10877                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10878                         NDR_PULL_ALLOC(ndr, r->out.count);
10879                 }
10880                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10881                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
10882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
10883                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10884                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10885         }
10886         return NDR_ERR_SUCCESS;
10887 }
10888
10889 _PUBLIC_ void ndr_print_lsa_LookupNames3(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames3 *r)
10890 {
10891         uint32_t cntr_names_0;
10892         ndr_print_struct(ndr, name, "lsa_LookupNames3");
10893         ndr->depth++;
10894         if (flags & NDR_SET_VALUES) {
10895                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10896         }
10897         if (flags & NDR_IN) {
10898                 ndr_print_struct(ndr, "in", "lsa_LookupNames3");
10899                 ndr->depth++;
10900                 ndr_print_ptr(ndr, "handle", r->in.handle);
10901                 ndr->depth++;
10902                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10903                 ndr->depth--;
10904                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
10905                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
10906                 ndr->depth++;
10907                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
10908                         char *idx_0=NULL;
10909                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
10910                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
10911                                 free(idx_0);
10912                         }
10913                 }
10914                 ndr->depth--;
10915                 ndr_print_ptr(ndr, "sids", r->in.sids);
10916                 ndr->depth++;
10917                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->in.sids);
10918                 ndr->depth--;
10919                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
10920                 ndr_print_ptr(ndr, "count", r->in.count);
10921                 ndr->depth++;
10922                 ndr_print_uint32(ndr, "count", *r->in.count);
10923                 ndr->depth--;
10924                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
10925                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
10926                 ndr->depth--;
10927         }
10928         if (flags & NDR_OUT) {
10929                 ndr_print_struct(ndr, "out", "lsa_LookupNames3");
10930                 ndr->depth++;
10931                 ndr_print_ptr(ndr, "domains", r->out.domains);
10932                 ndr->depth++;
10933                 ndr_print_ptr(ndr, "domains", *r->out.domains);
10934                 ndr->depth++;
10935                 if (*r->out.domains) {
10936                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
10937                 }
10938                 ndr->depth--;
10939                 ndr->depth--;
10940                 ndr_print_ptr(ndr, "sids", r->out.sids);
10941                 ndr->depth++;
10942                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->out.sids);
10943                 ndr->depth--;
10944                 ndr_print_ptr(ndr, "count", r->out.count);
10945                 ndr->depth++;
10946                 ndr_print_uint32(ndr, "count", *r->out.count);
10947                 ndr->depth--;
10948                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10949                 ndr->depth--;
10950         }
10951         ndr->depth--;
10952 }
10953
10954 static enum ndr_err_code ndr_push_lsa_CREDRGETSESSIONTYPES(struct ndr_push *ndr, int flags, const struct lsa_CREDRGETSESSIONTYPES *r)
10955 {
10956         if (flags & NDR_IN) {
10957         }
10958         if (flags & NDR_OUT) {
10959                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10960         }
10961         return NDR_ERR_SUCCESS;
10962 }
10963
10964 static enum ndr_err_code ndr_pull_lsa_CREDRGETSESSIONTYPES(struct ndr_pull *ndr, int flags, struct lsa_CREDRGETSESSIONTYPES *r)
10965 {
10966         if (flags & NDR_IN) {
10967         }
10968         if (flags & NDR_OUT) {
10969                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10970         }
10971         return NDR_ERR_SUCCESS;
10972 }
10973
10974 _PUBLIC_ void ndr_print_lsa_CREDRGETSESSIONTYPES(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRGETSESSIONTYPES *r)
10975 {
10976         ndr_print_struct(ndr, name, "lsa_CREDRGETSESSIONTYPES");
10977         ndr->depth++;
10978         if (flags & NDR_SET_VALUES) {
10979                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10980         }
10981         if (flags & NDR_IN) {
10982                 ndr_print_struct(ndr, "in", "lsa_CREDRGETSESSIONTYPES");
10983                 ndr->depth++;
10984                 ndr->depth--;
10985         }
10986         if (flags & NDR_OUT) {
10987                 ndr_print_struct(ndr, "out", "lsa_CREDRGETSESSIONTYPES");
10988                 ndr->depth++;
10989                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10990                 ndr->depth--;
10991         }
10992         ndr->depth--;
10993 }
10994
10995 static enum ndr_err_code ndr_push_lsa_LSARREGISTERAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARREGISTERAUDITEVENT *r)
10996 {
10997         if (flags & NDR_IN) {
10998         }
10999         if (flags & NDR_OUT) {
11000                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11001         }
11002         return NDR_ERR_SUCCESS;
11003 }
11004
11005 static enum ndr_err_code ndr_pull_lsa_LSARREGISTERAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARREGISTERAUDITEVENT *r)
11006 {
11007         if (flags & NDR_IN) {
11008         }
11009         if (flags & NDR_OUT) {
11010                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11011         }
11012         return NDR_ERR_SUCCESS;
11013 }
11014
11015 _PUBLIC_ void ndr_print_lsa_LSARREGISTERAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARREGISTERAUDITEVENT *r)
11016 {
11017         ndr_print_struct(ndr, name, "lsa_LSARREGISTERAUDITEVENT");
11018         ndr->depth++;
11019         if (flags & NDR_SET_VALUES) {
11020                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11021         }
11022         if (flags & NDR_IN) {
11023                 ndr_print_struct(ndr, "in", "lsa_LSARREGISTERAUDITEVENT");
11024                 ndr->depth++;
11025                 ndr->depth--;
11026         }
11027         if (flags & NDR_OUT) {
11028                 ndr_print_struct(ndr, "out", "lsa_LSARREGISTERAUDITEVENT");
11029                 ndr->depth++;
11030                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11031                 ndr->depth--;
11032         }
11033         ndr->depth--;
11034 }
11035
11036 static enum ndr_err_code ndr_push_lsa_LSARGENAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARGENAUDITEVENT *r)
11037 {
11038         if (flags & NDR_IN) {
11039         }
11040         if (flags & NDR_OUT) {
11041                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11042         }
11043         return NDR_ERR_SUCCESS;
11044 }
11045
11046 static enum ndr_err_code ndr_pull_lsa_LSARGENAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARGENAUDITEVENT *r)
11047 {
11048         if (flags & NDR_IN) {
11049         }
11050         if (flags & NDR_OUT) {
11051                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11052         }
11053         return NDR_ERR_SUCCESS;
11054 }
11055
11056 _PUBLIC_ void ndr_print_lsa_LSARGENAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARGENAUDITEVENT *r)
11057 {
11058         ndr_print_struct(ndr, name, "lsa_LSARGENAUDITEVENT");
11059         ndr->depth++;
11060         if (flags & NDR_SET_VALUES) {
11061                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11062         }
11063         if (flags & NDR_IN) {
11064                 ndr_print_struct(ndr, "in", "lsa_LSARGENAUDITEVENT");
11065                 ndr->depth++;
11066                 ndr->depth--;
11067         }
11068         if (flags & NDR_OUT) {
11069                 ndr_print_struct(ndr, "out", "lsa_LSARGENAUDITEVENT");
11070                 ndr->depth++;
11071                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11072                 ndr->depth--;
11073         }
11074         ndr->depth--;
11075 }
11076
11077 static enum ndr_err_code ndr_push_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARUNREGISTERAUDITEVENT *r)
11078 {
11079         if (flags & NDR_IN) {
11080         }
11081         if (flags & NDR_OUT) {
11082                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11083         }
11084         return NDR_ERR_SUCCESS;
11085 }
11086
11087 static enum ndr_err_code ndr_pull_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARUNREGISTERAUDITEVENT *r)
11088 {
11089         if (flags & NDR_IN) {
11090         }
11091         if (flags & NDR_OUT) {
11092                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11093         }
11094         return NDR_ERR_SUCCESS;
11095 }
11096
11097 _PUBLIC_ void ndr_print_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARUNREGISTERAUDITEVENT *r)
11098 {
11099         ndr_print_struct(ndr, name, "lsa_LSARUNREGISTERAUDITEVENT");
11100         ndr->depth++;
11101         if (flags & NDR_SET_VALUES) {
11102                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11103         }
11104         if (flags & NDR_IN) {
11105                 ndr_print_struct(ndr, "in", "lsa_LSARUNREGISTERAUDITEVENT");
11106                 ndr->depth++;
11107                 ndr->depth--;
11108         }
11109         if (flags & NDR_OUT) {
11110                 ndr_print_struct(ndr, "out", "lsa_LSARUNREGISTERAUDITEVENT");
11111                 ndr->depth++;
11112                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11113                 ndr->depth--;
11114         }
11115         ndr->depth--;
11116 }
11117
11118 static enum ndr_err_code ndr_push_lsa_lsaRQueryForestTrustInformation(struct ndr_push *ndr, int flags, const struct lsa_lsaRQueryForestTrustInformation *r)
11119 {
11120         if (flags & NDR_IN) {
11121                 if (r->in.handle == NULL) {
11122                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11123                 }
11124                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
11125                 if (r->in.trusted_domain_name == NULL) {
11126                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11127                 }
11128                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain_name));
11129                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.unknown));
11130         }
11131         if (flags & NDR_OUT) {
11132                 if (r->out.forest_trust_info == NULL) {
11133                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11134                 }
11135                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.forest_trust_info));
11136                 if (*r->out.forest_trust_info) {
11137                         NDR_CHECK(ndr_push_lsa_ForestTrustInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.forest_trust_info));
11138                 }
11139                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11140         }
11141         return NDR_ERR_SUCCESS;
11142 }
11143
11144 static enum ndr_err_code ndr_pull_lsa_lsaRQueryForestTrustInformation(struct ndr_pull *ndr, int flags, struct lsa_lsaRQueryForestTrustInformation *r)
11145 {
11146         uint32_t _ptr_forest_trust_info;
11147         TALLOC_CTX *_mem_save_handle_0;
11148         TALLOC_CTX *_mem_save_trusted_domain_name_0;
11149         TALLOC_CTX *_mem_save_forest_trust_info_0;
11150         TALLOC_CTX *_mem_save_forest_trust_info_1;
11151         if (flags & NDR_IN) {
11152                 ZERO_STRUCT(r->out);
11153
11154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11155                         NDR_PULL_ALLOC(ndr, r->in.handle);
11156                 }
11157                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11158                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11159                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
11160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11161                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11162                         NDR_PULL_ALLOC(ndr, r->in.trusted_domain_name);
11163                 }
11164                 _mem_save_trusted_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11165                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trusted_domain_name, LIBNDR_FLAG_REF_ALLOC);
11166                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain_name));
11167                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trusted_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
11168                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.unknown));
11169                 NDR_PULL_ALLOC(ndr, r->out.forest_trust_info);
11170                 ZERO_STRUCTP(r->out.forest_trust_info);
11171         }
11172         if (flags & NDR_OUT) {
11173                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11174                         NDR_PULL_ALLOC(ndr, r->out.forest_trust_info);
11175                 }
11176                 _mem_save_forest_trust_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11177                 NDR_PULL_SET_MEM_CTX(ndr, r->out.forest_trust_info, LIBNDR_FLAG_REF_ALLOC);
11178                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_forest_trust_info));
11179                 if (_ptr_forest_trust_info) {
11180                         NDR_PULL_ALLOC(ndr, *r->out.forest_trust_info);
11181                 } else {
11182                         *r->out.forest_trust_info = NULL;
11183                 }
11184                 if (*r->out.forest_trust_info) {
11185                         _mem_save_forest_trust_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
11186                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.forest_trust_info, 0);
11187                         NDR_CHECK(ndr_pull_lsa_ForestTrustInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.forest_trust_info));
11188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_forest_trust_info_1, 0);
11189                 }
11190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_forest_trust_info_0, LIBNDR_FLAG_REF_ALLOC);
11191                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11192         }
11193         return NDR_ERR_SUCCESS;
11194 }
11195
11196 _PUBLIC_ void ndr_print_lsa_lsaRQueryForestTrustInformation(struct ndr_print *ndr, const char *name, int flags, const struct lsa_lsaRQueryForestTrustInformation *r)
11197 {
11198         ndr_print_struct(ndr, name, "lsa_lsaRQueryForestTrustInformation");
11199         ndr->depth++;
11200         if (flags & NDR_SET_VALUES) {
11201                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11202         }
11203         if (flags & NDR_IN) {
11204                 ndr_print_struct(ndr, "in", "lsa_lsaRQueryForestTrustInformation");
11205                 ndr->depth++;
11206                 ndr_print_ptr(ndr, "handle", r->in.handle);
11207                 ndr->depth++;
11208                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11209                 ndr->depth--;
11210                 ndr_print_ptr(ndr, "trusted_domain_name", r->in.trusted_domain_name);
11211                 ndr->depth++;
11212                 ndr_print_lsa_String(ndr, "trusted_domain_name", r->in.trusted_domain_name);
11213                 ndr->depth--;
11214                 ndr_print_uint16(ndr, "unknown", r->in.unknown);
11215                 ndr->depth--;
11216         }
11217         if (flags & NDR_OUT) {
11218                 ndr_print_struct(ndr, "out", "lsa_lsaRQueryForestTrustInformation");
11219                 ndr->depth++;
11220                 ndr_print_ptr(ndr, "forest_trust_info", r->out.forest_trust_info);
11221                 ndr->depth++;
11222                 ndr_print_ptr(ndr, "forest_trust_info", *r->out.forest_trust_info);
11223                 ndr->depth++;
11224                 if (*r->out.forest_trust_info) {
11225                         ndr_print_lsa_ForestTrustInformation(ndr, "forest_trust_info", *r->out.forest_trust_info);
11226                 }
11227                 ndr->depth--;
11228                 ndr->depth--;
11229                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11230                 ndr->depth--;
11231         }
11232         ndr->depth--;
11233 }
11234
11235 static enum ndr_err_code ndr_push_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_push *ndr, int flags, const struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
11236 {
11237         if (flags & NDR_IN) {
11238         }
11239         if (flags & NDR_OUT) {
11240                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11241         }
11242         return NDR_ERR_SUCCESS;
11243 }
11244
11245 static enum ndr_err_code ndr_pull_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_pull *ndr, int flags, struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
11246 {
11247         if (flags & NDR_IN) {
11248         }
11249         if (flags & NDR_OUT) {
11250                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11251         }
11252         return NDR_ERR_SUCCESS;
11253 }
11254
11255 _PUBLIC_ void ndr_print_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
11256 {
11257         ndr_print_struct(ndr, name, "lsa_LSARSETFORESTTRUSTINFORMATION");
11258         ndr->depth++;
11259         if (flags & NDR_SET_VALUES) {
11260                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11261         }
11262         if (flags & NDR_IN) {
11263                 ndr_print_struct(ndr, "in", "lsa_LSARSETFORESTTRUSTINFORMATION");
11264                 ndr->depth++;
11265                 ndr->depth--;
11266         }
11267         if (flags & NDR_OUT) {
11268                 ndr_print_struct(ndr, "out", "lsa_LSARSETFORESTTRUSTINFORMATION");
11269                 ndr->depth++;
11270                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11271                 ndr->depth--;
11272         }
11273         ndr->depth--;
11274 }
11275
11276 static enum ndr_err_code ndr_push_lsa_CREDRRENAME(struct ndr_push *ndr, int flags, const struct lsa_CREDRRENAME *r)
11277 {
11278         if (flags & NDR_IN) {
11279         }
11280         if (flags & NDR_OUT) {
11281                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11282         }
11283         return NDR_ERR_SUCCESS;
11284 }
11285
11286 static enum ndr_err_code ndr_pull_lsa_CREDRRENAME(struct ndr_pull *ndr, int flags, struct lsa_CREDRRENAME *r)
11287 {
11288         if (flags & NDR_IN) {
11289         }
11290         if (flags & NDR_OUT) {
11291                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11292         }
11293         return NDR_ERR_SUCCESS;
11294 }
11295
11296 _PUBLIC_ void ndr_print_lsa_CREDRRENAME(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRRENAME *r)
11297 {
11298         ndr_print_struct(ndr, name, "lsa_CREDRRENAME");
11299         ndr->depth++;
11300         if (flags & NDR_SET_VALUES) {
11301                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11302         }
11303         if (flags & NDR_IN) {
11304                 ndr_print_struct(ndr, "in", "lsa_CREDRRENAME");
11305                 ndr->depth++;
11306                 ndr->depth--;
11307         }
11308         if (flags & NDR_OUT) {
11309                 ndr_print_struct(ndr, "out", "lsa_CREDRRENAME");
11310                 ndr->depth++;
11311                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11312                 ndr->depth--;
11313         }
11314         ndr->depth--;
11315 }
11316
11317 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupSids3(struct ndr_push *ndr, int flags, const struct lsa_LookupSids3 *r)
11318 {
11319         if (flags & NDR_IN) {
11320                 if (r->in.sids == NULL) {
11321                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11322                 }
11323                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11324                 if (r->in.names == NULL) {
11325                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11326                 }
11327                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
11328                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
11329                 if (r->in.count == NULL) {
11330                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11331                 }
11332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
11333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
11334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
11335         }
11336         if (flags & NDR_OUT) {
11337                 if (r->out.domains == NULL) {
11338                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11339                 }
11340                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
11341                 if (*r->out.domains) {
11342                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11343                 }
11344                 if (r->out.names == NULL) {
11345                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11346                 }
11347                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
11348                 if (r->out.count == NULL) {
11349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11350                 }
11351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
11352                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11353         }
11354         return NDR_ERR_SUCCESS;
11355 }
11356
11357 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupSids3(struct ndr_pull *ndr, int flags, struct lsa_LookupSids3 *r)
11358 {
11359         uint32_t _ptr_domains;
11360         TALLOC_CTX *_mem_save_sids_0;
11361         TALLOC_CTX *_mem_save_domains_0;
11362         TALLOC_CTX *_mem_save_domains_1;
11363         TALLOC_CTX *_mem_save_names_0;
11364         TALLOC_CTX *_mem_save_count_0;
11365         if (flags & NDR_IN) {
11366                 ZERO_STRUCT(r->out);
11367
11368                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11369                         NDR_PULL_ALLOC(ndr, r->in.sids);
11370                 }
11371                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11372                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
11373                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11374                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11375                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11376                         NDR_PULL_ALLOC(ndr, r->in.names);
11377                 }
11378                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11379                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
11380                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
11381                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
11382                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
11383                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11384                         NDR_PULL_ALLOC(ndr, r->in.count);
11385                 }
11386                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11387                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
11388                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
11389                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
11391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
11392                 NDR_PULL_ALLOC(ndr, r->out.domains);
11393                 ZERO_STRUCTP(r->out.domains);
11394                 NDR_PULL_ALLOC(ndr, r->out.names);
11395                 *r->out.names = *r->in.names;
11396                 NDR_PULL_ALLOC(ndr, r->out.count);
11397                 *r->out.count = *r->in.count;
11398         }
11399         if (flags & NDR_OUT) {
11400                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11401                         NDR_PULL_ALLOC(ndr, r->out.domains);
11402                 }
11403                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
11404                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
11405                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
11406                 if (_ptr_domains) {
11407                         NDR_PULL_ALLOC(ndr, *r->out.domains);
11408                 } else {
11409                         *r->out.domains = NULL;
11410                 }
11411                 if (*r->out.domains) {
11412                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
11413                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
11414                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11415                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
11416                 }
11417                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
11418                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11419                         NDR_PULL_ALLOC(ndr, r->out.names);
11420                 }
11421                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11422                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
11423                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
11424                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
11425                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11426                         NDR_PULL_ALLOC(ndr, r->out.count);
11427                 }
11428                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11429                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
11430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
11431                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11432                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11433         }
11434         return NDR_ERR_SUCCESS;
11435 }
11436
11437 _PUBLIC_ void ndr_print_lsa_LookupSids3(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids3 *r)
11438 {
11439         ndr_print_struct(ndr, name, "lsa_LookupSids3");
11440         ndr->depth++;
11441         if (flags & NDR_SET_VALUES) {
11442                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11443         }
11444         if (flags & NDR_IN) {
11445                 ndr_print_struct(ndr, "in", "lsa_LookupSids3");
11446                 ndr->depth++;
11447                 ndr_print_ptr(ndr, "sids", r->in.sids);
11448                 ndr->depth++;
11449                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
11450                 ndr->depth--;
11451                 ndr_print_ptr(ndr, "names", r->in.names);
11452                 ndr->depth++;
11453                 ndr_print_lsa_TransNameArray2(ndr, "names", r->in.names);
11454                 ndr->depth--;
11455                 ndr_print_uint16(ndr, "level", r->in.level);
11456                 ndr_print_ptr(ndr, "count", r->in.count);
11457                 ndr->depth++;
11458                 ndr_print_uint32(ndr, "count", *r->in.count);
11459                 ndr->depth--;
11460                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
11461                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
11462                 ndr->depth--;
11463         }
11464         if (flags & NDR_OUT) {
11465                 ndr_print_struct(ndr, "out", "lsa_LookupSids3");
11466                 ndr->depth++;
11467                 ndr_print_ptr(ndr, "domains", r->out.domains);
11468                 ndr->depth++;
11469                 ndr_print_ptr(ndr, "domains", *r->out.domains);
11470                 ndr->depth++;
11471                 if (*r->out.domains) {
11472                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
11473                 }
11474                 ndr->depth--;
11475                 ndr->depth--;
11476                 ndr_print_ptr(ndr, "names", r->out.names);
11477                 ndr->depth++;
11478                 ndr_print_lsa_TransNameArray2(ndr, "names", r->out.names);
11479                 ndr->depth--;
11480                 ndr_print_ptr(ndr, "count", r->out.count);
11481                 ndr->depth++;
11482                 ndr_print_uint32(ndr, "count", *r->out.count);
11483                 ndr->depth--;
11484                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11485                 ndr->depth--;
11486         }
11487         ndr->depth--;
11488 }
11489
11490 static enum ndr_err_code ndr_push_lsa_LookupNames4(struct ndr_push *ndr, int flags, const struct lsa_LookupNames4 *r)
11491 {
11492         uint32_t cntr_names_0;
11493         if (flags & NDR_IN) {
11494                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
11495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
11496                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11497                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
11498                 }
11499                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11500                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
11501                 }
11502                 if (r->in.sids == NULL) {
11503                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11504                 }
11505                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11506                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
11507                 if (r->in.count == NULL) {
11508                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11509                 }
11510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
11511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
11512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
11513         }
11514         if (flags & NDR_OUT) {
11515                 if (r->out.domains == NULL) {
11516                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11517                 }
11518                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
11519                 if (*r->out.domains) {
11520                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11521                 }
11522                 if (r->out.sids == NULL) {
11523                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11524                 }
11525                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
11526                 if (r->out.count == NULL) {
11527                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11528                 }
11529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
11530                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11531         }
11532         return NDR_ERR_SUCCESS;
11533 }
11534
11535 static enum ndr_err_code ndr_pull_lsa_LookupNames4(struct ndr_pull *ndr, int flags, struct lsa_LookupNames4 *r)
11536 {
11537         uint32_t cntr_names_0;
11538         uint32_t _ptr_domains;
11539         TALLOC_CTX *_mem_save_names_0;
11540         TALLOC_CTX *_mem_save_domains_0;
11541         TALLOC_CTX *_mem_save_domains_1;
11542         TALLOC_CTX *_mem_save_sids_0;
11543         TALLOC_CTX *_mem_save_count_0;
11544         if (flags & NDR_IN) {
11545                 ZERO_STRUCT(r->out);
11546
11547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
11548                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
11549                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11550                 }
11551                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
11552                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
11553                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11554                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
11555                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11556                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
11557                 }
11558                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11559                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
11560                 }
11561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
11562                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11563                         NDR_PULL_ALLOC(ndr, r->in.sids);
11564                 }
11565                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11566                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
11567                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11568                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11569                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
11570                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11571                         NDR_PULL_ALLOC(ndr, r->in.count);
11572                 }
11573                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11574                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
11575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
11576                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
11578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
11579                 NDR_PULL_ALLOC(ndr, r->out.domains);
11580                 ZERO_STRUCTP(r->out.domains);
11581                 NDR_PULL_ALLOC(ndr, r->out.sids);
11582                 *r->out.sids = *r->in.sids;
11583                 NDR_PULL_ALLOC(ndr, r->out.count);
11584                 *r->out.count = *r->in.count;
11585                 if (r->in.names) {
11586                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
11587                 }
11588         }
11589         if (flags & NDR_OUT) {
11590                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11591                         NDR_PULL_ALLOC(ndr, r->out.domains);
11592                 }
11593                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
11594                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
11595                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
11596                 if (_ptr_domains) {
11597                         NDR_PULL_ALLOC(ndr, *r->out.domains);
11598                 } else {
11599                         *r->out.domains = NULL;
11600                 }
11601                 if (*r->out.domains) {
11602                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
11603                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
11604                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
11606                 }
11607                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
11608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11609                         NDR_PULL_ALLOC(ndr, r->out.sids);
11610                 }
11611                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11612                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
11613                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
11614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11615                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11616                         NDR_PULL_ALLOC(ndr, r->out.count);
11617                 }
11618                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11619                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
11620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
11621                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11622                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11623         }
11624         return NDR_ERR_SUCCESS;
11625 }
11626
11627 _PUBLIC_ void ndr_print_lsa_LookupNames4(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames4 *r)
11628 {
11629         uint32_t cntr_names_0;
11630         ndr_print_struct(ndr, name, "lsa_LookupNames4");
11631         ndr->depth++;
11632         if (flags & NDR_SET_VALUES) {
11633                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11634         }
11635         if (flags & NDR_IN) {
11636                 ndr_print_struct(ndr, "in", "lsa_LookupNames4");
11637                 ndr->depth++;
11638                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
11639                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
11640                 ndr->depth++;
11641                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
11642                         char *idx_0=NULL;
11643                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
11644                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
11645                                 free(idx_0);
11646                         }
11647                 }
11648                 ndr->depth--;
11649                 ndr_print_ptr(ndr, "sids", r->in.sids);
11650                 ndr->depth++;
11651                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->in.sids);
11652                 ndr->depth--;
11653                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
11654                 ndr_print_ptr(ndr, "count", r->in.count);
11655                 ndr->depth++;
11656                 ndr_print_uint32(ndr, "count", *r->in.count);
11657                 ndr->depth--;
11658                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
11659                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
11660                 ndr->depth--;
11661         }
11662         if (flags & NDR_OUT) {
11663                 ndr_print_struct(ndr, "out", "lsa_LookupNames4");
11664                 ndr->depth++;
11665                 ndr_print_ptr(ndr, "domains", r->out.domains);
11666                 ndr->depth++;
11667                 ndr_print_ptr(ndr, "domains", *r->out.domains);
11668                 ndr->depth++;
11669                 if (*r->out.domains) {
11670                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
11671                 }
11672                 ndr->depth--;
11673                 ndr->depth--;
11674                 ndr_print_ptr(ndr, "sids", r->out.sids);
11675                 ndr->depth++;
11676                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->out.sids);
11677                 ndr->depth--;
11678                 ndr_print_ptr(ndr, "count", r->out.count);
11679                 ndr->depth++;
11680                 ndr_print_uint32(ndr, "count", *r->out.count);
11681                 ndr->depth--;
11682                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11683                 ndr->depth--;
11684         }
11685         ndr->depth--;
11686 }
11687
11688 static enum ndr_err_code ndr_push_lsa_LSAROPENPOLICYSCE(struct ndr_push *ndr, int flags, const struct lsa_LSAROPENPOLICYSCE *r)
11689 {
11690         if (flags & NDR_IN) {
11691         }
11692         if (flags & NDR_OUT) {
11693                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11694         }
11695         return NDR_ERR_SUCCESS;
11696 }
11697
11698 static enum ndr_err_code ndr_pull_lsa_LSAROPENPOLICYSCE(struct ndr_pull *ndr, int flags, struct lsa_LSAROPENPOLICYSCE *r)
11699 {
11700         if (flags & NDR_IN) {
11701         }
11702         if (flags & NDR_OUT) {
11703                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11704         }
11705         return NDR_ERR_SUCCESS;
11706 }
11707
11708 _PUBLIC_ void ndr_print_lsa_LSAROPENPOLICYSCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSAROPENPOLICYSCE *r)
11709 {
11710         ndr_print_struct(ndr, name, "lsa_LSAROPENPOLICYSCE");
11711         ndr->depth++;
11712         if (flags & NDR_SET_VALUES) {
11713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11714         }
11715         if (flags & NDR_IN) {
11716                 ndr_print_struct(ndr, "in", "lsa_LSAROPENPOLICYSCE");
11717                 ndr->depth++;
11718                 ndr->depth--;
11719         }
11720         if (flags & NDR_OUT) {
11721                 ndr_print_struct(ndr, "out", "lsa_LSAROPENPOLICYSCE");
11722                 ndr->depth++;
11723                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11724                 ndr->depth--;
11725         }
11726         ndr->depth--;
11727 }
11728
11729 static enum ndr_err_code ndr_push_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_push *ndr, int flags, const struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
11730 {
11731         if (flags & NDR_IN) {
11732         }
11733         if (flags & NDR_OUT) {
11734                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11735         }
11736         return NDR_ERR_SUCCESS;
11737 }
11738
11739 static enum ndr_err_code ndr_pull_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_pull *ndr, int flags, struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
11740 {
11741         if (flags & NDR_IN) {
11742         }
11743         if (flags & NDR_OUT) {
11744                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11745         }
11746         return NDR_ERR_SUCCESS;
11747 }
11748
11749 _PUBLIC_ void ndr_print_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
11750 {
11751         ndr_print_struct(ndr, name, "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
11752         ndr->depth++;
11753         if (flags & NDR_SET_VALUES) {
11754                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11755         }
11756         if (flags & NDR_IN) {
11757                 ndr_print_struct(ndr, "in", "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
11758                 ndr->depth++;
11759                 ndr->depth--;
11760         }
11761         if (flags & NDR_OUT) {
11762                 ndr_print_struct(ndr, "out", "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
11763                 ndr->depth++;
11764                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11765                 ndr->depth--;
11766         }
11767         ndr->depth--;
11768 }
11769
11770 static enum ndr_err_code ndr_push_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_push *ndr, int flags, const struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
11771 {
11772         if (flags & NDR_IN) {
11773         }
11774         if (flags & NDR_OUT) {
11775                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11776         }
11777         return NDR_ERR_SUCCESS;
11778 }
11779
11780 static enum ndr_err_code ndr_pull_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_pull *ndr, int flags, struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
11781 {
11782         if (flags & NDR_IN) {
11783         }
11784         if (flags & NDR_OUT) {
11785                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11786         }
11787         return NDR_ERR_SUCCESS;
11788 }
11789
11790 _PUBLIC_ void ndr_print_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
11791 {
11792         ndr_print_struct(ndr, name, "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
11793         ndr->depth++;
11794         if (flags & NDR_SET_VALUES) {
11795                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11796         }
11797         if (flags & NDR_IN) {
11798                 ndr_print_struct(ndr, "in", "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
11799                 ndr->depth++;
11800                 ndr->depth--;
11801         }
11802         if (flags & NDR_OUT) {
11803                 ndr_print_struct(ndr, "out", "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
11804                 ndr->depth++;
11805                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11806                 ndr->depth--;
11807         }
11808         ndr->depth--;
11809 }
11810
11811 static enum ndr_err_code ndr_push_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARADTREPORTSECURITYEVENT *r)
11812 {
11813         if (flags & NDR_IN) {
11814         }
11815         if (flags & NDR_OUT) {
11816                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11817         }
11818         return NDR_ERR_SUCCESS;
11819 }
11820
11821 static enum ndr_err_code ndr_pull_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARADTREPORTSECURITYEVENT *r)
11822 {
11823         if (flags & NDR_IN) {
11824         }
11825         if (flags & NDR_OUT) {
11826                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11827         }
11828         return NDR_ERR_SUCCESS;
11829 }
11830
11831 _PUBLIC_ void ndr_print_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTREPORTSECURITYEVENT *r)
11832 {
11833         ndr_print_struct(ndr, name, "lsa_LSARADTREPORTSECURITYEVENT");
11834         ndr->depth++;
11835         if (flags & NDR_SET_VALUES) {
11836                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11837         }
11838         if (flags & NDR_IN) {
11839                 ndr_print_struct(ndr, "in", "lsa_LSARADTREPORTSECURITYEVENT");
11840                 ndr->depth++;
11841                 ndr->depth--;
11842         }
11843         if (flags & NDR_OUT) {
11844                 ndr_print_struct(ndr, "out", "lsa_LSARADTREPORTSECURITYEVENT");
11845                 ndr->depth++;
11846                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11847                 ndr->depth--;
11848         }
11849         ndr->depth--;
11850 }
11851
11852 static const struct ndr_interface_call lsarpc_calls[] = {
11853         {
11854                 "lsa_Close",
11855                 sizeof(struct lsa_Close),
11856                 (ndr_push_flags_fn_t) ndr_push_lsa_Close,
11857                 (ndr_pull_flags_fn_t) ndr_pull_lsa_Close,
11858                 (ndr_print_function_t) ndr_print_lsa_Close,
11859                 false,
11860         },
11861         {
11862                 "lsa_Delete",
11863                 sizeof(struct lsa_Delete),
11864                 (ndr_push_flags_fn_t) ndr_push_lsa_Delete,
11865                 (ndr_pull_flags_fn_t) ndr_pull_lsa_Delete,
11866                 (ndr_print_function_t) ndr_print_lsa_Delete,
11867                 false,
11868         },
11869         {
11870                 "lsa_EnumPrivs",
11871                 sizeof(struct lsa_EnumPrivs),
11872                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumPrivs,
11873                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumPrivs,
11874                 (ndr_print_function_t) ndr_print_lsa_EnumPrivs,
11875                 false,
11876         },
11877         {
11878                 "lsa_QuerySecurity",
11879                 sizeof(struct lsa_QuerySecurity),
11880                 (ndr_push_flags_fn_t) ndr_push_lsa_QuerySecurity,
11881                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QuerySecurity,
11882                 (ndr_print_function_t) ndr_print_lsa_QuerySecurity,
11883                 false,
11884         },
11885         {
11886                 "lsa_SetSecObj",
11887                 sizeof(struct lsa_SetSecObj),
11888                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSecObj,
11889                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSecObj,
11890                 (ndr_print_function_t) ndr_print_lsa_SetSecObj,
11891                 false,
11892         },
11893         {
11894                 "lsa_ChangePassword",
11895                 sizeof(struct lsa_ChangePassword),
11896                 (ndr_push_flags_fn_t) ndr_push_lsa_ChangePassword,
11897                 (ndr_pull_flags_fn_t) ndr_pull_lsa_ChangePassword,
11898                 (ndr_print_function_t) ndr_print_lsa_ChangePassword,
11899                 false,
11900         },
11901         {
11902                 "lsa_OpenPolicy",
11903                 sizeof(struct lsa_OpenPolicy),
11904                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenPolicy,
11905                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenPolicy,
11906                 (ndr_print_function_t) ndr_print_lsa_OpenPolicy,
11907                 false,
11908         },
11909         {
11910                 "lsa_QueryInfoPolicy",
11911                 sizeof(struct lsa_QueryInfoPolicy),
11912                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryInfoPolicy,
11913                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryInfoPolicy,
11914                 (ndr_print_function_t) ndr_print_lsa_QueryInfoPolicy,
11915                 false,
11916         },
11917         {
11918                 "lsa_SetInfoPolicy",
11919                 sizeof(struct lsa_SetInfoPolicy),
11920                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInfoPolicy,
11921                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInfoPolicy,
11922                 (ndr_print_function_t) ndr_print_lsa_SetInfoPolicy,
11923                 false,
11924         },
11925         {
11926                 "lsa_ClearAuditLog",
11927                 sizeof(struct lsa_ClearAuditLog),
11928                 (ndr_push_flags_fn_t) ndr_push_lsa_ClearAuditLog,
11929                 (ndr_pull_flags_fn_t) ndr_pull_lsa_ClearAuditLog,
11930                 (ndr_print_function_t) ndr_print_lsa_ClearAuditLog,
11931                 false,
11932         },
11933         {
11934                 "lsa_CreateAccount",
11935                 sizeof(struct lsa_CreateAccount),
11936                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateAccount,
11937                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateAccount,
11938                 (ndr_print_function_t) ndr_print_lsa_CreateAccount,
11939                 false,
11940         },
11941         {
11942                 "lsa_EnumAccounts",
11943                 sizeof(struct lsa_EnumAccounts),
11944                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccounts,
11945                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccounts,
11946                 (ndr_print_function_t) ndr_print_lsa_EnumAccounts,
11947                 false,
11948         },
11949         {
11950                 "lsa_CreateTrustedDomain",
11951                 sizeof(struct lsa_CreateTrustedDomain),
11952                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomain,
11953                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomain,
11954                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomain,
11955                 false,
11956         },
11957         {
11958                 "lsa_EnumTrustDom",
11959                 sizeof(struct lsa_EnumTrustDom),
11960                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumTrustDom,
11961                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumTrustDom,
11962                 (ndr_print_function_t) ndr_print_lsa_EnumTrustDom,
11963                 false,
11964         },
11965         {
11966                 "lsa_LookupNames",
11967                 sizeof(struct lsa_LookupNames),
11968                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames,
11969                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames,
11970                 (ndr_print_function_t) ndr_print_lsa_LookupNames,
11971                 false,
11972         },
11973         {
11974                 "lsa_LookupSids",
11975                 sizeof(struct lsa_LookupSids),
11976                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids,
11977                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids,
11978                 (ndr_print_function_t) ndr_print_lsa_LookupSids,
11979                 false,
11980         },
11981         {
11982                 "lsa_CreateSecret",
11983                 sizeof(struct lsa_CreateSecret),
11984                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateSecret,
11985                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateSecret,
11986                 (ndr_print_function_t) ndr_print_lsa_CreateSecret,
11987                 false,
11988         },
11989         {
11990                 "lsa_OpenAccount",
11991                 sizeof(struct lsa_OpenAccount),
11992                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenAccount,
11993                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenAccount,
11994                 (ndr_print_function_t) ndr_print_lsa_OpenAccount,
11995                 false,
11996         },
11997         {
11998                 "lsa_EnumPrivsAccount",
11999                 sizeof(struct lsa_EnumPrivsAccount),
12000                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumPrivsAccount,
12001                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumPrivsAccount,
12002                 (ndr_print_function_t) ndr_print_lsa_EnumPrivsAccount,
12003                 false,
12004         },
12005         {
12006                 "lsa_AddPrivilegesToAccount",
12007                 sizeof(struct lsa_AddPrivilegesToAccount),
12008                 (ndr_push_flags_fn_t) ndr_push_lsa_AddPrivilegesToAccount,
12009                 (ndr_pull_flags_fn_t) ndr_pull_lsa_AddPrivilegesToAccount,
12010                 (ndr_print_function_t) ndr_print_lsa_AddPrivilegesToAccount,
12011                 false,
12012         },
12013         {
12014                 "lsa_RemovePrivilegesFromAccount",
12015                 sizeof(struct lsa_RemovePrivilegesFromAccount),
12016                 (ndr_push_flags_fn_t) ndr_push_lsa_RemovePrivilegesFromAccount,
12017                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RemovePrivilegesFromAccount,
12018                 (ndr_print_function_t) ndr_print_lsa_RemovePrivilegesFromAccount,
12019                 false,
12020         },
12021         {
12022                 "lsa_GetQuotasForAccount",
12023                 sizeof(struct lsa_GetQuotasForAccount),
12024                 (ndr_push_flags_fn_t) ndr_push_lsa_GetQuotasForAccount,
12025                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetQuotasForAccount,
12026                 (ndr_print_function_t) ndr_print_lsa_GetQuotasForAccount,
12027                 false,
12028         },
12029         {
12030                 "lsa_SetQuotasForAccount",
12031                 sizeof(struct lsa_SetQuotasForAccount),
12032                 (ndr_push_flags_fn_t) ndr_push_lsa_SetQuotasForAccount,
12033                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetQuotasForAccount,
12034                 (ndr_print_function_t) ndr_print_lsa_SetQuotasForAccount,
12035                 false,
12036         },
12037         {
12038                 "lsa_GetSystemAccessAccount",
12039                 sizeof(struct lsa_GetSystemAccessAccount),
12040                 (ndr_push_flags_fn_t) ndr_push_lsa_GetSystemAccessAccount,
12041                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetSystemAccessAccount,
12042                 (ndr_print_function_t) ndr_print_lsa_GetSystemAccessAccount,
12043                 false,
12044         },
12045         {
12046                 "lsa_SetSystemAccessAccount",
12047                 sizeof(struct lsa_SetSystemAccessAccount),
12048                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSystemAccessAccount,
12049                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSystemAccessAccount,
12050                 (ndr_print_function_t) ndr_print_lsa_SetSystemAccessAccount,
12051                 false,
12052         },
12053         {
12054                 "lsa_OpenTrustedDomain",
12055                 sizeof(struct lsa_OpenTrustedDomain),
12056                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenTrustedDomain,
12057                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenTrustedDomain,
12058                 (ndr_print_function_t) ndr_print_lsa_OpenTrustedDomain,
12059                 false,
12060         },
12061         {
12062                 "lsa_QueryTrustedDomainInfo",
12063                 sizeof(struct lsa_QueryTrustedDomainInfo),
12064                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfo,
12065                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfo,
12066                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfo,
12067                 false,
12068         },
12069         {
12070                 "lsa_SetInformationTrustedDomain",
12071                 sizeof(struct lsa_SetInformationTrustedDomain),
12072                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInformationTrustedDomain,
12073                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInformationTrustedDomain,
12074                 (ndr_print_function_t) ndr_print_lsa_SetInformationTrustedDomain,
12075                 false,
12076         },
12077         {
12078                 "lsa_OpenSecret",
12079                 sizeof(struct lsa_OpenSecret),
12080                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenSecret,
12081                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenSecret,
12082                 (ndr_print_function_t) ndr_print_lsa_OpenSecret,
12083                 false,
12084         },
12085         {
12086                 "lsa_SetSecret",
12087                 sizeof(struct lsa_SetSecret),
12088                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSecret,
12089                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSecret,
12090                 (ndr_print_function_t) ndr_print_lsa_SetSecret,
12091                 false,
12092         },
12093         {
12094                 "lsa_QuerySecret",
12095                 sizeof(struct lsa_QuerySecret),
12096                 (ndr_push_flags_fn_t) ndr_push_lsa_QuerySecret,
12097                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QuerySecret,
12098                 (ndr_print_function_t) ndr_print_lsa_QuerySecret,
12099                 false,
12100         },
12101         {
12102                 "lsa_LookupPrivValue",
12103                 sizeof(struct lsa_LookupPrivValue),
12104                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivValue,
12105                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivValue,
12106                 (ndr_print_function_t) ndr_print_lsa_LookupPrivValue,
12107                 false,
12108         },
12109         {
12110                 "lsa_LookupPrivName",
12111                 sizeof(struct lsa_LookupPrivName),
12112                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivName,
12113                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivName,
12114                 (ndr_print_function_t) ndr_print_lsa_LookupPrivName,
12115                 false,
12116         },
12117         {
12118                 "lsa_LookupPrivDisplayName",
12119                 sizeof(struct lsa_LookupPrivDisplayName),
12120                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivDisplayName,
12121                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivDisplayName,
12122                 (ndr_print_function_t) ndr_print_lsa_LookupPrivDisplayName,
12123                 false,
12124         },
12125         {
12126                 "lsa_DeleteObject",
12127                 sizeof(struct lsa_DeleteObject),
12128                 (ndr_push_flags_fn_t) ndr_push_lsa_DeleteObject,
12129                 (ndr_pull_flags_fn_t) ndr_pull_lsa_DeleteObject,
12130                 (ndr_print_function_t) ndr_print_lsa_DeleteObject,
12131                 false,
12132         },
12133         {
12134                 "lsa_EnumAccountsWithUserRight",
12135                 sizeof(struct lsa_EnumAccountsWithUserRight),
12136                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccountsWithUserRight,
12137                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccountsWithUserRight,
12138                 (ndr_print_function_t) ndr_print_lsa_EnumAccountsWithUserRight,
12139                 false,
12140         },
12141         {
12142                 "lsa_EnumAccountRights",
12143                 sizeof(struct lsa_EnumAccountRights),
12144                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccountRights,
12145                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccountRights,
12146                 (ndr_print_function_t) ndr_print_lsa_EnumAccountRights,
12147                 false,
12148         },
12149         {
12150                 "lsa_AddAccountRights",
12151                 sizeof(struct lsa_AddAccountRights),
12152                 (ndr_push_flags_fn_t) ndr_push_lsa_AddAccountRights,
12153                 (ndr_pull_flags_fn_t) ndr_pull_lsa_AddAccountRights,
12154                 (ndr_print_function_t) ndr_print_lsa_AddAccountRights,
12155                 false,
12156         },
12157         {
12158                 "lsa_RemoveAccountRights",
12159                 sizeof(struct lsa_RemoveAccountRights),
12160                 (ndr_push_flags_fn_t) ndr_push_lsa_RemoveAccountRights,
12161                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RemoveAccountRights,
12162                 (ndr_print_function_t) ndr_print_lsa_RemoveAccountRights,
12163                 false,
12164         },
12165         {
12166                 "lsa_QueryTrustedDomainInfoBySid",
12167                 sizeof(struct lsa_QueryTrustedDomainInfoBySid),
12168                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfoBySid,
12169                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfoBySid,
12170                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfoBySid,
12171                 false,
12172         },
12173         {
12174                 "lsa_SetTrustedDomainInfo",
12175                 sizeof(struct lsa_SetTrustedDomainInfo),
12176                 (ndr_push_flags_fn_t) ndr_push_lsa_SetTrustedDomainInfo,
12177                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetTrustedDomainInfo,
12178                 (ndr_print_function_t) ndr_print_lsa_SetTrustedDomainInfo,
12179                 false,
12180         },
12181         {
12182                 "lsa_DeleteTrustedDomain",
12183                 sizeof(struct lsa_DeleteTrustedDomain),
12184                 (ndr_push_flags_fn_t) ndr_push_lsa_DeleteTrustedDomain,
12185                 (ndr_pull_flags_fn_t) ndr_pull_lsa_DeleteTrustedDomain,
12186                 (ndr_print_function_t) ndr_print_lsa_DeleteTrustedDomain,
12187                 false,
12188         },
12189         {
12190                 "lsa_StorePrivateData",
12191                 sizeof(struct lsa_StorePrivateData),
12192                 (ndr_push_flags_fn_t) ndr_push_lsa_StorePrivateData,
12193                 (ndr_pull_flags_fn_t) ndr_pull_lsa_StorePrivateData,
12194                 (ndr_print_function_t) ndr_print_lsa_StorePrivateData,
12195                 false,
12196         },
12197         {
12198                 "lsa_RetrievePrivateData",
12199                 sizeof(struct lsa_RetrievePrivateData),
12200                 (ndr_push_flags_fn_t) ndr_push_lsa_RetrievePrivateData,
12201                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RetrievePrivateData,
12202                 (ndr_print_function_t) ndr_print_lsa_RetrievePrivateData,
12203                 false,
12204         },
12205         {
12206                 "lsa_OpenPolicy2",
12207                 sizeof(struct lsa_OpenPolicy2),
12208                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenPolicy2,
12209                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenPolicy2,
12210                 (ndr_print_function_t) ndr_print_lsa_OpenPolicy2,
12211                 false,
12212         },
12213         {
12214                 "lsa_GetUserName",
12215                 sizeof(struct lsa_GetUserName),
12216                 (ndr_push_flags_fn_t) ndr_push_lsa_GetUserName,
12217                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetUserName,
12218                 (ndr_print_function_t) ndr_print_lsa_GetUserName,
12219                 false,
12220         },
12221         {
12222                 "lsa_QueryInfoPolicy2",
12223                 sizeof(struct lsa_QueryInfoPolicy2),
12224                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryInfoPolicy2,
12225                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryInfoPolicy2,
12226                 (ndr_print_function_t) ndr_print_lsa_QueryInfoPolicy2,
12227                 false,
12228         },
12229         {
12230                 "lsa_SetInfoPolicy2",
12231                 sizeof(struct lsa_SetInfoPolicy2),
12232                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInfoPolicy2,
12233                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInfoPolicy2,
12234                 (ndr_print_function_t) ndr_print_lsa_SetInfoPolicy2,
12235                 false,
12236         },
12237         {
12238                 "lsa_QueryTrustedDomainInfoByName",
12239                 sizeof(struct lsa_QueryTrustedDomainInfoByName),
12240                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfoByName,
12241                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfoByName,
12242                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfoByName,
12243                 false,
12244         },
12245         {
12246                 "lsa_SetTrustedDomainInfoByName",
12247                 sizeof(struct lsa_SetTrustedDomainInfoByName),
12248                 (ndr_push_flags_fn_t) ndr_push_lsa_SetTrustedDomainInfoByName,
12249                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetTrustedDomainInfoByName,
12250                 (ndr_print_function_t) ndr_print_lsa_SetTrustedDomainInfoByName,
12251                 false,
12252         },
12253         {
12254                 "lsa_EnumTrustedDomainsEx",
12255                 sizeof(struct lsa_EnumTrustedDomainsEx),
12256                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumTrustedDomainsEx,
12257                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumTrustedDomainsEx,
12258                 (ndr_print_function_t) ndr_print_lsa_EnumTrustedDomainsEx,
12259                 false,
12260         },
12261         {
12262                 "lsa_CreateTrustedDomainEx",
12263                 sizeof(struct lsa_CreateTrustedDomainEx),
12264                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomainEx,
12265                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomainEx,
12266                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomainEx,
12267                 false,
12268         },
12269         {
12270                 "lsa_CloseTrustedDomainEx",
12271                 sizeof(struct lsa_CloseTrustedDomainEx),
12272                 (ndr_push_flags_fn_t) ndr_push_lsa_CloseTrustedDomainEx,
12273                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CloseTrustedDomainEx,
12274                 (ndr_print_function_t) ndr_print_lsa_CloseTrustedDomainEx,
12275                 false,
12276         },
12277         {
12278                 "lsa_QueryDomainInformationPolicy",
12279                 sizeof(struct lsa_QueryDomainInformationPolicy),
12280                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryDomainInformationPolicy,
12281                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryDomainInformationPolicy,
12282                 (ndr_print_function_t) ndr_print_lsa_QueryDomainInformationPolicy,
12283                 false,
12284         },
12285         {
12286                 "lsa_SetDomainInformationPolicy",
12287                 sizeof(struct lsa_SetDomainInformationPolicy),
12288                 (ndr_push_flags_fn_t) ndr_push_lsa_SetDomainInformationPolicy,
12289                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetDomainInformationPolicy,
12290                 (ndr_print_function_t) ndr_print_lsa_SetDomainInformationPolicy,
12291                 false,
12292         },
12293         {
12294                 "lsa_OpenTrustedDomainByName",
12295                 sizeof(struct lsa_OpenTrustedDomainByName),
12296                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenTrustedDomainByName,
12297                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenTrustedDomainByName,
12298                 (ndr_print_function_t) ndr_print_lsa_OpenTrustedDomainByName,
12299                 false,
12300         },
12301         {
12302                 "lsa_TestCall",
12303                 sizeof(struct lsa_TestCall),
12304                 (ndr_push_flags_fn_t) ndr_push_lsa_TestCall,
12305                 (ndr_pull_flags_fn_t) ndr_pull_lsa_TestCall,
12306                 (ndr_print_function_t) ndr_print_lsa_TestCall,
12307                 false,
12308         },
12309         {
12310                 "lsa_LookupSids2",
12311                 sizeof(struct lsa_LookupSids2),
12312                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids2,
12313                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids2,
12314                 (ndr_print_function_t) ndr_print_lsa_LookupSids2,
12315                 false,
12316         },
12317         {
12318                 "lsa_LookupNames2",
12319                 sizeof(struct lsa_LookupNames2),
12320                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames2,
12321                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames2,
12322                 (ndr_print_function_t) ndr_print_lsa_LookupNames2,
12323                 false,
12324         },
12325         {
12326                 "lsa_CreateTrustedDomainEx2",
12327                 sizeof(struct lsa_CreateTrustedDomainEx2),
12328                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomainEx2,
12329                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomainEx2,
12330                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomainEx2,
12331                 false,
12332         },
12333         {
12334                 "lsa_CREDRWRITE",
12335                 sizeof(struct lsa_CREDRWRITE),
12336                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRWRITE,
12337                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRWRITE,
12338                 (ndr_print_function_t) ndr_print_lsa_CREDRWRITE,
12339                 false,
12340         },
12341         {
12342                 "lsa_CREDRREAD",
12343                 sizeof(struct lsa_CREDRREAD),
12344                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRREAD,
12345                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRREAD,
12346                 (ndr_print_function_t) ndr_print_lsa_CREDRREAD,
12347                 false,
12348         },
12349         {
12350                 "lsa_CREDRENUMERATE",
12351                 sizeof(struct lsa_CREDRENUMERATE),
12352                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRENUMERATE,
12353                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRENUMERATE,
12354                 (ndr_print_function_t) ndr_print_lsa_CREDRENUMERATE,
12355                 false,
12356         },
12357         {
12358                 "lsa_CREDRWRITEDOMAINCREDENTIALS",
12359                 sizeof(struct lsa_CREDRWRITEDOMAINCREDENTIALS),
12360                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRWRITEDOMAINCREDENTIALS,
12361                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRWRITEDOMAINCREDENTIALS,
12362                 (ndr_print_function_t) ndr_print_lsa_CREDRWRITEDOMAINCREDENTIALS,
12363                 false,
12364         },
12365         {
12366                 "lsa_CREDRREADDOMAINCREDENTIALS",
12367                 sizeof(struct lsa_CREDRREADDOMAINCREDENTIALS),
12368                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRREADDOMAINCREDENTIALS,
12369                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRREADDOMAINCREDENTIALS,
12370                 (ndr_print_function_t) ndr_print_lsa_CREDRREADDOMAINCREDENTIALS,
12371                 false,
12372         },
12373         {
12374                 "lsa_CREDRDELETE",
12375                 sizeof(struct lsa_CREDRDELETE),
12376                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRDELETE,
12377                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRDELETE,
12378                 (ndr_print_function_t) ndr_print_lsa_CREDRDELETE,
12379                 false,
12380         },
12381         {
12382                 "lsa_CREDRGETTARGETINFO",
12383                 sizeof(struct lsa_CREDRGETTARGETINFO),
12384                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRGETTARGETINFO,
12385                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRGETTARGETINFO,
12386                 (ndr_print_function_t) ndr_print_lsa_CREDRGETTARGETINFO,
12387                 false,
12388         },
12389         {
12390                 "lsa_CREDRPROFILELOADED",
12391                 sizeof(struct lsa_CREDRPROFILELOADED),
12392                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRPROFILELOADED,
12393                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRPROFILELOADED,
12394                 (ndr_print_function_t) ndr_print_lsa_CREDRPROFILELOADED,
12395                 false,
12396         },
12397         {
12398                 "lsa_LookupNames3",
12399                 sizeof(struct lsa_LookupNames3),
12400                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames3,
12401                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames3,
12402                 (ndr_print_function_t) ndr_print_lsa_LookupNames3,
12403                 false,
12404         },
12405         {
12406                 "lsa_CREDRGETSESSIONTYPES",
12407                 sizeof(struct lsa_CREDRGETSESSIONTYPES),
12408                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRGETSESSIONTYPES,
12409                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRGETSESSIONTYPES,
12410                 (ndr_print_function_t) ndr_print_lsa_CREDRGETSESSIONTYPES,
12411                 false,
12412         },
12413         {
12414                 "lsa_LSARREGISTERAUDITEVENT",
12415                 sizeof(struct lsa_LSARREGISTERAUDITEVENT),
12416                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARREGISTERAUDITEVENT,
12417                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARREGISTERAUDITEVENT,
12418                 (ndr_print_function_t) ndr_print_lsa_LSARREGISTERAUDITEVENT,
12419                 false,
12420         },
12421         {
12422                 "lsa_LSARGENAUDITEVENT",
12423                 sizeof(struct lsa_LSARGENAUDITEVENT),
12424                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARGENAUDITEVENT,
12425                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARGENAUDITEVENT,
12426                 (ndr_print_function_t) ndr_print_lsa_LSARGENAUDITEVENT,
12427                 false,
12428         },
12429         {
12430                 "lsa_LSARUNREGISTERAUDITEVENT",
12431                 sizeof(struct lsa_LSARUNREGISTERAUDITEVENT),
12432                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARUNREGISTERAUDITEVENT,
12433                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARUNREGISTERAUDITEVENT,
12434                 (ndr_print_function_t) ndr_print_lsa_LSARUNREGISTERAUDITEVENT,
12435                 false,
12436         },
12437         {
12438                 "lsa_lsaRQueryForestTrustInformation",
12439                 sizeof(struct lsa_lsaRQueryForestTrustInformation),
12440                 (ndr_push_flags_fn_t) ndr_push_lsa_lsaRQueryForestTrustInformation,
12441                 (ndr_pull_flags_fn_t) ndr_pull_lsa_lsaRQueryForestTrustInformation,
12442                 (ndr_print_function_t) ndr_print_lsa_lsaRQueryForestTrustInformation,
12443                 false,
12444         },
12445         {
12446                 "lsa_LSARSETFORESTTRUSTINFORMATION",
12447                 sizeof(struct lsa_LSARSETFORESTTRUSTINFORMATION),
12448                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARSETFORESTTRUSTINFORMATION,
12449                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARSETFORESTTRUSTINFORMATION,
12450                 (ndr_print_function_t) ndr_print_lsa_LSARSETFORESTTRUSTINFORMATION,
12451                 false,
12452         },
12453         {
12454                 "lsa_CREDRRENAME",
12455                 sizeof(struct lsa_CREDRRENAME),
12456                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRRENAME,
12457                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRRENAME,
12458                 (ndr_print_function_t) ndr_print_lsa_CREDRRENAME,
12459                 false,
12460         },
12461         {
12462                 "lsa_LookupSids3",
12463                 sizeof(struct lsa_LookupSids3),
12464                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids3,
12465                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids3,
12466                 (ndr_print_function_t) ndr_print_lsa_LookupSids3,
12467                 false,
12468         },
12469         {
12470                 "lsa_LookupNames4",
12471                 sizeof(struct lsa_LookupNames4),
12472                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames4,
12473                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames4,
12474                 (ndr_print_function_t) ndr_print_lsa_LookupNames4,
12475                 false,
12476         },
12477         {
12478                 "lsa_LSAROPENPOLICYSCE",
12479                 sizeof(struct lsa_LSAROPENPOLICYSCE),
12480                 (ndr_push_flags_fn_t) ndr_push_lsa_LSAROPENPOLICYSCE,
12481                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSAROPENPOLICYSCE,
12482                 (ndr_print_function_t) ndr_print_lsa_LSAROPENPOLICYSCE,
12483                 false,
12484         },
12485         {
12486                 "lsa_LSARADTREGISTERSECURITYEVENTSOURCE",
12487                 sizeof(struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE),
12488                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
12489                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
12490                 (ndr_print_function_t) ndr_print_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
12491                 false,
12492         },
12493         {
12494                 "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE",
12495                 sizeof(struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE),
12496                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
12497                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
12498                 (ndr_print_function_t) ndr_print_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
12499                 false,
12500         },
12501         {
12502                 "lsa_LSARADTREPORTSECURITYEVENT",
12503                 sizeof(struct lsa_LSARADTREPORTSECURITYEVENT),
12504                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTREPORTSECURITYEVENT,
12505                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTREPORTSECURITYEVENT,
12506                 (ndr_print_function_t) ndr_print_lsa_LSARADTREPORTSECURITYEVENT,
12507                 false,
12508         },
12509         { NULL, 0, NULL, NULL, NULL, false }
12510 };
12511
12512 static const char * const lsarpc_endpoint_strings[] = {
12513         "ncacn_np:[\\pipe\\lsarpc]",
12514         "ncacn_np:[\\pipe\\netlogon]",
12515         "ncacn_np:[\\pipe\\lsass]",
12516         "ncacn_ip_tcp:",
12517         "ncalrpc:",
12518 };
12519
12520 static const struct ndr_interface_string_array lsarpc_endpoints = {
12521         .count  = 5,
12522         .names  = lsarpc_endpoint_strings
12523 };
12524
12525 static const char * const lsarpc_authservice_strings[] = {
12526         "host",
12527 };
12528
12529 static const struct ndr_interface_string_array lsarpc_authservices = {
12530         .count  = 1,
12531         .names  = lsarpc_authservice_strings
12532 };
12533
12534
12535 const struct ndr_interface_table ndr_table_lsarpc = {
12536         .name           = "lsarpc",
12537         .syntax_id      = {
12538                 {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
12539                 NDR_LSARPC_VERSION
12540         },
12541         .helpstring     = NDR_LSARPC_HELPSTRING,
12542         .num_calls      = 82,
12543         .calls          = lsarpc_calls,
12544         .endpoints      = &lsarpc_endpoints,
12545         .authservices   = &lsarpc_authservices
12546 };
12547