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_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 _PUBLIC_ enum ndr_err_code ndr_push_lsa_String(struct ndr_push *ndr, int ndr_flags, const struct lsa_String *r)
   9 {
  10         if (ndr_flags & NDR_SCALARS) {
  11                 NDR_CHECK(ndr_push_align(ndr, 4));
  12                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  14                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
  15         }
  16         if (ndr_flags & NDR_BUFFERS) {
  17                 if (r->string) {
  18                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m(r->string) / 2));
  19                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  20                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m(r->string) / 2));
  21                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, 2 * strlen_m(r->string) / 2, sizeof(uint16_t), CH_UTF16));
  22                 }
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_String(struct ndr_pull *ndr, int ndr_flags, struct lsa_String *r)
  28 {
  29         uint32_t _ptr_string;
  30         TALLOC_CTX *_mem_save_string_0;
  31         if (ndr_flags & NDR_SCALARS) {
  32                 NDR_CHECK(ndr_pull_align(ndr, 4));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
  35                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
  36                 if (_ptr_string) {
  37                         NDR_PULL_ALLOC(ndr, r->string);
  38                 } else {
  39                         r->string = NULL;
  40                 }
  41         }
  42         if (ndr_flags & NDR_BUFFERS) {
  43                 if (r->string) {
  44                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
  45                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
  46                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
  47                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
  48                         if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
  49                                 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));
  50                         }
  51                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
  52                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
  53                 }
  54                 if (r->string) {
  55                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
  56                 }
  57                 if (r->string) {
  58                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->string, r->length / 2));
  59                 }
  60         }
  61         return NDR_ERR_SUCCESS;
  62 }
  63
  64 _PUBLIC_ void ndr_print_lsa_String(struct ndr_print *ndr, const char *name, const struct lsa_String *r)
  65 {
  66         ndr_print_struct(ndr, name, "lsa_String");
  67         ndr->depth++;
  68         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->length);
  69         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->size);
  70         ndr_print_ptr(ndr, "string", r->string);
  71         ndr->depth++;
  72         if (r->string) {
  73                 ndr_print_string(ndr, "string", r->string);
  74         }
  75         ndr->depth--;
  76         ndr->depth--;
  77 }
  78
  79 _PUBLIC_ enum ndr_err_code ndr_push_lsa_StringLarge(struct ndr_push *ndr, int ndr_flags, const struct lsa_StringLarge *r)
  80 {
  81         if (ndr_flags & NDR_SCALARS) {
  82                 NDR_CHECK(ndr_push_align(ndr, 4));
  83                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  84                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m_term(r->string)));
  85                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
  86         }
  87         if (ndr_flags & NDR_BUFFERS) {
  88                 if (r->string) {
  89                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->string) / 2));
  90                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  91                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m(r->string) / 2));
  92                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, 2 * strlen_m(r->string) / 2, sizeof(uint16_t), CH_UTF16));
  93                 }
  94         }
  95         return NDR_ERR_SUCCESS;
  96 }
  97
  98 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_StringLarge(struct ndr_pull *ndr, int ndr_flags, struct lsa_StringLarge *r)
  99 {
 100         uint32_t _ptr_string;
 101         TALLOC_CTX *_mem_save_string_0;
 102         if (ndr_flags & NDR_SCALARS) {
 103                 NDR_CHECK(ndr_pull_align(ndr, 4));
 104                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 105                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 106                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
 107                 if (_ptr_string) {
 108                         NDR_PULL_ALLOC(ndr, r->string);
 109                 } else {
 110                         r->string = NULL;
 111                 }
 112         }
 113         if (ndr_flags & NDR_BUFFERS) {
 114                 if (r->string) {
 115                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
 116                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
 117                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
 118                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
 119                         if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
 120                                 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));
 121                         }
 122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
 123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
 124                 }
 125                 if (r->string) {
 126                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
 127                 }
 128                 if (r->string) {
 129                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->string, r->length / 2));
 130                 }
 131         }
 132         return NDR_ERR_SUCCESS;
 133 }
 134
 135 _PUBLIC_ void ndr_print_lsa_StringLarge(struct ndr_print *ndr, const char *name, const struct lsa_StringLarge *r)
 136 {
 137         ndr_print_struct(ndr, name, "lsa_StringLarge");
 138         ndr->depth++;
 139         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->length);
 140         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->string):r->size);
 141         ndr_print_ptr(ndr, "string", r->string);
 142         ndr->depth++;
 143         if (r->string) {
 144                 ndr_print_string(ndr, "string", r->string);
 145         }
 146         ndr->depth--;
 147         ndr->depth--;
 148 }
 149
 150 _PUBLIC_ enum ndr_err_code ndr_push_lsa_Strings(struct ndr_push *ndr, int ndr_flags, const struct lsa_Strings *r)
 151 {
 152         uint32_t cntr_names_1;
 153         if (ndr_flags & NDR_SCALARS) {
 154                 NDR_CHECK(ndr_push_align(ndr, 4));
 155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 156                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
 157         }
 158         if (ndr_flags & NDR_BUFFERS) {
 159                 if (r->names) {
 160                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 161                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 162                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
 163                         }
 164                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 165                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
 166                         }
 167                 }
 168         }
 169         return NDR_ERR_SUCCESS;
 170 }
 171
 172 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_Strings(struct ndr_pull *ndr, int ndr_flags, struct lsa_Strings *r)
 173 {
 174         uint32_t _ptr_names;
 175         uint32_t cntr_names_1;
 176         TALLOC_CTX *_mem_save_names_0;
 177         TALLOC_CTX *_mem_save_names_1;
 178         if (ndr_flags & NDR_SCALARS) {
 179                 NDR_CHECK(ndr_pull_align(ndr, 4));
 180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
 182                 if (_ptr_names) {
 183                         NDR_PULL_ALLOC(ndr, r->names);
 184                 } else {
 185                         r->names = NULL;
 186                 }
 187         }
 188         if (ndr_flags & NDR_BUFFERS) {
 189                 if (r->names) {
 190                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 191                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
 192                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
 193                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
 194                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
 195                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
 196                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 197                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
 198                         }
 199                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 200                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
 201                         }
 202                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
 203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
 204                 }
 205                 if (r->names) {
 206                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
 207                 }
 208         }
 209         return NDR_ERR_SUCCESS;
 210 }
 211
 212 _PUBLIC_ void ndr_print_lsa_Strings(struct ndr_print *ndr, const char *name, const struct lsa_Strings *r)
 213 {
 214         uint32_t cntr_names_1;
 215         ndr_print_struct(ndr, name, "lsa_Strings");
 216         ndr->depth++;
 217         ndr_print_uint32(ndr, "count", r->count);
 218         ndr_print_ptr(ndr, "names", r->names);
 219         ndr->depth++;
 220         if (r->names) {
 221                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
 222                 ndr->depth++;
 223                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
 224                         char *idx_1=NULL;
 225                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
 226                                 ndr_print_lsa_String(ndr, "names", &r->names[cntr_names_1]);
 227                                 free(idx_1);
 228                         }
 229                 }
 230                 ndr->depth--;
 231         }
 232         ndr->depth--;
 233         ndr->depth--;
 234 }
 235
 236 _PUBLIC_ enum ndr_err_code ndr_push_lsa_AsciiString(struct ndr_push *ndr, int ndr_flags, const struct lsa_AsciiString *r)
 237 {
 238         if (ndr_flags & NDR_SCALARS) {
 239                 NDR_CHECK(ndr_push_align(ndr, 4));
 240                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->string)));
 241                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->string)));
 242                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
 243         }
 244         if (ndr_flags & NDR_BUFFERS) {
 245                 if (r->string) {
 246                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->string)));
 247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->string)));
 249                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, strlen_m(r->string), sizeof(uint8_t), CH_DOS));
 250                 }
 251         }
 252         return NDR_ERR_SUCCESS;
 253 }
 254
 255 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_AsciiString(struct ndr_pull *ndr, int ndr_flags, struct lsa_AsciiString *r)
 256 {
 257         uint32_t _ptr_string;
 258         TALLOC_CTX *_mem_save_string_0;
 259         if (ndr_flags & NDR_SCALARS) {
 260                 NDR_CHECK(ndr_pull_align(ndr, 4));
 261                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 262                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
 264                 if (_ptr_string) {
 265                         NDR_PULL_ALLOC(ndr, r->string);
 266                 } else {
 267                         r->string = NULL;
 268                 }
 269         }
 270         if (ndr_flags & NDR_BUFFERS) {
 271                 if (r->string) {
 272                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
 273                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
 274                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
 275                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
 276                         if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
 277                                 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));
 278                         }
 279                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint8_t), CH_DOS));
 280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
 281                 }
 282                 if (r->string) {
 283                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size));
 284                 }
 285                 if (r->string) {
 286                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->string, r->length));
 287                 }
 288         }
 289         return NDR_ERR_SUCCESS;
 290 }
 291
 292 _PUBLIC_ void ndr_print_lsa_AsciiString(struct ndr_print *ndr, const char *name, const struct lsa_AsciiString *r)
 293 {
 294         ndr_print_struct(ndr, name, "lsa_AsciiString");
 295         ndr->depth++;
 296         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->length);
 297         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->size);
 298         ndr_print_ptr(ndr, "string", r->string);
 299         ndr->depth++;
 300         if (r->string) {
 301                 ndr_print_string(ndr, "string", r->string);
 302         }
 303         ndr->depth--;
 304         ndr->depth--;
 305 }
 306
 307 _PUBLIC_ enum ndr_err_code ndr_push_lsa_AsciiStringLarge(struct ndr_push *ndr, int ndr_flags, const struct lsa_AsciiStringLarge *r)
 308 {
 309         if (ndr_flags & NDR_SCALARS) {
 310                 NDR_CHECK(ndr_push_align(ndr, 4));
 311                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->string)));
 312                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->string)));
 313                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
 314         }
 315         if (ndr_flags & NDR_BUFFERS) {
 316                 if (r->string) {
 317                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m_term(r->string)));
 318                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 319                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->string)));
 320                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, strlen_m(r->string), sizeof(uint8_t), CH_DOS));
 321                 }
 322         }
 323         return NDR_ERR_SUCCESS;
 324 }
 325
 326 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_AsciiStringLarge(struct ndr_pull *ndr, int ndr_flags, struct lsa_AsciiStringLarge *r)
 327 {
 328         uint32_t _ptr_string;
 329         TALLOC_CTX *_mem_save_string_0;
 330         if (ndr_flags & NDR_SCALARS) {
 331                 NDR_CHECK(ndr_pull_align(ndr, 4));
 332                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 333                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 334                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
 335                 if (_ptr_string) {
 336                         NDR_PULL_ALLOC(ndr, r->string);
 337                 } else {
 338                         r->string = NULL;
 339                 }
 340         }
 341         if (ndr_flags & NDR_BUFFERS) {
 342                 if (r->string) {
 343                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
 344                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
 345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
 346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
 347                         if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
 348                                 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));
 349                         }
 350                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint8_t), CH_DOS));
 351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
 352                 }
 353                 if (r->string) {
 354                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size));
 355                 }
 356                 if (r->string) {
 357                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->string, r->length));
 358                 }
 359         }
 360         return NDR_ERR_SUCCESS;
 361 }
 362
 363 _PUBLIC_ void ndr_print_lsa_AsciiStringLarge(struct ndr_print *ndr, const char *name, const struct lsa_AsciiStringLarge *r)
 364 {
 365         ndr_print_struct(ndr, name, "lsa_AsciiStringLarge");
 366         ndr->depth++;
 367         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->length);
 368         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->string):r->size);
 369         ndr_print_ptr(ndr, "string", r->string);
 370         ndr->depth++;
 371         if (r->string) {
 372                 ndr_print_string(ndr, "string", r->string);
 373         }
 374         ndr->depth--;
 375         ndr->depth--;
 376 }
 377
 378 _PUBLIC_ enum ndr_err_code ndr_push_lsa_BinaryString(struct ndr_push *ndr, int ndr_flags, const struct lsa_BinaryString *r)
 379 {
 380         uint32_t cntr_array_1;
 381         if (ndr_flags & NDR_SCALARS) {
 382                 NDR_CHECK(ndr_push_align(ndr, 4));
 383                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
 384                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 385                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
 386         }
 387         if (ndr_flags & NDR_BUFFERS) {
 388                 if (r->array) {
 389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
 390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length / 2));
 392                         for (cntr_array_1 = 0; cntr_array_1 < r->length / 2; cntr_array_1++) {
 393                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->array[cntr_array_1]));
 394                         }
 395                 }
 396         }
 397         return NDR_ERR_SUCCESS;
 398 }
 399
 400 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_BinaryString(struct ndr_pull *ndr, int ndr_flags, struct lsa_BinaryString *r)
 401 {
 402         uint32_t _ptr_array;
 403         uint32_t cntr_array_1;
 404         TALLOC_CTX *_mem_save_array_0;
 405         TALLOC_CTX *_mem_save_array_1;
 406         if (ndr_flags & NDR_SCALARS) {
 407                 NDR_CHECK(ndr_pull_align(ndr, 4));
 408                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 409                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
 411                 if (_ptr_array) {
 412                         NDR_PULL_ALLOC(ndr, r->array);
 413                 } else {
 414                         r->array = NULL;
 415                 }
 416         }
 417         if (ndr_flags & NDR_BUFFERS) {
 418                 if (r->array) {
 419                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
 420                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 421                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
 422                         NDR_CHECK(ndr_pull_array_length(ndr, &r->array));
 423                         if (ndr_get_array_length(ndr, &r->array) > ndr_get_array_size(ndr, &r->array)) {
 424                                 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));
 425                         }
 426                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
 427                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
 428                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
 429                         for (cntr_array_1 = 0; cntr_array_1 < r->length / 2; cntr_array_1++) {
 430                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
 431                         }
 432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
 433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
 434                 }
 435                 if (r->array) {
 436                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->size / 2));
 437                 }
 438                 if (r->array) {
 439                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->array, r->length / 2));
 440                 }
 441         }
 442         return NDR_ERR_SUCCESS;
 443 }
 444
 445 _PUBLIC_ void ndr_print_lsa_BinaryString(struct ndr_print *ndr, const char *name, const struct lsa_BinaryString *r)
 446 {
 447         uint32_t cntr_array_1;
 448         ndr_print_struct(ndr, name, "lsa_BinaryString");
 449         ndr->depth++;
 450         ndr_print_uint16(ndr, "length", r->length);
 451         ndr_print_uint16(ndr, "size", r->size);
 452         ndr_print_ptr(ndr, "array", r->array);
 453         ndr->depth++;
 454         if (r->array) {
 455                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->length / 2);
 456                 ndr->depth++;
 457                 for (cntr_array_1=0;cntr_array_1<r->length / 2;cntr_array_1++) {
 458                         char *idx_1=NULL;
 459                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
 460                                 ndr_print_uint16(ndr, "array", r->array[cntr_array_1]);
 461                                 free(idx_1);
 462                         }
 463                 }
 464                 ndr->depth--;
 465         }
 466         ndr->depth--;
 467         ndr->depth--;
 468 }
 469
 470 static enum ndr_err_code ndr_push_lsa_LUID(struct ndr_push *ndr, int ndr_flags, const struct lsa_LUID *r)
 471 {
 472         if (ndr_flags & NDR_SCALARS) {
 473                 NDR_CHECK(ndr_push_align(ndr, 4));
 474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->low));
 475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high));
 476         }
 477         if (ndr_flags & NDR_BUFFERS) {
 478         }
 479         return NDR_ERR_SUCCESS;
 480 }
 481
 482 static enum ndr_err_code ndr_pull_lsa_LUID(struct ndr_pull *ndr, int ndr_flags, struct lsa_LUID *r)
 483 {
 484         if (ndr_flags & NDR_SCALARS) {
 485                 NDR_CHECK(ndr_pull_align(ndr, 4));
 486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->low));
 487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high));
 488         }
 489         if (ndr_flags & NDR_BUFFERS) {
 490         }
 491         return NDR_ERR_SUCCESS;
 492 }
 493
 494 _PUBLIC_ void ndr_print_lsa_LUID(struct ndr_print *ndr, const char *name, const struct lsa_LUID *r)
 495 {
 496         ndr_print_struct(ndr, name, "lsa_LUID");
 497         ndr->depth++;
 498         ndr_print_uint32(ndr, "low", r->low);
 499         ndr_print_uint32(ndr, "high", r->high);
 500         ndr->depth--;
 501 }
 502
 503 static enum ndr_err_code ndr_push_lsa_PrivEntry(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivEntry *r)
 504 {
 505         if (ndr_flags & NDR_SCALARS) {
 506                 NDR_CHECK(ndr_push_align(ndr, 4));
 507                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 508                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
 509         }
 510         if (ndr_flags & NDR_BUFFERS) {
 511                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 512         }
 513         return NDR_ERR_SUCCESS;
 514 }
 515
 516 static enum ndr_err_code ndr_pull_lsa_PrivEntry(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivEntry *r)
 517 {
 518         if (ndr_flags & NDR_SCALARS) {
 519                 NDR_CHECK(ndr_pull_align(ndr, 4));
 520                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 521                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
 522         }
 523         if (ndr_flags & NDR_BUFFERS) {
 524                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 525         }
 526         return NDR_ERR_SUCCESS;
 527 }
 528
 529 _PUBLIC_ void ndr_print_lsa_PrivEntry(struct ndr_print *ndr, const char *name, const struct lsa_PrivEntry *r)
 530 {
 531         ndr_print_struct(ndr, name, "lsa_PrivEntry");
 532         ndr->depth++;
 533         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
 534         ndr_print_lsa_LUID(ndr, "luid", &r->luid);
 535         ndr->depth--;
 536 }
 537
 538 static enum ndr_err_code ndr_push_lsa_PrivArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivArray *r)
 539 {
 540         uint32_t cntr_privs_1;
 541         if (ndr_flags & NDR_SCALARS) {
 542                 NDR_CHECK(ndr_push_align(ndr, 4));
 543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->privs));
 545         }
 546         if (ndr_flags & NDR_BUFFERS) {
 547                 if (r->privs) {
 548                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 549                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 550                                 NDR_CHECK(ndr_push_lsa_PrivEntry(ndr, NDR_SCALARS, &r->privs[cntr_privs_1]));
 551                         }
 552                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 553                                 NDR_CHECK(ndr_push_lsa_PrivEntry(ndr, NDR_BUFFERS, &r->privs[cntr_privs_1]));
 554                         }
 555                 }
 556         }
 557         return NDR_ERR_SUCCESS;
 558 }
 559
 560 static enum ndr_err_code ndr_pull_lsa_PrivArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivArray *r)
 561 {
 562         uint32_t _ptr_privs;
 563         uint32_t cntr_privs_1;
 564         TALLOC_CTX *_mem_save_privs_0;
 565         TALLOC_CTX *_mem_save_privs_1;
 566         if (ndr_flags & NDR_SCALARS) {
 567                 NDR_CHECK(ndr_pull_align(ndr, 4));
 568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 569                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
 570                 if (_ptr_privs) {
 571                         NDR_PULL_ALLOC(ndr, r->privs);
 572                 } else {
 573                         r->privs = NULL;
 574                 }
 575         }
 576         if (ndr_flags & NDR_BUFFERS) {
 577                 if (r->privs) {
 578                         _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
 579                         NDR_PULL_SET_MEM_CTX(ndr, r->privs, 0);
 580                         NDR_CHECK(ndr_pull_array_size(ndr, &r->privs));
 581                         NDR_PULL_ALLOC_N(ndr, r->privs, ndr_get_array_size(ndr, &r->privs));
 582                         _mem_save_privs_1 = NDR_PULL_GET_MEM_CTX(ndr);
 583                         NDR_PULL_SET_MEM_CTX(ndr, r->privs, 0);
 584                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 585                                 NDR_CHECK(ndr_pull_lsa_PrivEntry(ndr, NDR_SCALARS, &r->privs[cntr_privs_1]));
 586                         }
 587                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 588                                 NDR_CHECK(ndr_pull_lsa_PrivEntry(ndr, NDR_BUFFERS, &r->privs[cntr_privs_1]));
 589                         }
 590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_1, 0);
 591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, 0);
 592                 }
 593                 if (r->privs) {
 594                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->privs, r->count));
 595                 }
 596         }
 597         return NDR_ERR_SUCCESS;
 598 }
 599
 600 _PUBLIC_ void ndr_print_lsa_PrivArray(struct ndr_print *ndr, const char *name, const struct lsa_PrivArray *r)
 601 {
 602         uint32_t cntr_privs_1;
 603         ndr_print_struct(ndr, name, "lsa_PrivArray");
 604         ndr->depth++;
 605         ndr_print_uint32(ndr, "count", r->count);
 606         ndr_print_ptr(ndr, "privs", r->privs);
 607         ndr->depth++;
 608         if (r->privs) {
 609                 ndr->print(ndr, "%s: ARRAY(%d)", "privs", (int)r->count);
 610                 ndr->depth++;
 611                 for (cntr_privs_1=0;cntr_privs_1<r->count;cntr_privs_1++) {
 612                         char *idx_1=NULL;
 613                         if (asprintf(&idx_1, "[%d]", cntr_privs_1) != -1) {
 614                                 ndr_print_lsa_PrivEntry(ndr, "privs", &r->privs[cntr_privs_1]);
 615                                 free(idx_1);
 616                         }
 617                 }
 618                 ndr->depth--;
 619         }
 620         ndr->depth--;
 621         ndr->depth--;
 622 }
 623
 624 static enum ndr_err_code ndr_push_lsa_QosInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_QosInfo *r)
 625 {
 626         if (ndr_flags & NDR_SCALARS) {
 627                 NDR_CHECK(ndr_push_align(ndr, 4));
 628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
 629                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->impersonation_level));
 630                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->context_mode));
 631                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->effective_only));
 632         }
 633         if (ndr_flags & NDR_BUFFERS) {
 634         }
 635         return NDR_ERR_SUCCESS;
 636 }
 637
 638 static enum ndr_err_code ndr_pull_lsa_QosInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_QosInfo *r)
 639 {
 640         if (ndr_flags & NDR_SCALARS) {
 641                 NDR_CHECK(ndr_pull_align(ndr, 4));
 642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
 643                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->impersonation_level));
 644                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->context_mode));
 645                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->effective_only));
 646         }
 647         if (ndr_flags & NDR_BUFFERS) {
 648         }
 649         return NDR_ERR_SUCCESS;
 650 }
 651
 652 _PUBLIC_ void ndr_print_lsa_QosInfo(struct ndr_print *ndr, const char *name, const struct lsa_QosInfo *r)
 653 {
 654         ndr_print_struct(ndr, name, "lsa_QosInfo");
 655         ndr->depth++;
 656         ndr_print_uint32(ndr, "len", r->len);
 657         ndr_print_uint16(ndr, "impersonation_level", r->impersonation_level);
 658         ndr_print_uint8(ndr, "context_mode", r->context_mode);
 659         ndr_print_uint8(ndr, "effective_only", r->effective_only);
 660         ndr->depth--;
 661 }
 662
 663 static enum ndr_err_code ndr_push_lsa_ObjectAttribute(struct ndr_push *ndr, int ndr_flags, const struct lsa_ObjectAttribute *r)
 664 {
 665         if (ndr_flags & NDR_SCALARS) {
 666                 NDR_CHECK(ndr_push_align(ndr, 4));
 667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
 668                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->root_dir));
 669                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_name));
 670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attributes));
 671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sec_desc));
 672                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sec_qos));
 673         }
 674         if (ndr_flags & NDR_BUFFERS) {
 675                 if (r->root_dir) {
 676                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->root_dir));
 677                 }
 678                 if (r->object_name) {
 679                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_name, CH_UTF16)));
 680                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_name, CH_UTF16)));
 682                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_name, ndr_charset_length(r->object_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 683                 }
 684                 if (r->sec_desc) {
 685                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sec_desc));
 686                 }
 687                 if (r->sec_qos) {
 688                         NDR_CHECK(ndr_push_lsa_QosInfo(ndr, NDR_SCALARS, r->sec_qos));
 689                 }
 690         }
 691         return NDR_ERR_SUCCESS;
 692 }
 693
 694 static enum ndr_err_code ndr_pull_lsa_ObjectAttribute(struct ndr_pull *ndr, int ndr_flags, struct lsa_ObjectAttribute *r)
 695 {
 696         uint32_t _ptr_root_dir;
 697         TALLOC_CTX *_mem_save_root_dir_0;
 698         uint32_t _ptr_object_name;
 699         TALLOC_CTX *_mem_save_object_name_0;
 700         uint32_t _ptr_sec_desc;
 701         TALLOC_CTX *_mem_save_sec_desc_0;
 702         uint32_t _ptr_sec_qos;
 703         TALLOC_CTX *_mem_save_sec_qos_0;
 704         if (ndr_flags & NDR_SCALARS) {
 705                 NDR_CHECK(ndr_pull_align(ndr, 4));
 706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
 707                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_root_dir));
 708                 if (_ptr_root_dir) {
 709                         NDR_PULL_ALLOC(ndr, r->root_dir);
 710                 } else {
 711                         r->root_dir = NULL;
 712                 }
 713                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_name));
 714                 if (_ptr_object_name) {
 715                         NDR_PULL_ALLOC(ndr, r->object_name);
 716                 } else {
 717                         r->object_name = NULL;
 718                 }
 719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attributes));
 720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_desc));
 721                 if (_ptr_sec_desc) {
 722                         NDR_PULL_ALLOC(ndr, r->sec_desc);
 723                 } else {
 724                         r->sec_desc = NULL;
 725                 }
 726                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_qos));
 727                 if (_ptr_sec_qos) {
 728                         NDR_PULL_ALLOC(ndr, r->sec_qos);
 729                 } else {
 730                         r->sec_qos = NULL;
 731                 }
 732         }
 733         if (ndr_flags & NDR_BUFFERS) {
 734                 if (r->root_dir) {
 735                         _mem_save_root_dir_0 = NDR_PULL_GET_MEM_CTX(ndr);
 736                         NDR_PULL_SET_MEM_CTX(ndr, r->root_dir, 0);
 737                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->root_dir));
 738                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_root_dir_0, 0);
 739                 }
 740                 if (r->object_name) {
 741                         _mem_save_object_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 742                         NDR_PULL_SET_MEM_CTX(ndr, r->object_name, 0);
 743                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_name));
 744                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_name));
 745                         if (ndr_get_array_length(ndr, &r->object_name) > ndr_get_array_size(ndr, &r->object_name)) {
 746                                 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));
 747                         }
 748                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_name), sizeof(uint16_t)));
 749                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_name, ndr_get_array_length(ndr, &r->object_name), sizeof(uint16_t), CH_UTF16));
 750                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_name_0, 0);
 751                 }
 752                 if (r->sec_desc) {
 753                         _mem_save_sec_desc_0 = NDR_PULL_GET_MEM_CTX(ndr);
 754                         NDR_PULL_SET_MEM_CTX(ndr, r->sec_desc, 0);
 755                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sec_desc));
 756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_desc_0, 0);
 757                 }
 758                 if (r->sec_qos) {
 759                         _mem_save_sec_qos_0 = NDR_PULL_GET_MEM_CTX(ndr);
 760                         NDR_PULL_SET_MEM_CTX(ndr, r->sec_qos, 0);
 761                         NDR_CHECK(ndr_pull_lsa_QosInfo(ndr, NDR_SCALARS, r->sec_qos));
 762                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_qos_0, 0);
 763                 }
 764         }
 765         return NDR_ERR_SUCCESS;
 766 }
 767
 768 _PUBLIC_ void ndr_print_lsa_ObjectAttribute(struct ndr_print *ndr, const char *name, const struct lsa_ObjectAttribute *r)
 769 {
 770         ndr_print_struct(ndr, name, "lsa_ObjectAttribute");
 771         ndr->depth++;
 772         ndr_print_uint32(ndr, "len", r->len);
 773         ndr_print_ptr(ndr, "root_dir", r->root_dir);
 774         ndr->depth++;
 775         if (r->root_dir) {
 776                 ndr_print_uint8(ndr, "root_dir", *r->root_dir);
 777         }
 778         ndr->depth--;
 779         ndr_print_ptr(ndr, "object_name", r->object_name);
 780         ndr->depth++;
 781         if (r->object_name) {
 782                 ndr_print_string(ndr, "object_name", r->object_name);
 783         }
 784         ndr->depth--;
 785         ndr_print_uint32(ndr, "attributes", r->attributes);
 786         ndr_print_ptr(ndr, "sec_desc", r->sec_desc);
 787         ndr->depth++;
 788         if (r->sec_desc) {
 789                 ndr_print_security_descriptor(ndr, "sec_desc", r->sec_desc);
 790         }
 791         ndr->depth--;
 792         ndr_print_ptr(ndr, "sec_qos", r->sec_qos);
 793         ndr->depth++;
 794         if (r->sec_qos) {
 795                 ndr_print_lsa_QosInfo(ndr, "sec_qos", r->sec_qos);
 796         }
 797         ndr->depth--;
 798         ndr->depth--;
 799 }
 800
 801 _PUBLIC_ enum ndr_err_code ndr_push_lsa_PolicyAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 802 {
 803         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 804         return NDR_ERR_SUCCESS;
 805 }
 806
 807 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_PolicyAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 808 {
 809         uint32_t v;
 810         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 811         *r = v;
 812         return NDR_ERR_SUCCESS;
 813 }
 814
 815 _PUBLIC_ void ndr_print_lsa_PolicyAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 816 {
 817         ndr_print_uint32(ndr, name, r);
 818         ndr->depth++;
 819         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_VIEW_LOCAL_INFORMATION", LSA_POLICY_VIEW_LOCAL_INFORMATION, r);
 820         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_VIEW_AUDIT_INFORMATION", LSA_POLICY_VIEW_AUDIT_INFORMATION, r);
 821         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_GET_PRIVATE_INFORMATION", LSA_POLICY_GET_PRIVATE_INFORMATION, r);
 822         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_TRUST_ADMIN", LSA_POLICY_TRUST_ADMIN, r);
 823         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_CREATE_ACCOUNT", LSA_POLICY_CREATE_ACCOUNT, r);
 824         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_CREATE_SECRET", LSA_POLICY_CREATE_SECRET, r);
 825         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_CREATE_PRIVILEGE", LSA_POLICY_CREATE_PRIVILEGE, r);
 826         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_SET_DEFAULT_QUOTA_LIMITS", LSA_POLICY_SET_DEFAULT_QUOTA_LIMITS, r);
 827         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_SET_AUDIT_REQUIREMENTS", LSA_POLICY_SET_AUDIT_REQUIREMENTS, r);
 828         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_AUDIT_LOG_ADMIN", LSA_POLICY_AUDIT_LOG_ADMIN, r);
 829         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_SERVER_ADMIN", LSA_POLICY_SERVER_ADMIN, r);
 830         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_LOOKUP_NAMES", LSA_POLICY_LOOKUP_NAMES, r);
 831         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_POLICY_NOTIFICATION", LSA_POLICY_NOTIFICATION, r);
 832         ndr->depth--;
 833 }
 834
 835 _PUBLIC_ enum ndr_err_code ndr_push_lsa_AccountAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 836 {
 837         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 838         return NDR_ERR_SUCCESS;
 839 }
 840
 841 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_AccountAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 842 {
 843         uint32_t v;
 844         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 845         *r = v;
 846         return NDR_ERR_SUCCESS;
 847 }
 848
 849 _PUBLIC_ void ndr_print_lsa_AccountAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 850 {
 851         ndr_print_uint32(ndr, name, r);
 852         ndr->depth++;
 853         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_ACCOUNT_VIEW", LSA_ACCOUNT_VIEW, r);
 854         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_ACCOUNT_ADJUST_PRIVILEGES", LSA_ACCOUNT_ADJUST_PRIVILEGES, r);
 855         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_ACCOUNT_ADJUST_QUOTAS", LSA_ACCOUNT_ADJUST_QUOTAS, r);
 856         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS", LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS, r);
 857         ndr->depth--;
 858 }
 859
 860 _PUBLIC_ enum ndr_err_code ndr_push_lsa_SecretAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 861 {
 862         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 863         return NDR_ERR_SUCCESS;
 864 }
 865
 866 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_SecretAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 867 {
 868         uint32_t v;
 869         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 870         *r = v;
 871         return NDR_ERR_SUCCESS;
 872 }
 873
 874 _PUBLIC_ void ndr_print_lsa_SecretAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 875 {
 876         ndr_print_uint32(ndr, name, r);
 877         ndr->depth++;
 878         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_SECRET_SET_VALUE", LSA_SECRET_SET_VALUE, r);
 879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_SECRET_QUERY_VALUE", LSA_SECRET_QUERY_VALUE, r);
 880         ndr->depth--;
 881 }
 882
 883 _PUBLIC_ enum ndr_err_code ndr_push_lsa_TrustedAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 884 {
 885         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 886         return NDR_ERR_SUCCESS;
 887 }
 888
 889 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_TrustedAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 890 {
 891         uint32_t v;
 892         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 893         *r = v;
 894         return NDR_ERR_SUCCESS;
 895 }
 896
 897 _PUBLIC_ void ndr_print_lsa_TrustedAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 898 {
 899         ndr_print_uint32(ndr, name, r);
 900         ndr->depth++;
 901         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUSTED_QUERY_DOMAIN_NAME", LSA_TRUSTED_QUERY_DOMAIN_NAME, r);
 902         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUSTED_QUERY_CONTROLLERS", LSA_TRUSTED_QUERY_CONTROLLERS, r);
 903         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUSTED_SET_CONTROLLERS", LSA_TRUSTED_SET_CONTROLLERS, r);
 904         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUSTED_QUERY_POSIX", LSA_TRUSTED_QUERY_POSIX, r);
 905         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUSTED_SET_POSIX", LSA_TRUSTED_SET_POSIX, r);
 906         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUSTED_SET_AUTH", LSA_TRUSTED_SET_AUTH, r);
 907         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUSTED_QUERY_AUTH", LSA_TRUSTED_QUERY_AUTH, r);
 908         ndr->depth--;
 909 }
 910
 911 static enum ndr_err_code ndr_push_lsa_AuditLogInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditLogInfo *r)
 912 {
 913         if (ndr_flags & NDR_SCALARS) {
 914                 NDR_CHECK(ndr_push_align(ndr, 8));
 915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->percent_full));
 916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->maximum_log_size));
 917                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->retention_time));
 918                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_in_progress));
 919                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->time_to_shutdown));
 920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_audit_record));
 921         }
 922         if (ndr_flags & NDR_BUFFERS) {
 923         }
 924         return NDR_ERR_SUCCESS;
 925 }
 926
 927 static enum ndr_err_code ndr_pull_lsa_AuditLogInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditLogInfo *r)
 928 {
 929         if (ndr_flags & NDR_SCALARS) {
 930                 NDR_CHECK(ndr_pull_align(ndr, 8));
 931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->percent_full));
 932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->maximum_log_size));
 933                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->retention_time));
 934                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_in_progress));
 935                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->time_to_shutdown));
 936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_audit_record));
 937         }
 938         if (ndr_flags & NDR_BUFFERS) {
 939         }
 940         return NDR_ERR_SUCCESS;
 941 }
 942
 943 _PUBLIC_ void ndr_print_lsa_AuditLogInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditLogInfo *r)
 944 {
 945         ndr_print_struct(ndr, name, "lsa_AuditLogInfo");
 946         ndr->depth++;
 947         ndr_print_uint32(ndr, "percent_full", r->percent_full);
 948         ndr_print_uint32(ndr, "maximum_log_size", r->maximum_log_size);
 949         ndr_print_hyper(ndr, "retention_time", r->retention_time);
 950         ndr_print_uint8(ndr, "shutdown_in_progress", r->shutdown_in_progress);
 951         ndr_print_hyper(ndr, "time_to_shutdown", r->time_to_shutdown);
 952         ndr_print_uint32(ndr, "next_audit_record", r->next_audit_record);
 953         ndr->depth--;
 954 }
 955
 956 static enum ndr_err_code ndr_push_lsa_PolicyAuditPolicy(struct ndr_push *ndr, int ndr_flags, enum lsa_PolicyAuditPolicy r)
 957 {
 958         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 959         return NDR_ERR_SUCCESS;
 960 }
 961
 962 static enum ndr_err_code ndr_pull_lsa_PolicyAuditPolicy(struct ndr_pull *ndr, int ndr_flags, enum lsa_PolicyAuditPolicy *r)
 963 {
 964         uint32_t v;
 965         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 966         *r = v;
 967         return NDR_ERR_SUCCESS;
 968 }
 969
 970 _PUBLIC_ void ndr_print_lsa_PolicyAuditPolicy(struct ndr_print *ndr, const char *name, enum lsa_PolicyAuditPolicy r)
 971 {
 972         const char *val = NULL;
 973
 974         switch (r) {
 975                 case LSA_AUDIT_POLICY_NONE: val = "LSA_AUDIT_POLICY_NONE"; break;
 976                 case LSA_AUDIT_POLICY_SUCCESS: val = "LSA_AUDIT_POLICY_SUCCESS"; break;
 977                 case LSA_AUDIT_POLICY_FAILURE: val = "LSA_AUDIT_POLICY_FAILURE"; break;
 978                 case LSA_AUDIT_POLICY_ALL: val = "LSA_AUDIT_POLICY_ALL"; break;
 979                 case LSA_AUDIT_POLICY_CLEAR: val = "LSA_AUDIT_POLICY_CLEAR"; break;
 980         }
 981         ndr_print_enum(ndr, name, "ENUM", val, r);
 982 }
 983
 984 static enum ndr_err_code ndr_push_lsa_AuditEventsInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditEventsInfo *r)
 985 {
 986         uint32_t cntr_settings_1;
 987         if (ndr_flags & NDR_SCALARS) {
 988                 NDR_CHECK(ndr_push_align(ndr, 4));
 989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditing_mode));
 990                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->settings));
 991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 992         }
 993         if (ndr_flags & NDR_BUFFERS) {
 994                 if (r->settings) {
 995                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 996                         for (cntr_settings_1 = 0; cntr_settings_1 < r->count; cntr_settings_1++) {
 997                                 NDR_CHECK(ndr_push_lsa_PolicyAuditPolicy(ndr, NDR_SCALARS, r->settings[cntr_settings_1]));
 998                         }
 999                 }
1000         }
1001         return NDR_ERR_SUCCESS;
1002 }
1003
1004 static enum ndr_err_code ndr_pull_lsa_AuditEventsInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditEventsInfo *r)
1005 {
1006         uint32_t _ptr_settings;
1007         uint32_t cntr_settings_1;
1008         TALLOC_CTX *_mem_save_settings_0;
1009         TALLOC_CTX *_mem_save_settings_1;
1010         if (ndr_flags & NDR_SCALARS) {
1011                 NDR_CHECK(ndr_pull_align(ndr, 4));
1012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditing_mode));
1013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_settings));
1014                 if (_ptr_settings) {
1015                         NDR_PULL_ALLOC(ndr, r->settings);
1016                 } else {
1017                         r->settings = NULL;
1018                 }
1019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1020         }
1021         if (ndr_flags & NDR_BUFFERS) {
1022                 if (r->settings) {
1023                         _mem_save_settings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1024                         NDR_PULL_SET_MEM_CTX(ndr, r->settings, 0);
1025                         NDR_CHECK(ndr_pull_array_size(ndr, &r->settings));
1026                         NDR_PULL_ALLOC_N(ndr, r->settings, ndr_get_array_size(ndr, &r->settings));
1027                         _mem_save_settings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1028                         NDR_PULL_SET_MEM_CTX(ndr, r->settings, 0);
1029                         for (cntr_settings_1 = 0; cntr_settings_1 < r->count; cntr_settings_1++) {
1030                                 NDR_CHECK(ndr_pull_lsa_PolicyAuditPolicy(ndr, NDR_SCALARS, &r->settings[cntr_settings_1]));
1031                         }
1032                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_settings_1, 0);
1033                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_settings_0, 0);
1034                 }
1035                 if (r->settings) {
1036                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->settings, r->count));
1037                 }
1038         }
1039         return NDR_ERR_SUCCESS;
1040 }
1041
1042 _PUBLIC_ void ndr_print_lsa_AuditEventsInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditEventsInfo *r)
1043 {
1044         uint32_t cntr_settings_1;
1045         ndr_print_struct(ndr, name, "lsa_AuditEventsInfo");
1046         ndr->depth++;
1047         ndr_print_uint32(ndr, "auditing_mode", r->auditing_mode);
1048         ndr_print_ptr(ndr, "settings", r->settings);
1049         ndr->depth++;
1050         if (r->settings) {
1051                 ndr->print(ndr, "%s: ARRAY(%d)", "settings", (int)r->count);
1052                 ndr->depth++;
1053                 for (cntr_settings_1=0;cntr_settings_1<r->count;cntr_settings_1++) {
1054                         char *idx_1=NULL;
1055                         if (asprintf(&idx_1, "[%d]", cntr_settings_1) != -1) {
1056                                 ndr_print_lsa_PolicyAuditPolicy(ndr, "settings", r->settings[cntr_settings_1]);
1057                                 free(idx_1);
1058                         }
1059                 }
1060                 ndr->depth--;
1061         }
1062         ndr->depth--;
1063         ndr_print_uint32(ndr, "count", r->count);
1064         ndr->depth--;
1065 }
1066
1067 static enum ndr_err_code ndr_push_lsa_DomainInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfo *r)
1068 {
1069         if (ndr_flags & NDR_SCALARS) {
1070                 NDR_CHECK(ndr_push_align(ndr, 4));
1071                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
1072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
1073         }
1074         if (ndr_flags & NDR_BUFFERS) {
1075                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1076                 if (r->sid) {
1077                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1078                 }
1079         }
1080         return NDR_ERR_SUCCESS;
1081 }
1082
1083 static enum ndr_err_code ndr_pull_lsa_DomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfo *r)
1084 {
1085         uint32_t _ptr_sid;
1086         TALLOC_CTX *_mem_save_sid_0;
1087         if (ndr_flags & NDR_SCALARS) {
1088                 NDR_CHECK(ndr_pull_align(ndr, 4));
1089                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
1090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
1091                 if (_ptr_sid) {
1092                         NDR_PULL_ALLOC(ndr, r->sid);
1093                 } else {
1094                         r->sid = NULL;
1095                 }
1096         }
1097         if (ndr_flags & NDR_BUFFERS) {
1098                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1099                 if (r->sid) {
1100                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1101                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1102                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1104                 }
1105         }
1106         return NDR_ERR_SUCCESS;
1107 }
1108
1109 _PUBLIC_ void ndr_print_lsa_DomainInfo(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfo *r)
1110 {
1111         ndr_print_struct(ndr, name, "lsa_DomainInfo");
1112         ndr->depth++;
1113         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
1114         ndr_print_ptr(ndr, "sid", r->sid);
1115         ndr->depth++;
1116         if (r->sid) {
1117                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1118         }
1119         ndr->depth--;
1120         ndr->depth--;
1121 }
1122
1123 static enum ndr_err_code ndr_push_lsa_PDAccountInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_PDAccountInfo *r)
1124 {
1125         if (ndr_flags & NDR_SCALARS) {
1126                 NDR_CHECK(ndr_push_align(ndr, 4));
1127                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1128         }
1129         if (ndr_flags & NDR_BUFFERS) {
1130                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1131         }
1132         return NDR_ERR_SUCCESS;
1133 }
1134
1135 static enum ndr_err_code ndr_pull_lsa_PDAccountInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_PDAccountInfo *r)
1136 {
1137         if (ndr_flags & NDR_SCALARS) {
1138                 NDR_CHECK(ndr_pull_align(ndr, 4));
1139                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1140         }
1141         if (ndr_flags & NDR_BUFFERS) {
1142                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1143         }
1144         return NDR_ERR_SUCCESS;
1145 }
1146
1147 _PUBLIC_ void ndr_print_lsa_PDAccountInfo(struct ndr_print *ndr, const char *name, const struct lsa_PDAccountInfo *r)
1148 {
1149         ndr_print_struct(ndr, name, "lsa_PDAccountInfo");
1150         ndr->depth++;
1151         ndr_print_lsa_String(ndr, "name", &r->name);
1152         ndr->depth--;
1153 }
1154
1155 static enum ndr_err_code ndr_push_lsa_Role(struct ndr_push *ndr, int ndr_flags, enum lsa_Role r)
1156 {
1157         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1158         return NDR_ERR_SUCCESS;
1159 }
1160
1161 static enum ndr_err_code ndr_pull_lsa_Role(struct ndr_pull *ndr, int ndr_flags, enum lsa_Role *r)
1162 {
1163         uint32_t v;
1164         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1165         *r = v;
1166         return NDR_ERR_SUCCESS;
1167 }
1168
1169 _PUBLIC_ void ndr_print_lsa_Role(struct ndr_print *ndr, const char *name, enum lsa_Role r)
1170 {
1171         const char *val = NULL;
1172
1173         switch (r) {
1174                 case LSA_ROLE_BACKUP: val = "LSA_ROLE_BACKUP"; break;
1175                 case LSA_ROLE_PRIMARY: val = "LSA_ROLE_PRIMARY"; break;
1176         }
1177         ndr_print_enum(ndr, name, "ENUM", val, r);
1178 }
1179
1180 static enum ndr_err_code ndr_push_lsa_ServerRole(struct ndr_push *ndr, int ndr_flags, const struct lsa_ServerRole *r)
1181 {
1182         if (ndr_flags & NDR_SCALARS) {
1183                 NDR_CHECK(ndr_push_align(ndr, 4));
1184                 NDR_CHECK(ndr_push_lsa_Role(ndr, NDR_SCALARS, r->role));
1185         }
1186         if (ndr_flags & NDR_BUFFERS) {
1187         }
1188         return NDR_ERR_SUCCESS;
1189 }
1190
1191 static enum ndr_err_code ndr_pull_lsa_ServerRole(struct ndr_pull *ndr, int ndr_flags, struct lsa_ServerRole *r)
1192 {
1193         if (ndr_flags & NDR_SCALARS) {
1194                 NDR_CHECK(ndr_pull_align(ndr, 4));
1195                 NDR_CHECK(ndr_pull_lsa_Role(ndr, NDR_SCALARS, &r->role));
1196         }
1197         if (ndr_flags & NDR_BUFFERS) {
1198         }
1199         return NDR_ERR_SUCCESS;
1200 }
1201
1202 _PUBLIC_ void ndr_print_lsa_ServerRole(struct ndr_print *ndr, const char *name, const struct lsa_ServerRole *r)
1203 {
1204         ndr_print_struct(ndr, name, "lsa_ServerRole");
1205         ndr->depth++;
1206         ndr_print_lsa_Role(ndr, "role", r->role);
1207         ndr->depth--;
1208 }
1209
1210 static enum ndr_err_code ndr_push_lsa_ReplicaSourceInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_ReplicaSourceInfo *r)
1211 {
1212         if (ndr_flags & NDR_SCALARS) {
1213                 NDR_CHECK(ndr_push_align(ndr, 4));
1214                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->source));
1215                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account));
1216         }
1217         if (ndr_flags & NDR_BUFFERS) {
1218                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->source));
1219                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account));
1220         }
1221         return NDR_ERR_SUCCESS;
1222 }
1223
1224 static enum ndr_err_code ndr_pull_lsa_ReplicaSourceInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ReplicaSourceInfo *r)
1225 {
1226         if (ndr_flags & NDR_SCALARS) {
1227                 NDR_CHECK(ndr_pull_align(ndr, 4));
1228                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->source));
1229                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account));
1230         }
1231         if (ndr_flags & NDR_BUFFERS) {
1232                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->source));
1233                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account));
1234         }
1235         return NDR_ERR_SUCCESS;
1236 }
1237
1238 _PUBLIC_ void ndr_print_lsa_ReplicaSourceInfo(struct ndr_print *ndr, const char *name, const struct lsa_ReplicaSourceInfo *r)
1239 {
1240         ndr_print_struct(ndr, name, "lsa_ReplicaSourceInfo");
1241         ndr->depth++;
1242         ndr_print_lsa_String(ndr, "source", &r->source);
1243         ndr_print_lsa_String(ndr, "account", &r->account);
1244         ndr->depth--;
1245 }
1246
1247 static enum ndr_err_code ndr_push_lsa_DefaultQuotaInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DefaultQuotaInfo *r)
1248 {
1249         if (ndr_flags & NDR_SCALARS) {
1250                 NDR_CHECK(ndr_push_align(ndr, 8));
1251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->paged_pool));
1252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->non_paged_pool));
1253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->min_wss));
1254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_wss));
1255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pagefile));
1256                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown));
1257         }
1258         if (ndr_flags & NDR_BUFFERS) {
1259         }
1260         return NDR_ERR_SUCCESS;
1261 }
1262
1263 static enum ndr_err_code ndr_pull_lsa_DefaultQuotaInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DefaultQuotaInfo *r)
1264 {
1265         if (ndr_flags & NDR_SCALARS) {
1266                 NDR_CHECK(ndr_pull_align(ndr, 8));
1267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->paged_pool));
1268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->non_paged_pool));
1269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->min_wss));
1270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_wss));
1271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pagefile));
1272                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown));
1273         }
1274         if (ndr_flags & NDR_BUFFERS) {
1275         }
1276         return NDR_ERR_SUCCESS;
1277 }
1278
1279 _PUBLIC_ void ndr_print_lsa_DefaultQuotaInfo(struct ndr_print *ndr, const char *name, const struct lsa_DefaultQuotaInfo *r)
1280 {
1281         ndr_print_struct(ndr, name, "lsa_DefaultQuotaInfo");
1282         ndr->depth++;
1283         ndr_print_uint32(ndr, "paged_pool", r->paged_pool);
1284         ndr_print_uint32(ndr, "non_paged_pool", r->non_paged_pool);
1285         ndr_print_uint32(ndr, "min_wss", r->min_wss);
1286         ndr_print_uint32(ndr, "max_wss", r->max_wss);
1287         ndr_print_uint32(ndr, "pagefile", r->pagefile);
1288         ndr_print_hyper(ndr, "unknown", r->unknown);
1289         ndr->depth--;
1290 }
1291
1292 static enum ndr_err_code ndr_push_lsa_ModificationInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_ModificationInfo *r)
1293 {
1294         if (ndr_flags & NDR_SCALARS) {
1295                 NDR_CHECK(ndr_push_align(ndr, 8));
1296                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_id));
1297                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->db_create_time));
1298         }
1299         if (ndr_flags & NDR_BUFFERS) {
1300         }
1301         return NDR_ERR_SUCCESS;
1302 }
1303
1304 static enum ndr_err_code ndr_pull_lsa_ModificationInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ModificationInfo *r)
1305 {
1306         if (ndr_flags & NDR_SCALARS) {
1307                 NDR_CHECK(ndr_pull_align(ndr, 8));
1308                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_id));
1309                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->db_create_time));
1310         }
1311         if (ndr_flags & NDR_BUFFERS) {
1312         }
1313         return NDR_ERR_SUCCESS;
1314 }
1315
1316 _PUBLIC_ void ndr_print_lsa_ModificationInfo(struct ndr_print *ndr, const char *name, const struct lsa_ModificationInfo *r)
1317 {
1318         ndr_print_struct(ndr, name, "lsa_ModificationInfo");
1319         ndr->depth++;
1320         ndr_print_hyper(ndr, "modified_id", r->modified_id);
1321         ndr_print_NTTIME_hyper(ndr, "db_create_time", r->db_create_time);
1322         ndr->depth--;
1323 }
1324
1325 static enum ndr_err_code ndr_push_lsa_AuditFullSetInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditFullSetInfo *r)
1326 {
1327         if (ndr_flags & NDR_SCALARS) {
1328                 NDR_CHECK(ndr_push_align(ndr, 1));
1329                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_on_full));
1330         }
1331         if (ndr_flags & NDR_BUFFERS) {
1332         }
1333         return NDR_ERR_SUCCESS;
1334 }
1335
1336 static enum ndr_err_code ndr_pull_lsa_AuditFullSetInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditFullSetInfo *r)
1337 {
1338         if (ndr_flags & NDR_SCALARS) {
1339                 NDR_CHECK(ndr_pull_align(ndr, 1));
1340                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_on_full));
1341         }
1342         if (ndr_flags & NDR_BUFFERS) {
1343         }
1344         return NDR_ERR_SUCCESS;
1345 }
1346
1347 _PUBLIC_ void ndr_print_lsa_AuditFullSetInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditFullSetInfo *r)
1348 {
1349         ndr_print_struct(ndr, name, "lsa_AuditFullSetInfo");
1350         ndr->depth++;
1351         ndr_print_uint8(ndr, "shutdown_on_full", r->shutdown_on_full);
1352         ndr->depth--;
1353 }
1354
1355 static enum ndr_err_code ndr_push_lsa_AuditFullQueryInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditFullQueryInfo *r)
1356 {
1357         if (ndr_flags & NDR_SCALARS) {
1358                 NDR_CHECK(ndr_push_align(ndr, 1));
1359                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_on_full));
1360                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->log_is_full));
1361         }
1362         if (ndr_flags & NDR_BUFFERS) {
1363         }
1364         return NDR_ERR_SUCCESS;
1365 }
1366
1367 static enum ndr_err_code ndr_pull_lsa_AuditFullQueryInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditFullQueryInfo *r)
1368 {
1369         if (ndr_flags & NDR_SCALARS) {
1370                 NDR_CHECK(ndr_pull_align(ndr, 1));
1371                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_on_full));
1372                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->log_is_full));
1373         }
1374         if (ndr_flags & NDR_BUFFERS) {
1375         }
1376         return NDR_ERR_SUCCESS;
1377 }
1378
1379 _PUBLIC_ void ndr_print_lsa_AuditFullQueryInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditFullQueryInfo *r)
1380 {
1381         ndr_print_struct(ndr, name, "lsa_AuditFullQueryInfo");
1382         ndr->depth++;
1383         ndr_print_uint8(ndr, "shutdown_on_full", r->shutdown_on_full);
1384         ndr_print_uint8(ndr, "log_is_full", r->log_is_full);
1385         ndr->depth--;
1386 }
1387
1388 static enum ndr_err_code ndr_push_lsa_DnsDomainInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DnsDomainInfo *r)
1389 {
1390         if (ndr_flags & NDR_SCALARS) {
1391                 NDR_CHECK(ndr_push_align(ndr, 4));
1392                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
1393                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain));
1394                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_forest));
1395                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_guid));
1396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
1397         }
1398         if (ndr_flags & NDR_BUFFERS) {
1399                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1400                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain));
1401                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_forest));
1402                 if (r->sid) {
1403                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1404                 }
1405         }
1406         return NDR_ERR_SUCCESS;
1407 }
1408
1409 static enum ndr_err_code ndr_pull_lsa_DnsDomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DnsDomainInfo *r)
1410 {
1411         uint32_t _ptr_sid;
1412         TALLOC_CTX *_mem_save_sid_0;
1413         if (ndr_flags & NDR_SCALARS) {
1414                 NDR_CHECK(ndr_pull_align(ndr, 4));
1415                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
1416                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain));
1417                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_forest));
1418                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_guid));
1419                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
1420                 if (_ptr_sid) {
1421                         NDR_PULL_ALLOC(ndr, r->sid);
1422                 } else {
1423                         r->sid = NULL;
1424                 }
1425         }
1426         if (ndr_flags & NDR_BUFFERS) {
1427                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1428                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain));
1429                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_forest));
1430                 if (r->sid) {
1431                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1432                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1433                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1435                 }
1436         }
1437         return NDR_ERR_SUCCESS;
1438 }
1439
1440 _PUBLIC_ void ndr_print_lsa_DnsDomainInfo(struct ndr_print *ndr, const char *name, const struct lsa_DnsDomainInfo *r)
1441 {
1442         ndr_print_struct(ndr, name, "lsa_DnsDomainInfo");
1443         ndr->depth++;
1444         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
1445         ndr_print_lsa_StringLarge(ndr, "dns_domain", &r->dns_domain);
1446         ndr_print_lsa_StringLarge(ndr, "dns_forest", &r->dns_forest);
1447         ndr_print_GUID(ndr, "domain_guid", &r->domain_guid);
1448         ndr_print_ptr(ndr, "sid", r->sid);
1449         ndr->depth++;
1450         if (r->sid) {
1451                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1452         }
1453         ndr->depth--;
1454         ndr->depth--;
1455 }
1456
1457 static enum ndr_err_code ndr_push_lsa_PolicyInfo(struct ndr_push *ndr, int ndr_flags, enum lsa_PolicyInfo r)
1458 {
1459         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1460         return NDR_ERR_SUCCESS;
1461 }
1462
1463 static enum ndr_err_code ndr_pull_lsa_PolicyInfo(struct ndr_pull *ndr, int ndr_flags, enum lsa_PolicyInfo *r)
1464 {
1465         uint16_t v;
1466         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1467         *r = v;
1468         return NDR_ERR_SUCCESS;
1469 }
1470
1471 _PUBLIC_ void ndr_print_lsa_PolicyInfo(struct ndr_print *ndr, const char *name, enum lsa_PolicyInfo r)
1472 {
1473         const char *val = NULL;
1474
1475         switch (r) {
1476                 case LSA_POLICY_INFO_AUDIT_LOG: val = "LSA_POLICY_INFO_AUDIT_LOG"; break;
1477                 case LSA_POLICY_INFO_AUDIT_EVENTS: val = "LSA_POLICY_INFO_AUDIT_EVENTS"; break;
1478                 case LSA_POLICY_INFO_DOMAIN: val = "LSA_POLICY_INFO_DOMAIN"; break;
1479                 case LSA_POLICY_INFO_PD: val = "LSA_POLICY_INFO_PD"; break;
1480                 case LSA_POLICY_INFO_ACCOUNT_DOMAIN: val = "LSA_POLICY_INFO_ACCOUNT_DOMAIN"; break;
1481                 case LSA_POLICY_INFO_ROLE: val = "LSA_POLICY_INFO_ROLE"; break;
1482                 case LSA_POLICY_INFO_REPLICA: val = "LSA_POLICY_INFO_REPLICA"; break;
1483                 case LSA_POLICY_INFO_QUOTA: val = "LSA_POLICY_INFO_QUOTA"; break;
1484                 case LSA_POLICY_INFO_MOD: val = "LSA_POLICY_INFO_MOD"; break;
1485                 case LSA_POLICY_INFO_AUDIT_FULL_SET: val = "LSA_POLICY_INFO_AUDIT_FULL_SET"; break;
1486                 case LSA_POLICY_INFO_AUDIT_FULL_QUERY: val = "LSA_POLICY_INFO_AUDIT_FULL_QUERY"; break;
1487                 case LSA_POLICY_INFO_DNS: val = "LSA_POLICY_INFO_DNS"; break;
1488                 case LSA_POLICY_INFO_DNS_INT: val = "LSA_POLICY_INFO_DNS_INT"; break;
1489                 case LSA_POLICY_INFO_L_ACCOUNT_DOMAIN: val = "LSA_POLICY_INFO_L_ACCOUNT_DOMAIN"; break;
1490         }
1491         ndr_print_enum(ndr, name, "ENUM", val, r);
1492 }
1493
1494 static enum ndr_err_code ndr_push_lsa_PolicyInformation(struct ndr_push *ndr, int ndr_flags, const union lsa_PolicyInformation *r)
1495 {
1496         if (ndr_flags & NDR_SCALARS) {
1497                 int level = ndr_push_get_switch_value(ndr, r);
1498                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
1499                 switch (level) {
1500                         case LSA_POLICY_INFO_AUDIT_LOG: {
1501                                 NDR_CHECK(ndr_push_lsa_AuditLogInfo(ndr, NDR_SCALARS, &r->audit_log));
1502                         break; }
1503
1504                         case LSA_POLICY_INFO_AUDIT_EVENTS: {
1505                                 NDR_CHECK(ndr_push_lsa_AuditEventsInfo(ndr, NDR_SCALARS, &r->audit_events));
1506                         break; }
1507
1508                         case LSA_POLICY_INFO_DOMAIN: {
1509                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domain));
1510                         break; }
1511
1512                         case LSA_POLICY_INFO_PD: {
1513                                 NDR_CHECK(ndr_push_lsa_PDAccountInfo(ndr, NDR_SCALARS, &r->pd));
1514                         break; }
1515
1516                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN: {
1517                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->account_domain));
1518                         break; }
1519
1520                         case LSA_POLICY_INFO_ROLE: {
1521                                 NDR_CHECK(ndr_push_lsa_ServerRole(ndr, NDR_SCALARS, &r->role));
1522                         break; }
1523
1524                         case LSA_POLICY_INFO_REPLICA: {
1525                                 NDR_CHECK(ndr_push_lsa_ReplicaSourceInfo(ndr, NDR_SCALARS, &r->replica));
1526                         break; }
1527
1528                         case LSA_POLICY_INFO_QUOTA: {
1529                                 NDR_CHECK(ndr_push_lsa_DefaultQuotaInfo(ndr, NDR_SCALARS, &r->quota));
1530                         break; }
1531
1532                         case LSA_POLICY_INFO_MOD: {
1533                                 NDR_CHECK(ndr_push_lsa_ModificationInfo(ndr, NDR_SCALARS, &r->mod));
1534                         break; }
1535
1536                         case LSA_POLICY_INFO_AUDIT_FULL_SET: {
1537                                 NDR_CHECK(ndr_push_lsa_AuditFullSetInfo(ndr, NDR_SCALARS, &r->auditfullset));
1538                         break; }
1539
1540                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY: {
1541                                 NDR_CHECK(ndr_push_lsa_AuditFullQueryInfo(ndr, NDR_SCALARS, &r->auditfullquery));
1542                         break; }
1543
1544                         case LSA_POLICY_INFO_DNS: {
1545                                 NDR_CHECK(ndr_push_lsa_DnsDomainInfo(ndr, NDR_SCALARS, &r->dns));
1546                         break; }
1547
1548                         case LSA_POLICY_INFO_DNS_INT: {
1549                                 NDR_CHECK(ndr_push_lsa_DnsDomainInfo(ndr, NDR_SCALARS, &r->dns));
1550                         break; }
1551
1552                         case LSA_POLICY_INFO_L_ACCOUNT_DOMAIN: {
1553                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->l_account_domain));
1554                         break; }
1555
1556                         default:
1557                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1558                 }
1559         }
1560         if (ndr_flags & NDR_BUFFERS) {
1561                 int level = ndr_push_get_switch_value(ndr, r);
1562                 switch (level) {
1563                         case LSA_POLICY_INFO_AUDIT_LOG:
1564                         break;
1565
1566                         case LSA_POLICY_INFO_AUDIT_EVENTS:
1567                                 NDR_CHECK(ndr_push_lsa_AuditEventsInfo(ndr, NDR_BUFFERS, &r->audit_events));
1568                         break;
1569
1570                         case LSA_POLICY_INFO_DOMAIN:
1571                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domain));
1572                         break;
1573
1574                         case LSA_POLICY_INFO_PD:
1575                                 NDR_CHECK(ndr_push_lsa_PDAccountInfo(ndr, NDR_BUFFERS, &r->pd));
1576                         break;
1577
1578                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1579                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->account_domain));
1580                         break;
1581
1582                         case LSA_POLICY_INFO_ROLE:
1583                         break;
1584
1585                         case LSA_POLICY_INFO_REPLICA:
1586                                 NDR_CHECK(ndr_push_lsa_ReplicaSourceInfo(ndr, NDR_BUFFERS, &r->replica));
1587                         break;
1588
1589                         case LSA_POLICY_INFO_QUOTA:
1590                         break;
1591
1592                         case LSA_POLICY_INFO_MOD:
1593                         break;
1594
1595                         case LSA_POLICY_INFO_AUDIT_FULL_SET:
1596                         break;
1597
1598                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1599                         break;
1600
1601                         case LSA_POLICY_INFO_DNS:
1602                                 NDR_CHECK(ndr_push_lsa_DnsDomainInfo(ndr, NDR_BUFFERS, &r->dns));
1603                         break;
1604
1605                         case LSA_POLICY_INFO_DNS_INT:
1606                                 NDR_CHECK(ndr_push_lsa_DnsDomainInfo(ndr, NDR_BUFFERS, &r->dns));
1607                         break;
1608
1609                         case LSA_POLICY_INFO_L_ACCOUNT_DOMAIN:
1610                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->l_account_domain));
1611                         break;
1612
1613                         default:
1614                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1615                 }
1616         }
1617         return NDR_ERR_SUCCESS;
1618 }
1619
1620 static enum ndr_err_code ndr_pull_lsa_PolicyInformation(struct ndr_pull *ndr, int ndr_flags, union lsa_PolicyInformation *r)
1621 {
1622         int level;
1623         uint16_t _level;
1624         level = ndr_pull_get_switch_value(ndr, r);
1625         if (ndr_flags & NDR_SCALARS) {
1626                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1627                 if (_level != level) {
1628                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1629                 }
1630                 switch (level) {
1631                         case LSA_POLICY_INFO_AUDIT_LOG: {
1632                                 NDR_CHECK(ndr_pull_lsa_AuditLogInfo(ndr, NDR_SCALARS, &r->audit_log));
1633                         break; }
1634
1635                         case LSA_POLICY_INFO_AUDIT_EVENTS: {
1636                                 NDR_CHECK(ndr_pull_lsa_AuditEventsInfo(ndr, NDR_SCALARS, &r->audit_events));
1637                         break; }
1638
1639                         case LSA_POLICY_INFO_DOMAIN: {
1640                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domain));
1641                         break; }
1642
1643                         case LSA_POLICY_INFO_PD: {
1644                                 NDR_CHECK(ndr_pull_lsa_PDAccountInfo(ndr, NDR_SCALARS, &r->pd));
1645                         break; }
1646
1647                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN: {
1648                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->account_domain));
1649                         break; }
1650
1651                         case LSA_POLICY_INFO_ROLE: {
1652                                 NDR_CHECK(ndr_pull_lsa_ServerRole(ndr, NDR_SCALARS, &r->role));
1653                         break; }
1654
1655                         case LSA_POLICY_INFO_REPLICA: {
1656                                 NDR_CHECK(ndr_pull_lsa_ReplicaSourceInfo(ndr, NDR_SCALARS, &r->replica));
1657                         break; }
1658
1659                         case LSA_POLICY_INFO_QUOTA: {
1660                                 NDR_CHECK(ndr_pull_lsa_DefaultQuotaInfo(ndr, NDR_SCALARS, &r->quota));
1661                         break; }
1662
1663                         case LSA_POLICY_INFO_MOD: {
1664                                 NDR_CHECK(ndr_pull_lsa_ModificationInfo(ndr, NDR_SCALARS, &r->mod));
1665                         break; }
1666
1667                         case LSA_POLICY_INFO_AUDIT_FULL_SET: {
1668                                 NDR_CHECK(ndr_pull_lsa_AuditFullSetInfo(ndr, NDR_SCALARS, &r->auditfullset));
1669                         break; }
1670
1671                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY: {
1672                                 NDR_CHECK(ndr_pull_lsa_AuditFullQueryInfo(ndr, NDR_SCALARS, &r->auditfullquery));
1673                         break; }
1674
1675                         case LSA_POLICY_INFO_DNS: {
1676                                 NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_SCALARS, &r->dns));
1677                         break; }
1678
1679                         case LSA_POLICY_INFO_DNS_INT: {
1680                                 NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_SCALARS, &r->dns));
1681                         break; }
1682
1683                         case LSA_POLICY_INFO_L_ACCOUNT_DOMAIN: {
1684                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->l_account_domain));
1685                         break; }
1686
1687                         default:
1688                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1689                 }
1690         }
1691         if (ndr_flags & NDR_BUFFERS) {
1692                 switch (level) {
1693                         case LSA_POLICY_INFO_AUDIT_LOG:
1694                         break;
1695
1696                         case LSA_POLICY_INFO_AUDIT_EVENTS:
1697                                 NDR_CHECK(ndr_pull_lsa_AuditEventsInfo(ndr, NDR_BUFFERS, &r->audit_events));
1698                         break;
1699
1700                         case LSA_POLICY_INFO_DOMAIN:
1701                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domain));
1702                         break;
1703
1704                         case LSA_POLICY_INFO_PD:
1705                                 NDR_CHECK(ndr_pull_lsa_PDAccountInfo(ndr, NDR_BUFFERS, &r->pd));
1706                         break;
1707
1708                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1709                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->account_domain));
1710                         break;
1711
1712                         case LSA_POLICY_INFO_ROLE:
1713                         break;
1714
1715                         case LSA_POLICY_INFO_REPLICA:
1716                                 NDR_CHECK(ndr_pull_lsa_ReplicaSourceInfo(ndr, NDR_BUFFERS, &r->replica));
1717                         break;
1718
1719                         case LSA_POLICY_INFO_QUOTA:
1720                         break;
1721
1722                         case LSA_POLICY_INFO_MOD:
1723                         break;
1724
1725                         case LSA_POLICY_INFO_AUDIT_FULL_SET:
1726                         break;
1727
1728                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1729                         break;
1730
1731                         case LSA_POLICY_INFO_DNS:
1732                                 NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_BUFFERS, &r->dns));
1733                         break;
1734
1735                         case LSA_POLICY_INFO_DNS_INT:
1736                                 NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_BUFFERS, &r->dns));
1737                         break;
1738
1739                         case LSA_POLICY_INFO_L_ACCOUNT_DOMAIN:
1740                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->l_account_domain));
1741                         break;
1742
1743                         default:
1744                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1745                 }
1746         }
1747         return NDR_ERR_SUCCESS;
1748 }
1749
1750 _PUBLIC_ void ndr_print_lsa_PolicyInformation(struct ndr_print *ndr, const char *name, const union lsa_PolicyInformation *r)
1751 {
1752         int level;
1753         level = ndr_print_get_switch_value(ndr, r);
1754         ndr_print_union(ndr, name, level, "lsa_PolicyInformation");
1755         switch (level) {
1756                 case LSA_POLICY_INFO_AUDIT_LOG:
1757                         ndr_print_lsa_AuditLogInfo(ndr, "audit_log", &r->audit_log);
1758                 break;
1759
1760                 case LSA_POLICY_INFO_AUDIT_EVENTS:
1761                         ndr_print_lsa_AuditEventsInfo(ndr, "audit_events", &r->audit_events);
1762                 break;
1763
1764                 case LSA_POLICY_INFO_DOMAIN:
1765                         ndr_print_lsa_DomainInfo(ndr, "domain", &r->domain);
1766                 break;
1767
1768                 case LSA_POLICY_INFO_PD:
1769                         ndr_print_lsa_PDAccountInfo(ndr, "pd", &r->pd);
1770                 break;
1771
1772                 case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1773                         ndr_print_lsa_DomainInfo(ndr, "account_domain", &r->account_domain);
1774                 break;
1775
1776                 case LSA_POLICY_INFO_ROLE:
1777                         ndr_print_lsa_ServerRole(ndr, "role", &r->role);
1778                 break;
1779
1780                 case LSA_POLICY_INFO_REPLICA:
1781                         ndr_print_lsa_ReplicaSourceInfo(ndr, "replica", &r->replica);
1782                 break;
1783
1784                 case LSA_POLICY_INFO_QUOTA:
1785                         ndr_print_lsa_DefaultQuotaInfo(ndr, "quota", &r->quota);
1786                 break;
1787
1788                 case LSA_POLICY_INFO_MOD:
1789                         ndr_print_lsa_ModificationInfo(ndr, "mod", &r->mod);
1790                 break;
1791
1792                 case LSA_POLICY_INFO_AUDIT_FULL_SET:
1793                         ndr_print_lsa_AuditFullSetInfo(ndr, "auditfullset", &r->auditfullset);
1794                 break;
1795
1796                 case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1797                         ndr_print_lsa_AuditFullQueryInfo(ndr, "auditfullquery", &r->auditfullquery);
1798                 break;
1799
1800                 case LSA_POLICY_INFO_DNS:
1801                         ndr_print_lsa_DnsDomainInfo(ndr, "dns", &r->dns);
1802                 break;
1803
1804                 case LSA_POLICY_INFO_DNS_INT:
1805                         ndr_print_lsa_DnsDomainInfo(ndr, "dns", &r->dns);
1806                 break;
1807
1808                 case LSA_POLICY_INFO_L_ACCOUNT_DOMAIN:
1809                         ndr_print_lsa_DomainInfo(ndr, "l_account_domain", &r->l_account_domain);
1810                 break;
1811
1812                 default:
1813                         ndr_print_bad_level(ndr, name, level);
1814         }
1815 }
1816
1817 static enum ndr_err_code ndr_push_lsa_SidPtr(struct ndr_push *ndr, int ndr_flags, const struct lsa_SidPtr *r)
1818 {
1819         if (ndr_flags & NDR_SCALARS) {
1820                 NDR_CHECK(ndr_push_align(ndr, 4));
1821                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
1822         }
1823         if (ndr_flags & NDR_BUFFERS) {
1824                 if (r->sid) {
1825                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1826                 }
1827         }
1828         return NDR_ERR_SUCCESS;
1829 }
1830
1831 static enum ndr_err_code ndr_pull_lsa_SidPtr(struct ndr_pull *ndr, int ndr_flags, struct lsa_SidPtr *r)
1832 {
1833         uint32_t _ptr_sid;
1834         TALLOC_CTX *_mem_save_sid_0;
1835         if (ndr_flags & NDR_SCALARS) {
1836                 NDR_CHECK(ndr_pull_align(ndr, 4));
1837                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
1838                 if (_ptr_sid) {
1839                         NDR_PULL_ALLOC(ndr, r->sid);
1840                 } else {
1841                         r->sid = NULL;
1842                 }
1843         }
1844         if (ndr_flags & NDR_BUFFERS) {
1845                 if (r->sid) {
1846                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1847                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1848                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1850                 }
1851         }
1852         return NDR_ERR_SUCCESS;
1853 }
1854
1855 _PUBLIC_ void ndr_print_lsa_SidPtr(struct ndr_print *ndr, const char *name, const struct lsa_SidPtr *r)
1856 {
1857         ndr_print_struct(ndr, name, "lsa_SidPtr");
1858         ndr->depth++;
1859         ndr_print_ptr(ndr, "sid", r->sid);
1860         ndr->depth++;
1861         if (r->sid) {
1862                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1863         }
1864         ndr->depth--;
1865         ndr->depth--;
1866 }
1867
1868 _PUBLIC_ enum ndr_err_code ndr_push_lsa_SidArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_SidArray *r)
1869 {
1870         uint32_t cntr_sids_1;
1871         if (ndr_flags & NDR_SCALARS) {
1872                 NDR_CHECK(ndr_push_align(ndr, 4));
1873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
1874                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
1875         }
1876         if (ndr_flags & NDR_BUFFERS) {
1877                 if (r->sids) {
1878                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
1879                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1880                                 NDR_CHECK(ndr_push_lsa_SidPtr(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1881                         }
1882                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1883                                 NDR_CHECK(ndr_push_lsa_SidPtr(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
1884                         }
1885                 }
1886         }
1887         return NDR_ERR_SUCCESS;
1888 }
1889
1890 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_SidArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_SidArray *r)
1891 {
1892         uint32_t _ptr_sids;
1893         uint32_t cntr_sids_1;
1894         TALLOC_CTX *_mem_save_sids_0;
1895         TALLOC_CTX *_mem_save_sids_1;
1896         if (ndr_flags & NDR_SCALARS) {
1897                 NDR_CHECK(ndr_pull_align(ndr, 4));
1898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
1899                 if (r->num_sids > 1000) {
1900                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1901                 }
1902                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
1903                 if (_ptr_sids) {
1904                         NDR_PULL_ALLOC(ndr, r->sids);
1905                 } else {
1906                         r->sids = NULL;
1907                 }
1908         }
1909         if (ndr_flags & NDR_BUFFERS) {
1910                 if (r->sids) {
1911                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1912                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1913                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
1914                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
1915                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1916                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1917                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1918                                 NDR_CHECK(ndr_pull_lsa_SidPtr(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1919                         }
1920                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1921                                 NDR_CHECK(ndr_pull_lsa_SidPtr(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
1922                         }
1923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
1924                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
1925                 }
1926                 if (r->sids) {
1927                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
1928                 }
1929         }
1930         return NDR_ERR_SUCCESS;
1931 }
1932
1933 _PUBLIC_ void ndr_print_lsa_SidArray(struct ndr_print *ndr, const char *name, const struct lsa_SidArray *r)
1934 {
1935         uint32_t cntr_sids_1;
1936         ndr_print_struct(ndr, name, "lsa_SidArray");
1937         ndr->depth++;
1938         ndr_print_uint32(ndr, "num_sids", r->num_sids);
1939         ndr_print_ptr(ndr, "sids", r->sids);
1940         ndr->depth++;
1941         if (r->sids) {
1942                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
1943                 ndr->depth++;
1944                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
1945                         char *idx_1=NULL;
1946                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
1947                                 ndr_print_lsa_SidPtr(ndr, "sids", &r->sids[cntr_sids_1]);
1948                                 free(idx_1);
1949                         }
1950                 }
1951                 ndr->depth--;
1952         }
1953         ndr->depth--;
1954         ndr->depth--;
1955 }
1956
1957 static enum ndr_err_code ndr_push_lsa_DomainList(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainList *r)
1958 {
1959         uint32_t cntr_domains_1;
1960         if (ndr_flags & NDR_SCALARS) {
1961                 NDR_CHECK(ndr_push_align(ndr, 4));
1962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
1964         }
1965         if (ndr_flags & NDR_BUFFERS) {
1966                 if (r->domains) {
1967                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1968                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1969                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
1970                         }
1971                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1972                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
1973                         }
1974                 }
1975         }
1976         return NDR_ERR_SUCCESS;
1977 }
1978
1979 static enum ndr_err_code ndr_pull_lsa_DomainList(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainList *r)
1980 {
1981         uint32_t _ptr_domains;
1982         uint32_t cntr_domains_1;
1983         TALLOC_CTX *_mem_save_domains_0;
1984         TALLOC_CTX *_mem_save_domains_1;
1985         if (ndr_flags & NDR_SCALARS) {
1986                 NDR_CHECK(ndr_pull_align(ndr, 4));
1987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
1989                 if (_ptr_domains) {
1990                         NDR_PULL_ALLOC(ndr, r->domains);
1991                 } else {
1992                         r->domains = NULL;
1993                 }
1994         }
1995         if (ndr_flags & NDR_BUFFERS) {
1996                 if (r->domains) {
1997                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
1998                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1999                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
2000                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
2001                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
2002                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
2003                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
2004                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
2005                         }
2006                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
2007                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
2008                         }
2009                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
2010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
2011                 }
2012                 if (r->domains) {
2013                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
2014                 }
2015         }
2016         return NDR_ERR_SUCCESS;
2017 }
2018
2019 _PUBLIC_ void ndr_print_lsa_DomainList(struct ndr_print *ndr, const char *name, const struct lsa_DomainList *r)
2020 {
2021         uint32_t cntr_domains_1;
2022         ndr_print_struct(ndr, name, "lsa_DomainList");
2023         ndr->depth++;
2024         ndr_print_uint32(ndr, "count", r->count);
2025         ndr_print_ptr(ndr, "domains", r->domains);
2026         ndr->depth++;
2027         if (r->domains) {
2028                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", (int)r->count);
2029                 ndr->depth++;
2030                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
2031                         char *idx_1=NULL;
2032                         if (asprintf(&idx_1, "[%d]", cntr_domains_1) != -1) {
2033                                 ndr_print_lsa_DomainInfo(ndr, "domains", &r->domains[cntr_domains_1]);
2034                                 free(idx_1);
2035                         }
2036                 }
2037                 ndr->depth--;
2038         }
2039         ndr->depth--;
2040         ndr->depth--;
2041 }
2042
2043 _PUBLIC_ enum ndr_err_code ndr_push_lsa_SidType(struct ndr_push *ndr, int ndr_flags, enum lsa_SidType r)
2044 {
2045         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
2046         return NDR_ERR_SUCCESS;
2047 }
2048
2049 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_SidType(struct ndr_pull *ndr, int ndr_flags, enum lsa_SidType *r)
2050 {
2051         uint16_t v;
2052         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
2053         *r = v;
2054         return NDR_ERR_SUCCESS;
2055 }
2056
2057 _PUBLIC_ void ndr_print_lsa_SidType(struct ndr_print *ndr, const char *name, enum lsa_SidType r)
2058 {
2059         const char *val = NULL;
2060
2061         switch (r) {
2062                 case SID_NAME_USE_NONE: val = "SID_NAME_USE_NONE"; break;
2063                 case SID_NAME_USER: val = "SID_NAME_USER"; break;
2064                 case SID_NAME_DOM_GRP: val = "SID_NAME_DOM_GRP"; break;
2065                 case SID_NAME_DOMAIN: val = "SID_NAME_DOMAIN"; break;
2066                 case SID_NAME_ALIAS: val = "SID_NAME_ALIAS"; break;
2067                 case SID_NAME_WKN_GRP: val = "SID_NAME_WKN_GRP"; break;
2068                 case SID_NAME_DELETED: val = "SID_NAME_DELETED"; break;
2069                 case SID_NAME_INVALID: val = "SID_NAME_INVALID"; break;
2070                 case SID_NAME_UNKNOWN: val = "SID_NAME_UNKNOWN"; break;
2071                 case SID_NAME_COMPUTER: val = "SID_NAME_COMPUTER"; break;
2072         }
2073         ndr_print_enum(ndr, name, "ENUM", val, r);
2074 }
2075
2076 static enum ndr_err_code ndr_push_lsa_TranslatedSid(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid *r)
2077 {
2078         if (ndr_flags & NDR_SCALARS) {
2079                 NDR_CHECK(ndr_push_align(ndr, 4));
2080                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
2081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
2082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
2083         }
2084         if (ndr_flags & NDR_BUFFERS) {
2085         }
2086         return NDR_ERR_SUCCESS;
2087 }
2088
2089 static enum ndr_err_code ndr_pull_lsa_TranslatedSid(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid *r)
2090 {
2091         if (ndr_flags & NDR_SCALARS) {
2092                 NDR_CHECK(ndr_pull_align(ndr, 4));
2093                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
2094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
2095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
2096         }
2097         if (ndr_flags & NDR_BUFFERS) {
2098         }
2099         return NDR_ERR_SUCCESS;
2100 }
2101
2102 _PUBLIC_ void ndr_print_lsa_TranslatedSid(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid *r)
2103 {
2104         ndr_print_struct(ndr, name, "lsa_TranslatedSid");
2105         ndr->depth++;
2106         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
2107         ndr_print_uint32(ndr, "rid", r->rid);
2108         ndr_print_uint32(ndr, "sid_index", r->sid_index);
2109         ndr->depth--;
2110 }
2111
2112 static enum ndr_err_code ndr_push_lsa_TransSidArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray *r)
2113 {
2114         uint32_t cntr_sids_1;
2115         if (ndr_flags & NDR_SCALARS) {
2116                 NDR_CHECK(ndr_push_align(ndr, 4));
2117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
2119         }
2120         if (ndr_flags & NDR_BUFFERS) {
2121                 if (r->sids) {
2122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2123                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
2124                                 NDR_CHECK(ndr_push_lsa_TranslatedSid(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
2125                         }
2126                 }
2127         }
2128         return NDR_ERR_SUCCESS;
2129 }
2130
2131 static enum ndr_err_code ndr_pull_lsa_TransSidArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray *r)
2132 {
2133         uint32_t _ptr_sids;
2134         uint32_t cntr_sids_1;
2135         TALLOC_CTX *_mem_save_sids_0;
2136         TALLOC_CTX *_mem_save_sids_1;
2137         if (ndr_flags & NDR_SCALARS) {
2138                 NDR_CHECK(ndr_pull_align(ndr, 4));
2139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2140                 if (r->count > 1000) {
2141                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2142                 }
2143                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
2144                 if (_ptr_sids) {
2145                         NDR_PULL_ALLOC(ndr, r->sids);
2146                 } else {
2147                         r->sids = NULL;
2148                 }
2149         }
2150         if (ndr_flags & NDR_BUFFERS) {
2151                 if (r->sids) {
2152                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
2153                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
2154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
2155                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
2156                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
2157                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
2158                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
2159                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
2160                         }
2161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
2162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
2163                 }
2164                 if (r->sids) {
2165                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
2166                 }
2167         }
2168         return NDR_ERR_SUCCESS;
2169 }
2170
2171 _PUBLIC_ void ndr_print_lsa_TransSidArray(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray *r)
2172 {
2173         uint32_t cntr_sids_1;
2174         ndr_print_struct(ndr, name, "lsa_TransSidArray");
2175         ndr->depth++;
2176         ndr_print_uint32(ndr, "count", r->count);
2177         ndr_print_ptr(ndr, "sids", r->sids);
2178         ndr->depth++;
2179         if (r->sids) {
2180                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->count);
2181                 ndr->depth++;
2182                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
2183                         char *idx_1=NULL;
2184                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
2185                                 ndr_print_lsa_TranslatedSid(ndr, "sids", &r->sids[cntr_sids_1]);
2186                                 free(idx_1);
2187                         }
2188                 }
2189                 ndr->depth--;
2190         }
2191         ndr->depth--;
2192         ndr->depth--;
2193 }
2194
2195 static enum ndr_err_code ndr_push_lsa_RefDomainList(struct ndr_push *ndr, int ndr_flags, const struct lsa_RefDomainList *r)
2196 {
2197         uint32_t cntr_domains_1;
2198         if (ndr_flags & NDR_SCALARS) {
2199                 NDR_CHECK(ndr_push_align(ndr, 4));
2200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2201                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
2202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_size));
2203         }
2204         if (ndr_flags & NDR_BUFFERS) {
2205                 if (r->domains) {
2206                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2207                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
2208                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
2209                         }
2210                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
2211                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
2212                         }
2213                 }
2214         }
2215         return NDR_ERR_SUCCESS;
2216 }
2217
2218 static enum ndr_err_code ndr_pull_lsa_RefDomainList(struct ndr_pull *ndr, int ndr_flags, struct lsa_RefDomainList *r)
2219 {
2220         uint32_t _ptr_domains;
2221         uint32_t cntr_domains_1;
2222         TALLOC_CTX *_mem_save_domains_0;
2223         TALLOC_CTX *_mem_save_domains_1;
2224         if (ndr_flags & NDR_SCALARS) {
2225                 NDR_CHECK(ndr_pull_align(ndr, 4));
2226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2227                 if (r->count > 1000) {
2228                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2229                 }
2230                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
2231                 if (_ptr_domains) {
2232                         NDR_PULL_ALLOC(ndr, r->domains);
2233                 } else {
2234                         r->domains = NULL;
2235                 }
2236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_size));
2237         }
2238         if (ndr_flags & NDR_BUFFERS) {
2239                 if (r->domains) {
2240                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
2241                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
2242                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
2243                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
2244                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
2245                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
2246                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
2247                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
2248                         }
2249                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
2250                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
2251                         }
2252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
2253                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
2254                 }
2255                 if (r->domains) {
2256                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
2257                 }
2258         }
2259         return NDR_ERR_SUCCESS;
2260 }
2261
2262 _PUBLIC_ void ndr_print_lsa_RefDomainList(struct ndr_print *ndr, const char *name, const struct lsa_RefDomainList *r)
2263 {
2264         uint32_t cntr_domains_1;
2265         ndr_print_struct(ndr, name, "lsa_RefDomainList");
2266         ndr->depth++;
2267         ndr_print_uint32(ndr, "count", r->count);
2268         ndr_print_ptr(ndr, "domains", r->domains);
2269         ndr->depth++;
2270         if (r->domains) {
2271                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", (int)r->count);
2272                 ndr->depth++;
2273                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
2274                         char *idx_1=NULL;
2275                         if (asprintf(&idx_1, "[%d]", cntr_domains_1) != -1) {
2276                                 ndr_print_lsa_DomainInfo(ndr, "domains", &r->domains[cntr_domains_1]);
2277                                 free(idx_1);
2278                         }
2279                 }
2280                 ndr->depth--;
2281         }
2282         ndr->depth--;
2283         ndr_print_uint32(ndr, "max_size", r->max_size);
2284         ndr->depth--;
2285 }
2286
2287 static enum ndr_err_code ndr_push_lsa_LookupNamesLevel(struct ndr_push *ndr, int ndr_flags, enum lsa_LookupNamesLevel r)
2288 {
2289         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
2290         return NDR_ERR_SUCCESS;
2291 }
2292
2293 static enum ndr_err_code ndr_pull_lsa_LookupNamesLevel(struct ndr_pull *ndr, int ndr_flags, enum lsa_LookupNamesLevel *r)
2294 {
2295         uint16_t v;
2296         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
2297         *r = v;
2298         return NDR_ERR_SUCCESS;
2299 }
2300
2301 _PUBLIC_ void ndr_print_lsa_LookupNamesLevel(struct ndr_print *ndr, const char *name, enum lsa_LookupNamesLevel r)
2302 {
2303         const char *val = NULL;
2304
2305         switch (r) {
2306                 case LSA_LOOKUP_NAMES_ALL: val = "LSA_LOOKUP_NAMES_ALL"; break;
2307                 case LSA_LOOKUP_NAMES_DOMAINS_ONLY: val = "LSA_LOOKUP_NAMES_DOMAINS_ONLY"; break;
2308                 case LSA_LOOKUP_NAMES_PRIMARY_DOMAIN_ONLY: val = "LSA_LOOKUP_NAMES_PRIMARY_DOMAIN_ONLY"; break;
2309                 case LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY: val = "LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY"; break;
2310                 case LSA_LOOKUP_NAMES_FOREST_TRUSTS_ONLY: val = "LSA_LOOKUP_NAMES_FOREST_TRUSTS_ONLY"; break;
2311                 case LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY2: val = "LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY2"; break;
2312                 case LSA_LOOKUP_NAMES_RODC_REFERRAL_TO_FULL_DC: val = "LSA_LOOKUP_NAMES_RODC_REFERRAL_TO_FULL_DC"; break;
2313         }
2314         ndr_print_enum(ndr, name, "ENUM", val, r);
2315 }
2316
2317 static enum ndr_err_code ndr_push_lsa_TranslatedName(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedName *r)
2318 {
2319         if (ndr_flags & NDR_SCALARS) {
2320                 NDR_CHECK(ndr_push_align(ndr, 4));
2321                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
2322                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
2323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
2324         }
2325         if (ndr_flags & NDR_BUFFERS) {
2326                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
2327         }
2328         return NDR_ERR_SUCCESS;
2329 }
2330
2331 static enum ndr_err_code ndr_pull_lsa_TranslatedName(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedName *r)
2332 {
2333         if (ndr_flags & NDR_SCALARS) {
2334                 NDR_CHECK(ndr_pull_align(ndr, 4));
2335                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
2336                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
2337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
2338         }
2339         if (ndr_flags & NDR_BUFFERS) {
2340                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
2341         }
2342         return NDR_ERR_SUCCESS;
2343 }
2344
2345 _PUBLIC_ void ndr_print_lsa_TranslatedName(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedName *r)
2346 {
2347         ndr_print_struct(ndr, name, "lsa_TranslatedName");
2348         ndr->depth++;
2349         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
2350         ndr_print_lsa_String(ndr, "name", &r->name);
2351         ndr_print_uint32(ndr, "sid_index", r->sid_index);
2352         ndr->depth--;
2353 }
2354
2355 static enum ndr_err_code ndr_push_lsa_TransNameArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransNameArray *r)
2356 {
2357         uint32_t cntr_names_1;
2358         if (ndr_flags & NDR_SCALARS) {
2359                 NDR_CHECK(ndr_push_align(ndr, 4));
2360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
2362         }
2363         if (ndr_flags & NDR_BUFFERS) {
2364                 if (r->names) {
2365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2366                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2367                                 NDR_CHECK(ndr_push_lsa_TranslatedName(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
2368                         }
2369                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2370                                 NDR_CHECK(ndr_push_lsa_TranslatedName(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
2371                         }
2372                 }
2373         }
2374         return NDR_ERR_SUCCESS;
2375 }
2376
2377 static enum ndr_err_code ndr_pull_lsa_TransNameArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransNameArray *r)
2378 {
2379         uint32_t _ptr_names;
2380         uint32_t cntr_names_1;
2381         TALLOC_CTX *_mem_save_names_0;
2382         TALLOC_CTX *_mem_save_names_1;
2383         if (ndr_flags & NDR_SCALARS) {
2384                 NDR_CHECK(ndr_pull_align(ndr, 4));
2385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2386                 if (r->count > 1000) {
2387                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2388                 }
2389                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
2390                 if (_ptr_names) {
2391                         NDR_PULL_ALLOC(ndr, r->names);
2392                 } else {
2393                         r->names = NULL;
2394                 }
2395         }
2396         if (ndr_flags & NDR_BUFFERS) {
2397                 if (r->names) {
2398                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
2399                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
2400                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
2401                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
2402                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
2403                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
2404                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2405                                 NDR_CHECK(ndr_pull_lsa_TranslatedName(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
2406                         }
2407                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2408                                 NDR_CHECK(ndr_pull_lsa_TranslatedName(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
2409                         }
2410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
2411                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
2412                 }
2413                 if (r->names) {
2414                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
2415                 }
2416         }
2417         return NDR_ERR_SUCCESS;
2418 }
2419
2420 _PUBLIC_ void ndr_print_lsa_TransNameArray(struct ndr_print *ndr, const char *name, const struct lsa_TransNameArray *r)
2421 {
2422         uint32_t cntr_names_1;
2423         ndr_print_struct(ndr, name, "lsa_TransNameArray");
2424         ndr->depth++;
2425         ndr_print_uint32(ndr, "count", r->count);
2426         ndr_print_ptr(ndr, "names", r->names);
2427         ndr->depth++;
2428         if (r->names) {
2429                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
2430                 ndr->depth++;
2431                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
2432                         char *idx_1=NULL;
2433                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
2434                                 ndr_print_lsa_TranslatedName(ndr, "names", &r->names[cntr_names_1]);
2435                                 free(idx_1);
2436                         }
2437                 }
2438                 ndr->depth--;
2439         }
2440         ndr->depth--;
2441         ndr->depth--;
2442 }
2443
2444 static enum ndr_err_code ndr_push_lsa_LUIDAttribute(struct ndr_push *ndr, int ndr_flags, const struct lsa_LUIDAttribute *r)
2445 {
2446         if (ndr_flags & NDR_SCALARS) {
2447                 NDR_CHECK(ndr_push_align(ndr, 4));
2448                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
2449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attribute));
2450         }
2451         if (ndr_flags & NDR_BUFFERS) {
2452         }
2453         return NDR_ERR_SUCCESS;
2454 }
2455
2456 static enum ndr_err_code ndr_pull_lsa_LUIDAttribute(struct ndr_pull *ndr, int ndr_flags, struct lsa_LUIDAttribute *r)
2457 {
2458         if (ndr_flags & NDR_SCALARS) {
2459                 NDR_CHECK(ndr_pull_align(ndr, 4));
2460                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
2461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attribute));
2462         }
2463         if (ndr_flags & NDR_BUFFERS) {
2464         }
2465         return NDR_ERR_SUCCESS;
2466 }
2467
2468 _PUBLIC_ void ndr_print_lsa_LUIDAttribute(struct ndr_print *ndr, const char *name, const struct lsa_LUIDAttribute *r)
2469 {
2470         ndr_print_struct(ndr, name, "lsa_LUIDAttribute");
2471         ndr->depth++;
2472         ndr_print_lsa_LUID(ndr, "luid", &r->luid);
2473         ndr_print_uint32(ndr, "attribute", r->attribute);
2474         ndr->depth--;
2475 }
2476
2477 static enum ndr_err_code ndr_push_lsa_PrivilegeSet(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivilegeSet *r)
2478 {
2479         uint32_t cntr_set_0;
2480         if (ndr_flags & NDR_SCALARS) {
2481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2482                 NDR_CHECK(ndr_push_align(ndr, 4));
2483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
2485                 for (cntr_set_0 = 0; cntr_set_0 < r->count; cntr_set_0++) {
2486                         NDR_CHECK(ndr_push_lsa_LUIDAttribute(ndr, NDR_SCALARS, &r->set[cntr_set_0]));
2487                 }
2488         }
2489         if (ndr_flags & NDR_BUFFERS) {
2490         }
2491         return NDR_ERR_SUCCESS;
2492 }
2493
2494 static enum ndr_err_code ndr_pull_lsa_PrivilegeSet(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivilegeSet *r)
2495 {
2496         uint32_t cntr_set_0;
2497         TALLOC_CTX *_mem_save_set_0;
2498         if (ndr_flags & NDR_SCALARS) {
2499                 NDR_CHECK(ndr_pull_array_size(ndr, &r->set));
2500                 NDR_CHECK(ndr_pull_align(ndr, 4));
2501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2502                 if (r->count > 1000) {
2503                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2504                 }
2505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
2506                 NDR_PULL_ALLOC_N(ndr, r->set, ndr_get_array_size(ndr, &r->set));
2507                 _mem_save_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
2508                 NDR_PULL_SET_MEM_CTX(ndr, r->set, 0);
2509                 for (cntr_set_0 = 0; cntr_set_0 < r->count; cntr_set_0++) {
2510                         NDR_CHECK(ndr_pull_lsa_LUIDAttribute(ndr, NDR_SCALARS, &r->set[cntr_set_0]));
2511                 }
2512                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_set_0, 0);
2513                 if (r->set) {
2514                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->set, r->count));
2515                 }
2516         }
2517         if (ndr_flags & NDR_BUFFERS) {
2518         }
2519         return NDR_ERR_SUCCESS;
2520 }
2521
2522 _PUBLIC_ void ndr_print_lsa_PrivilegeSet(struct ndr_print *ndr, const char *name, const struct lsa_PrivilegeSet *r)
2523 {
2524         uint32_t cntr_set_0;
2525         ndr_print_struct(ndr, name, "lsa_PrivilegeSet");
2526         ndr->depth++;
2527         ndr_print_uint32(ndr, "count", r->count);
2528         ndr_print_uint32(ndr, "unknown", r->unknown);
2529         ndr->print(ndr, "%s: ARRAY(%d)", "set", (int)r->count);
2530         ndr->depth++;
2531         for (cntr_set_0=0;cntr_set_0<r->count;cntr_set_0++) {
2532                 char *idx_0=NULL;
2533                 if (asprintf(&idx_0, "[%d]", cntr_set_0) != -1) {
2534                         ndr_print_lsa_LUIDAttribute(ndr, "set", &r->set[cntr_set_0]);
2535                         free(idx_0);
2536                 }
2537         }
2538         ndr->depth--;
2539         ndr->depth--;
2540 }
2541
2542 static enum ndr_err_code ndr_push_lsa_DATA_BUF(struct ndr_push *ndr, int ndr_flags, const struct lsa_DATA_BUF *r)
2543 {
2544         {
2545                 uint32_t _flags_save_STRUCT = ndr->flags;
2546                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2547                 if (ndr_flags & NDR_SCALARS) {
2548                         NDR_CHECK(ndr_push_align(ndr, 4));
2549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
2550                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2551                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
2552                 }
2553                 if (ndr_flags & NDR_BUFFERS) {
2554                         if (r->data) {
2555                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2556                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2557                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
2558                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
2559                         }
2560                 }
2561                 ndr->flags = _flags_save_STRUCT;
2562         }
2563         return NDR_ERR_SUCCESS;
2564 }
2565
2566 static enum ndr_err_code ndr_pull_lsa_DATA_BUF(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF *r)
2567 {
2568         uint32_t _ptr_data;
2569         TALLOC_CTX *_mem_save_data_0;
2570         {
2571                 uint32_t _flags_save_STRUCT = ndr->flags;
2572                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2573                 if (ndr_flags & NDR_SCALARS) {
2574                         NDR_CHECK(ndr_pull_align(ndr, 4));
2575                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
2576                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2577                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2578                         if (_ptr_data) {
2579                                 NDR_PULL_ALLOC(ndr, r->data);
2580                         } else {
2581                                 r->data = NULL;
2582                         }
2583                 }
2584                 if (ndr_flags & NDR_BUFFERS) {
2585                         if (r->data) {
2586                                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2587                                 NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
2588                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
2589                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->data));
2590                                 if (ndr_get_array_length(ndr, &r->data) > ndr_get_array_size(ndr, &r->data)) {
2591                                         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));
2592                                 }
2593                                 NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
2594                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_length(ndr, &r->data)));
2595                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2596                         }
2597                         if (r->data) {
2598                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
2599                         }
2600                         if (r->data) {
2601                                 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->data, r->length));
2602                         }
2603                 }
2604                 ndr->flags = _flags_save_STRUCT;
2605         }
2606         return NDR_ERR_SUCCESS;
2607 }
2608
2609 _PUBLIC_ void ndr_print_lsa_DATA_BUF(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF *r)
2610 {
2611         ndr_print_struct(ndr, name, "lsa_DATA_BUF");
2612         {
2613                 uint32_t _flags_save_STRUCT = ndr->flags;
2614                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2615                 ndr->depth++;
2616                 ndr_print_uint32(ndr, "length", r->length);
2617                 ndr_print_uint32(ndr, "size", r->size);
2618                 ndr_print_ptr(ndr, "data", r->data);
2619                 ndr->depth++;
2620                 if (r->data) {
2621                         ndr_print_array_uint8(ndr, "data", r->data, r->length);
2622                 }
2623                 ndr->depth--;
2624                 ndr->depth--;
2625                 ndr->flags = _flags_save_STRUCT;
2626         }
2627 }
2628
2629 static enum ndr_err_code ndr_push_lsa_DATA_BUF2(struct ndr_push *ndr, int ndr_flags, const struct lsa_DATA_BUF2 *r)
2630 {
2631         {
2632                 uint32_t _flags_save_STRUCT = ndr->flags;
2633                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2634                 if (ndr_flags & NDR_SCALARS) {
2635                         NDR_CHECK(ndr_push_align(ndr, 4));
2636                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2637                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
2638                 }
2639                 if (ndr_flags & NDR_BUFFERS) {
2640                         if (r->data) {
2641                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2642                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
2643                         }
2644                 }
2645                 ndr->flags = _flags_save_STRUCT;
2646         }
2647         return NDR_ERR_SUCCESS;
2648 }
2649
2650 static enum ndr_err_code ndr_pull_lsa_DATA_BUF2(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF2 *r)
2651 {
2652         uint32_t _ptr_data;
2653         TALLOC_CTX *_mem_save_data_0;
2654         {
2655                 uint32_t _flags_save_STRUCT = ndr->flags;
2656                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2657                 if (ndr_flags & NDR_SCALARS) {
2658                         NDR_CHECK(ndr_pull_align(ndr, 4));
2659                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2660                         if (r->size > 65536) {
2661                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2662                         }
2663                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2664                         if (_ptr_data) {
2665                                 NDR_PULL_ALLOC(ndr, r->data);
2666                         } else {
2667                                 r->data = NULL;
2668                         }
2669                 }
2670                 if (ndr_flags & NDR_BUFFERS) {
2671                         if (r->data) {
2672                                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2673                                 NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
2674                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
2675                                 NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
2676                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
2677                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2678                         }
2679                         if (r->data) {
2680                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
2681                         }
2682                 }
2683                 ndr->flags = _flags_save_STRUCT;
2684         }
2685         return NDR_ERR_SUCCESS;
2686 }
2687
2688 _PUBLIC_ void ndr_print_lsa_DATA_BUF2(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF2 *r)
2689 {
2690         ndr_print_struct(ndr, name, "lsa_DATA_BUF2");
2691         {
2692                 uint32_t _flags_save_STRUCT = ndr->flags;
2693                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2694                 ndr->depth++;
2695                 ndr_print_uint32(ndr, "size", r->size);
2696                 ndr_print_ptr(ndr, "data", r->data);
2697                 ndr->depth++;
2698                 if (r->data) {
2699                         ndr_print_array_uint8(ndr, "data", r->data, r->size);
2700                 }
2701                 ndr->depth--;
2702                 ndr->depth--;
2703                 ndr->flags = _flags_save_STRUCT;
2704         }
2705 }
2706
2707 static enum ndr_err_code ndr_push_lsa_TrustDomInfoEnum(struct ndr_push *ndr, int ndr_flags, enum lsa_TrustDomInfoEnum r)
2708 {
2709         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
2710         return NDR_ERR_SUCCESS;
2711 }
2712
2713 static enum ndr_err_code ndr_pull_lsa_TrustDomInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum lsa_TrustDomInfoEnum *r)
2714 {
2715         uint16_t v;
2716         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
2717         *r = v;
2718         return NDR_ERR_SUCCESS;
2719 }
2720
2721 _PUBLIC_ void ndr_print_lsa_TrustDomInfoEnum(struct ndr_print *ndr, const char *name, enum lsa_TrustDomInfoEnum r)
2722 {
2723         const char *val = NULL;
2724
2725         switch (r) {
2726                 case LSA_TRUSTED_DOMAIN_INFO_NAME: val = "LSA_TRUSTED_DOMAIN_INFO_NAME"; break;
2727                 case LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS: val = "LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS"; break;
2728                 case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET: val = "LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET"; break;
2729                 case LSA_TRUSTED_DOMAIN_INFO_PASSWORD: val = "LSA_TRUSTED_DOMAIN_INFO_PASSWORD"; break;
2730                 case LSA_TRUSTED_DOMAIN_INFO_BASIC: val = "LSA_TRUSTED_DOMAIN_INFO_BASIC"; break;
2731                 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX: val = "LSA_TRUSTED_DOMAIN_INFO_INFO_EX"; break;
2732                 case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO: val = "LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO"; break;
2733                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO: val = "LSA_TRUSTED_DOMAIN_INFO_FULL_INFO"; break;
2734                 case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO_INTERNAL: val = "LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO_INTERNAL"; break;
2735                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_INTERNAL: val = "LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_INTERNAL"; break;
2736                 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX2_INTERNAL: val = "LSA_TRUSTED_DOMAIN_INFO_INFO_EX2_INTERNAL"; break;
2737                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_2_INTERNAL: val = "LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_2_INTERNAL"; break;
2738                 case LSA_TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES: val = "LSA_TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES"; break;
2739         }
2740         ndr_print_enum(ndr, name, "ENUM", val, r);
2741 }
2742
2743 _PUBLIC_ enum ndr_err_code ndr_push_lsa_TrustDirection(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2744 {
2745         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2746         return NDR_ERR_SUCCESS;
2747 }
2748
2749 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_TrustDirection(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2750 {
2751         uint32_t v;
2752         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2753         *r = v;
2754         return NDR_ERR_SUCCESS;
2755 }
2756
2757 _PUBLIC_ void ndr_print_lsa_TrustDirection(struct ndr_print *ndr, const char *name, uint32_t r)
2758 {
2759         ndr_print_uint32(ndr, name, r);
2760         ndr->depth++;
2761         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUST_DIRECTION_INBOUND", LSA_TRUST_DIRECTION_INBOUND, r);
2762         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUST_DIRECTION_OUTBOUND", LSA_TRUST_DIRECTION_OUTBOUND, r);
2763         ndr->depth--;
2764 }
2765
2766 static enum ndr_err_code ndr_push_lsa_TrustType(struct ndr_push *ndr, int ndr_flags, enum lsa_TrustType r)
2767 {
2768         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2769         return NDR_ERR_SUCCESS;
2770 }
2771
2772 static enum ndr_err_code ndr_pull_lsa_TrustType(struct ndr_pull *ndr, int ndr_flags, enum lsa_TrustType *r)
2773 {
2774         uint32_t v;
2775         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2776         *r = v;
2777         return NDR_ERR_SUCCESS;
2778 }
2779
2780 _PUBLIC_ void ndr_print_lsa_TrustType(struct ndr_print *ndr, const char *name, enum lsa_TrustType r)
2781 {
2782         const char *val = NULL;
2783
2784         switch (r) {
2785                 case LSA_TRUST_TYPE_DOWNLEVEL: val = "LSA_TRUST_TYPE_DOWNLEVEL"; break;
2786                 case LSA_TRUST_TYPE_UPLEVEL: val = "LSA_TRUST_TYPE_UPLEVEL"; break;
2787                 case LSA_TRUST_TYPE_MIT: val = "LSA_TRUST_TYPE_MIT"; break;
2788         }
2789         ndr_print_enum(ndr, name, "ENUM", val, r);
2790 }
2791
2792 _PUBLIC_ enum ndr_err_code ndr_push_lsa_TrustAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2793 {
2794         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2795         return NDR_ERR_SUCCESS;
2796 }
2797
2798 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_TrustAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2799 {
2800         uint32_t v;
2801         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2802         *r = v;
2803         return NDR_ERR_SUCCESS;
2804 }
2805
2806 _PUBLIC_ void ndr_print_lsa_TrustAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
2807 {
2808         ndr_print_uint32(ndr, name, r);
2809         ndr->depth++;
2810         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUST_ATTRIBUTE_NON_TRANSITIVE", LSA_TRUST_ATTRIBUTE_NON_TRANSITIVE, r);
2811         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUST_ATTRIBUTE_UPLEVEL_ONLY", LSA_TRUST_ATTRIBUTE_UPLEVEL_ONLY, r);
2812         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUST_ATTRIBUTE_QUARANTINED_DOMAIN", LSA_TRUST_ATTRIBUTE_QUARANTINED_DOMAIN, r);
2813         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUST_ATTRIBUTE_FOREST_TRANSITIVE", LSA_TRUST_ATTRIBUTE_FOREST_TRANSITIVE, r);
2814         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUST_ATTRIBUTE_CROSS_ORGANIZATION", LSA_TRUST_ATTRIBUTE_CROSS_ORGANIZATION, r);
2815         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUST_ATTRIBUTE_WITHIN_FOREST", LSA_TRUST_ATTRIBUTE_WITHIN_FOREST, r);
2816         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUST_ATTRIBUTE_TREAT_AS_EXTERNAL", LSA_TRUST_ATTRIBUTE_TREAT_AS_EXTERNAL, r);
2817         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "LSA_TRUST_ATTRIBUTE_USES_RC4_ENCRYPTION", LSA_TRUST_ATTRIBUTE_USES_RC4_ENCRYPTION, r);
2818         ndr->depth--;
2819 }
2820
2821 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoName(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoName *r)
2822 {
2823         if (ndr_flags & NDR_SCALARS) {
2824                 NDR_CHECK(ndr_push_align(ndr, 4));
2825                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2826         }
2827         if (ndr_flags & NDR_BUFFERS) {
2828                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2829         }
2830         return NDR_ERR_SUCCESS;
2831 }
2832
2833 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoName(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoName *r)
2834 {
2835         if (ndr_flags & NDR_SCALARS) {
2836                 NDR_CHECK(ndr_pull_align(ndr, 4));
2837                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2838         }
2839         if (ndr_flags & NDR_BUFFERS) {
2840                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2841         }
2842         return NDR_ERR_SUCCESS;
2843 }
2844
2845 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoName(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoName *r)
2846 {
2847         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoName");
2848         ndr->depth++;
2849         ndr_print_lsa_StringLarge(ndr, "netbios_name", &r->netbios_name);
2850         ndr->depth--;
2851 }
2852
2853 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoControllers(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoControllers *r)
2854 {
2855         uint32_t cntr_netbios_names_1;
2856         if (ndr_flags & NDR_SCALARS) {
2857                 NDR_CHECK(ndr_push_align(ndr, 4));
2858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries));
2859                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_names));
2860         }
2861         if (ndr_flags & NDR_BUFFERS) {
2862                 if (r->netbios_names) {
2863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->entries));
2864                         for (cntr_netbios_names_1 = 0; cntr_netbios_names_1 < r->entries; cntr_netbios_names_1++) {
2865                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_names[cntr_netbios_names_1]));
2866                         }
2867                         for (cntr_netbios_names_1 = 0; cntr_netbios_names_1 < r->entries; cntr_netbios_names_1++) {
2868                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_names[cntr_netbios_names_1]));
2869                         }
2870                 }
2871         }
2872         return NDR_ERR_SUCCESS;
2873 }
2874
2875 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoControllers(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoControllers *r)
2876 {
2877         uint32_t _ptr_netbios_names;
2878         uint32_t cntr_netbios_names_1;
2879         TALLOC_CTX *_mem_save_netbios_names_0;
2880         TALLOC_CTX *_mem_save_netbios_names_1;
2881         if (ndr_flags & NDR_SCALARS) {
2882                 NDR_CHECK(ndr_pull_align(ndr, 4));
2883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->entries));
2884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_names));
2885                 if (_ptr_netbios_names) {
2886                         NDR_PULL_ALLOC(ndr, r->netbios_names);
2887                 } else {
2888                         r->netbios_names = NULL;
2889                 }
2890         }
2891         if (ndr_flags & NDR_BUFFERS) {
2892                 if (r->netbios_names) {
2893                         _mem_save_netbios_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
2894                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_names, 0);
2895                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_names));
2896                         NDR_PULL_ALLOC_N(ndr, r->netbios_names, ndr_get_array_size(ndr, &r->netbios_names));
2897                         _mem_save_netbios_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
2898                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_names, 0);
2899                         for (cntr_netbios_names_1 = 0; cntr_netbios_names_1 < r->entries; cntr_netbios_names_1++) {
2900                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_names[cntr_netbios_names_1]));
2901                         }
2902                         for (cntr_netbios_names_1 = 0; cntr_netbios_names_1 < r->entries; cntr_netbios_names_1++) {
2903                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_names[cntr_netbios_names_1]));
2904                         }
2905                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_names_1, 0);
2906                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_names_0, 0);
2907                 }
2908                 if (r->netbios_names) {
2909                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->netbios_names, r->entries));
2910                 }
2911         }
2912         return NDR_ERR_SUCCESS;
2913 }
2914
2915 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoControllers(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoControllers *r)
2916 {
2917         uint32_t cntr_netbios_names_1;
2918         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoControllers");
2919         ndr->depth++;
2920         ndr_print_uint32(ndr, "entries", r->entries);
2921         ndr_print_ptr(ndr, "netbios_names", r->netbios_names);
2922         ndr->depth++;
2923         if (r->netbios_names) {
2924                 ndr->print(ndr, "%s: ARRAY(%d)", "netbios_names", (int)r->entries);
2925                 ndr->depth++;
2926                 for (cntr_netbios_names_1=0;cntr_netbios_names_1<r->entries;cntr_netbios_names_1++) {
2927                         char *idx_1=NULL;
2928                         if (asprintf(&idx_1, "[%d]", cntr_netbios_names_1) != -1) {
2929                                 ndr_print_lsa_StringLarge(ndr, "netbios_names", &r->netbios_names[cntr_netbios_names_1]);
2930                                 free(idx_1);
2931                         }
2932                 }
2933                 ndr->depth--;
2934         }
2935         ndr->depth--;
2936         ndr->depth--;
2937 }
2938
2939 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoPosixOffset(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoPosixOffset *r)
2940 {
2941         if (ndr_flags & NDR_SCALARS) {
2942                 NDR_CHECK(ndr_push_align(ndr, 4));
2943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->posix_offset));
2944         }
2945         if (ndr_flags & NDR_BUFFERS) {
2946         }
2947         return NDR_ERR_SUCCESS;
2948 }
2949
2950 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoPosixOffset(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoPosixOffset *r)
2951 {
2952         if (ndr_flags & NDR_SCALARS) {
2953                 NDR_CHECK(ndr_pull_align(ndr, 4));
2954                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->posix_offset));
2955         }
2956         if (ndr_flags & NDR_BUFFERS) {
2957         }
2958         return NDR_ERR_SUCCESS;
2959 }
2960
2961 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoPosixOffset(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoPosixOffset *r)
2962 {
2963         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoPosixOffset");
2964         ndr->depth++;
2965         ndr_print_uint32(ndr, "posix_offset", r->posix_offset);
2966         ndr->depth--;
2967 }
2968
2969 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoPassword(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoPassword *r)
2970 {
2971         if (ndr_flags & NDR_SCALARS) {
2972                 NDR_CHECK(ndr_push_align(ndr, 4));
2973                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
2974                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->old_password));
2975         }
2976         if (ndr_flags & NDR_BUFFERS) {
2977                 if (r->password) {
2978                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->password));
2979                 }
2980                 if (r->old_password) {
2981                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->old_password));
2982                 }
2983         }
2984         return NDR_ERR_SUCCESS;
2985 }
2986
2987 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoPassword(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoPassword *r)
2988 {
2989         uint32_t _ptr_password;
2990         TALLOC_CTX *_mem_save_password_0;
2991         uint32_t _ptr_old_password;
2992         TALLOC_CTX *_mem_save_old_password_0;
2993         if (ndr_flags & NDR_SCALARS) {
2994                 NDR_CHECK(ndr_pull_align(ndr, 4));
2995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
2996                 if (_ptr_password) {
2997                         NDR_PULL_ALLOC(ndr, r->password);
2998                 } else {
2999                         r->password = NULL;
3000                 }
3001                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_password));
3002                 if (_ptr_old_password) {
3003                         NDR_PULL_ALLOC(ndr, r->old_password);
3004                 } else {
3005                         r->old_password = NULL;
3006                 }
3007         }
3008         if (ndr_flags & NDR_BUFFERS) {
3009                 if (r->password) {
3010                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
3011                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
3012                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->password));
3013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
3014                 }
3015                 if (r->old_password) {
3016                         _mem_save_old_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
3017                         NDR_PULL_SET_MEM_CTX(ndr, r->old_password, 0);
3018                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->old_password));
3019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_password_0, 0);
3020                 }
3021         }
3022         return NDR_ERR_SUCCESS;
3023 }
3024
3025 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoPassword(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoPassword *r)
3026 {
3027         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoPassword");
3028         ndr->depth++;
3029         ndr_print_ptr(ndr, "password", r->password);
3030         ndr->depth++;
3031         if (r->password) {
3032                 ndr_print_lsa_DATA_BUF(ndr, "password", r->password);
3033         }
3034         ndr->depth--;
3035         ndr_print_ptr(ndr, "old_password", r->old_password);
3036         ndr->depth++;
3037         if (r->old_password) {
3038                 ndr_print_lsa_DATA_BUF(ndr, "old_password", r->old_password);
3039         }
3040         ndr->depth--;
3041         ndr->depth--;
3042 }
3043
3044 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoBasic(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoBasic *r)
3045 {
3046         if (ndr_flags & NDR_SCALARS) {
3047                 NDR_CHECK(ndr_push_align(ndr, 4));
3048                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->netbios_name));
3049                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
3050         }
3051         if (ndr_flags & NDR_BUFFERS) {
3052                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->netbios_name));
3053                 if (r->sid) {
3054                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
3055                 }
3056         }
3057         return NDR_ERR_SUCCESS;
3058 }
3059
3060 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoBasic(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoBasic *r)
3061 {
3062         uint32_t _ptr_sid;
3063         TALLOC_CTX *_mem_save_sid_0;
3064         if (ndr_flags & NDR_SCALARS) {
3065                 NDR_CHECK(ndr_pull_align(ndr, 4));
3066                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->netbios_name));
3067                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
3068                 if (_ptr_sid) {
3069                         NDR_PULL_ALLOC(ndr, r->sid);
3070                 } else {
3071                         r->sid = NULL;
3072                 }
3073         }
3074         if (ndr_flags & NDR_BUFFERS) {
3075                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->netbios_name));
3076                 if (r->sid) {
3077                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
3078                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
3079                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
3080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
3081                 }
3082         }
3083         return NDR_ERR_SUCCESS;
3084 }
3085
3086 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoBasic(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoBasic *r)
3087 {
3088         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoBasic");
3089         ndr->depth++;
3090         ndr_print_lsa_String(ndr, "netbios_name", &r->netbios_name);
3091         ndr_print_ptr(ndr, "sid", r->sid);
3092         ndr->depth++;
3093         if (r->sid) {
3094                 ndr_print_dom_sid2(ndr, "sid", r->sid);
3095         }
3096         ndr->depth--;
3097         ndr->depth--;
3098 }
3099
3100 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoInfoEx(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoInfoEx *r)
3101 {
3102         if (ndr_flags & NDR_SCALARS) {
3103                 NDR_CHECK(ndr_push_align(ndr, 4));
3104                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->domain_name));
3105                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
3106                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
3107                 NDR_CHECK(ndr_push_lsa_TrustDirection(ndr, NDR_SCALARS, r->trust_direction));
3108                 NDR_CHECK(ndr_push_lsa_TrustType(ndr, NDR_SCALARS, r->trust_type));
3109                 NDR_CHECK(ndr_push_lsa_TrustAttributes(ndr, NDR_SCALARS, r->trust_attributes));
3110         }
3111         if (ndr_flags & NDR_BUFFERS) {
3112                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domain_name));
3113                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
3114                 if (r->sid) {
3115                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
3116                 }
3117         }
3118         return NDR_ERR_SUCCESS;
3119 }
3120
3121 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoInfoEx(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoInfoEx *r)
3122 {
3123         uint32_t _ptr_sid;
3124         TALLOC_CTX *_mem_save_sid_0;
3125         if (ndr_flags & NDR_SCALARS) {
3126                 NDR_CHECK(ndr_pull_align(ndr, 4));
3127                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->domain_name));
3128                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
3129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
3130                 if (_ptr_sid) {
3131                         NDR_PULL_ALLOC(ndr, r->sid);
3132                 } else {
3133                         r->sid = NULL;
3134                 }
3135                 NDR_CHECK(ndr_pull_lsa_TrustDirection(ndr, NDR_SCALARS, &r->trust_direction));
3136                 NDR_CHECK(ndr_pull_lsa_TrustType(ndr, NDR_SCALARS, &r->trust_type));
3137                 NDR_CHECK(ndr_pull_lsa_TrustAttributes(ndr, NDR_SCALARS, &r->trust_attributes));
3138         }
3139         if (ndr_flags & NDR_BUFFERS) {
3140                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domain_name));
3141                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
3142                 if (r->sid) {
3143                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
3144                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
3145                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
3146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
3147                 }
3148         }
3149         return NDR_ERR_SUCCESS;
3150 }
3151
3152 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoInfoEx(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoInfoEx *r)
3153 {
3154         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoInfoEx");
3155         ndr->depth++;
3156         ndr_print_lsa_StringLarge(ndr, "domain_name", &r->domain_name);
3157         ndr_print_lsa_StringLarge(ndr, "netbios_name", &r->netbios_name);
3158         ndr_print_ptr(ndr, "sid", r->sid);
3159         ndr->depth++;
3160         if (r->sid) {
3161                 ndr_print_dom_sid2(ndr, "sid", r->sid);
3162         }
3163         ndr->depth--;
3164         ndr_print_lsa_TrustDirection(ndr, "trust_direction", r->trust_direction);
3165         ndr_print_lsa_TrustType(ndr, "trust_type", r->trust_type);
3166         ndr_print_lsa_TrustAttributes(ndr, "trust_attributes", r->trust_attributes);
3167         ndr->depth--;
3168 }
3169
3170 _PUBLIC_ enum ndr_err_code ndr_push_lsa_TrustAuthType(struct ndr_push *ndr, int ndr_flags, enum lsa_TrustAuthType r)
3171 {
3172         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3173         return NDR_ERR_SUCCESS;
3174 }
3175
3176 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_TrustAuthType(struct ndr_pull *ndr, int ndr_flags, enum lsa_TrustAuthType *r)
3177 {
3178         uint32_t v;
3179         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3180         *r = v;
3181         return NDR_ERR_SUCCESS;
3182 }
3183
3184 _PUBLIC_ void ndr_print_lsa_TrustAuthType(struct ndr_print *ndr, const char *name, enum lsa_TrustAuthType r)
3185 {
3186         const char *val = NULL;
3187
3188         switch (r) {
3189                 case TRUST_AUTH_TYPE_NONE: val = "TRUST_AUTH_TYPE_NONE"; break;
3190                 case TRUST_AUTH_TYPE_NT4OWF: val = "TRUST_AUTH_TYPE_NT4OWF"; break;
3191                 case TRUST_AUTH_TYPE_CLEAR: val = "TRUST_AUTH_TYPE_CLEAR"; break;
3192                 case TRUST_AUTH_TYPE_VERSION: val = "TRUST_AUTH_TYPE_VERSION"; break;
3193         }
3194         ndr_print_enum(ndr, name, "ENUM", val, r);
3195 }
3196
3197 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoBuffer(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoBuffer *r)
3198 {
3199         if (ndr_flags & NDR_SCALARS) {
3200                 NDR_CHECK(ndr_push_align(ndr, 8));
3201                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_update_time));
3202                 NDR_CHECK(ndr_push_lsa_TrustAuthType(ndr, NDR_SCALARS, r->AuthType));
3203                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data));
3204         }
3205         if (ndr_flags & NDR_BUFFERS) {
3206                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data));
3207         }
3208         return NDR_ERR_SUCCESS;
3209 }
3210
3211 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoBuffer(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoBuffer *r)
3212 {
3213         if (ndr_flags & NDR_SCALARS) {
3214                 NDR_CHECK(ndr_pull_align(ndr, 8));
3215                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_update_time));
3216                 NDR_CHECK(ndr_pull_lsa_TrustAuthType(ndr, NDR_SCALARS, &r->AuthType));
3217                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data));
3218         }
3219         if (ndr_flags & NDR_BUFFERS) {
3220                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data));
3221         }
3222         return NDR_ERR_SUCCESS;
3223 }
3224
3225 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoBuffer(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoBuffer *r)
3226 {
3227         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoBuffer");
3228         ndr->depth++;
3229         ndr_print_NTTIME_hyper(ndr, "last_update_time", r->last_update_time);
3230         ndr_print_lsa_TrustAuthType(ndr, "AuthType", r->AuthType);
3231         ndr_print_lsa_DATA_BUF2(ndr, "data", &r->data);
3232         ndr->depth--;
3233 }
3234
3235 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoAuthInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoAuthInfo *r)
3236 {
3237         if (ndr_flags & NDR_SCALARS) {
3238                 NDR_CHECK(ndr_push_align(ndr, 4));
3239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->incoming_count));
3240                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->incoming_current_auth_info));
3241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->incoming_previous_auth_info));
3242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->outgoing_count));
3243                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->outgoing_current_auth_info));
3244                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->outgoing_previous_auth_info));
3245         }
3246         if (ndr_flags & NDR_BUFFERS) {
3247                 if (r->incoming_current_auth_info) {
3248                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_current_auth_info));
3249                 }
3250                 if (r->incoming_previous_auth_info) {
3251                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_previous_auth_info));
3252                 }
3253                 if (r->outgoing_current_auth_info) {
3254                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_current_auth_info));
3255                 }
3256                 if (r->outgoing_previous_auth_info) {
3257                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_previous_auth_info));
3258                 }
3259         }
3260         return NDR_ERR_SUCCESS;
3261 }
3262
3263 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoAuthInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoAuthInfo *r)
3264 {
3265         uint32_t _ptr_incoming_current_auth_info;
3266         TALLOC_CTX *_mem_save_incoming_current_auth_info_0;
3267         uint32_t _ptr_incoming_previous_auth_info;
3268         TALLOC_CTX *_mem_save_incoming_previous_auth_info_0;
3269         uint32_t _ptr_outgoing_current_auth_info;
3270         TALLOC_CTX *_mem_save_outgoing_current_auth_info_0;
3271         uint32_t _ptr_outgoing_previous_auth_info;
3272         TALLOC_CTX *_mem_save_outgoing_previous_auth_info_0;
3273         if (ndr_flags & NDR_SCALARS) {
3274                 NDR_CHECK(ndr_pull_align(ndr, 4));
3275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->incoming_count));
3276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_incoming_current_auth_info));
3277                 if (_ptr_incoming_current_auth_info) {
3278                         NDR_PULL_ALLOC(ndr, r->incoming_current_auth_info);
3279                 } else {
3280                         r->incoming_current_auth_info = NULL;
3281                 }
3282                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_incoming_previous_auth_info));
3283                 if (_ptr_incoming_previous_auth_info) {
3284                         NDR_PULL_ALLOC(ndr, r->incoming_previous_auth_info);
3285                 } else {
3286                         r->incoming_previous_auth_info = NULL;
3287                 }
3288                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->outgoing_count));
3289                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_outgoing_current_auth_info));
3290                 if (_ptr_outgoing_current_auth_info) {
3291                         NDR_PULL_ALLOC(ndr, r->outgoing_current_auth_info);
3292                 } else {
3293                         r->outgoing_current_auth_info = NULL;
3294                 }
3295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_outgoing_previous_auth_info));
3296                 if (_ptr_outgoing_previous_auth_info) {
3297                         NDR_PULL_ALLOC(ndr, r->outgoing_previous_auth_info);
3298                 } else {
3299                         r->outgoing_previous_auth_info = NULL;
3300                 }
3301         }
3302         if (ndr_flags & NDR_BUFFERS) {
3303                 if (r->incoming_current_auth_info) {
3304                         _mem_save_incoming_current_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
3305                         NDR_PULL_SET_MEM_CTX(ndr, r->incoming_current_auth_info, 0);
3306                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_current_auth_info));
3307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_incoming_current_auth_info_0, 0);
3308                 }
3309                 if (r->incoming_previous_auth_info) {
3310                         _mem_save_incoming_previous_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
3311                         NDR_PULL_SET_MEM_CTX(ndr, r->incoming_previous_auth_info, 0);
3312                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_previous_auth_info));
3313                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_incoming_previous_auth_info_0, 0);
3314                 }
3315                 if (r->outgoing_current_auth_info) {
3316                         _mem_save_outgoing_current_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
3317                         NDR_PULL_SET_MEM_CTX(ndr, r->outgoing_current_auth_info, 0);
3318                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_current_auth_info));
3319                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_outgoing_current_auth_info_0, 0);
3320                 }
3321                 if (r->outgoing_previous_auth_info) {
3322                         _mem_save_outgoing_previous_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
3323                         NDR_PULL_SET_MEM_CTX(ndr, r->outgoing_previous_auth_info, 0);
3324                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_previous_auth_info));
3325                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_outgoing_previous_auth_info_0, 0);
3326                 }
3327         }
3328         return NDR_ERR_SUCCESS;
3329 }
3330
3331 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoAuthInfo(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoAuthInfo *r)
3332 {
3333         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoAuthInfo");
3334         ndr->depth++;
3335         ndr_print_uint32(ndr, "incoming_count", r->incoming_count);
3336         ndr_print_ptr(ndr, "incoming_current_auth_info", r->incoming_current_auth_info);
3337         ndr->depth++;
3338         if (r->incoming_current_auth_info) {
3339                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "incoming_current_auth_info", r->incoming_current_auth_info);
3340         }
3341         ndr->depth--;
3342         ndr_print_ptr(ndr, "incoming_previous_auth_info", r->incoming_previous_auth_info);
3343         ndr->depth++;
3344         if (r->incoming_previous_auth_info) {
3345                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "incoming_previous_auth_info", r->incoming_previous_auth_info);
3346         }
3347         ndr->depth--;
3348         ndr_print_uint32(ndr, "outgoing_count", r->outgoing_count);
3349         ndr_print_ptr(ndr, "outgoing_current_auth_info", r->outgoing_current_auth_info);
3350         ndr->depth++;
3351         if (r->outgoing_current_auth_info) {
3352                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "outgoing_current_auth_info", r->outgoing_current_auth_info);
3353         }
3354         ndr->depth--;
3355         ndr_print_ptr(ndr, "outgoing_previous_auth_info", r->outgoing_previous_auth_info);
3356         ndr->depth++;
3357         if (r->outgoing_previous_auth_info) {
3358                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "outgoing_previous_auth_info", r->outgoing_previous_auth_info);
3359         }
3360         ndr->depth--;
3361         ndr->depth--;
3362 }
3363
3364 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoFullInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoFullInfo *r)
3365 {
3366         if (ndr_flags & NDR_SCALARS) {
3367                 NDR_CHECK(ndr_push_align(ndr, 4));
3368                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3369                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3370                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3371         }
3372         if (ndr_flags & NDR_BUFFERS) {
3373                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3374                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3375         }
3376         return NDR_ERR_SUCCESS;
3377 }
3378
3379 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoFullInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoFullInfo *r)
3380 {
3381         if (ndr_flags & NDR_SCALARS) {
3382                 NDR_CHECK(ndr_pull_align(ndr, 4));
3383                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3384                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3385                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3386         }
3387         if (ndr_flags & NDR_BUFFERS) {
3388                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3389                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3390         }
3391         return NDR_ERR_SUCCESS;
3392 }
3393
3394 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoFullInfo(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoFullInfo *r)
3395 {
3396         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoFullInfo");
3397         ndr->depth++;
3398         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
3399         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
3400         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
3401         ndr->depth--;
3402 }
3403
3404 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoAuthInfoInternal(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoAuthInfoInternal *r)
3405 {
3406         if (ndr_flags & NDR_SCALARS) {
3407                 NDR_CHECK(ndr_push_align(ndr, 4));
3408                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->auth_blob));
3409         }
3410         if (ndr_flags & NDR_BUFFERS) {
3411                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->auth_blob));
3412         }
3413         return NDR_ERR_SUCCESS;
3414 }
3415
3416 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoAuthInfoInternal(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoAuthInfoInternal *r)
3417 {
3418         if (ndr_flags & NDR_SCALARS) {
3419                 NDR_CHECK(ndr_pull_align(ndr, 4));
3420                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->auth_blob));
3421         }
3422         if (ndr_flags & NDR_BUFFERS) {
3423                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->auth_blob));
3424         }
3425         return NDR_ERR_SUCCESS;
3426 }
3427
3428 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoAuthInfoInternal(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoAuthInfoInternal *r)
3429 {
3430         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoAuthInfoInternal");
3431         ndr->depth++;
3432         ndr_print_lsa_DATA_BUF2(ndr, "auth_blob", &r->auth_blob);
3433         ndr->depth--;
3434 }
3435
3436 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoFullInfoInternal(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoFullInfoInternal *r)
3437 {
3438         if (ndr_flags & NDR_SCALARS) {
3439                 NDR_CHECK(ndr_push_align(ndr, 4));
3440                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3441                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3442                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS, &r->auth_info));
3443         }
3444         if (ndr_flags & NDR_BUFFERS) {
3445                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3446                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_BUFFERS, &r->auth_info));
3447         }
3448         return NDR_ERR_SUCCESS;
3449 }
3450
3451 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoFullInfoInternal(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoFullInfoInternal *r)
3452 {
3453         if (ndr_flags & NDR_SCALARS) {
3454                 NDR_CHECK(ndr_pull_align(ndr, 4));
3455                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3456                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3457                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS, &r->auth_info));
3458         }
3459         if (ndr_flags & NDR_BUFFERS) {
3460                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3461                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_BUFFERS, &r->auth_info));
3462         }
3463         return NDR_ERR_SUCCESS;
3464 }
3465
3466 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoFullInfoInternal(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoFullInfoInternal *r)
3467 {
3468         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoFullInfoInternal");
3469         ndr->depth++;
3470         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
3471         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
3472         ndr_print_lsa_TrustDomainInfoAuthInfoInternal(ndr, "auth_info", &r->auth_info);
3473         ndr->depth--;
3474 }
3475
3476 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoInfoEx2Internal(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoInfoEx2Internal *r)
3477 {
3478         if (ndr_flags & NDR_SCALARS) {
3479                 NDR_CHECK(ndr_push_align(ndr, 4));
3480                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->forest_trust_length));
3482                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->forest_trust_data));
3483         }
3484         if (ndr_flags & NDR_BUFFERS) {
3485                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3486                 if (r->forest_trust_data) {
3487                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->forest_trust_length));
3488                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->forest_trust_data, r->forest_trust_length));
3489                 }
3490         }
3491         return NDR_ERR_SUCCESS;
3492 }
3493
3494 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoInfoEx2Internal(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoInfoEx2Internal *r)
3495 {
3496         uint32_t _ptr_forest_trust_data;
3497         TALLOC_CTX *_mem_save_forest_trust_data_0;
3498         if (ndr_flags & NDR_SCALARS) {
3499                 NDR_CHECK(ndr_pull_align(ndr, 4));
3500                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->forest_trust_length));
3502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_forest_trust_data));
3503                 if (_ptr_forest_trust_data) {
3504                         NDR_PULL_ALLOC(ndr, r->forest_trust_data);
3505                 } else {
3506                         r->forest_trust_data = NULL;
3507                 }
3508         }
3509         if (ndr_flags & NDR_BUFFERS) {
3510                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3511                 if (r->forest_trust_data) {
3512                         _mem_save_forest_trust_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
3513                         NDR_PULL_SET_MEM_CTX(ndr, r->forest_trust_data, 0);
3514                         NDR_CHECK(ndr_pull_array_size(ndr, &r->forest_trust_data));
3515                         NDR_PULL_ALLOC_N(ndr, r->forest_trust_data, ndr_get_array_size(ndr, &r->forest_trust_data));
3516                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->forest_trust_data, ndr_get_array_size(ndr, &r->forest_trust_data)));
3517                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_forest_trust_data_0, 0);
3518                 }
3519                 if (r->forest_trust_data) {
3520                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->forest_trust_data, r->forest_trust_length));
3521                 }
3522         }
3523         return NDR_ERR_SUCCESS;
3524 }
3525
3526 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoInfoEx2Internal(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoInfoEx2Internal *r)
3527 {
3528         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoInfoEx2Internal");
3529         ndr->depth++;
3530         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
3531         ndr_print_uint32(ndr, "forest_trust_length", r->forest_trust_length);
3532         ndr_print_ptr(ndr, "forest_trust_data", r->forest_trust_data);
3533         ndr->depth++;
3534         if (r->forest_trust_data) {
3535                 ndr_print_array_uint8(ndr, "forest_trust_data", r->forest_trust_data, r->forest_trust_length);
3536         }
3537         ndr->depth--;
3538         ndr->depth--;
3539 }
3540
3541 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoFullInfo2Internal(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoFullInfo2Internal *r)
3542 {
3543         if (ndr_flags & NDR_SCALARS) {
3544                 NDR_CHECK(ndr_push_align(ndr, 4));
3545                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_SCALARS, &r->info));
3546                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3547                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3548         }
3549         if (ndr_flags & NDR_BUFFERS) {
3550                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_BUFFERS, &r->info));
3551                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3552         }
3553         return NDR_ERR_SUCCESS;
3554 }
3555
3556 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoFullInfo2Internal(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoFullInfo2Internal *r)
3557 {
3558         if (ndr_flags & NDR_SCALARS) {
3559                 NDR_CHECK(ndr_pull_align(ndr, 4));
3560                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_SCALARS, &r->info));
3561                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3562                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3563         }
3564         if (ndr_flags & NDR_BUFFERS) {
3565                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_BUFFERS, &r->info));
3566                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3567         }
3568         return NDR_ERR_SUCCESS;
3569 }
3570
3571 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoFullInfo2Internal(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoFullInfo2Internal *r)
3572 {
3573         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoFullInfo2Internal");
3574         ndr->depth++;
3575         ndr_print_lsa_TrustDomainInfoInfoEx2Internal(ndr, "info", &r->info);
3576         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
3577         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
3578         ndr->depth--;
3579 }
3580
3581 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoSupportedEncTypes(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoSupportedEncTypes *r)
3582 {
3583         if (ndr_flags & NDR_SCALARS) {
3584                 NDR_CHECK(ndr_push_align(ndr, 4));
3585                 NDR_CHECK(ndr_push_kerb_EncTypes(ndr, NDR_SCALARS, r->enc_types));
3586         }
3587         if (ndr_flags & NDR_BUFFERS) {
3588         }
3589         return NDR_ERR_SUCCESS;
3590 }
3591
3592 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoSupportedEncTypes(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoSupportedEncTypes *r)
3593 {
3594         if (ndr_flags & NDR_SCALARS) {
3595                 NDR_CHECK(ndr_pull_align(ndr, 4));
3596                 NDR_CHECK(ndr_pull_kerb_EncTypes(ndr, NDR_SCALARS, &r->enc_types));
3597         }
3598         if (ndr_flags & NDR_BUFFERS) {
3599         }
3600         return NDR_ERR_SUCCESS;
3601 }
3602
3603 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoSupportedEncTypes(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoSupportedEncTypes *r)
3604 {
3605         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoSupportedEncTypes");
3606         ndr->depth++;
3607         ndr_print_kerb_EncTypes(ndr, "enc_types", r->enc_types);
3608         ndr->depth--;
3609 }
3610
3611 static enum ndr_err_code ndr_push_lsa_TrustedDomainInfo(struct ndr_push *ndr, int ndr_flags, const union lsa_TrustedDomainInfo *r)
3612 {
3613         if (ndr_flags & NDR_SCALARS) {
3614                 int level = ndr_push_get_switch_value(ndr, r);
3615                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, level));
3616                 switch (level) {
3617                         case LSA_TRUSTED_DOMAIN_INFO_NAME: {
3618                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoName(ndr, NDR_SCALARS, &r->name));
3619                         break; }
3620
3621                         case LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS: {
3622                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoControllers(ndr, NDR_SCALARS, &r->controllers));
3623                         break; }
3624
3625                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET: {
3626                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3627                         break; }
3628
3629                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD: {
3630                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPassword(ndr, NDR_SCALARS, &r->password));
3631                         break; }
3632
3633                         case LSA_TRUSTED_DOMAIN_INFO_BASIC: {
3634                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoBasic(ndr, NDR_SCALARS, &r->info_basic));
3635                         break; }
3636
3637                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX: {
3638                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3639                         break; }
3640
3641                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO: {
3642                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3643                         break; }
3644
3645                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO: {
3646                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfo(ndr, NDR_SCALARS, &r->full_info));
3647                         break; }
3648
3649                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO_INTERNAL: {
3650                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS, &r->auth_info_internal));
3651                         break; }
3652
3653                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_INTERNAL: {
3654                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfoInternal(ndr, NDR_SCALARS, &r->full_info_internal));
3655                         break; }
3656
3657                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX2_INTERNAL: {
3658                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_SCALARS, &r->info_ex2_internal));
3659                         break; }
3660
3661                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_2_INTERNAL: {
3662                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfo2Internal(ndr, NDR_SCALARS, &r->full_info2_internal));
3663                         break; }
3664
3665                         case LSA_TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES: {
3666                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoSupportedEncTypes(ndr, NDR_SCALARS, &r->enc_types));
3667                         break; }
3668
3669                         default:
3670                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3671                 }
3672         }
3673         if (ndr_flags & NDR_BUFFERS) {
3674                 int level = ndr_push_get_switch_value(ndr, r);
3675                 switch (level) {
3676                         case LSA_TRUSTED_DOMAIN_INFO_NAME:
3677                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoName(ndr, NDR_BUFFERS, &r->name));
3678                         break;
3679
3680                         case LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS:
3681                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoControllers(ndr, NDR_BUFFERS, &r->controllers));
3682                         break;
3683
3684                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
3685                         break;
3686
3687                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
3688                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPassword(ndr, NDR_BUFFERS, &r->password));
3689                         break;
3690
3691                         case LSA_TRUSTED_DOMAIN_INFO_BASIC:
3692                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoBasic(ndr, NDR_BUFFERS, &r->info_basic));
3693                         break;
3694
3695                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
3696                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3697                         break;
3698
3699                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
3700                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3701                         break;
3702
3703                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
3704                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfo(ndr, NDR_BUFFERS, &r->full_info));
3705                         break;
3706
3707                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO_INTERNAL:
3708                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_BUFFERS, &r->auth_info_internal));
3709                         break;
3710
3711                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_INTERNAL:
3712                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfoInternal(ndr, NDR_BUFFERS, &r->full_info_internal));
3713                         break;
3714
3715                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX2_INTERNAL:
3716                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_BUFFERS, &r->info_ex2_internal));
3717                         break;
3718
3719                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_2_INTERNAL:
3720                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfo2Internal(ndr, NDR_BUFFERS, &r->full_info2_internal));
3721                         break;
3722
3723                         case LSA_TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES:
3724                         break;
3725
3726                         default:
3727                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3728                 }
3729         }
3730         return NDR_ERR_SUCCESS;
3731 }
3732
3733 static enum ndr_err_code ndr_pull_lsa_TrustedDomainInfo(struct ndr_pull *ndr, int ndr_flags, union lsa_TrustedDomainInfo *r)
3734 {
3735         int level;
3736         uint16_t _level;
3737         level = ndr_pull_get_switch_value(ndr, r);
3738         if (ndr_flags & NDR_SCALARS) {
3739                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3740                 if (_level != level) {
3741                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3742                 }
3743                 switch (level) {
3744                         case LSA_TRUSTED_DOMAIN_INFO_NAME: {
3745                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoName(ndr, NDR_SCALARS, &r->name));
3746                         break; }
3747
3748                         case LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS: {
3749                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoControllers(ndr, NDR_SCALARS, &r->controllers));
3750                         break; }
3751
3752                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET: {
3753                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3754                         break; }
3755
3756                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD: {
3757                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPassword(ndr, NDR_SCALARS, &r->password));
3758                         break; }
3759
3760                         case LSA_TRUSTED_DOMAIN_INFO_BASIC: {
3761                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBasic(ndr, NDR_SCALARS, &r->info_basic));
3762                         break; }
3763
3764                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX: {
3765                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3766                         break; }
3767
3768                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO: {
3769                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3770                         break; }
3771
3772                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO: {
3773                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfo(ndr, NDR_SCALARS, &r->full_info));
3774                         break; }
3775
3776                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO_INTERNAL: {
3777                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS, &r->auth_info_internal));
3778                         break; }
3779
3780                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_INTERNAL: {
3781                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfoInternal(ndr, NDR_SCALARS, &r->full_info_internal));
3782                         break; }
3783
3784                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX2_INTERNAL: {
3785                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_SCALARS, &r->info_ex2_internal));
3786                         break; }
3787
3788                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_2_INTERNAL: {
3789                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfo2Internal(ndr, NDR_SCALARS, &r->full_info2_internal));
3790                         break; }
3791
3792                         case LSA_TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES: {
3793                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoSupportedEncTypes(ndr, NDR_SCALARS, &r->enc_types));
3794                         break; }
3795
3796                         default:
3797                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3798                 }
3799         }
3800         if (ndr_flags & NDR_BUFFERS) {
3801                 switch (level) {
3802                         case LSA_TRUSTED_DOMAIN_INFO_NAME:
3803                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoName(ndr, NDR_BUFFERS, &r->name));
3804                         break;
3805
3806                         case LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS:
3807                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoControllers(ndr, NDR_BUFFERS, &r->controllers));
3808                         break;
3809
3810                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
3811                         break;
3812
3813                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
3814                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPassword(ndr, NDR_BUFFERS, &r->password));
3815                         break;
3816
3817                         case LSA_TRUSTED_DOMAIN_INFO_BASIC:
3818                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBasic(ndr, NDR_BUFFERS, &r->info_basic));
3819                         break;
3820
3821                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
3822                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3823                         break;
3824
3825                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
3826                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3827                         break;
3828
3829                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
3830                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfo(ndr, NDR_BUFFERS, &r->full_info));
3831                         break;
3832
3833                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO_INTERNAL:
3834                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_BUFFERS, &r->auth_info_internal));
3835                         break;
3836
3837                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_INTERNAL:
3838                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfoInternal(ndr, NDR_BUFFERS, &r->full_info_internal));
3839                         break;
3840
3841                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX2_INTERNAL:
3842                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx2Internal(ndr, NDR_BUFFERS, &r->info_ex2_internal));
3843                         break;
3844
3845                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_2_INTERNAL:
3846                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfo2Internal(ndr, NDR_BUFFERS, &r->full_info2_internal));
3847                         break;
3848
3849                         case LSA_TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES:
3850                         break;
3851
3852                         default:
3853                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3854                 }
3855         }
3856         return NDR_ERR_SUCCESS;
3857 }
3858
3859 _PUBLIC_ void ndr_print_lsa_TrustedDomainInfo(struct ndr_print *ndr, const char *name, const union lsa_TrustedDomainInfo *r)
3860 {
3861         int level;
3862         level = ndr_print_get_switch_value(ndr, r);
3863         ndr_print_union(ndr, name, level, "lsa_TrustedDomainInfo");
3864         switch (level) {
3865                 case LSA_TRUSTED_DOMAIN_INFO_NAME:
3866                         ndr_print_lsa_TrustDomainInfoName(ndr, "name", &r->name);
3867                 break;
3868
3869                 case LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS:
3870                         ndr_print_lsa_TrustDomainInfoControllers(ndr, "controllers", &r->controllers);
3871                 break;
3872
3873                 case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
3874                         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
3875                 break;
3876
3877                 case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
3878                         ndr_print_lsa_TrustDomainInfoPassword(ndr, "password", &r->password);
3879                 break;
3880
3881                 case LSA_TRUSTED_DOMAIN_INFO_BASIC:
3882                         ndr_print_lsa_TrustDomainInfoBasic(ndr, "info_basic", &r->info_basic);
3883                 break;
3884
3885                 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
3886                         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
3887                 break;
3888
3889                 case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
3890                         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
3891                 break;
3892
3893                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
3894                         ndr_print_lsa_TrustDomainInfoFullInfo(ndr, "full_info", &r->full_info);
3895                 break;
3896
3897                 case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO_INTERNAL:
3898                         ndr_print_lsa_TrustDomainInfoAuthInfoInternal(ndr, "auth_info_internal", &r->auth_info_internal);
3899                 break;
3900
3901                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_INTERNAL:
3902                         ndr_print_lsa_TrustDomainInfoFullInfoInternal(ndr, "full_info_internal", &r->full_info_internal);
3903                 break;
3904
3905                 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX2_INTERNAL:
3906                         ndr_print_lsa_TrustDomainInfoInfoEx2Internal(ndr, "info_ex2_internal", &r->info_ex2_internal);
3907                 break;
3908
3909                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_2_INTERNAL:
3910                         ndr_print_lsa_TrustDomainInfoFullInfo2Internal(ndr, "full_info2_internal", &r->full_info2_internal);
3911                 break;
3912
3913                 case LSA_TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES:
3914                         ndr_print_lsa_TrustDomainInfoSupportedEncTypes(ndr, "enc_types", &r->enc_types);
3915                 break;
3916
3917                 default:
3918                         ndr_print_bad_level(ndr, name, level);
3919         }
3920 }
3921
3922 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)
3923 {
3924         if (ndr_flags & NDR_SCALARS) {
3925                 NDR_CHECK(ndr_push_align(ndr, 4));
3926                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->buf));
3927         }
3928         if (ndr_flags & NDR_BUFFERS) {
3929                 if (r->buf) {
3930                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->buf));
3931                 }
3932         }
3933         return NDR_ERR_SUCCESS;
3934 }
3935
3936 static enum ndr_err_code ndr_pull_lsa_DATA_BUF_PTR(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF_PTR *r)
3937 {
3938         uint32_t _ptr_buf;
3939         TALLOC_CTX *_mem_save_buf_0;
3940         if (ndr_flags & NDR_SCALARS) {
3941                 NDR_CHECK(ndr_pull_align(ndr, 4));
3942                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buf));
3943                 if (_ptr_buf) {
3944                         NDR_PULL_ALLOC(ndr, r->buf);
3945                 } else {
3946                         r->buf = NULL;
3947                 }
3948         }
3949         if (ndr_flags & NDR_BUFFERS) {
3950                 if (r->buf) {
3951                         _mem_save_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);
3952                         NDR_PULL_SET_MEM_CTX(ndr, r->buf, 0);
3953                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->buf));
3954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buf_0, 0);
3955                 }
3956         }
3957         return NDR_ERR_SUCCESS;
3958 }
3959
3960 _PUBLIC_ void ndr_print_lsa_DATA_BUF_PTR(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF_PTR *r)
3961 {
3962         ndr_print_struct(ndr, name, "lsa_DATA_BUF_PTR");
3963         ndr->depth++;
3964         ndr_print_ptr(ndr, "buf", r->buf);
3965         ndr->depth++;
3966         if (r->buf) {
3967                 ndr_print_lsa_DATA_BUF(ndr, "buf", r->buf);
3968         }
3969         ndr->depth--;
3970         ndr->depth--;
3971 }
3972
3973 static enum ndr_err_code ndr_push_lsa_RightSet(struct ndr_push *ndr, int ndr_flags, const struct lsa_RightSet *r)
3974 {
3975         uint32_t cntr_names_1;
3976         if (ndr_flags & NDR_SCALARS) {
3977                 NDR_CHECK(ndr_push_align(ndr, 4));
3978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3979                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
3980         }
3981         if (ndr_flags & NDR_BUFFERS) {
3982                 if (r->names) {
3983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3984                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3985                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3986                         }
3987                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3988                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3989                         }
3990                 }
3991         }
3992         return NDR_ERR_SUCCESS;
3993 }
3994
3995 static enum ndr_err_code ndr_pull_lsa_RightSet(struct ndr_pull *ndr, int ndr_flags, struct lsa_RightSet *r)
3996 {
3997         uint32_t _ptr_names;
3998         uint32_t cntr_names_1;
3999         TALLOC_CTX *_mem_save_names_0;
4000         TALLOC_CTX *_mem_save_names_1;
4001         if (ndr_flags & NDR_SCALARS) {
4002                 NDR_CHECK(ndr_pull_align(ndr, 4));
4003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4004                 if (r->count > 256) {
4005                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4006                 }
4007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
4008                 if (_ptr_names) {
4009                         NDR_PULL_ALLOC(ndr, r->names);
4010                 } else {
4011                         r->names = NULL;
4012                 }
4013         }
4014         if (ndr_flags & NDR_BUFFERS) {
4015                 if (r->names) {
4016                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
4017                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
4018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
4019                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
4020                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
4021                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
4022                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4023                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
4024                         }
4025                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4026                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
4027                         }
4028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
4029                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
4030                 }
4031                 if (r->names) {
4032                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
4033                 }
4034         }
4035         return NDR_ERR_SUCCESS;
4036 }
4037
4038 _PUBLIC_ void ndr_print_lsa_RightSet(struct ndr_print *ndr, const char *name, const struct lsa_RightSet *r)
4039 {
4040         uint32_t cntr_names_1;
4041         ndr_print_struct(ndr, name, "lsa_RightSet");
4042         ndr->depth++;
4043         ndr_print_uint32(ndr, "count", r->count);
4044         ndr_print_ptr(ndr, "names", r->names);
4045         ndr->depth++;
4046         if (r->names) {
4047                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
4048                 ndr->depth++;
4049                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
4050                         char *idx_1=NULL;
4051                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
4052                                 ndr_print_lsa_StringLarge(ndr, "names", &r->names[cntr_names_1]);
4053                                 free(idx_1);
4054                         }
4055                 }
4056                 ndr->depth--;
4057         }
4058         ndr->depth--;
4059         ndr->depth--;
4060 }
4061
4062 static enum ndr_err_code ndr_push_lsa_DomainListEx(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainListEx *r)
4063 {
4064         uint32_t cntr_domains_1;
4065         if (ndr_flags & NDR_SCALARS) {
4066                 NDR_CHECK(ndr_push_align(ndr, 4));
4067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
4069         }
4070         if (ndr_flags & NDR_BUFFERS) {
4071                 if (r->domains) {
4072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4073                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
4074                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
4075                         }
4076                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
4077                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
4078                         }
4079                 }
4080         }
4081         return NDR_ERR_SUCCESS;
4082 }
4083
4084 static enum ndr_err_code ndr_pull_lsa_DomainListEx(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainListEx *r)
4085 {
4086         uint32_t _ptr_domains;
4087         uint32_t cntr_domains_1;
4088         TALLOC_CTX *_mem_save_domains_0;
4089         TALLOC_CTX *_mem_save_domains_1;
4090         if (ndr_flags & NDR_SCALARS) {
4091                 NDR_CHECK(ndr_pull_align(ndr, 4));
4092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4093                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
4094                 if (_ptr_domains) {
4095                         NDR_PULL_ALLOC(ndr, r->domains);
4096                 } else {
4097                         r->domains = NULL;
4098                 }
4099         }
4100         if (ndr_flags & NDR_BUFFERS) {
4101                 if (r->domains) {
4102                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
4103                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
4104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
4105                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
4106                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
4107                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
4108                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
4109                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
4110                         }
4111                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
4112                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
4113                         }
4114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
4115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
4116                 }
4117                 if (r->domains) {
4118                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
4119                 }
4120         }
4121         return NDR_ERR_SUCCESS;
4122 }
4123
4124 _PUBLIC_ void ndr_print_lsa_DomainListEx(struct ndr_print *ndr, const char *name, const struct lsa_DomainListEx *r)
4125 {
4126         uint32_t cntr_domains_1;
4127         ndr_print_struct(ndr, name, "lsa_DomainListEx");
4128         ndr->depth++;
4129         ndr_print_uint32(ndr, "count", r->count);
4130         ndr_print_ptr(ndr, "domains", r->domains);
4131         ndr->depth++;
4132         if (r->domains) {
4133                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", (int)r->count);
4134                 ndr->depth++;
4135                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
4136                         char *idx_1=NULL;
4137                         if (asprintf(&idx_1, "[%d]", cntr_domains_1) != -1) {
4138                                 ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "domains", &r->domains[cntr_domains_1]);
4139                                 free(idx_1);
4140                         }
4141                 }
4142                 ndr->depth--;
4143         }
4144         ndr->depth--;
4145         ndr->depth--;
4146 }
4147
4148 static enum ndr_err_code ndr_push_lsa_DomainInfoKerberos(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfoKerberos *r)
4149 {
4150         if (ndr_flags & NDR_SCALARS) {
4151                 NDR_CHECK(ndr_push_align(ndr, 8));
4152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enforce_restrictions));
4153                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->service_tkt_lifetime));
4154                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->user_tkt_lifetime));
4155                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->user_tkt_renewaltime));
4156                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->clock_skew));
4157                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown6));
4158         }
4159         if (ndr_flags & NDR_BUFFERS) {
4160         }
4161         return NDR_ERR_SUCCESS;
4162 }
4163
4164 static enum ndr_err_code ndr_pull_lsa_DomainInfoKerberos(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfoKerberos *r)
4165 {
4166         if (ndr_flags & NDR_SCALARS) {
4167                 NDR_CHECK(ndr_pull_align(ndr, 8));
4168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enforce_restrictions));
4169                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->service_tkt_lifetime));
4170                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->user_tkt_lifetime));
4171                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->user_tkt_renewaltime));
4172                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->clock_skew));
4173                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown6));
4174         }
4175         if (ndr_flags & NDR_BUFFERS) {
4176         }
4177         return NDR_ERR_SUCCESS;
4178 }
4179
4180 _PUBLIC_ void ndr_print_lsa_DomainInfoKerberos(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfoKerberos *r)
4181 {
4182         ndr_print_struct(ndr, name, "lsa_DomainInfoKerberos");
4183         ndr->depth++;
4184         ndr_print_uint32(ndr, "enforce_restrictions", r->enforce_restrictions);
4185         ndr_print_hyper(ndr, "service_tkt_lifetime", r->service_tkt_lifetime);
4186         ndr_print_hyper(ndr, "user_tkt_lifetime", r->user_tkt_lifetime);
4187         ndr_print_hyper(ndr, "user_tkt_renewaltime", r->user_tkt_renewaltime);
4188         ndr_print_hyper(ndr, "clock_skew", r->clock_skew);
4189         ndr_print_hyper(ndr, "unknown6", r->unknown6);
4190         ndr->depth--;
4191 }
4192
4193 static enum ndr_err_code ndr_push_lsa_DomainInfoEfs(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfoEfs *r)
4194 {
4195         if (ndr_flags & NDR_SCALARS) {
4196                 NDR_CHECK(ndr_push_align(ndr, 4));
4197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->blob_size));
4198                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->efs_blob));
4199         }
4200         if (ndr_flags & NDR_BUFFERS) {
4201                 if (r->efs_blob) {
4202                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->blob_size));
4203                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->efs_blob, r->blob_size));
4204                 }
4205         }
4206         return NDR_ERR_SUCCESS;
4207 }
4208
4209 static enum ndr_err_code ndr_pull_lsa_DomainInfoEfs(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfoEfs *r)
4210 {
4211         uint32_t _ptr_efs_blob;
4212         TALLOC_CTX *_mem_save_efs_blob_0;
4213         if (ndr_flags & NDR_SCALARS) {
4214                 NDR_CHECK(ndr_pull_align(ndr, 4));
4215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->blob_size));
4216                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_efs_blob));
4217                 if (_ptr_efs_blob) {
4218                         NDR_PULL_ALLOC(ndr, r->efs_blob);
4219                 } else {
4220                         r->efs_blob = NULL;
4221                 }
4222         }
4223         if (ndr_flags & NDR_BUFFERS) {
4224                 if (r->efs_blob) {
4225                         _mem_save_efs_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
4226                         NDR_PULL_SET_MEM_CTX(ndr, r->efs_blob, 0);
4227                         NDR_CHECK(ndr_pull_array_size(ndr, &r->efs_blob));
4228                         NDR_PULL_ALLOC_N(ndr, r->efs_blob, ndr_get_array_size(ndr, &r->efs_blob));
4229                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->efs_blob, ndr_get_array_size(ndr, &r->efs_blob)));
4230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_efs_blob_0, 0);
4231                 }
4232                 if (r->efs_blob) {
4233                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->efs_blob, r->blob_size));
4234                 }
4235         }
4236         return NDR_ERR_SUCCESS;
4237 }
4238
4239 _PUBLIC_ void ndr_print_lsa_DomainInfoEfs(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfoEfs *r)
4240 {
4241         ndr_print_struct(ndr, name, "lsa_DomainInfoEfs");
4242         ndr->depth++;
4243         ndr_print_uint32(ndr, "blob_size", r->blob_size);
4244         ndr_print_ptr(ndr, "efs_blob", r->efs_blob);
4245         ndr->depth++;
4246         if (r->efs_blob) {
4247                 ndr_print_array_uint8(ndr, "efs_blob", r->efs_blob, r->blob_size);
4248         }
4249         ndr->depth--;
4250         ndr->depth--;
4251 }
4252
4253 static enum ndr_err_code ndr_push_lsa_DomainInformationPolicy(struct ndr_push *ndr, int ndr_flags, const union lsa_DomainInformationPolicy *r)
4254 {
4255         if (ndr_flags & NDR_SCALARS) {
4256                 int level = ndr_push_get_switch_value(ndr, r);
4257                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
4258                 switch (level) {
4259                         case LSA_DOMAIN_INFO_POLICY_EFS: {
4260                                 NDR_CHECK(ndr_push_lsa_DomainInfoEfs(ndr, NDR_SCALARS, &r->efs_info));
4261                         break; }
4262
4263                         case LSA_DOMAIN_INFO_POLICY_KERBEROS: {
4264                                 NDR_CHECK(ndr_push_lsa_DomainInfoKerberos(ndr, NDR_SCALARS, &r->kerberos_info));
4265                         break; }
4266
4267                         default:
4268                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4269                 }
4270         }
4271         if (ndr_flags & NDR_BUFFERS) {
4272                 int level = ndr_push_get_switch_value(ndr, r);
4273                 switch (level) {
4274                         case LSA_DOMAIN_INFO_POLICY_EFS:
4275                                 NDR_CHECK(ndr_push_lsa_DomainInfoEfs(ndr, NDR_BUFFERS, &r->efs_info));
4276                         break;
4277
4278                         case LSA_DOMAIN_INFO_POLICY_KERBEROS:
4279                         break;
4280
4281                         default:
4282                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4283                 }
4284         }
4285         return NDR_ERR_SUCCESS;
4286 }
4287
4288 static enum ndr_err_code ndr_pull_lsa_DomainInformationPolicy(struct ndr_pull *ndr, int ndr_flags, union lsa_DomainInformationPolicy *r)
4289 {
4290         int level;
4291         uint16_t _level;
4292         level = ndr_pull_get_switch_value(ndr, r);
4293         if (ndr_flags & NDR_SCALARS) {
4294                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
4295                 if (_level != level) {
4296                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4297                 }
4298                 switch (level) {
4299                         case LSA_DOMAIN_INFO_POLICY_EFS: {
4300                                 NDR_CHECK(ndr_pull_lsa_DomainInfoEfs(ndr, NDR_SCALARS, &r->efs_info));
4301                         break; }
4302
4303                         case LSA_DOMAIN_INFO_POLICY_KERBEROS: {
4304                                 NDR_CHECK(ndr_pull_lsa_DomainInfoKerberos(ndr, NDR_SCALARS, &r->kerberos_info));
4305                         break; }
4306
4307                         default:
4308                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4309                 }
4310         }
4311         if (ndr_flags & NDR_BUFFERS) {
4312                 switch (level) {
4313                         case LSA_DOMAIN_INFO_POLICY_EFS:
4314                                 NDR_CHECK(ndr_pull_lsa_DomainInfoEfs(ndr, NDR_BUFFERS, &r->efs_info));
4315                         break;
4316
4317                         case LSA_DOMAIN_INFO_POLICY_KERBEROS:
4318                         break;
4319
4320                         default:
4321                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
4322                 }
4323         }
4324         return NDR_ERR_SUCCESS;
4325 }
4326
4327 _PUBLIC_ void ndr_print_lsa_DomainInformationPolicy(struct ndr_print *ndr, const char *name, const union lsa_DomainInformationPolicy *r)
4328 {
4329         int level;
4330         level = ndr_print_get_switch_value(ndr, r);
4331         ndr_print_union(ndr, name, level, "lsa_DomainInformationPolicy");
4332         switch (level) {
4333                 case LSA_DOMAIN_INFO_POLICY_EFS:
4334                         ndr_print_lsa_DomainInfoEfs(ndr, "efs_info", &r->efs_info);
4335                 break;
4336
4337                 case LSA_DOMAIN_INFO_POLICY_KERBEROS:
4338                         ndr_print_lsa_DomainInfoKerberos(ndr, "kerberos_info", &r->kerberos_info);
4339                 break;
4340
4341                 default:
4342                         ndr_print_bad_level(ndr, name, level);
4343         }
4344 }
4345
4346 static enum ndr_err_code ndr_push_lsa_TranslatedName2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedName2 *r)
4347 {
4348         if (ndr_flags & NDR_SCALARS) {
4349                 NDR_CHECK(ndr_push_align(ndr, 4));
4350                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
4351                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
4352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
4353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
4354         }
4355         if (ndr_flags & NDR_BUFFERS) {
4356                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
4357         }
4358         return NDR_ERR_SUCCESS;
4359 }
4360
4361 static enum ndr_err_code ndr_pull_lsa_TranslatedName2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedName2 *r)
4362 {
4363         if (ndr_flags & NDR_SCALARS) {
4364                 NDR_CHECK(ndr_pull_align(ndr, 4));
4365                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
4366                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
4367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
4368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
4369         }
4370         if (ndr_flags & NDR_BUFFERS) {
4371                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
4372         }
4373         return NDR_ERR_SUCCESS;
4374 }
4375
4376 _PUBLIC_ void ndr_print_lsa_TranslatedName2(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedName2 *r)
4377 {
4378         ndr_print_struct(ndr, name, "lsa_TranslatedName2");
4379         ndr->depth++;
4380         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
4381         ndr_print_lsa_String(ndr, "name", &r->name);
4382         ndr_print_uint32(ndr, "sid_index", r->sid_index);
4383         ndr_print_uint32(ndr, "unknown", r->unknown);
4384         ndr->depth--;
4385 }
4386
4387 static enum ndr_err_code ndr_push_lsa_TransNameArray2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransNameArray2 *r)
4388 {
4389         uint32_t cntr_names_1;
4390         if (ndr_flags & NDR_SCALARS) {
4391                 NDR_CHECK(ndr_push_align(ndr, 4));
4392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4393                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
4394         }
4395         if (ndr_flags & NDR_BUFFERS) {
4396                 if (r->names) {
4397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4398                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4399                                 NDR_CHECK(ndr_push_lsa_TranslatedName2(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
4400                         }
4401                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4402                                 NDR_CHECK(ndr_push_lsa_TranslatedName2(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
4403                         }
4404                 }
4405         }
4406         return NDR_ERR_SUCCESS;
4407 }
4408
4409 static enum ndr_err_code ndr_pull_lsa_TransNameArray2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransNameArray2 *r)
4410 {
4411         uint32_t _ptr_names;
4412         uint32_t cntr_names_1;
4413         TALLOC_CTX *_mem_save_names_0;
4414         TALLOC_CTX *_mem_save_names_1;
4415         if (ndr_flags & NDR_SCALARS) {
4416                 NDR_CHECK(ndr_pull_align(ndr, 4));
4417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4418                 if (r->count > 1000) {
4419                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4420                 }
4421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
4422                 if (_ptr_names) {
4423                         NDR_PULL_ALLOC(ndr, r->names);
4424                 } else {
4425                         r->names = NULL;
4426                 }
4427         }
4428         if (ndr_flags & NDR_BUFFERS) {
4429                 if (r->names) {
4430                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
4431                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
4432                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
4433                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
4434                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
4435                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
4436                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4437                                 NDR_CHECK(ndr_pull_lsa_TranslatedName2(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
4438                         }
4439                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
4440                                 NDR_CHECK(ndr_pull_lsa_TranslatedName2(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
4441                         }
4442                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
4443                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
4444                 }
4445                 if (r->names) {
4446                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
4447                 }
4448         }
4449         return NDR_ERR_SUCCESS;
4450 }
4451
4452 _PUBLIC_ void ndr_print_lsa_TransNameArray2(struct ndr_print *ndr, const char *name, const struct lsa_TransNameArray2 *r)
4453 {
4454         uint32_t cntr_names_1;
4455         ndr_print_struct(ndr, name, "lsa_TransNameArray2");
4456         ndr->depth++;
4457         ndr_print_uint32(ndr, "count", r->count);
4458         ndr_print_ptr(ndr, "names", r->names);
4459         ndr->depth++;
4460         if (r->names) {
4461                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
4462                 ndr->depth++;
4463                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
4464                         char *idx_1=NULL;
4465                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
4466                                 ndr_print_lsa_TranslatedName2(ndr, "names", &r->names[cntr_names_1]);
4467                                 free(idx_1);
4468                         }
4469                 }
4470                 ndr->depth--;
4471         }
4472         ndr->depth--;
4473         ndr->depth--;
4474 }
4475
4476 static enum ndr_err_code ndr_push_lsa_TranslatedSid2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid2 *r)
4477 {
4478         if (ndr_flags & NDR_SCALARS) {
4479                 NDR_CHECK(ndr_push_align(ndr, 4));
4480                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
4481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
4482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
4483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
4484         }
4485         if (ndr_flags & NDR_BUFFERS) {
4486         }
4487         return NDR_ERR_SUCCESS;
4488 }
4489
4490 static enum ndr_err_code ndr_pull_lsa_TranslatedSid2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid2 *r)
4491 {
4492         if (ndr_flags & NDR_SCALARS) {
4493                 NDR_CHECK(ndr_pull_align(ndr, 4));
4494                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
4495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
4496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
4497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
4498         }
4499         if (ndr_flags & NDR_BUFFERS) {
4500         }
4501         return NDR_ERR_SUCCESS;
4502 }
4503
4504 _PUBLIC_ void ndr_print_lsa_TranslatedSid2(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid2 *r)
4505 {
4506         ndr_print_struct(ndr, name, "lsa_TranslatedSid2");
4507         ndr->depth++;
4508         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
4509         ndr_print_uint32(ndr, "rid", r->rid);
4510         ndr_print_uint32(ndr, "sid_index", r->sid_index);
4511         ndr_print_uint32(ndr, "unknown", r->unknown);
4512         ndr->depth--;
4513 }
4514
4515 static enum ndr_err_code ndr_push_lsa_TransSidArray2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray2 *r)
4516 {
4517         uint32_t cntr_sids_1;
4518         if (ndr_flags & NDR_SCALARS) {
4519                 NDR_CHECK(ndr_push_align(ndr, 4));
4520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4521                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4522         }
4523         if (ndr_flags & NDR_BUFFERS) {
4524                 if (r->sids) {
4525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4526                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
4527                                 NDR_CHECK(ndr_push_lsa_TranslatedSid2(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
4528                         }
4529                 }
4530         }
4531         return NDR_ERR_SUCCESS;
4532 }
4533
4534 static enum ndr_err_code ndr_pull_lsa_TransSidArray2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray2 *r)
4535 {
4536         uint32_t _ptr_sids;
4537         uint32_t cntr_sids_1;
4538         TALLOC_CTX *_mem_save_sids_0;
4539         TALLOC_CTX *_mem_save_sids_1;
4540         if (ndr_flags & NDR_SCALARS) {
4541                 NDR_CHECK(ndr_pull_align(ndr, 4));
4542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4543                 if (r->count > 1000) {
4544                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4545                 }
4546                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4547                 if (_ptr_sids) {
4548                         NDR_PULL_ALLOC(ndr, r->sids);
4549                 } else {
4550                         r->sids = NULL;
4551                 }
4552         }
4553         if (ndr_flags & NDR_BUFFERS) {
4554                 if (r->sids) {
4555                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4556                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4557                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4558                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4559                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4560                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4561                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
4562                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid2(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
4563                         }
4564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4565                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4566                 }
4567                 if (r->sids) {
4568                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
4569                 }
4570         }
4571         return NDR_ERR_SUCCESS;
4572 }
4573
4574 _PUBLIC_ void ndr_print_lsa_TransSidArray2(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray2 *r)
4575 {
4576         uint32_t cntr_sids_1;
4577         ndr_print_struct(ndr, name, "lsa_TransSidArray2");
4578         ndr->depth++;
4579         ndr_print_uint32(ndr, "count", r->count);
4580         ndr_print_ptr(ndr, "sids", r->sids);
4581         ndr->depth++;
4582         if (r->sids) {
4583                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->count);
4584                 ndr->depth++;
4585                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
4586                         char *idx_1=NULL;
4587                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4588                                 ndr_print_lsa_TranslatedSid2(ndr, "sids", &r->sids[cntr_sids_1]);
4589                                 free(idx_1);
4590                         }
4591                 }
4592                 ndr->depth--;
4593         }
4594         ndr->depth--;
4595         ndr->depth--;
4596 }
4597
4598 static enum ndr_err_code ndr_push_lsa_TranslatedSid3(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid3 *r)
4599 {
4600         if (ndr_flags & NDR_SCALARS) {
4601                 NDR_CHECK(ndr_push_align(ndr, 4));
4602                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
4603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
4604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
4605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4606         }
4607         if (ndr_flags & NDR_BUFFERS) {
4608                 if (r->sid) {
4609                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
4610                 }
4611         }
4612         return NDR_ERR_SUCCESS;
4613 }
4614
4615 static enum ndr_err_code ndr_pull_lsa_TranslatedSid3(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid3 *r)
4616 {
4617         uint32_t _ptr_sid;
4618         TALLOC_CTX *_mem_save_sid_0;
4619         if (ndr_flags & NDR_SCALARS) {
4620                 NDR_CHECK(ndr_pull_align(ndr, 4));
4621                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
4622                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
4623                 if (_ptr_sid) {
4624                         NDR_PULL_ALLOC(ndr, r->sid);
4625                 } else {
4626                         r->sid = NULL;
4627                 }
4628                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
4629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
4630         }
4631         if (ndr_flags & NDR_BUFFERS) {
4632                 if (r->sid) {
4633                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4634                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
4635                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
4636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
4637                 }
4638         }
4639         return NDR_ERR_SUCCESS;
4640 }
4641
4642 _PUBLIC_ void ndr_print_lsa_TranslatedSid3(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid3 *r)
4643 {
4644         ndr_print_struct(ndr, name, "lsa_TranslatedSid3");
4645         ndr->depth++;
4646         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
4647         ndr_print_ptr(ndr, "sid", r->sid);
4648         ndr->depth++;
4649         if (r->sid) {
4650                 ndr_print_dom_sid2(ndr, "sid", r->sid);
4651         }
4652         ndr->depth--;
4653         ndr_print_uint32(ndr, "sid_index", r->sid_index);
4654         ndr_print_uint32(ndr, "flags", r->flags);
4655         ndr->depth--;
4656 }
4657
4658 static enum ndr_err_code ndr_push_lsa_TransSidArray3(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray3 *r)
4659 {
4660         uint32_t cntr_sids_1;
4661         if (ndr_flags & NDR_SCALARS) {
4662                 NDR_CHECK(ndr_push_align(ndr, 4));
4663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4664                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4665         }
4666         if (ndr_flags & NDR_BUFFERS) {
4667                 if (r->sids) {
4668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4669                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
4670                                 NDR_CHECK(ndr_push_lsa_TranslatedSid3(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
4671                         }
4672                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
4673                                 NDR_CHECK(ndr_push_lsa_TranslatedSid3(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
4674                         }
4675                 }
4676         }
4677         return NDR_ERR_SUCCESS;
4678 }
4679
4680 static enum ndr_err_code ndr_pull_lsa_TransSidArray3(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray3 *r)
4681 {
4682         uint32_t _ptr_sids;
4683         uint32_t cntr_sids_1;
4684         TALLOC_CTX *_mem_save_sids_0;
4685         TALLOC_CTX *_mem_save_sids_1;
4686         if (ndr_flags & NDR_SCALARS) {
4687                 NDR_CHECK(ndr_pull_align(ndr, 4));
4688                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4689                 if (r->count > 1000) {
4690                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4691                 }
4692                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4693                 if (_ptr_sids) {
4694                         NDR_PULL_ALLOC(ndr, r->sids);
4695                 } else {
4696                         r->sids = NULL;
4697                 }
4698         }
4699         if (ndr_flags & NDR_BUFFERS) {
4700                 if (r->sids) {
4701                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4702                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4703                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4704                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4705                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4706                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4707                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
4708                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid3(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
4709                         }
4710                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
4711                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid3(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
4712                         }
4713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4714                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4715                 }
4716                 if (r->sids) {
4717                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
4718                 }
4719         }
4720         return NDR_ERR_SUCCESS;
4721 }
4722
4723 _PUBLIC_ void ndr_print_lsa_TransSidArray3(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray3 *r)
4724 {
4725         uint32_t cntr_sids_1;
4726         ndr_print_struct(ndr, name, "lsa_TransSidArray3");
4727         ndr->depth++;
4728         ndr_print_uint32(ndr, "count", r->count);
4729         ndr_print_ptr(ndr, "sids", r->sids);
4730         ndr->depth++;
4731         if (r->sids) {
4732                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->count);
4733                 ndr->depth++;
4734                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
4735                         char *idx_1=NULL;
4736                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4737                                 ndr_print_lsa_TranslatedSid3(ndr, "sids", &r->sids[cntr_sids_1]);
4738                                 free(idx_1);
4739                         }
4740                 }
4741                 ndr->depth--;
4742         }
4743         ndr->depth--;
4744         ndr->depth--;
4745 }
4746
4747 static enum ndr_err_code ndr_push_lsa_ForestTrustBinaryData(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustBinaryData *r)
4748 {
4749         if (ndr_flags & NDR_SCALARS) {
4750                 NDR_CHECK(ndr_push_align(ndr, 4));
4751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
4753         }
4754         if (ndr_flags & NDR_BUFFERS) {
4755                 if (r->data) {
4756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4757                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
4758                 }
4759         }
4760         return NDR_ERR_SUCCESS;
4761 }
4762
4763 static enum ndr_err_code ndr_pull_lsa_ForestTrustBinaryData(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustBinaryData *r)
4764 {
4765         uint32_t _ptr_data;
4766         TALLOC_CTX *_mem_save_data_0;
4767         if (ndr_flags & NDR_SCALARS) {
4768                 NDR_CHECK(ndr_pull_align(ndr, 4));
4769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
4770                 if (r->length > 131072) {
4771                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4772                 }
4773                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
4774                 if (_ptr_data) {
4775                         NDR_PULL_ALLOC(ndr, r->data);
4776                 } else {
4777                         r->data = NULL;
4778                 }
4779         }
4780         if (ndr_flags & NDR_BUFFERS) {
4781                 if (r->data) {
4782                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
4783                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
4784                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
4785                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
4786                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
4787                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
4788                 }
4789                 if (r->data) {
4790                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
4791                 }
4792         }
4793         return NDR_ERR_SUCCESS;
4794 }
4795
4796 _PUBLIC_ void ndr_print_lsa_ForestTrustBinaryData(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustBinaryData *r)
4797 {
4798         ndr_print_struct(ndr, name, "lsa_ForestTrustBinaryData");
4799         ndr->depth++;
4800         ndr_print_uint32(ndr, "length", r->length);
4801         ndr_print_ptr(ndr, "data", r->data);
4802         ndr->depth++;
4803         if (r->data) {
4804                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
4805         }
4806         ndr->depth--;
4807         ndr->depth--;
4808 }
4809
4810 static enum ndr_err_code ndr_push_lsa_ForestTrustDomainInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustDomainInfo *r)
4811 {
4812         if (ndr_flags & NDR_SCALARS) {
4813                 NDR_CHECK(ndr_push_align(ndr, 4));
4814                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_sid));
4815                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain_name));
4816                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_domain_name));
4817         }
4818         if (ndr_flags & NDR_BUFFERS) {
4819                 if (r->domain_sid) {
4820                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
4821                 }
4822                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain_name));
4823                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_domain_name));
4824         }
4825         return NDR_ERR_SUCCESS;
4826 }
4827
4828 static enum ndr_err_code ndr_pull_lsa_ForestTrustDomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustDomainInfo *r)
4829 {
4830         uint32_t _ptr_domain_sid;
4831         TALLOC_CTX *_mem_save_domain_sid_0;
4832         if (ndr_flags & NDR_SCALARS) {
4833                 NDR_CHECK(ndr_pull_align(ndr, 4));
4834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_sid));
4835                 if (_ptr_domain_sid) {
4836                         NDR_PULL_ALLOC(ndr, r->domain_sid);
4837                 } else {
4838                         r->domain_sid = NULL;
4839                 }
4840                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain_name));
4841                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_domain_name));
4842         }
4843         if (ndr_flags & NDR_BUFFERS) {
4844                 if (r->domain_sid) {
4845                         _mem_save_domain_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4846                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_sid, 0);
4847                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
4848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_sid_0, 0);
4849                 }
4850                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain_name));
4851                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_domain_name));
4852         }
4853         return NDR_ERR_SUCCESS;
4854 }
4855
4856 _PUBLIC_ void ndr_print_lsa_ForestTrustDomainInfo(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustDomainInfo *r)
4857 {
4858         ndr_print_struct(ndr, name, "lsa_ForestTrustDomainInfo");
4859         ndr->depth++;
4860         ndr_print_ptr(ndr, "domain_sid", r->domain_sid);
4861         ndr->depth++;
4862         if (r->domain_sid) {
4863                 ndr_print_dom_sid2(ndr, "domain_sid", r->domain_sid);
4864         }
4865         ndr->depth--;
4866         ndr_print_lsa_StringLarge(ndr, "dns_domain_name", &r->dns_domain_name);
4867         ndr_print_lsa_StringLarge(ndr, "netbios_domain_name", &r->netbios_domain_name);
4868         ndr->depth--;
4869 }
4870
4871 static enum ndr_err_code ndr_push_lsa_ForestTrustData(struct ndr_push *ndr, int ndr_flags, const union lsa_ForestTrustData *r)
4872 {
4873         if (ndr_flags & NDR_SCALARS) {
4874                 int level = ndr_push_get_switch_value(ndr, r);
4875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4876                 switch (level) {
4877                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME: {
4878                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->top_level_name));
4879                         break; }
4880
4881                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX: {
4882                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->top_level_name_ex));
4883                         break; }
4884
4885                         case LSA_FOREST_TRUST_DOMAIN_INFO: {
4886                                 NDR_CHECK(ndr_push_lsa_ForestTrustDomainInfo(ndr, NDR_SCALARS, &r->domain_info));
4887                         break; }
4888
4889                         default: {
4890                                 NDR_CHECK(ndr_push_lsa_ForestTrustBinaryData(ndr, NDR_SCALARS, &r->data));
4891                         break; }
4892
4893                 }
4894         }
4895         if (ndr_flags & NDR_BUFFERS) {
4896                 int level = ndr_push_get_switch_value(ndr, r);
4897                 switch (level) {
4898                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME:
4899                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->top_level_name));
4900                         break;
4901
4902                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX:
4903                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->top_level_name_ex));
4904                         break;
4905
4906                         case LSA_FOREST_TRUST_DOMAIN_INFO:
4907                                 NDR_CHECK(ndr_push_lsa_ForestTrustDomainInfo(ndr, NDR_BUFFERS, &r->domain_info));
4908                         break;
4909
4910                         default:
4911                                 NDR_CHECK(ndr_push_lsa_ForestTrustBinaryData(ndr, NDR_BUFFERS, &r->data));
4912                         break;
4913
4914                 }
4915         }
4916         return NDR_ERR_SUCCESS;
4917 }
4918
4919 static enum ndr_err_code ndr_pull_lsa_ForestTrustData(struct ndr_pull *ndr, int ndr_flags, union lsa_ForestTrustData *r)
4920 {
4921         int level;
4922         uint32_t _level;
4923         level = ndr_pull_get_switch_value(ndr, r);
4924         if (ndr_flags & NDR_SCALARS) {
4925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4926                 if (_level != level) {
4927                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4928                 }
4929                 switch (level) {
4930                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME: {
4931                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->top_level_name));
4932                         break; }
4933
4934                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX: {
4935                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->top_level_name_ex));
4936                         break; }
4937
4938                         case LSA_FOREST_TRUST_DOMAIN_INFO: {
4939                                 NDR_CHECK(ndr_pull_lsa_ForestTrustDomainInfo(ndr, NDR_SCALARS, &r->domain_info));
4940                         break; }
4941
4942                         default: {
4943                                 NDR_CHECK(ndr_pull_lsa_ForestTrustBinaryData(ndr, NDR_SCALARS, &r->data));
4944                         break; }
4945
4946                 }
4947         }
4948         if (ndr_flags & NDR_BUFFERS) {
4949                 switch (level) {
4950                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME:
4951                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->top_level_name));
4952                         break;
4953
4954                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX:
4955                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->top_level_name_ex));
4956                         break;
4957
4958                         case LSA_FOREST_TRUST_DOMAIN_INFO:
4959                                 NDR_CHECK(ndr_pull_lsa_ForestTrustDomainInfo(ndr, NDR_BUFFERS, &r->domain_info));
4960                         break;
4961
4962                         default:
4963                                 NDR_CHECK(ndr_pull_lsa_ForestTrustBinaryData(ndr, NDR_BUFFERS, &r->data));
4964                         break;
4965
4966                 }
4967         }
4968         return NDR_ERR_SUCCESS;
4969 }
4970
4971 _PUBLIC_ void ndr_print_lsa_ForestTrustData(struct ndr_print *ndr, const char *name, const union lsa_ForestTrustData *r)
4972 {
4973         int level;
4974         level = ndr_print_get_switch_value(ndr, r);
4975         ndr_print_union(ndr, name, level, "lsa_ForestTrustData");
4976         switch (level) {
4977                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME:
4978                         ndr_print_lsa_String(ndr, "top_level_name", &r->top_level_name);
4979                 break;
4980
4981                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX:
4982                         ndr_print_lsa_StringLarge(ndr, "top_level_name_ex", &r->top_level_name_ex);
4983                 break;
4984
4985                 case LSA_FOREST_TRUST_DOMAIN_INFO:
4986                         ndr_print_lsa_ForestTrustDomainInfo(ndr, "domain_info", &r->domain_info);
4987                 break;
4988
4989                 default:
4990                         ndr_print_lsa_ForestTrustBinaryData(ndr, "data", &r->data);
4991                 break;
4992
4993         }
4994 }
4995
4996 static enum ndr_err_code ndr_push_lsa_ForestTrustRecordType(struct ndr_push *ndr, int ndr_flags, enum lsa_ForestTrustRecordType r)
4997 {
4998         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4999         return NDR_ERR_SUCCESS;
5000 }
5001
5002 static enum ndr_err_code ndr_pull_lsa_ForestTrustRecordType(struct ndr_pull *ndr, int ndr_flags, enum lsa_ForestTrustRecordType *r)
5003 {
5004         uint32_t v;
5005         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5006         *r = v;
5007         return NDR_ERR_SUCCESS;
5008 }
5009
5010 _PUBLIC_ void ndr_print_lsa_ForestTrustRecordType(struct ndr_print *ndr, const char *name, enum lsa_ForestTrustRecordType r)
5011 {
5012         const char *val = NULL;
5013
5014         switch (r) {
5015                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME: val = "LSA_FOREST_TRUST_TOP_LEVEL_NAME"; break;
5016                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX: val = "LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX"; break;
5017                 case LSA_FOREST_TRUST_DOMAIN_INFO: val = "LSA_FOREST_TRUST_DOMAIN_INFO"; break;
5018                 case LSA_FOREST_TRUST_RECORD_TYPE_LAST: val = "LSA_FOREST_TRUST_RECORD_TYPE_LAST"; break;
5019         }
5020         ndr_print_enum(ndr, name, "ENUM", val, r);
5021 }
5022
5023 static enum ndr_err_code ndr_push_lsa_ForestTrustRecord(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustRecord *r)
5024 {
5025         if (ndr_flags & NDR_SCALARS) {
5026                 NDR_CHECK(ndr_push_align(ndr, 8));
5027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
5028                 NDR_CHECK(ndr_push_lsa_ForestTrustRecordType(ndr, NDR_SCALARS, r->level));
5029                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown));
5030                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->forest_trust_data, r->level));
5031                 NDR_CHECK(ndr_push_lsa_ForestTrustData(ndr, NDR_SCALARS, &r->forest_trust_data));
5032         }
5033         if (ndr_flags & NDR_BUFFERS) {
5034                 NDR_CHECK(ndr_push_lsa_ForestTrustData(ndr, NDR_BUFFERS, &r->forest_trust_data));
5035         }
5036         return NDR_ERR_SUCCESS;
5037 }
5038
5039 static enum ndr_err_code ndr_pull_lsa_ForestTrustRecord(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustRecord *r)
5040 {
5041         if (ndr_flags & NDR_SCALARS) {
5042                 NDR_CHECK(ndr_pull_align(ndr, 8));
5043                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5044                 NDR_CHECK(ndr_pull_lsa_ForestTrustRecordType(ndr, NDR_SCALARS, &r->level));
5045                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown));
5046                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->forest_trust_data, r->level));
5047                 NDR_CHECK(ndr_pull_lsa_ForestTrustData(ndr, NDR_SCALARS, &r->forest_trust_data));
5048         }
5049         if (ndr_flags & NDR_BUFFERS) {
5050                 NDR_CHECK(ndr_pull_lsa_ForestTrustData(ndr, NDR_BUFFERS, &r->forest_trust_data));
5051         }
5052         return NDR_ERR_SUCCESS;
5053 }
5054
5055 _PUBLIC_ void ndr_print_lsa_ForestTrustRecord(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustRecord *r)
5056 {
5057         ndr_print_struct(ndr, name, "lsa_ForestTrustRecord");
5058         ndr->depth++;
5059         ndr_print_uint32(ndr, "flags", r->flags);
5060         ndr_print_lsa_ForestTrustRecordType(ndr, "level", r->level);
5061         ndr_print_hyper(ndr, "unknown", r->unknown);
5062         ndr_print_set_switch_value(ndr, &r->forest_trust_data, r->level);
5063         ndr_print_lsa_ForestTrustData(ndr, "forest_trust_data", &r->forest_trust_data);
5064         ndr->depth--;
5065 }
5066
5067 _PUBLIC_ enum ndr_err_code ndr_push_lsa_ForestTrustInformation(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustInformation *r)
5068 {
5069         uint32_t cntr_entries_1;
5070         if (ndr_flags & NDR_SCALARS) {
5071                 NDR_CHECK(ndr_push_align(ndr, 4));
5072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
5074         }
5075         if (ndr_flags & NDR_BUFFERS) {
5076                 if (r->entries) {
5077                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5078                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
5079                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries[cntr_entries_1]));
5080                         }
5081                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
5082                                 if (r->entries[cntr_entries_1]) {
5083                                         NDR_CHECK(ndr_push_lsa_ForestTrustRecord(ndr, NDR_SCALARS|NDR_BUFFERS, r->entries[cntr_entries_1]));
5084                                 }
5085                         }
5086                 }
5087         }
5088         return NDR_ERR_SUCCESS;
5089 }
5090
5091 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_ForestTrustInformation(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustInformation *r)
5092 {
5093         uint32_t _ptr_entries;
5094         uint32_t cntr_entries_1;
5095         TALLOC_CTX *_mem_save_entries_0;
5096         TALLOC_CTX *_mem_save_entries_1;
5097         TALLOC_CTX *_mem_save_entries_2;
5098         if (ndr_flags & NDR_SCALARS) {
5099                 NDR_CHECK(ndr_pull_align(ndr, 4));
5100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5101                 if (r->count > 4000) {
5102                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5103                 }
5104                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
5105                 if (_ptr_entries) {
5106                         NDR_PULL_ALLOC(ndr, r->entries);
5107                 } else {
5108                         r->entries = NULL;
5109                 }
5110         }
5111         if (ndr_flags & NDR_BUFFERS) {
5112                 if (r->entries) {
5113                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
5114                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
5115                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
5116                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
5117                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
5118                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
5119                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
5120                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
5121                                 if (_ptr_entries) {
5122                                         NDR_PULL_ALLOC(ndr, r->entries[cntr_entries_1]);
5123                                 } else {
5124                                         r->entries[cntr_entries_1] = NULL;
5125                                 }
5126                         }
5127                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
5128                                 if (r->entries[cntr_entries_1]) {
5129                                         _mem_save_entries_2 = NDR_PULL_GET_MEM_CTX(ndr);
5130                                         NDR_PULL_SET_MEM_CTX(ndr, r->entries[cntr_entries_1], 0);
5131                                         NDR_CHECK(ndr_pull_lsa_ForestTrustRecord(ndr, NDR_SCALARS|NDR_BUFFERS, r->entries[cntr_entries_1]));
5132                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_2, 0);
5133                                 }
5134                         }
5135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
5136                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
5137                 }
5138                 if (r->entries) {
5139                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
5140                 }
5141         }
5142         return NDR_ERR_SUCCESS;
5143 }
5144
5145 _PUBLIC_ void ndr_print_lsa_ForestTrustInformation(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustInformation *r)
5146 {
5147         uint32_t cntr_entries_1;
5148         ndr_print_struct(ndr, name, "lsa_ForestTrustInformation");
5149         ndr->depth++;
5150         ndr_print_uint32(ndr, "count", r->count);
5151         ndr_print_ptr(ndr, "entries", r->entries);
5152         ndr->depth++;
5153         if (r->entries) {
5154                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->count);
5155                 ndr->depth++;
5156                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
5157                         char *idx_1=NULL;
5158                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
5159                                 ndr_print_ptr(ndr, "entries", r->entries[cntr_entries_1]);
5160                                 ndr->depth++;
5161                                 if (r->entries[cntr_entries_1]) {
5162                                         ndr_print_lsa_ForestTrustRecord(ndr, "entries", r->entries[cntr_entries_1]);
5163                                 }
5164                                 ndr->depth--;
5165                                 free(idx_1);
5166                         }
5167                 }
5168                 ndr->depth--;
5169         }
5170         ndr->depth--;
5171         ndr->depth--;
5172 }
5173
5174 static enum ndr_err_code ndr_push_lsa_Close(struct ndr_push *ndr, int flags, const struct lsa_Close *r)
5175 {
5176         if (flags & NDR_IN) {
5177                 if (r->in.handle == NULL) {
5178                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5179                 }
5180                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5181         }
5182         if (flags & NDR_OUT) {
5183                 if (r->out.handle == NULL) {
5184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5185                 }
5186                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5187                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5188         }
5189         return NDR_ERR_SUCCESS;
5190 }
5191
5192 static enum ndr_err_code ndr_pull_lsa_Close(struct ndr_pull *ndr, int flags, struct lsa_Close *r)
5193 {
5194         TALLOC_CTX *_mem_save_handle_0;
5195         if (flags & NDR_IN) {
5196                 ZERO_STRUCT(r->out);
5197
5198                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5199                         NDR_PULL_ALLOC(ndr, r->in.handle);
5200                 }
5201                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5202                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5203                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5204                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5205                 NDR_PULL_ALLOC(ndr, r->out.handle);
5206                 *r->out.handle = *r->in.handle;
5207         }
5208         if (flags & NDR_OUT) {
5209                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5210                         NDR_PULL_ALLOC(ndr, r->out.handle);
5211                 }
5212                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5213                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5214                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5215                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5216                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5217         }
5218         return NDR_ERR_SUCCESS;
5219 }
5220
5221 _PUBLIC_ void ndr_print_lsa_Close(struct ndr_print *ndr, const char *name, int flags, const struct lsa_Close *r)
5222 {
5223         ndr_print_struct(ndr, name, "lsa_Close");
5224         ndr->depth++;
5225         if (flags & NDR_SET_VALUES) {
5226                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5227         }
5228         if (flags & NDR_IN) {
5229                 ndr_print_struct(ndr, "in", "lsa_Close");
5230                 ndr->depth++;
5231                 ndr_print_ptr(ndr, "handle", r->in.handle);
5232                 ndr->depth++;
5233                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5234                 ndr->depth--;
5235                 ndr->depth--;
5236         }
5237         if (flags & NDR_OUT) {
5238                 ndr_print_struct(ndr, "out", "lsa_Close");
5239                 ndr->depth++;
5240                 ndr_print_ptr(ndr, "handle", r->out.handle);
5241                 ndr->depth++;
5242                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
5243                 ndr->depth--;
5244                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5245                 ndr->depth--;
5246         }
5247         ndr->depth--;
5248 }
5249
5250 _PUBLIC_ enum ndr_err_code ndr_push_lsa_Delete(struct ndr_push *ndr, int flags, const struct lsa_Delete *r)
5251 {
5252         if (flags & NDR_IN) {
5253                 if (r->in.handle == NULL) {
5254                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5255                 }
5256                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5257         }
5258         if (flags & NDR_OUT) {
5259                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5260         }
5261         return NDR_ERR_SUCCESS;
5262 }
5263
5264 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_Delete(struct ndr_pull *ndr, int flags, struct lsa_Delete *r)
5265 {
5266         TALLOC_CTX *_mem_save_handle_0;
5267         if (flags & NDR_IN) {
5268                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5269                         NDR_PULL_ALLOC(ndr, r->in.handle);
5270                 }
5271                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5272                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5273                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5274                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5275         }
5276         if (flags & NDR_OUT) {
5277                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5278         }
5279         return NDR_ERR_SUCCESS;
5280 }
5281
5282 _PUBLIC_ void ndr_print_lsa_Delete(struct ndr_print *ndr, const char *name, int flags, const struct lsa_Delete *r)
5283 {
5284         ndr_print_struct(ndr, name, "lsa_Delete");
5285         ndr->depth++;
5286         if (flags & NDR_SET_VALUES) {
5287                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5288         }
5289         if (flags & NDR_IN) {
5290                 ndr_print_struct(ndr, "in", "lsa_Delete");
5291                 ndr->depth++;
5292                 ndr_print_ptr(ndr, "handle", r->in.handle);
5293                 ndr->depth++;
5294                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5295                 ndr->depth--;
5296                 ndr->depth--;
5297         }
5298         if (flags & NDR_OUT) {
5299                 ndr_print_struct(ndr, "out", "lsa_Delete");
5300                 ndr->depth++;
5301                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5302                 ndr->depth--;
5303         }
5304         ndr->depth--;
5305 }
5306
5307 _PUBLIC_ enum ndr_err_code ndr_push_lsa_EnumPrivs(struct ndr_push *ndr, int flags, const struct lsa_EnumPrivs *r)
5308 {
5309         if (flags & NDR_IN) {
5310                 if (r->in.handle == NULL) {
5311                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5312                 }
5313                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5314                 if (r->in.resume_handle == NULL) {
5315                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5316                 }
5317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_count));
5319         }
5320         if (flags & NDR_OUT) {
5321                 if (r->out.resume_handle == NULL) {
5322                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5323                 }
5324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5325                 if (r->out.privs == NULL) {
5326                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5327                 }
5328                 NDR_CHECK(ndr_push_lsa_PrivArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.privs));
5329                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5330         }
5331         return NDR_ERR_SUCCESS;
5332 }
5333
5334 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_EnumPrivs(struct ndr_pull *ndr, int flags, struct lsa_EnumPrivs *r)
5335 {
5336         TALLOC_CTX *_mem_save_handle_0;
5337         TALLOC_CTX *_mem_save_resume_handle_0;
5338         TALLOC_CTX *_mem_save_privs_0;
5339         if (flags & NDR_IN) {
5340                 ZERO_STRUCT(r->out);
5341
5342                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5343                         NDR_PULL_ALLOC(ndr, r->in.handle);
5344                 }
5345                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5346                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5347                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5348                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5349                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5350                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5351                 }
5352                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5353                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5355                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_count));
5357                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5358                 *r->out.resume_handle = *r->in.resume_handle;
5359                 NDR_PULL_ALLOC(ndr, r->out.privs);
5360                 ZERO_STRUCTP(r->out.privs);
5361         }
5362         if (flags & NDR_OUT) {
5363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5364                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5365                 }
5366                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5367                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5370                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5371                         NDR_PULL_ALLOC(ndr, r->out.privs);
5372                 }
5373                 _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
5374                 NDR_PULL_SET_MEM_CTX(ndr, r->out.privs, LIBNDR_FLAG_REF_ALLOC);
5375                 NDR_CHECK(ndr_pull_lsa_PrivArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.privs));
5376                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, LIBNDR_FLAG_REF_ALLOC);
5377                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5378         }
5379         return NDR_ERR_SUCCESS;
5380 }
5381
5382 _PUBLIC_ void ndr_print_lsa_EnumPrivs(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumPrivs *r)
5383 {
5384         ndr_print_struct(ndr, name, "lsa_EnumPrivs");
5385         ndr->depth++;
5386         if (flags & NDR_SET_VALUES) {
5387                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5388         }
5389         if (flags & NDR_IN) {
5390                 ndr_print_struct(ndr, "in", "lsa_EnumPrivs");
5391                 ndr->depth++;
5392                 ndr_print_ptr(ndr, "handle", r->in.handle);
5393                 ndr->depth++;
5394                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5395                 ndr->depth--;
5396                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5397                 ndr->depth++;
5398                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5399                 ndr->depth--;
5400                 ndr_print_uint32(ndr, "max_count", r->in.max_count);
5401                 ndr->depth--;
5402         }
5403         if (flags & NDR_OUT) {
5404                 ndr_print_struct(ndr, "out", "lsa_EnumPrivs");
5405                 ndr->depth++;
5406                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5407                 ndr->depth++;
5408                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5409                 ndr->depth--;
5410                 ndr_print_ptr(ndr, "privs", r->out.privs);
5411                 ndr->depth++;
5412                 ndr_print_lsa_PrivArray(ndr, "privs", r->out.privs);
5413                 ndr->depth--;
5414                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5415                 ndr->depth--;
5416         }
5417         ndr->depth--;
5418 }
5419
5420 static enum ndr_err_code ndr_push_lsa_QuerySecurity(struct ndr_push *ndr, int flags, const struct lsa_QuerySecurity *r)
5421 {
5422         if (flags & NDR_IN) {
5423                 if (r->in.handle == NULL) {
5424                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5425                 }
5426                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5427                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5428         }
5429         if (flags & NDR_OUT) {
5430                 if (r->out.sdbuf == NULL) {
5431                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5432                 }
5433                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));
5434                 if (*r->out.sdbuf) {
5435                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5436                 }
5437                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5438         }
5439         return NDR_ERR_SUCCESS;
5440 }
5441
5442 static enum ndr_err_code ndr_pull_lsa_QuerySecurity(struct ndr_pull *ndr, int flags, struct lsa_QuerySecurity *r)
5443 {
5444         uint32_t _ptr_sdbuf;
5445         TALLOC_CTX *_mem_save_handle_0;
5446         TALLOC_CTX *_mem_save_sdbuf_0;
5447         TALLOC_CTX *_mem_save_sdbuf_1;
5448         if (flags & NDR_IN) {
5449                 ZERO_STRUCT(r->out);
5450
5451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5452                         NDR_PULL_ALLOC(ndr, r->in.handle);
5453                 }
5454                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5455                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5456                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5458                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5459                 NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5460                 ZERO_STRUCTP(r->out.sdbuf);
5461         }
5462         if (flags & NDR_OUT) {
5463                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5464                         NDR_PULL_ALLOC(ndr, r->out.sdbuf);
5465                 }
5466                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5467                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
5469                 if (_ptr_sdbuf) {
5470                         NDR_PULL_ALLOC(ndr, *r->out.sdbuf);
5471                 } else {
5472                         *r->out.sdbuf = NULL;
5473                 }
5474                 if (*r->out.sdbuf) {
5475                         _mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);
5476                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);
5477                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
5478                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);
5479                 }
5480                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5481                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5482         }
5483         return NDR_ERR_SUCCESS;
5484 }
5485
5486 _PUBLIC_ void ndr_print_lsa_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QuerySecurity *r)
5487 {
5488         ndr_print_struct(ndr, name, "lsa_QuerySecurity");
5489         ndr->depth++;
5490         if (flags & NDR_SET_VALUES) {
5491                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5492         }
5493         if (flags & NDR_IN) {
5494                 ndr_print_struct(ndr, "in", "lsa_QuerySecurity");
5495                 ndr->depth++;
5496                 ndr_print_ptr(ndr, "handle", r->in.handle);
5497                 ndr->depth++;
5498                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5499                 ndr->depth--;
5500                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5501                 ndr->depth--;
5502         }
5503         if (flags & NDR_OUT) {
5504                 ndr_print_struct(ndr, "out", "lsa_QuerySecurity");
5505                 ndr->depth++;
5506                 ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
5507                 ndr->depth++;
5508                 ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);
5509                 ndr->depth++;
5510                 if (*r->out.sdbuf) {
5511                         ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);
5512                 }
5513                 ndr->depth--;
5514                 ndr->depth--;
5515                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5516                 ndr->depth--;
5517         }
5518         ndr->depth--;
5519 }
5520
5521 static enum ndr_err_code ndr_push_lsa_SetSecObj(struct ndr_push *ndr, int flags, const struct lsa_SetSecObj *r)
5522 {
5523         if (flags & NDR_IN) {
5524                 if (r->in.handle == NULL) {
5525                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5526                 }
5527                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5528                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
5529                 if (r->in.sdbuf == NULL) {
5530                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5531                 }
5532                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5533         }
5534         if (flags & NDR_OUT) {
5535                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5536         }
5537         return NDR_ERR_SUCCESS;
5538 }
5539
5540 static enum ndr_err_code ndr_pull_lsa_SetSecObj(struct ndr_pull *ndr, int flags, struct lsa_SetSecObj *r)
5541 {
5542         TALLOC_CTX *_mem_save_handle_0;
5543         TALLOC_CTX *_mem_save_sdbuf_0;
5544         if (flags & NDR_IN) {
5545                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5546                         NDR_PULL_ALLOC(ndr, r->in.handle);
5547                 }
5548                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5549                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5550                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5551                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5552                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5554                         NDR_PULL_ALLOC(ndr, r->in.sdbuf);
5555                 }
5556                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
5557                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);
5558                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
5559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
5560         }
5561         if (flags & NDR_OUT) {
5562                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5563         }
5564         return NDR_ERR_SUCCESS;
5565 }
5566
5567 _PUBLIC_ void ndr_print_lsa_SetSecObj(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSecObj *r)
5568 {
5569         ndr_print_struct(ndr, name, "lsa_SetSecObj");
5570         ndr->depth++;
5571         if (flags & NDR_SET_VALUES) {
5572                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5573         }
5574         if (flags & NDR_IN) {
5575                 ndr_print_struct(ndr, "in", "lsa_SetSecObj");
5576                 ndr->depth++;
5577                 ndr_print_ptr(ndr, "handle", r->in.handle);
5578                 ndr->depth++;
5579                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5580                 ndr->depth--;
5581                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
5582                 ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);
5583                 ndr->depth++;
5584                 ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);
5585                 ndr->depth--;
5586                 ndr->depth--;
5587         }
5588         if (flags & NDR_OUT) {
5589                 ndr_print_struct(ndr, "out", "lsa_SetSecObj");
5590                 ndr->depth++;
5591                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5592                 ndr->depth--;
5593         }
5594         ndr->depth--;
5595 }
5596
5597 static enum ndr_err_code ndr_push_lsa_ChangePassword(struct ndr_push *ndr, int flags, const struct lsa_ChangePassword *r)
5598 {
5599         if (flags & NDR_IN) {
5600         }
5601         if (flags & NDR_OUT) {
5602                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5603         }
5604         return NDR_ERR_SUCCESS;
5605 }
5606
5607 static enum ndr_err_code ndr_pull_lsa_ChangePassword(struct ndr_pull *ndr, int flags, struct lsa_ChangePassword *r)
5608 {
5609         if (flags & NDR_IN) {
5610         }
5611         if (flags & NDR_OUT) {
5612                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5613         }
5614         return NDR_ERR_SUCCESS;
5615 }
5616
5617 _PUBLIC_ void ndr_print_lsa_ChangePassword(struct ndr_print *ndr, const char *name, int flags, const struct lsa_ChangePassword *r)
5618 {
5619         ndr_print_struct(ndr, name, "lsa_ChangePassword");
5620         ndr->depth++;
5621         if (flags & NDR_SET_VALUES) {
5622                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5623         }
5624         if (flags & NDR_IN) {
5625                 ndr_print_struct(ndr, "in", "lsa_ChangePassword");
5626                 ndr->depth++;
5627                 ndr->depth--;
5628         }
5629         if (flags & NDR_OUT) {
5630                 ndr_print_struct(ndr, "out", "lsa_ChangePassword");
5631                 ndr->depth++;
5632                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5633                 ndr->depth--;
5634         }
5635         ndr->depth--;
5636 }
5637
5638 _PUBLIC_ enum ndr_err_code ndr_push_lsa_OpenPolicy(struct ndr_push *ndr, int flags, const struct lsa_OpenPolicy *r)
5639 {
5640         if (flags & NDR_IN) {
5641                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
5642                 if (r->in.system_name) {
5643                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
5644                 }
5645                 if (r->in.attr == NULL) {
5646                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5647                 }
5648                 NDR_CHECK(ndr_push_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
5649                 NDR_CHECK(ndr_push_lsa_PolicyAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5650         }
5651         if (flags & NDR_OUT) {
5652                 if (r->out.handle == NULL) {
5653                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5654                 }
5655                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5656                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5657         }
5658         return NDR_ERR_SUCCESS;
5659 }
5660
5661 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_OpenPolicy(struct ndr_pull *ndr, int flags, struct lsa_OpenPolicy *r)
5662 {
5663         uint32_t _ptr_system_name;
5664         TALLOC_CTX *_mem_save_system_name_0;
5665         TALLOC_CTX *_mem_save_attr_0;
5666         TALLOC_CTX *_mem_save_handle_0;
5667         if (flags & NDR_IN) {
5668                 ZERO_STRUCT(r->out);
5669
5670                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
5671                 if (_ptr_system_name) {
5672                         NDR_PULL_ALLOC(ndr, r->in.system_name);
5673                 } else {
5674                         r->in.system_name = NULL;
5675                 }
5676                 if (r->in.system_name) {
5677                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5678                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
5679                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
5680                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
5681                 }
5682                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5683                         NDR_PULL_ALLOC(ndr, r->in.attr);
5684                 }
5685                 _mem_save_attr_0 = NDR_PULL_GET_MEM_CTX(ndr);
5686                 NDR_PULL_SET_MEM_CTX(ndr, r->in.attr, LIBNDR_FLAG_REF_ALLOC);
5687                 NDR_CHECK(ndr_pull_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
5688                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attr_0, LIBNDR_FLAG_REF_ALLOC);
5689                 NDR_CHECK(ndr_pull_lsa_PolicyAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
5690                 NDR_PULL_ALLOC(ndr, r->out.handle);
5691                 ZERO_STRUCTP(r->out.handle);
5692         }
5693         if (flags & NDR_OUT) {
5694                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5695                         NDR_PULL_ALLOC(ndr, r->out.handle);
5696                 }
5697                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5698                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5699                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5700                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5701                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5702         }
5703         return NDR_ERR_SUCCESS;
5704 }
5705
5706 _PUBLIC_ void ndr_print_lsa_OpenPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenPolicy *r)
5707 {
5708         ndr_print_struct(ndr, name, "lsa_OpenPolicy");
5709         ndr->depth++;
5710         if (flags & NDR_SET_VALUES) {
5711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5712         }
5713         if (flags & NDR_IN) {
5714                 ndr_print_struct(ndr, "in", "lsa_OpenPolicy");
5715                 ndr->depth++;
5716                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
5717                 ndr->depth++;
5718                 if (r->in.system_name) {
5719                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
5720                 }
5721                 ndr->depth--;
5722                 ndr_print_ptr(ndr, "attr", r->in.attr);
5723                 ndr->depth++;
5724                 ndr_print_lsa_ObjectAttribute(ndr, "attr", r->in.attr);
5725                 ndr->depth--;
5726                 ndr_print_lsa_PolicyAccessMask(ndr, "access_mask", r->in.access_mask);
5727                 ndr->depth--;
5728         }
5729         if (flags & NDR_OUT) {
5730                 ndr_print_struct(ndr, "out", "lsa_OpenPolicy");
5731                 ndr->depth++;
5732                 ndr_print_ptr(ndr, "handle", r->out.handle);
5733                 ndr->depth++;
5734                 ndr_print_policy_handle(ndr, "handle", r->out.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_QueryInfoPolicy(struct ndr_push *ndr, int flags, const struct lsa_QueryInfoPolicy *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, r->in.handle));
5749                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
5750         }
5751         if (flags & NDR_OUT) {
5752                 if (r->out.info == NULL) {
5753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5754                 }
5755                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
5756                 if (*r->out.info) {
5757                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
5758                         NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
5759                 }
5760                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5761         }
5762         return NDR_ERR_SUCCESS;
5763 }
5764
5765 static enum ndr_err_code ndr_pull_lsa_QueryInfoPolicy(struct ndr_pull *ndr, int flags, struct lsa_QueryInfoPolicy *r)
5766 {
5767         uint32_t _ptr_info;
5768         TALLOC_CTX *_mem_save_handle_0;
5769         TALLOC_CTX *_mem_save_info_0;
5770         TALLOC_CTX *_mem_save_info_1;
5771         if (flags & NDR_IN) {
5772                 ZERO_STRUCT(r->out);
5773
5774                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5775                         NDR_PULL_ALLOC(ndr, r->in.handle);
5776                 }
5777                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5778                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5779                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5780                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5781                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
5782                 NDR_PULL_ALLOC(ndr, r->out.info);
5783                 ZERO_STRUCTP(r->out.info);
5784         }
5785         if (flags & NDR_OUT) {
5786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5787                         NDR_PULL_ALLOC(ndr, r->out.info);
5788                 }
5789                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5790                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
5791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
5792                 if (_ptr_info) {
5793                         NDR_PULL_ALLOC(ndr, *r->out.info);
5794                 } else {
5795                         *r->out.info = NULL;
5796                 }
5797                 if (*r->out.info) {
5798                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
5799                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
5800                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
5801                         NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
5802                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
5803                 }
5804                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5805                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5806         }
5807         return NDR_ERR_SUCCESS;
5808 }
5809
5810 _PUBLIC_ void ndr_print_lsa_QueryInfoPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryInfoPolicy *r)
5811 {
5812         ndr_print_struct(ndr, name, "lsa_QueryInfoPolicy");
5813         ndr->depth++;
5814         if (flags & NDR_SET_VALUES) {
5815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5816         }
5817         if (flags & NDR_IN) {
5818                 ndr_print_struct(ndr, "in", "lsa_QueryInfoPolicy");
5819                 ndr->depth++;
5820                 ndr_print_ptr(ndr, "handle", r->in.handle);
5821                 ndr->depth++;
5822                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5823                 ndr->depth--;
5824                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
5825                 ndr->depth--;
5826         }
5827         if (flags & NDR_OUT) {
5828                 ndr_print_struct(ndr, "out", "lsa_QueryInfoPolicy");
5829                 ndr->depth++;
5830                 ndr_print_ptr(ndr, "info", r->out.info);
5831                 ndr->depth++;
5832                 ndr_print_ptr(ndr, "info", *r->out.info);
5833                 ndr->depth++;
5834                 if (*r->out.info) {
5835                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
5836                         ndr_print_lsa_PolicyInformation(ndr, "info", *r->out.info);
5837                 }
5838                 ndr->depth--;
5839                 ndr->depth--;
5840                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5841                 ndr->depth--;
5842         }
5843         ndr->depth--;
5844 }
5845
5846 static enum ndr_err_code ndr_push_lsa_SetInfoPolicy(struct ndr_push *ndr, int flags, const struct lsa_SetInfoPolicy *r)
5847 {
5848         if (flags & NDR_IN) {
5849                 if (r->in.handle == NULL) {
5850                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5851                 }
5852                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5853                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
5854                 if (r->in.info == NULL) {
5855                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5856                 }
5857                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
5858                 NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5859         }
5860         if (flags & NDR_OUT) {
5861                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5862         }
5863         return NDR_ERR_SUCCESS;
5864 }
5865
5866 static enum ndr_err_code ndr_pull_lsa_SetInfoPolicy(struct ndr_pull *ndr, int flags, struct lsa_SetInfoPolicy *r)
5867 {
5868         TALLOC_CTX *_mem_save_handle_0;
5869         TALLOC_CTX *_mem_save_info_0;
5870         if (flags & NDR_IN) {
5871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5872                         NDR_PULL_ALLOC(ndr, r->in.handle);
5873                 }
5874                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5875                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5876                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5878                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
5879                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5880                         NDR_PULL_ALLOC(ndr, r->in.info);
5881                 }
5882                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5883                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5884                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
5885                 NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5886                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5887         }
5888         if (flags & NDR_OUT) {
5889                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5890         }
5891         return NDR_ERR_SUCCESS;
5892 }
5893
5894 _PUBLIC_ void ndr_print_lsa_SetInfoPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInfoPolicy *r)
5895 {
5896         ndr_print_struct(ndr, name, "lsa_SetInfoPolicy");
5897         ndr->depth++;
5898         if (flags & NDR_SET_VALUES) {
5899                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5900         }
5901         if (flags & NDR_IN) {
5902                 ndr_print_struct(ndr, "in", "lsa_SetInfoPolicy");
5903                 ndr->depth++;
5904                 ndr_print_ptr(ndr, "handle", r->in.handle);
5905                 ndr->depth++;
5906                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5907                 ndr->depth--;
5908                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
5909                 ndr_print_ptr(ndr, "info", r->in.info);
5910                 ndr->depth++;
5911                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
5912                 ndr_print_lsa_PolicyInformation(ndr, "info", r->in.info);
5913                 ndr->depth--;
5914                 ndr->depth--;
5915         }
5916         if (flags & NDR_OUT) {
5917                 ndr_print_struct(ndr, "out", "lsa_SetInfoPolicy");
5918                 ndr->depth++;
5919                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5920                 ndr->depth--;
5921         }
5922         ndr->depth--;
5923 }
5924
5925 static enum ndr_err_code ndr_push_lsa_ClearAuditLog(struct ndr_push *ndr, int flags, const struct lsa_ClearAuditLog *r)
5926 {
5927         if (flags & NDR_IN) {
5928         }
5929         if (flags & NDR_OUT) {
5930                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5931         }
5932         return NDR_ERR_SUCCESS;
5933 }
5934
5935 static enum ndr_err_code ndr_pull_lsa_ClearAuditLog(struct ndr_pull *ndr, int flags, struct lsa_ClearAuditLog *r)
5936 {
5937         if (flags & NDR_IN) {
5938         }
5939         if (flags & NDR_OUT) {
5940                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5941         }
5942         return NDR_ERR_SUCCESS;
5943 }
5944
5945 _PUBLIC_ void ndr_print_lsa_ClearAuditLog(struct ndr_print *ndr, const char *name, int flags, const struct lsa_ClearAuditLog *r)
5946 {
5947         ndr_print_struct(ndr, name, "lsa_ClearAuditLog");
5948         ndr->depth++;
5949         if (flags & NDR_SET_VALUES) {
5950                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5951         }
5952         if (flags & NDR_IN) {
5953                 ndr_print_struct(ndr, "in", "lsa_ClearAuditLog");
5954                 ndr->depth++;
5955                 ndr->depth--;
5956         }
5957         if (flags & NDR_OUT) {
5958                 ndr_print_struct(ndr, "out", "lsa_ClearAuditLog");
5959                 ndr->depth++;
5960                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5961                 ndr->depth--;
5962         }
5963         ndr->depth--;
5964 }
5965
5966 _PUBLIC_ enum ndr_err_code ndr_push_lsa_CreateAccount(struct ndr_push *ndr, int flags, const struct lsa_CreateAccount *r)
5967 {
5968         if (flags & NDR_IN) {
5969                 if (r->in.handle == NULL) {
5970                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5971                 }
5972                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5973                 if (r->in.sid == NULL) {
5974                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5975                 }
5976                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
5977                 NDR_CHECK(ndr_push_lsa_AccountAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
5978         }
5979         if (flags & NDR_OUT) {
5980                 if (r->out.acct_handle == NULL) {
5981                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5982                 }
5983                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.acct_handle));
5984                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5985         }
5986         return NDR_ERR_SUCCESS;
5987 }
5988
5989 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_CreateAccount(struct ndr_pull *ndr, int flags, struct lsa_CreateAccount *r)
5990 {
5991         TALLOC_CTX *_mem_save_handle_0;
5992         TALLOC_CTX *_mem_save_sid_0;
5993         TALLOC_CTX *_mem_save_acct_handle_0;
5994         if (flags & NDR_IN) {
5995                 ZERO_STRUCT(r->out);
5996
5997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5998                         NDR_PULL_ALLOC(ndr, r->in.handle);
5999                 }
6000                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6001                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6002                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6004                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6005                         NDR_PULL_ALLOC(ndr, r->in.sid);
6006                 }
6007                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6008                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6009                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6010                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6011                 NDR_CHECK(ndr_pull_lsa_AccountAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6012                 NDR_PULL_ALLOC(ndr, r->out.acct_handle);
6013                 ZERO_STRUCTP(r->out.acct_handle);
6014         }
6015         if (flags & NDR_OUT) {
6016                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6017                         NDR_PULL_ALLOC(ndr, r->out.acct_handle);
6018                 }
6019                 _mem_save_acct_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6020                 NDR_PULL_SET_MEM_CTX(ndr, r->out.acct_handle, LIBNDR_FLAG_REF_ALLOC);
6021                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.acct_handle));
6022                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_handle_0, LIBNDR_FLAG_REF_ALLOC);
6023                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6024         }
6025         return NDR_ERR_SUCCESS;
6026 }
6027
6028 _PUBLIC_ void ndr_print_lsa_CreateAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateAccount *r)
6029 {
6030         ndr_print_struct(ndr, name, "lsa_CreateAccount");
6031         ndr->depth++;
6032         if (flags & NDR_SET_VALUES) {
6033                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6034         }
6035         if (flags & NDR_IN) {
6036                 ndr_print_struct(ndr, "in", "lsa_CreateAccount");
6037                 ndr->depth++;
6038                 ndr_print_ptr(ndr, "handle", r->in.handle);
6039                 ndr->depth++;
6040                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6041                 ndr->depth--;
6042                 ndr_print_ptr(ndr, "sid", r->in.sid);
6043                 ndr->depth++;
6044                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6045                 ndr->depth--;
6046                 ndr_print_lsa_AccountAccessMask(ndr, "access_mask", r->in.access_mask);
6047                 ndr->depth--;
6048         }
6049         if (flags & NDR_OUT) {
6050                 ndr_print_struct(ndr, "out", "lsa_CreateAccount");
6051                 ndr->depth++;
6052                 ndr_print_ptr(ndr, "acct_handle", r->out.acct_handle);
6053                 ndr->depth++;
6054                 ndr_print_policy_handle(ndr, "acct_handle", r->out.acct_handle);
6055                 ndr->depth--;
6056                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6057                 ndr->depth--;
6058         }
6059         ndr->depth--;
6060 }
6061
6062 _PUBLIC_ enum ndr_err_code ndr_push_lsa_EnumAccounts(struct ndr_push *ndr, int flags, const struct lsa_EnumAccounts *r)
6063 {
6064         if (flags & NDR_IN) {
6065                 if (r->in.handle == NULL) {
6066                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6067                 }
6068                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6069                 if (r->in.resume_handle == NULL) {
6070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6071                 }
6072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_entries));
6074         }
6075         if (flags & NDR_OUT) {
6076                 if (r->out.resume_handle == NULL) {
6077                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6078                 }
6079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6080                 if (r->out.sids == NULL) {
6081                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6082                 }
6083                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
6084                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6085         }
6086         return NDR_ERR_SUCCESS;
6087 }
6088
6089 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_EnumAccounts(struct ndr_pull *ndr, int flags, struct lsa_EnumAccounts *r)
6090 {
6091         TALLOC_CTX *_mem_save_handle_0;
6092         TALLOC_CTX *_mem_save_resume_handle_0;
6093         TALLOC_CTX *_mem_save_sids_0;
6094         if (flags & NDR_IN) {
6095                 ZERO_STRUCT(r->out);
6096
6097                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6098                         NDR_PULL_ALLOC(ndr, r->in.handle);
6099                 }
6100                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6101                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6102                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6103                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6104                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6105                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6106                 }
6107                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6108                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6110                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_entries));
6112                 if (r->in.num_entries > 8192) {
6113                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6114                 }
6115                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6116                 *r->out.resume_handle = *r->in.resume_handle;
6117                 NDR_PULL_ALLOC(ndr, r->out.sids);
6118                 ZERO_STRUCTP(r->out.sids);
6119         }
6120         if (flags & NDR_OUT) {
6121                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6122                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6123                 }
6124                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6125                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6127                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6128                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6129                         NDR_PULL_ALLOC(ndr, r->out.sids);
6130                 }
6131                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
6132                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
6133                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
6134                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
6135                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6136         }
6137         return NDR_ERR_SUCCESS;
6138 }
6139
6140 _PUBLIC_ void ndr_print_lsa_EnumAccounts(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccounts *r)
6141 {
6142         ndr_print_struct(ndr, name, "lsa_EnumAccounts");
6143         ndr->depth++;
6144         if (flags & NDR_SET_VALUES) {
6145                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6146         }
6147         if (flags & NDR_IN) {
6148                 ndr_print_struct(ndr, "in", "lsa_EnumAccounts");
6149                 ndr->depth++;
6150                 ndr_print_ptr(ndr, "handle", r->in.handle);
6151                 ndr->depth++;
6152                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6153                 ndr->depth--;
6154                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6155                 ndr->depth++;
6156                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6157                 ndr->depth--;
6158                 ndr_print_uint32(ndr, "num_entries", r->in.num_entries);
6159                 ndr->depth--;
6160         }
6161         if (flags & NDR_OUT) {
6162                 ndr_print_struct(ndr, "out", "lsa_EnumAccounts");
6163                 ndr->depth++;
6164                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6165                 ndr->depth++;
6166                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6167                 ndr->depth--;
6168                 ndr_print_ptr(ndr, "sids", r->out.sids);
6169                 ndr->depth++;
6170                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
6171                 ndr->depth--;
6172                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6173                 ndr->depth--;
6174         }
6175         ndr->depth--;
6176 }
6177
6178 _PUBLIC_ enum ndr_err_code ndr_push_lsa_CreateTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomain *r)
6179 {
6180         if (flags & NDR_IN) {
6181                 if (r->in.policy_handle == NULL) {
6182                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6183                 }
6184                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.policy_handle));
6185                 if (r->in.info == NULL) {
6186                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6187                 }
6188                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6189                 NDR_CHECK(ndr_push_lsa_TrustedAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6190         }
6191         if (flags & NDR_OUT) {
6192                 if (r->out.trustdom_handle == NULL) {
6193                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6194                 }
6195                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
6196                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6197         }
6198         return NDR_ERR_SUCCESS;
6199 }
6200
6201 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_CreateTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomain *r)
6202 {
6203         TALLOC_CTX *_mem_save_policy_handle_0;
6204         TALLOC_CTX *_mem_save_info_0;
6205         TALLOC_CTX *_mem_save_trustdom_handle_0;
6206         if (flags & NDR_IN) {
6207                 ZERO_STRUCT(r->out);
6208
6209                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6210                         NDR_PULL_ALLOC(ndr, r->in.policy_handle);
6211                 }
6212                 _mem_save_policy_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6213                 NDR_PULL_SET_MEM_CTX(ndr, r->in.policy_handle, LIBNDR_FLAG_REF_ALLOC);
6214                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.policy_handle));
6215                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_policy_handle_0, LIBNDR_FLAG_REF_ALLOC);
6216                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6217                         NDR_PULL_ALLOC(ndr, r->in.info);
6218                 }
6219                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6220                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
6221                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
6222                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
6223                 NDR_CHECK(ndr_pull_lsa_TrustedAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6224                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
6225                 ZERO_STRUCTP(r->out.trustdom_handle);
6226         }
6227         if (flags & NDR_OUT) {
6228                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6229                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
6230                 }
6231                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6232                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
6233                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
6234                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
6235                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6236         }
6237         return NDR_ERR_SUCCESS;
6238 }
6239
6240 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomain *r)
6241 {
6242         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomain");
6243         ndr->depth++;
6244         if (flags & NDR_SET_VALUES) {
6245                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6246         }
6247         if (flags & NDR_IN) {
6248                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomain");
6249                 ndr->depth++;
6250                 ndr_print_ptr(ndr, "policy_handle", r->in.policy_handle);
6251                 ndr->depth++;
6252                 ndr_print_policy_handle(ndr, "policy_handle", r->in.policy_handle);
6253                 ndr->depth--;
6254                 ndr_print_ptr(ndr, "info", r->in.info);
6255                 ndr->depth++;
6256                 ndr_print_lsa_DomainInfo(ndr, "info", r->in.info);
6257                 ndr->depth--;
6258                 ndr_print_lsa_TrustedAccessMask(ndr, "access_mask", r->in.access_mask);
6259                 ndr->depth--;
6260         }
6261         if (flags & NDR_OUT) {
6262                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomain");
6263                 ndr->depth++;
6264                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
6265                 ndr->depth++;
6266                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
6267                 ndr->depth--;
6268                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6269                 ndr->depth--;
6270         }
6271         ndr->depth--;
6272 }
6273
6274 static enum ndr_err_code ndr_push_lsa_EnumTrustDom(struct ndr_push *ndr, int flags, const struct lsa_EnumTrustDom *r)
6275 {
6276         if (flags & NDR_IN) {
6277                 if (r->in.handle == NULL) {
6278                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6279                 }
6280                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6281                 if (r->in.resume_handle == NULL) {
6282                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6283                 }
6284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
6286         }
6287         if (flags & NDR_OUT) {
6288                 if (r->out.resume_handle == NULL) {
6289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6290                 }
6291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6292                 if (r->out.domains == NULL) {
6293                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6294                 }
6295                 NDR_CHECK(ndr_push_lsa_DomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
6296                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6297         }
6298         return NDR_ERR_SUCCESS;
6299 }
6300
6301 static enum ndr_err_code ndr_pull_lsa_EnumTrustDom(struct ndr_pull *ndr, int flags, struct lsa_EnumTrustDom *r)
6302 {
6303         TALLOC_CTX *_mem_save_handle_0;
6304         TALLOC_CTX *_mem_save_resume_handle_0;
6305         TALLOC_CTX *_mem_save_domains_0;
6306         if (flags & NDR_IN) {
6307                 ZERO_STRUCT(r->out);
6308
6309                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6310                         NDR_PULL_ALLOC(ndr, r->in.handle);
6311                 }
6312                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6313                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6314                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6316                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6317                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6318                 }
6319                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6320                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6322                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
6324                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6325                 *r->out.resume_handle = *r->in.resume_handle;
6326                 NDR_PULL_ALLOC(ndr, r->out.domains);
6327                 ZERO_STRUCTP(r->out.domains);
6328         }
6329         if (flags & NDR_OUT) {
6330                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6331                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6332                 }
6333                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6334                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
6335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6336                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
6337                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6338                         NDR_PULL_ALLOC(ndr, r->out.domains);
6339                 }
6340                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
6341                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
6342                 NDR_CHECK(ndr_pull_lsa_DomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
6343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
6344                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6345         }
6346         return NDR_ERR_SUCCESS;
6347 }
6348
6349 _PUBLIC_ void ndr_print_lsa_EnumTrustDom(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumTrustDom *r)
6350 {
6351         ndr_print_struct(ndr, name, "lsa_EnumTrustDom");
6352         ndr->depth++;
6353         if (flags & NDR_SET_VALUES) {
6354                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6355         }
6356         if (flags & NDR_IN) {
6357                 ndr_print_struct(ndr, "in", "lsa_EnumTrustDom");
6358                 ndr->depth++;
6359                 ndr_print_ptr(ndr, "handle", r->in.handle);
6360                 ndr->depth++;
6361                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6362                 ndr->depth--;
6363                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6364                 ndr->depth++;
6365                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6366                 ndr->depth--;
6367                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
6368                 ndr->depth--;
6369         }
6370         if (flags & NDR_OUT) {
6371                 ndr_print_struct(ndr, "out", "lsa_EnumTrustDom");
6372                 ndr->depth++;
6373                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6374                 ndr->depth++;
6375                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6376                 ndr->depth--;
6377                 ndr_print_ptr(ndr, "domains", r->out.domains);
6378                 ndr->depth++;
6379                 ndr_print_lsa_DomainList(ndr, "domains", r->out.domains);
6380                 ndr->depth--;
6381                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6382                 ndr->depth--;
6383         }
6384         ndr->depth--;
6385 }
6386
6387 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupNames(struct ndr_push *ndr, int flags, const struct lsa_LookupNames *r)
6388 {
6389         uint32_t cntr_names_0;
6390         if (flags & NDR_IN) {
6391                 if (r->in.handle == NULL) {
6392                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6393                 }
6394                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
6396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
6397                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
6398                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
6399                 }
6400                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
6401                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
6402                 }
6403                 if (r->in.sids == NULL) {
6404                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6405                 }
6406                 NDR_CHECK(ndr_push_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
6407                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
6408                 if (r->in.count == NULL) {
6409                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6410                 }
6411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
6412         }
6413         if (flags & NDR_OUT) {
6414                 if (r->out.domains == NULL) {
6415                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6416                 }
6417                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
6418                 if (*r->out.domains) {
6419                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
6420                 }
6421                 if (r->out.sids == NULL) {
6422                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6423                 }
6424                 NDR_CHECK(ndr_push_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
6425                 if (r->out.count == NULL) {
6426                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6427                 }
6428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
6429                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6430         }
6431         return NDR_ERR_SUCCESS;
6432 }
6433
6434 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupNames(struct ndr_pull *ndr, int flags, struct lsa_LookupNames *r)
6435 {
6436         uint32_t cntr_names_0;
6437         uint32_t _ptr_domains;
6438         TALLOC_CTX *_mem_save_handle_0;
6439         TALLOC_CTX *_mem_save_names_0;
6440         TALLOC_CTX *_mem_save_domains_0;
6441         TALLOC_CTX *_mem_save_domains_1;
6442         TALLOC_CTX *_mem_save_sids_0;
6443         TALLOC_CTX *_mem_save_count_0;
6444         if (flags & NDR_IN) {
6445                 ZERO_STRUCT(r->out);
6446
6447                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6448                         NDR_PULL_ALLOC(ndr, r->in.handle);
6449                 }
6450                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6451                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6452                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6453                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
6455                 if (r->in.num_names > 1000) {
6456                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6457                 }
6458                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
6459                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
6460                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6461                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
6462                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
6463                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
6464                 }
6465                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
6466                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
6467                 }
6468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
6469                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6470                         NDR_PULL_ALLOC(ndr, r->in.sids);
6471                 }
6472                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
6473                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
6474                 NDR_CHECK(ndr_pull_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
6475                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
6476                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
6477                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6478                         NDR_PULL_ALLOC(ndr, r->in.count);
6479                 }
6480                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
6481                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
6482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
6483                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
6484                 NDR_PULL_ALLOC(ndr, r->out.domains);
6485                 ZERO_STRUCTP(r->out.domains);
6486                 NDR_PULL_ALLOC(ndr, r->out.sids);
6487                 *r->out.sids = *r->in.sids;
6488                 NDR_PULL_ALLOC(ndr, r->out.count);
6489                 *r->out.count = *r->in.count;
6490                 if (r->in.names) {
6491                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
6492                 }
6493         }
6494         if (flags & NDR_OUT) {
6495                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6496                         NDR_PULL_ALLOC(ndr, r->out.domains);
6497                 }
6498                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
6499                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
6500                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
6501                 if (_ptr_domains) {
6502                         NDR_PULL_ALLOC(ndr, *r->out.domains);
6503                 } else {
6504                         *r->out.domains = NULL;
6505                 }
6506                 if (*r->out.domains) {
6507                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
6508                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
6509                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
6510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
6511                 }
6512                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
6513                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6514                         NDR_PULL_ALLOC(ndr, r->out.sids);
6515                 }
6516                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
6517                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
6518                 NDR_CHECK(ndr_pull_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
6519                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
6520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6521                         NDR_PULL_ALLOC(ndr, r->out.count);
6522                 }
6523                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
6524                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
6525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
6526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
6527                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6528         }
6529         return NDR_ERR_SUCCESS;
6530 }
6531
6532 _PUBLIC_ void ndr_print_lsa_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames *r)
6533 {
6534         uint32_t cntr_names_0;
6535         ndr_print_struct(ndr, name, "lsa_LookupNames");
6536         ndr->depth++;
6537         if (flags & NDR_SET_VALUES) {
6538                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6539         }
6540         if (flags & NDR_IN) {
6541                 ndr_print_struct(ndr, "in", "lsa_LookupNames");
6542                 ndr->depth++;
6543                 ndr_print_ptr(ndr, "handle", r->in.handle);
6544                 ndr->depth++;
6545                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6546                 ndr->depth--;
6547                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
6548                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
6549                 ndr->depth++;
6550                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
6551                         char *idx_0=NULL;
6552                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
6553                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
6554                                 free(idx_0);
6555                         }
6556                 }
6557                 ndr->depth--;
6558                 ndr_print_ptr(ndr, "sids", r->in.sids);
6559                 ndr->depth++;
6560                 ndr_print_lsa_TransSidArray(ndr, "sids", r->in.sids);
6561                 ndr->depth--;
6562                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
6563                 ndr_print_ptr(ndr, "count", r->in.count);
6564                 ndr->depth++;
6565                 ndr_print_uint32(ndr, "count", *r->in.count);
6566                 ndr->depth--;
6567                 ndr->depth--;
6568         }
6569         if (flags & NDR_OUT) {
6570                 ndr_print_struct(ndr, "out", "lsa_LookupNames");
6571                 ndr->depth++;
6572                 ndr_print_ptr(ndr, "domains", r->out.domains);
6573                 ndr->depth++;
6574                 ndr_print_ptr(ndr, "domains", *r->out.domains);
6575                 ndr->depth++;
6576                 if (*r->out.domains) {
6577                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
6578                 }
6579                 ndr->depth--;
6580                 ndr->depth--;
6581                 ndr_print_ptr(ndr, "sids", r->out.sids);
6582                 ndr->depth++;
6583                 ndr_print_lsa_TransSidArray(ndr, "sids", r->out.sids);
6584                 ndr->depth--;
6585                 ndr_print_ptr(ndr, "count", r->out.count);
6586                 ndr->depth++;
6587                 ndr_print_uint32(ndr, "count", *r->out.count);
6588                 ndr->depth--;
6589                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6590                 ndr->depth--;
6591         }
6592         ndr->depth--;
6593 }
6594
6595 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupSids(struct ndr_push *ndr, int flags, const struct lsa_LookupSids *r)
6596 {
6597         if (flags & NDR_IN) {
6598                 if (r->in.handle == NULL) {
6599                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6600                 }
6601                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6602                 if (r->in.sids == NULL) {
6603                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6604                 }
6605                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
6606                 if (r->in.names == NULL) {
6607                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6608                 }
6609                 NDR_CHECK(ndr_push_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
6610                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
6611                 if (r->in.count == NULL) {
6612                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6613                 }
6614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
6615         }
6616         if (flags & NDR_OUT) {
6617                 if (r->out.domains == NULL) {
6618                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6619                 }
6620                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
6621                 if (*r->out.domains) {
6622                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
6623                 }
6624                 if (r->out.names == NULL) {
6625                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6626                 }
6627                 NDR_CHECK(ndr_push_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
6628                 if (r->out.count == NULL) {
6629                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6630                 }
6631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
6632                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6633         }
6634         return NDR_ERR_SUCCESS;
6635 }
6636
6637 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupSids(struct ndr_pull *ndr, int flags, struct lsa_LookupSids *r)
6638 {
6639         uint32_t _ptr_domains;
6640         TALLOC_CTX *_mem_save_handle_0;
6641         TALLOC_CTX *_mem_save_sids_0;
6642         TALLOC_CTX *_mem_save_domains_0;
6643         TALLOC_CTX *_mem_save_domains_1;
6644         TALLOC_CTX *_mem_save_names_0;
6645         TALLOC_CTX *_mem_save_count_0;
6646         if (flags & NDR_IN) {
6647                 ZERO_STRUCT(r->out);
6648
6649                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6650                         NDR_PULL_ALLOC(ndr, r->in.handle);
6651                 }
6652                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6653                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6654                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6655                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6656                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6657                         NDR_PULL_ALLOC(ndr, r->in.sids);
6658                 }
6659                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
6660                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
6661                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
6662                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
6663                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6664                         NDR_PULL_ALLOC(ndr, r->in.names);
6665                 }
6666                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6667                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
6668                 NDR_CHECK(ndr_pull_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
6669                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
6670                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
6671                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6672                         NDR_PULL_ALLOC(ndr, r->in.count);
6673                 }
6674                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
6675                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
6676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
6677                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
6678                 NDR_PULL_ALLOC(ndr, r->out.domains);
6679                 ZERO_STRUCTP(r->out.domains);
6680                 NDR_PULL_ALLOC(ndr, r->out.names);
6681                 *r->out.names = *r->in.names;
6682                 NDR_PULL_ALLOC(ndr, r->out.count);
6683                 *r->out.count = *r->in.count;
6684         }
6685         if (flags & NDR_OUT) {
6686                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6687                         NDR_PULL_ALLOC(ndr, r->out.domains);
6688                 }
6689                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
6690                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
6691                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
6692                 if (_ptr_domains) {
6693                         NDR_PULL_ALLOC(ndr, *r->out.domains);
6694                 } else {
6695                         *r->out.domains = NULL;
6696                 }
6697                 if (*r->out.domains) {
6698                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
6699                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
6700                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
6701                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
6702                 }
6703                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
6704                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6705                         NDR_PULL_ALLOC(ndr, r->out.names);
6706                 }
6707                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6708                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
6709                 NDR_CHECK(ndr_pull_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
6710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
6711                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6712                         NDR_PULL_ALLOC(ndr, r->out.count);
6713                 }
6714                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
6715                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
6716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
6717                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
6718                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6719         }
6720         return NDR_ERR_SUCCESS;
6721 }
6722
6723 _PUBLIC_ void ndr_print_lsa_LookupSids(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids *r)
6724 {
6725         ndr_print_struct(ndr, name, "lsa_LookupSids");
6726         ndr->depth++;
6727         if (flags & NDR_SET_VALUES) {
6728                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6729         }
6730         if (flags & NDR_IN) {
6731                 ndr_print_struct(ndr, "in", "lsa_LookupSids");
6732                 ndr->depth++;
6733                 ndr_print_ptr(ndr, "handle", r->in.handle);
6734                 ndr->depth++;
6735                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6736                 ndr->depth--;
6737                 ndr_print_ptr(ndr, "sids", r->in.sids);
6738                 ndr->depth++;
6739                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
6740                 ndr->depth--;
6741                 ndr_print_ptr(ndr, "names", r->in.names);
6742                 ndr->depth++;
6743                 ndr_print_lsa_TransNameArray(ndr, "names", r->in.names);
6744                 ndr->depth--;
6745                 ndr_print_uint16(ndr, "level", r->in.level);
6746                 ndr_print_ptr(ndr, "count", r->in.count);
6747                 ndr->depth++;
6748                 ndr_print_uint32(ndr, "count", *r->in.count);
6749                 ndr->depth--;
6750                 ndr->depth--;
6751         }
6752         if (flags & NDR_OUT) {
6753                 ndr_print_struct(ndr, "out", "lsa_LookupSids");
6754                 ndr->depth++;
6755                 ndr_print_ptr(ndr, "domains", r->out.domains);
6756                 ndr->depth++;
6757                 ndr_print_ptr(ndr, "domains", *r->out.domains);
6758                 ndr->depth++;
6759                 if (*r->out.domains) {
6760                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
6761                 }
6762                 ndr->depth--;
6763                 ndr->depth--;
6764                 ndr_print_ptr(ndr, "names", r->out.names);
6765                 ndr->depth++;
6766                 ndr_print_lsa_TransNameArray(ndr, "names", r->out.names);
6767                 ndr->depth--;
6768                 ndr_print_ptr(ndr, "count", r->out.count);
6769                 ndr->depth++;
6770                 ndr_print_uint32(ndr, "count", *r->out.count);
6771                 ndr->depth--;
6772                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6773                 ndr->depth--;
6774         }
6775         ndr->depth--;
6776 }
6777
6778 _PUBLIC_ enum ndr_err_code ndr_push_lsa_CreateSecret(struct ndr_push *ndr, int flags, const struct lsa_CreateSecret *r)
6779 {
6780         if (flags & NDR_IN) {
6781                 if (r->in.handle == NULL) {
6782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6783                 }
6784                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6785                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6786                 NDR_CHECK(ndr_push_lsa_SecretAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6787         }
6788         if (flags & NDR_OUT) {
6789                 if (r->out.sec_handle == NULL) {
6790                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6791                 }
6792                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.sec_handle));
6793                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6794         }
6795         return NDR_ERR_SUCCESS;
6796 }
6797
6798 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_CreateSecret(struct ndr_pull *ndr, int flags, struct lsa_CreateSecret *r)
6799 {
6800         TALLOC_CTX *_mem_save_handle_0;
6801         TALLOC_CTX *_mem_save_sec_handle_0;
6802         if (flags & NDR_IN) {
6803                 ZERO_STRUCT(r->out);
6804
6805                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6806                         NDR_PULL_ALLOC(ndr, r->in.handle);
6807                 }
6808                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6809                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6810                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6812                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6813                 NDR_CHECK(ndr_pull_lsa_SecretAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6814                 NDR_PULL_ALLOC(ndr, r->out.sec_handle);
6815                 ZERO_STRUCTP(r->out.sec_handle);
6816         }
6817         if (flags & NDR_OUT) {
6818                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6819                         NDR_PULL_ALLOC(ndr, r->out.sec_handle);
6820                 }
6821                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6822                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sec_handle, LIBNDR_FLAG_REF_ALLOC);
6823                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.sec_handle));
6824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
6825                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6826         }
6827         return NDR_ERR_SUCCESS;
6828 }
6829
6830 _PUBLIC_ void ndr_print_lsa_CreateSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateSecret *r)
6831 {
6832         ndr_print_struct(ndr, name, "lsa_CreateSecret");
6833         ndr->depth++;
6834         if (flags & NDR_SET_VALUES) {
6835                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6836         }
6837         if (flags & NDR_IN) {
6838                 ndr_print_struct(ndr, "in", "lsa_CreateSecret");
6839                 ndr->depth++;
6840                 ndr_print_ptr(ndr, "handle", r->in.handle);
6841                 ndr->depth++;
6842                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6843                 ndr->depth--;
6844                 ndr_print_lsa_String(ndr, "name", &r->in.name);
6845                 ndr_print_lsa_SecretAccessMask(ndr, "access_mask", r->in.access_mask);
6846                 ndr->depth--;
6847         }
6848         if (flags & NDR_OUT) {
6849                 ndr_print_struct(ndr, "out", "lsa_CreateSecret");
6850                 ndr->depth++;
6851                 ndr_print_ptr(ndr, "sec_handle", r->out.sec_handle);
6852                 ndr->depth++;
6853                 ndr_print_policy_handle(ndr, "sec_handle", r->out.sec_handle);
6854                 ndr->depth--;
6855                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6856                 ndr->depth--;
6857         }
6858         ndr->depth--;
6859 }
6860
6861 static enum ndr_err_code ndr_push_lsa_OpenAccount(struct ndr_push *ndr, int flags, const struct lsa_OpenAccount *r)
6862 {
6863         if (flags & NDR_IN) {
6864                 if (r->in.handle == NULL) {
6865                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6866                 }
6867                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6868                 if (r->in.sid == NULL) {
6869                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6870                 }
6871                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6872                 NDR_CHECK(ndr_push_lsa_AccountAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
6873         }
6874         if (flags & NDR_OUT) {
6875                 if (r->out.acct_handle == NULL) {
6876                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6877                 }
6878                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.acct_handle));
6879                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6880         }
6881         return NDR_ERR_SUCCESS;
6882 }
6883
6884 static enum ndr_err_code ndr_pull_lsa_OpenAccount(struct ndr_pull *ndr, int flags, struct lsa_OpenAccount *r)
6885 {
6886         TALLOC_CTX *_mem_save_handle_0;
6887         TALLOC_CTX *_mem_save_sid_0;
6888         TALLOC_CTX *_mem_save_acct_handle_0;
6889         if (flags & NDR_IN) {
6890                 ZERO_STRUCT(r->out);
6891
6892                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6893                         NDR_PULL_ALLOC(ndr, r->in.handle);
6894                 }
6895                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6896                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6897                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6898                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6899                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6900                         NDR_PULL_ALLOC(ndr, r->in.sid);
6901                 }
6902                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6903                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6904                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6905                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6906                 NDR_CHECK(ndr_pull_lsa_AccountAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
6907                 NDR_PULL_ALLOC(ndr, r->out.acct_handle);
6908                 ZERO_STRUCTP(r->out.acct_handle);
6909         }
6910         if (flags & NDR_OUT) {
6911                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6912                         NDR_PULL_ALLOC(ndr, r->out.acct_handle);
6913                 }
6914                 _mem_save_acct_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6915                 NDR_PULL_SET_MEM_CTX(ndr, r->out.acct_handle, LIBNDR_FLAG_REF_ALLOC);
6916                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.acct_handle));
6917                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_handle_0, LIBNDR_FLAG_REF_ALLOC);
6918                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6919         }
6920         return NDR_ERR_SUCCESS;
6921 }
6922
6923 _PUBLIC_ void ndr_print_lsa_OpenAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenAccount *r)
6924 {
6925         ndr_print_struct(ndr, name, "lsa_OpenAccount");
6926         ndr->depth++;
6927         if (flags & NDR_SET_VALUES) {
6928                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6929         }
6930         if (flags & NDR_IN) {
6931                 ndr_print_struct(ndr, "in", "lsa_OpenAccount");
6932                 ndr->depth++;
6933                 ndr_print_ptr(ndr, "handle", r->in.handle);
6934                 ndr->depth++;
6935                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6936                 ndr->depth--;
6937                 ndr_print_ptr(ndr, "sid", r->in.sid);
6938                 ndr->depth++;
6939                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6940                 ndr->depth--;
6941                 ndr_print_lsa_AccountAccessMask(ndr, "access_mask", r->in.access_mask);
6942                 ndr->depth--;
6943         }
6944         if (flags & NDR_OUT) {
6945                 ndr_print_struct(ndr, "out", "lsa_OpenAccount");
6946                 ndr->depth++;
6947                 ndr_print_ptr(ndr, "acct_handle", r->out.acct_handle);
6948                 ndr->depth++;
6949                 ndr_print_policy_handle(ndr, "acct_handle", r->out.acct_handle);
6950                 ndr->depth--;
6951                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6952                 ndr->depth--;
6953         }
6954         ndr->depth--;
6955 }
6956
6957 static enum ndr_err_code ndr_push_lsa_EnumPrivsAccount(struct ndr_push *ndr, int flags, const struct lsa_EnumPrivsAccount *r)
6958 {
6959         if (flags & NDR_IN) {
6960                 if (r->in.handle == NULL) {
6961                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6962                 }
6963                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6964         }
6965         if (flags & NDR_OUT) {
6966                 if (r->out.privs == NULL) {
6967                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6968                 }
6969                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.privs));
6970                 if (*r->out.privs) {
6971                         NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, *r->out.privs));
6972                 }
6973                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6974         }
6975         return NDR_ERR_SUCCESS;
6976 }
6977
6978 static enum ndr_err_code ndr_pull_lsa_EnumPrivsAccount(struct ndr_pull *ndr, int flags, struct lsa_EnumPrivsAccount *r)
6979 {
6980         uint32_t _ptr_privs;
6981         TALLOC_CTX *_mem_save_handle_0;
6982         TALLOC_CTX *_mem_save_privs_0;
6983         TALLOC_CTX *_mem_save_privs_1;
6984         if (flags & NDR_IN) {
6985                 ZERO_STRUCT(r->out);
6986
6987                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6988                         NDR_PULL_ALLOC(ndr, r->in.handle);
6989                 }
6990                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6991                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6992                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6993                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6994                 NDR_PULL_ALLOC(ndr, r->out.privs);
6995                 ZERO_STRUCTP(r->out.privs);
6996         }
6997         if (flags & NDR_OUT) {
6998                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6999                         NDR_PULL_ALLOC(ndr, r->out.privs);
7000                 }
7001                 _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
7002                 NDR_PULL_SET_MEM_CTX(ndr, r->out.privs, LIBNDR_FLAG_REF_ALLOC);
7003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
7004                 if (_ptr_privs) {
7005                         NDR_PULL_ALLOC(ndr, *r->out.privs);
7006                 } else {
7007                         *r->out.privs = NULL;
7008                 }
7009                 if (*r->out.privs) {
7010                         _mem_save_privs_1 = NDR_PULL_GET_MEM_CTX(ndr);
7011                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.privs, 0);
7012                         NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, *r->out.privs));
7013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_1, 0);
7014                 }
7015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, LIBNDR_FLAG_REF_ALLOC);
7016                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7017         }
7018         return NDR_ERR_SUCCESS;
7019 }
7020
7021 _PUBLIC_ void ndr_print_lsa_EnumPrivsAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumPrivsAccount *r)
7022 {
7023         ndr_print_struct(ndr, name, "lsa_EnumPrivsAccount");
7024         ndr->depth++;
7025         if (flags & NDR_SET_VALUES) {
7026                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7027         }
7028         if (flags & NDR_IN) {
7029                 ndr_print_struct(ndr, "in", "lsa_EnumPrivsAccount");
7030                 ndr->depth++;
7031                 ndr_print_ptr(ndr, "handle", r->in.handle);
7032                 ndr->depth++;
7033                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7034                 ndr->depth--;
7035                 ndr->depth--;
7036         }
7037         if (flags & NDR_OUT) {
7038                 ndr_print_struct(ndr, "out", "lsa_EnumPrivsAccount");
7039                 ndr->depth++;
7040                 ndr_print_ptr(ndr, "privs", r->out.privs);
7041                 ndr->depth++;
7042                 ndr_print_ptr(ndr, "privs", *r->out.privs);
7043                 ndr->depth++;
7044                 if (*r->out.privs) {
7045                         ndr_print_lsa_PrivilegeSet(ndr, "privs", *r->out.privs);
7046                 }
7047                 ndr->depth--;
7048                 ndr->depth--;
7049                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7050                 ndr->depth--;
7051         }
7052         ndr->depth--;
7053 }
7054
7055 static enum ndr_err_code ndr_push_lsa_AddPrivilegesToAccount(struct ndr_push *ndr, int flags, const struct lsa_AddPrivilegesToAccount *r)
7056 {
7057         if (flags & NDR_IN) {
7058                 if (r->in.handle == NULL) {
7059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7060                 }
7061                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7062                 if (r->in.privs == NULL) {
7063                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7064                 }
7065                 NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
7066         }
7067         if (flags & NDR_OUT) {
7068                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7069         }
7070         return NDR_ERR_SUCCESS;
7071 }
7072
7073 static enum ndr_err_code ndr_pull_lsa_AddPrivilegesToAccount(struct ndr_pull *ndr, int flags, struct lsa_AddPrivilegesToAccount *r)
7074 {
7075         TALLOC_CTX *_mem_save_handle_0;
7076         TALLOC_CTX *_mem_save_privs_0;
7077         if (flags & NDR_IN) {
7078                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7079                         NDR_PULL_ALLOC(ndr, r->in.handle);
7080                 }
7081                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7082                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7083                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7084                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7085                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7086                         NDR_PULL_ALLOC(ndr, r->in.privs);
7087                 }
7088                 _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
7089                 NDR_PULL_SET_MEM_CTX(ndr, r->in.privs, LIBNDR_FLAG_REF_ALLOC);
7090                 NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
7091                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, LIBNDR_FLAG_REF_ALLOC);
7092         }
7093         if (flags & NDR_OUT) {
7094                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7095         }
7096         return NDR_ERR_SUCCESS;
7097 }
7098
7099 _PUBLIC_ void ndr_print_lsa_AddPrivilegesToAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_AddPrivilegesToAccount *r)
7100 {
7101         ndr_print_struct(ndr, name, "lsa_AddPrivilegesToAccount");
7102         ndr->depth++;
7103         if (flags & NDR_SET_VALUES) {
7104                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7105         }
7106         if (flags & NDR_IN) {
7107                 ndr_print_struct(ndr, "in", "lsa_AddPrivilegesToAccount");
7108                 ndr->depth++;
7109                 ndr_print_ptr(ndr, "handle", r->in.handle);
7110                 ndr->depth++;
7111                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7112                 ndr->depth--;
7113                 ndr_print_ptr(ndr, "privs", r->in.privs);
7114                 ndr->depth++;
7115                 ndr_print_lsa_PrivilegeSet(ndr, "privs", r->in.privs);
7116                 ndr->depth--;
7117                 ndr->depth--;
7118         }
7119         if (flags & NDR_OUT) {
7120                 ndr_print_struct(ndr, "out", "lsa_AddPrivilegesToAccount");
7121                 ndr->depth++;
7122                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7123                 ndr->depth--;
7124         }
7125         ndr->depth--;
7126 }
7127
7128 static enum ndr_err_code ndr_push_lsa_RemovePrivilegesFromAccount(struct ndr_push *ndr, int flags, const struct lsa_RemovePrivilegesFromAccount *r)
7129 {
7130         if (flags & NDR_IN) {
7131                 if (r->in.handle == NULL) {
7132                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7133                 }
7134                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7135                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.remove_all));
7136                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.privs));
7137                 if (r->in.privs) {
7138                         NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
7139                 }
7140         }
7141         if (flags & NDR_OUT) {
7142                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7143         }
7144         return NDR_ERR_SUCCESS;
7145 }
7146
7147 static enum ndr_err_code ndr_pull_lsa_RemovePrivilegesFromAccount(struct ndr_pull *ndr, int flags, struct lsa_RemovePrivilegesFromAccount *r)
7148 {
7149         uint32_t _ptr_privs;
7150         TALLOC_CTX *_mem_save_handle_0;
7151         TALLOC_CTX *_mem_save_privs_0;
7152         if (flags & NDR_IN) {
7153                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7154                         NDR_PULL_ALLOC(ndr, r->in.handle);
7155                 }
7156                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7157                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7158                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7160                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.remove_all));
7161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
7162                 if (_ptr_privs) {
7163                         NDR_PULL_ALLOC(ndr, r->in.privs);
7164                 } else {
7165                         r->in.privs = NULL;
7166                 }
7167                 if (r->in.privs) {
7168                         _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
7169                         NDR_PULL_SET_MEM_CTX(ndr, r->in.privs, 0);
7170                         NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
7171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, 0);
7172                 }
7173         }
7174         if (flags & NDR_OUT) {
7175                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7176         }
7177         return NDR_ERR_SUCCESS;
7178 }
7179
7180 _PUBLIC_ void ndr_print_lsa_RemovePrivilegesFromAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RemovePrivilegesFromAccount *r)
7181 {
7182         ndr_print_struct(ndr, name, "lsa_RemovePrivilegesFromAccount");
7183         ndr->depth++;
7184         if (flags & NDR_SET_VALUES) {
7185                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7186         }
7187         if (flags & NDR_IN) {
7188                 ndr_print_struct(ndr, "in", "lsa_RemovePrivilegesFromAccount");
7189                 ndr->depth++;
7190                 ndr_print_ptr(ndr, "handle", r->in.handle);
7191                 ndr->depth++;
7192                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7193                 ndr->depth--;
7194                 ndr_print_uint8(ndr, "remove_all", r->in.remove_all);
7195                 ndr_print_ptr(ndr, "privs", r->in.privs);
7196                 ndr->depth++;
7197                 if (r->in.privs) {
7198                         ndr_print_lsa_PrivilegeSet(ndr, "privs", r->in.privs);
7199                 }
7200                 ndr->depth--;
7201                 ndr->depth--;
7202         }
7203         if (flags & NDR_OUT) {
7204                 ndr_print_struct(ndr, "out", "lsa_RemovePrivilegesFromAccount");
7205                 ndr->depth++;
7206                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7207                 ndr->depth--;
7208         }
7209         ndr->depth--;
7210 }
7211
7212 static enum ndr_err_code ndr_push_lsa_GetQuotasForAccount(struct ndr_push *ndr, int flags, const struct lsa_GetQuotasForAccount *r)
7213 {
7214         if (flags & NDR_IN) {
7215         }
7216         if (flags & NDR_OUT) {
7217                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7218         }
7219         return NDR_ERR_SUCCESS;
7220 }
7221
7222 static enum ndr_err_code ndr_pull_lsa_GetQuotasForAccount(struct ndr_pull *ndr, int flags, struct lsa_GetQuotasForAccount *r)
7223 {
7224         if (flags & NDR_IN) {
7225         }
7226         if (flags & NDR_OUT) {
7227                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7228         }
7229         return NDR_ERR_SUCCESS;
7230 }
7231
7232 _PUBLIC_ void ndr_print_lsa_GetQuotasForAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetQuotasForAccount *r)
7233 {
7234         ndr_print_struct(ndr, name, "lsa_GetQuotasForAccount");
7235         ndr->depth++;
7236         if (flags & NDR_SET_VALUES) {
7237                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7238         }
7239         if (flags & NDR_IN) {
7240                 ndr_print_struct(ndr, "in", "lsa_GetQuotasForAccount");
7241                 ndr->depth++;
7242                 ndr->depth--;
7243         }
7244         if (flags & NDR_OUT) {
7245                 ndr_print_struct(ndr, "out", "lsa_GetQuotasForAccount");
7246                 ndr->depth++;
7247                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7248                 ndr->depth--;
7249         }
7250         ndr->depth--;
7251 }
7252
7253 static enum ndr_err_code ndr_push_lsa_SetQuotasForAccount(struct ndr_push *ndr, int flags, const struct lsa_SetQuotasForAccount *r)
7254 {
7255         if (flags & NDR_IN) {
7256         }
7257         if (flags & NDR_OUT) {
7258                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7259         }
7260         return NDR_ERR_SUCCESS;
7261 }
7262
7263 static enum ndr_err_code ndr_pull_lsa_SetQuotasForAccount(struct ndr_pull *ndr, int flags, struct lsa_SetQuotasForAccount *r)
7264 {
7265         if (flags & NDR_IN) {
7266         }
7267         if (flags & NDR_OUT) {
7268                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7269         }
7270         return NDR_ERR_SUCCESS;
7271 }
7272
7273 _PUBLIC_ void ndr_print_lsa_SetQuotasForAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetQuotasForAccount *r)
7274 {
7275         ndr_print_struct(ndr, name, "lsa_SetQuotasForAccount");
7276         ndr->depth++;
7277         if (flags & NDR_SET_VALUES) {
7278                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7279         }
7280         if (flags & NDR_IN) {
7281                 ndr_print_struct(ndr, "in", "lsa_SetQuotasForAccount");
7282                 ndr->depth++;
7283                 ndr->depth--;
7284         }
7285         if (flags & NDR_OUT) {
7286                 ndr_print_struct(ndr, "out", "lsa_SetQuotasForAccount");
7287                 ndr->depth++;
7288                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7289                 ndr->depth--;
7290         }
7291         ndr->depth--;
7292 }
7293
7294 static enum ndr_err_code ndr_push_lsa_GetSystemAccessAccount(struct ndr_push *ndr, int flags, const struct lsa_GetSystemAccessAccount *r)
7295 {
7296         if (flags & NDR_IN) {
7297                 if (r->in.handle == NULL) {
7298                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7299                 }
7300                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7301         }
7302         if (flags & NDR_OUT) {
7303                 if (r->out.access_mask == NULL) {
7304                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7305                 }
7306                 NDR_CHECK(ndr_push_lsa_AccountAccessMask(ndr, NDR_SCALARS, *r->out.access_mask));
7307                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7308         }
7309         return NDR_ERR_SUCCESS;
7310 }
7311
7312 static enum ndr_err_code ndr_pull_lsa_GetSystemAccessAccount(struct ndr_pull *ndr, int flags, struct lsa_GetSystemAccessAccount *r)
7313 {
7314         TALLOC_CTX *_mem_save_handle_0;
7315         TALLOC_CTX *_mem_save_access_mask_0;
7316         if (flags & NDR_IN) {
7317                 ZERO_STRUCT(r->out);
7318
7319                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7320                         NDR_PULL_ALLOC(ndr, r->in.handle);
7321                 }
7322                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7323                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7324                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7325                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7326                 NDR_PULL_ALLOC(ndr, r->out.access_mask);
7327                 ZERO_STRUCTP(r->out.access_mask);
7328         }
7329         if (flags & NDR_OUT) {
7330                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7331                         NDR_PULL_ALLOC(ndr, r->out.access_mask);
7332                 }
7333                 _mem_save_access_mask_0 = NDR_PULL_GET_MEM_CTX(ndr);
7334                 NDR_PULL_SET_MEM_CTX(ndr, r->out.access_mask, LIBNDR_FLAG_REF_ALLOC);
7335                 NDR_CHECK(ndr_pull_lsa_AccountAccessMask(ndr, NDR_SCALARS, r->out.access_mask));
7336                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_mask_0, LIBNDR_FLAG_REF_ALLOC);
7337                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7338         }
7339         return NDR_ERR_SUCCESS;
7340 }
7341
7342 _PUBLIC_ void ndr_print_lsa_GetSystemAccessAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetSystemAccessAccount *r)
7343 {
7344         ndr_print_struct(ndr, name, "lsa_GetSystemAccessAccount");
7345         ndr->depth++;
7346         if (flags & NDR_SET_VALUES) {
7347                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7348         }
7349         if (flags & NDR_IN) {
7350                 ndr_print_struct(ndr, "in", "lsa_GetSystemAccessAccount");
7351                 ndr->depth++;
7352                 ndr_print_ptr(ndr, "handle", r->in.handle);
7353                 ndr->depth++;
7354                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7355                 ndr->depth--;
7356                 ndr->depth--;
7357         }
7358         if (flags & NDR_OUT) {
7359                 ndr_print_struct(ndr, "out", "lsa_GetSystemAccessAccount");
7360                 ndr->depth++;
7361                 ndr_print_ptr(ndr, "access_mask", r->out.access_mask);
7362                 ndr->depth++;
7363                 ndr_print_lsa_AccountAccessMask(ndr, "access_mask", *r->out.access_mask);
7364                 ndr->depth--;
7365                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7366                 ndr->depth--;
7367         }
7368         ndr->depth--;
7369 }
7370
7371 static enum ndr_err_code ndr_push_lsa_SetSystemAccessAccount(struct ndr_push *ndr, int flags, const struct lsa_SetSystemAccessAccount *r)
7372 {
7373         if (flags & NDR_IN) {
7374                 if (r->in.handle == NULL) {
7375                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7376                 }
7377                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7378                 NDR_CHECK(ndr_push_lsa_AccountAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7379         }
7380         if (flags & NDR_OUT) {
7381                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7382         }
7383         return NDR_ERR_SUCCESS;
7384 }
7385
7386 static enum ndr_err_code ndr_pull_lsa_SetSystemAccessAccount(struct ndr_pull *ndr, int flags, struct lsa_SetSystemAccessAccount *r)
7387 {
7388         TALLOC_CTX *_mem_save_handle_0;
7389         if (flags & NDR_IN) {
7390                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7391                         NDR_PULL_ALLOC(ndr, r->in.handle);
7392                 }
7393                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7394                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7395                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7396                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7397                 NDR_CHECK(ndr_pull_lsa_AccountAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7398         }
7399         if (flags & NDR_OUT) {
7400                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7401         }
7402         return NDR_ERR_SUCCESS;
7403 }
7404
7405 _PUBLIC_ void ndr_print_lsa_SetSystemAccessAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSystemAccessAccount *r)
7406 {
7407         ndr_print_struct(ndr, name, "lsa_SetSystemAccessAccount");
7408         ndr->depth++;
7409         if (flags & NDR_SET_VALUES) {
7410                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7411         }
7412         if (flags & NDR_IN) {
7413                 ndr_print_struct(ndr, "in", "lsa_SetSystemAccessAccount");
7414                 ndr->depth++;
7415                 ndr_print_ptr(ndr, "handle", r->in.handle);
7416                 ndr->depth++;
7417                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7418                 ndr->depth--;
7419                 ndr_print_lsa_AccountAccessMask(ndr, "access_mask", r->in.access_mask);
7420                 ndr->depth--;
7421         }
7422         if (flags & NDR_OUT) {
7423                 ndr_print_struct(ndr, "out", "lsa_SetSystemAccessAccount");
7424                 ndr->depth++;
7425                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7426                 ndr->depth--;
7427         }
7428         ndr->depth--;
7429 }
7430
7431 static enum ndr_err_code ndr_push_lsa_OpenTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_OpenTrustedDomain *r)
7432 {
7433         if (flags & NDR_IN) {
7434                 if (r->in.handle == NULL) {
7435                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7436                 }
7437                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7438                 if (r->in.sid == NULL) {
7439                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7440                 }
7441                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
7442                 NDR_CHECK(ndr_push_lsa_TrustedAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7443         }
7444         if (flags & NDR_OUT) {
7445                 if (r->out.trustdom_handle == NULL) {
7446                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7447                 }
7448                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
7449                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7450         }
7451         return NDR_ERR_SUCCESS;
7452 }
7453
7454 static enum ndr_err_code ndr_pull_lsa_OpenTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_OpenTrustedDomain *r)
7455 {
7456         TALLOC_CTX *_mem_save_handle_0;
7457         TALLOC_CTX *_mem_save_sid_0;
7458         TALLOC_CTX *_mem_save_trustdom_handle_0;
7459         if (flags & NDR_IN) {
7460                 ZERO_STRUCT(r->out);
7461
7462                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7463                         NDR_PULL_ALLOC(ndr, r->in.handle);
7464                 }
7465                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7466                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7467                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7469                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7470                         NDR_PULL_ALLOC(ndr, r->in.sid);
7471                 }
7472                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7473                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
7474                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
7475                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
7476                 NDR_CHECK(ndr_pull_lsa_TrustedAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7477                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
7478                 ZERO_STRUCTP(r->out.trustdom_handle);
7479         }
7480         if (flags & NDR_OUT) {
7481                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7482                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
7483                 }
7484                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7485                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
7486                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
7487                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
7488                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7489         }
7490         return NDR_ERR_SUCCESS;
7491 }
7492
7493 _PUBLIC_ void ndr_print_lsa_OpenTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenTrustedDomain *r)
7494 {
7495         ndr_print_struct(ndr, name, "lsa_OpenTrustedDomain");
7496         ndr->depth++;
7497         if (flags & NDR_SET_VALUES) {
7498                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7499         }
7500         if (flags & NDR_IN) {
7501                 ndr_print_struct(ndr, "in", "lsa_OpenTrustedDomain");
7502                 ndr->depth++;
7503                 ndr_print_ptr(ndr, "handle", r->in.handle);
7504                 ndr->depth++;
7505                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7506                 ndr->depth--;
7507                 ndr_print_ptr(ndr, "sid", r->in.sid);
7508                 ndr->depth++;
7509                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
7510                 ndr->depth--;
7511                 ndr_print_lsa_TrustedAccessMask(ndr, "access_mask", r->in.access_mask);
7512                 ndr->depth--;
7513         }
7514         if (flags & NDR_OUT) {
7515                 ndr_print_struct(ndr, "out", "lsa_OpenTrustedDomain");
7516                 ndr->depth++;
7517                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
7518                 ndr->depth++;
7519                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
7520                 ndr->depth--;
7521                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7522                 ndr->depth--;
7523         }
7524         ndr->depth--;
7525 }
7526
7527 static enum ndr_err_code ndr_push_lsa_QueryTrustedDomainInfo(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfo *r)
7528 {
7529         if (flags & NDR_IN) {
7530                 if (r->in.trustdom_handle == NULL) {
7531                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7532                 }
7533                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.trustdom_handle));
7534                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
7535         }
7536         if (flags & NDR_OUT) {
7537                 if (r->out.info == NULL) {
7538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7539                 }
7540                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
7541                 if (*r->out.info) {
7542                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
7543                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7544                 }
7545                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7546         }
7547         return NDR_ERR_SUCCESS;
7548 }
7549
7550 static enum ndr_err_code ndr_pull_lsa_QueryTrustedDomainInfo(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfo *r)
7551 {
7552         uint32_t _ptr_info;
7553         TALLOC_CTX *_mem_save_trustdom_handle_0;
7554         TALLOC_CTX *_mem_save_info_0;
7555         TALLOC_CTX *_mem_save_info_1;
7556         if (flags & NDR_IN) {
7557                 ZERO_STRUCT(r->out);
7558
7559                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7560                         NDR_PULL_ALLOC(ndr, r->in.trustdom_handle);
7561                 }
7562                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7563                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
7564                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.trustdom_handle));
7565                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
7566                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7567                 NDR_PULL_ALLOC(ndr, r->out.info);
7568                 ZERO_STRUCTP(r->out.info);
7569         }
7570         if (flags & NDR_OUT) {
7571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7572                         NDR_PULL_ALLOC(ndr, r->out.info);
7573                 }
7574                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7575                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
7576                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7577                 if (_ptr_info) {
7578                         NDR_PULL_ALLOC(ndr, *r->out.info);
7579                 } else {
7580                         *r->out.info = NULL;
7581                 }
7582                 if (*r->out.info) {
7583                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
7584                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
7585                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
7586                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
7587                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
7588                 }
7589                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7590                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7591         }
7592         return NDR_ERR_SUCCESS;
7593 }
7594
7595 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfo *r)
7596 {
7597         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfo");
7598         ndr->depth++;
7599         if (flags & NDR_SET_VALUES) {
7600                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7601         }
7602         if (flags & NDR_IN) {
7603                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfo");
7604                 ndr->depth++;
7605                 ndr_print_ptr(ndr, "trustdom_handle", r->in.trustdom_handle);
7606                 ndr->depth++;
7607                 ndr_print_policy_handle(ndr, "trustdom_handle", r->in.trustdom_handle);
7608                 ndr->depth--;
7609                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
7610                 ndr->depth--;
7611         }
7612         if (flags & NDR_OUT) {
7613                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfo");
7614                 ndr->depth++;
7615                 ndr_print_ptr(ndr, "info", r->out.info);
7616                 ndr->depth++;
7617                 ndr_print_ptr(ndr, "info", *r->out.info);
7618                 ndr->depth++;
7619                 if (*r->out.info) {
7620                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
7621                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", *r->out.info);
7622                 }
7623                 ndr->depth--;
7624                 ndr->depth--;
7625                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7626                 ndr->depth--;
7627         }
7628         ndr->depth--;
7629 }
7630
7631 static enum ndr_err_code ndr_push_lsa_SetInformationTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_SetInformationTrustedDomain *r)
7632 {
7633         if (flags & NDR_IN) {
7634                 if (r->in.trustdom_handle == NULL) {
7635                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7636                 }
7637                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.trustdom_handle));
7638                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
7639                 if (r->in.info == NULL) {
7640                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7641                 }
7642                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
7643                 NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7644         }
7645         if (flags & NDR_OUT) {
7646                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7647         }
7648         return NDR_ERR_SUCCESS;
7649 }
7650
7651 static enum ndr_err_code ndr_pull_lsa_SetInformationTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_SetInformationTrustedDomain *r)
7652 {
7653         TALLOC_CTX *_mem_save_trustdom_handle_0;
7654         TALLOC_CTX *_mem_save_info_0;
7655         if (flags & NDR_IN) {
7656                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7657                         NDR_PULL_ALLOC(ndr, r->in.trustdom_handle);
7658                 }
7659                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7660                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
7661                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.trustdom_handle));
7662                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
7663                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7664                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7665                         NDR_PULL_ALLOC(ndr, r->in.info);
7666                 }
7667                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7668                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
7669                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
7670                 NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
7671                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
7672         }
7673         if (flags & NDR_OUT) {
7674                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7675         }
7676         return NDR_ERR_SUCCESS;
7677 }
7678
7679 _PUBLIC_ void ndr_print_lsa_SetInformationTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInformationTrustedDomain *r)
7680 {
7681         ndr_print_struct(ndr, name, "lsa_SetInformationTrustedDomain");
7682         ndr->depth++;
7683         if (flags & NDR_SET_VALUES) {
7684                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7685         }
7686         if (flags & NDR_IN) {
7687                 ndr_print_struct(ndr, "in", "lsa_SetInformationTrustedDomain");
7688                 ndr->depth++;
7689                 ndr_print_ptr(ndr, "trustdom_handle", r->in.trustdom_handle);
7690                 ndr->depth++;
7691                 ndr_print_policy_handle(ndr, "trustdom_handle", r->in.trustdom_handle);
7692                 ndr->depth--;
7693                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
7694                 ndr_print_ptr(ndr, "info", r->in.info);
7695                 ndr->depth++;
7696                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
7697                 ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->in.info);
7698                 ndr->depth--;
7699                 ndr->depth--;
7700         }
7701         if (flags & NDR_OUT) {
7702                 ndr_print_struct(ndr, "out", "lsa_SetInformationTrustedDomain");
7703                 ndr->depth++;
7704                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7705                 ndr->depth--;
7706         }
7707         ndr->depth--;
7708 }
7709
7710 _PUBLIC_ enum ndr_err_code ndr_push_lsa_OpenSecret(struct ndr_push *ndr, int flags, const struct lsa_OpenSecret *r)
7711 {
7712         if (flags & NDR_IN) {
7713                 if (r->in.handle == NULL) {
7714                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7715                 }
7716                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7717                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
7718                 NDR_CHECK(ndr_push_lsa_SecretAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
7719         }
7720         if (flags & NDR_OUT) {
7721                 if (r->out.sec_handle == NULL) {
7722                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7723                 }
7724                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.sec_handle));
7725                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7726         }
7727         return NDR_ERR_SUCCESS;
7728 }
7729
7730 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_OpenSecret(struct ndr_pull *ndr, int flags, struct lsa_OpenSecret *r)
7731 {
7732         TALLOC_CTX *_mem_save_handle_0;
7733         TALLOC_CTX *_mem_save_sec_handle_0;
7734         if (flags & NDR_IN) {
7735                 ZERO_STRUCT(r->out);
7736
7737                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7738                         NDR_PULL_ALLOC(ndr, r->in.handle);
7739                 }
7740                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7741                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7742                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7743                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7744                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
7745                 NDR_CHECK(ndr_pull_lsa_SecretAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
7746                 NDR_PULL_ALLOC(ndr, r->out.sec_handle);
7747                 ZERO_STRUCTP(r->out.sec_handle);
7748         }
7749         if (flags & NDR_OUT) {
7750                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7751                         NDR_PULL_ALLOC(ndr, r->out.sec_handle);
7752                 }
7753                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7754                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sec_handle, LIBNDR_FLAG_REF_ALLOC);
7755                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.sec_handle));
7756                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
7757                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7758         }
7759         return NDR_ERR_SUCCESS;
7760 }
7761
7762 _PUBLIC_ void ndr_print_lsa_OpenSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenSecret *r)
7763 {
7764         ndr_print_struct(ndr, name, "lsa_OpenSecret");
7765         ndr->depth++;
7766         if (flags & NDR_SET_VALUES) {
7767                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7768         }
7769         if (flags & NDR_IN) {
7770                 ndr_print_struct(ndr, "in", "lsa_OpenSecret");
7771                 ndr->depth++;
7772                 ndr_print_ptr(ndr, "handle", r->in.handle);
7773                 ndr->depth++;
7774                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7775                 ndr->depth--;
7776                 ndr_print_lsa_String(ndr, "name", &r->in.name);
7777                 ndr_print_lsa_SecretAccessMask(ndr, "access_mask", r->in.access_mask);
7778                 ndr->depth--;
7779         }
7780         if (flags & NDR_OUT) {
7781                 ndr_print_struct(ndr, "out", "lsa_OpenSecret");
7782                 ndr->depth++;
7783                 ndr_print_ptr(ndr, "sec_handle", r->out.sec_handle);
7784                 ndr->depth++;
7785                 ndr_print_policy_handle(ndr, "sec_handle", r->out.sec_handle);
7786                 ndr->depth--;
7787                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7788                 ndr->depth--;
7789         }
7790         ndr->depth--;
7791 }
7792
7793 _PUBLIC_ enum ndr_err_code ndr_push_lsa_SetSecret(struct ndr_push *ndr, int flags, const struct lsa_SetSecret *r)
7794 {
7795         if (flags & NDR_IN) {
7796                 if (r->in.sec_handle == NULL) {
7797                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7798                 }
7799                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.sec_handle));
7800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_val));
7801                 if (r->in.new_val) {
7802                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7803                 }
7804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_val));
7805                 if (r->in.old_val) {
7806                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7807                 }
7808         }
7809         if (flags & NDR_OUT) {
7810                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7811         }
7812         return NDR_ERR_SUCCESS;
7813 }
7814
7815 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_SetSecret(struct ndr_pull *ndr, int flags, struct lsa_SetSecret *r)
7816 {
7817         uint32_t _ptr_new_val;
7818         uint32_t _ptr_old_val;
7819         TALLOC_CTX *_mem_save_sec_handle_0;
7820         TALLOC_CTX *_mem_save_new_val_0;
7821         TALLOC_CTX *_mem_save_old_val_0;
7822         if (flags & NDR_IN) {
7823                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7824                         NDR_PULL_ALLOC(ndr, r->in.sec_handle);
7825                 }
7826                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7827                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_handle, LIBNDR_FLAG_REF_ALLOC);
7828                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.sec_handle));
7829                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
7830                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
7831                 if (_ptr_new_val) {
7832                         NDR_PULL_ALLOC(ndr, r->in.new_val);
7833                 } else {
7834                         r->in.new_val = NULL;
7835                 }
7836                 if (r->in.new_val) {
7837                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7838                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_val, 0);
7839                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7840                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
7841                 }
7842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
7843                 if (_ptr_old_val) {
7844                         NDR_PULL_ALLOC(ndr, r->in.old_val);
7845                 } else {
7846                         r->in.old_val = NULL;
7847                 }
7848                 if (r->in.old_val) {
7849                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7850                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_val, 0);
7851                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7852                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
7853                 }
7854         }
7855         if (flags & NDR_OUT) {
7856                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7857         }
7858         return NDR_ERR_SUCCESS;
7859 }
7860
7861 _PUBLIC_ void ndr_print_lsa_SetSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSecret *r)
7862 {
7863         ndr_print_struct(ndr, name, "lsa_SetSecret");
7864         ndr->depth++;
7865         if (flags & NDR_SET_VALUES) {
7866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7867         }
7868         if (flags & NDR_IN) {
7869                 ndr_print_struct(ndr, "in", "lsa_SetSecret");
7870                 ndr->depth++;
7871                 ndr_print_ptr(ndr, "sec_handle", r->in.sec_handle);
7872                 ndr->depth++;
7873                 ndr_print_policy_handle(ndr, "sec_handle", r->in.sec_handle);
7874                 ndr->depth--;
7875                 ndr_print_ptr(ndr, "new_val", r->in.new_val);
7876                 ndr->depth++;
7877                 if (r->in.new_val) {
7878                         ndr_print_lsa_DATA_BUF(ndr, "new_val", r->in.new_val);
7879                 }
7880                 ndr->depth--;
7881                 ndr_print_ptr(ndr, "old_val", r->in.old_val);
7882                 ndr->depth++;
7883                 if (r->in.old_val) {
7884                         ndr_print_lsa_DATA_BUF(ndr, "old_val", r->in.old_val);
7885                 }
7886                 ndr->depth--;
7887                 ndr->depth--;
7888         }
7889         if (flags & NDR_OUT) {
7890                 ndr_print_struct(ndr, "out", "lsa_SetSecret");
7891                 ndr->depth++;
7892                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7893                 ndr->depth--;
7894         }
7895         ndr->depth--;
7896 }
7897
7898 _PUBLIC_ enum ndr_err_code ndr_push_lsa_QuerySecret(struct ndr_push *ndr, int flags, const struct lsa_QuerySecret *r)
7899 {
7900         if (flags & NDR_IN) {
7901                 if (r->in.sec_handle == NULL) {
7902                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7903                 }
7904                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.sec_handle));
7905                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_val));
7906                 if (r->in.new_val) {
7907                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7908                 }
7909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_mtime));
7910                 if (r->in.new_mtime) {
7911                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->in.new_mtime));
7912                 }
7913                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_val));
7914                 if (r->in.old_val) {
7915                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7916                 }
7917                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_mtime));
7918                 if (r->in.old_mtime) {
7919                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->in.old_mtime));
7920                 }
7921         }
7922         if (flags & NDR_OUT) {
7923                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.new_val));
7924                 if (r->out.new_val) {
7925                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.new_val));
7926                 }
7927                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.new_mtime));
7928                 if (r->out.new_mtime) {
7929                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->out.new_mtime));
7930                 }
7931                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.old_val));
7932                 if (r->out.old_val) {
7933                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.old_val));
7934                 }
7935                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.old_mtime));
7936                 if (r->out.old_mtime) {
7937                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->out.old_mtime));
7938                 }
7939                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7940         }
7941         return NDR_ERR_SUCCESS;
7942 }
7943
7944 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_QuerySecret(struct ndr_pull *ndr, int flags, struct lsa_QuerySecret *r)
7945 {
7946         uint32_t _ptr_new_val;
7947         uint32_t _ptr_new_mtime;
7948         uint32_t _ptr_old_val;
7949         uint32_t _ptr_old_mtime;
7950         TALLOC_CTX *_mem_save_sec_handle_0;
7951         TALLOC_CTX *_mem_save_new_val_0;
7952         TALLOC_CTX *_mem_save_new_mtime_0;
7953         TALLOC_CTX *_mem_save_old_val_0;
7954         TALLOC_CTX *_mem_save_old_mtime_0;
7955         if (flags & NDR_IN) {
7956                 ZERO_STRUCT(r->out);
7957
7958                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7959                         NDR_PULL_ALLOC(ndr, r->in.sec_handle);
7960                 }
7961                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7962                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_handle, LIBNDR_FLAG_REF_ALLOC);
7963                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.sec_handle));
7964                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
7965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
7966                 if (_ptr_new_val) {
7967                         NDR_PULL_ALLOC(ndr, r->in.new_val);
7968                 } else {
7969                         r->in.new_val = NULL;
7970                 }
7971                 if (r->in.new_val) {
7972                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7973                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_val, 0);
7974                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
7976                 }
7977                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_mtime));
7978                 if (_ptr_new_mtime) {
7979                         NDR_PULL_ALLOC(ndr, r->in.new_mtime);
7980                 } else {
7981                         r->in.new_mtime = NULL;
7982                 }
7983                 if (r->in.new_mtime) {
7984                         _mem_save_new_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
7985                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_mtime, 0);
7986                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->in.new_mtime));
7987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_mtime_0, 0);
7988                 }
7989                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
7990                 if (_ptr_old_val) {
7991                         NDR_PULL_ALLOC(ndr, r->in.old_val);
7992                 } else {
7993                         r->in.old_val = NULL;
7994                 }
7995                 if (r->in.old_val) {
7996                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7997                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_val, 0);
7998                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
8000                 }
8001                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_mtime));
8002                 if (_ptr_old_mtime) {
8003                         NDR_PULL_ALLOC(ndr, r->in.old_mtime);
8004                 } else {
8005                         r->in.old_mtime = NULL;
8006                 }
8007                 if (r->in.old_mtime) {
8008                         _mem_save_old_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
8009                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_mtime, 0);
8010                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->in.old_mtime));
8011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_mtime_0, 0);
8012                 }
8013         }
8014         if (flags & NDR_OUT) {
8015                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
8016                 if (_ptr_new_val) {
8017                         NDR_PULL_ALLOC(ndr, r->out.new_val);
8018                 } else {
8019                         r->out.new_val = NULL;
8020                 }
8021                 if (r->out.new_val) {
8022                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
8023                         NDR_PULL_SET_MEM_CTX(ndr, r->out.new_val, 0);
8024                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.new_val));
8025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
8026                 }
8027                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_mtime));
8028                 if (_ptr_new_mtime) {
8029                         NDR_PULL_ALLOC(ndr, r->out.new_mtime);
8030                 } else {
8031                         r->out.new_mtime = NULL;
8032                 }
8033                 if (r->out.new_mtime) {
8034                         _mem_save_new_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
8035                         NDR_PULL_SET_MEM_CTX(ndr, r->out.new_mtime, 0);
8036                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->out.new_mtime));
8037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_mtime_0, 0);
8038                 }
8039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
8040                 if (_ptr_old_val) {
8041                         NDR_PULL_ALLOC(ndr, r->out.old_val);
8042                 } else {
8043                         r->out.old_val = NULL;
8044                 }
8045                 if (r->out.old_val) {
8046                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
8047                         NDR_PULL_SET_MEM_CTX(ndr, r->out.old_val, 0);
8048                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.old_val));
8049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
8050                 }
8051                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_mtime));
8052                 if (_ptr_old_mtime) {
8053                         NDR_PULL_ALLOC(ndr, r->out.old_mtime);
8054                 } else {
8055                         r->out.old_mtime = NULL;
8056                 }
8057                 if (r->out.old_mtime) {
8058                         _mem_save_old_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
8059                         NDR_PULL_SET_MEM_CTX(ndr, r->out.old_mtime, 0);
8060                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->out.old_mtime));
8061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_mtime_0, 0);
8062                 }
8063                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8064         }
8065         return NDR_ERR_SUCCESS;
8066 }
8067
8068 _PUBLIC_ void ndr_print_lsa_QuerySecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QuerySecret *r)
8069 {
8070         ndr_print_struct(ndr, name, "lsa_QuerySecret");
8071         ndr->depth++;
8072         if (flags & NDR_SET_VALUES) {
8073                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8074         }
8075         if (flags & NDR_IN) {
8076                 ndr_print_struct(ndr, "in", "lsa_QuerySecret");
8077                 ndr->depth++;
8078                 ndr_print_ptr(ndr, "sec_handle", r->in.sec_handle);
8079                 ndr->depth++;
8080                 ndr_print_policy_handle(ndr, "sec_handle", r->in.sec_handle);
8081                 ndr->depth--;
8082                 ndr_print_ptr(ndr, "new_val", r->in.new_val);
8083                 ndr->depth++;
8084                 if (r->in.new_val) {
8085                         ndr_print_lsa_DATA_BUF_PTR(ndr, "new_val", r->in.new_val);
8086                 }
8087                 ndr->depth--;
8088                 ndr_print_ptr(ndr, "new_mtime", r->in.new_mtime);
8089                 ndr->depth++;
8090                 if (r->in.new_mtime) {
8091                         ndr_print_NTTIME_hyper(ndr, "new_mtime", *r->in.new_mtime);
8092                 }
8093                 ndr->depth--;
8094                 ndr_print_ptr(ndr, "old_val", r->in.old_val);
8095                 ndr->depth++;
8096                 if (r->in.old_val) {
8097                         ndr_print_lsa_DATA_BUF_PTR(ndr, "old_val", r->in.old_val);
8098                 }
8099                 ndr->depth--;
8100                 ndr_print_ptr(ndr, "old_mtime", r->in.old_mtime);
8101                 ndr->depth++;
8102                 if (r->in.old_mtime) {
8103                         ndr_print_NTTIME_hyper(ndr, "old_mtime", *r->in.old_mtime);
8104                 }
8105                 ndr->depth--;
8106                 ndr->depth--;
8107         }
8108         if (flags & NDR_OUT) {
8109                 ndr_print_struct(ndr, "out", "lsa_QuerySecret");
8110                 ndr->depth++;
8111                 ndr_print_ptr(ndr, "new_val", r->out.new_val);
8112                 ndr->depth++;
8113                 if (r->out.new_val) {
8114                         ndr_print_lsa_DATA_BUF_PTR(ndr, "new_val", r->out.new_val);
8115                 }
8116                 ndr->depth--;
8117                 ndr_print_ptr(ndr, "new_mtime", r->out.new_mtime);
8118                 ndr->depth++;
8119                 if (r->out.new_mtime) {
8120                         ndr_print_NTTIME_hyper(ndr, "new_mtime", *r->out.new_mtime);
8121                 }
8122                 ndr->depth--;
8123                 ndr_print_ptr(ndr, "old_val", r->out.old_val);
8124                 ndr->depth++;
8125                 if (r->out.old_val) {
8126                         ndr_print_lsa_DATA_BUF_PTR(ndr, "old_val", r->out.old_val);
8127                 }
8128                 ndr->depth--;
8129                 ndr_print_ptr(ndr, "old_mtime", r->out.old_mtime);
8130                 ndr->depth++;
8131                 if (r->out.old_mtime) {
8132                         ndr_print_NTTIME_hyper(ndr, "old_mtime", *r->out.old_mtime);
8133                 }
8134                 ndr->depth--;
8135                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8136                 ndr->depth--;
8137         }
8138         ndr->depth--;
8139 }
8140
8141 static enum ndr_err_code ndr_push_lsa_LookupPrivValue(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivValue *r)
8142 {
8143         if (flags & NDR_IN) {
8144                 if (r->in.handle == NULL) {
8145                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8146                 }
8147                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8148                 if (r->in.name == NULL) {
8149                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8150                 }
8151                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
8152         }
8153         if (flags & NDR_OUT) {
8154                 if (r->out.luid == NULL) {
8155                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8156                 }
8157                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, r->out.luid));
8158                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8159         }
8160         return NDR_ERR_SUCCESS;
8161 }
8162
8163 static enum ndr_err_code ndr_pull_lsa_LookupPrivValue(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivValue *r)
8164 {
8165         TALLOC_CTX *_mem_save_handle_0;
8166         TALLOC_CTX *_mem_save_name_0;
8167         TALLOC_CTX *_mem_save_luid_0;
8168         if (flags & NDR_IN) {
8169                 ZERO_STRUCT(r->out);
8170
8171                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8172                         NDR_PULL_ALLOC(ndr, r->in.handle);
8173                 }
8174                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8175                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8176                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8177                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8178                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8179                         NDR_PULL_ALLOC(ndr, r->in.name);
8180                 }
8181                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8182                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
8183                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
8184                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
8185                 NDR_PULL_ALLOC(ndr, r->out.luid);
8186                 ZERO_STRUCTP(r->out.luid);
8187         }
8188         if (flags & NDR_OUT) {
8189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8190                         NDR_PULL_ALLOC(ndr, r->out.luid);
8191                 }
8192                 _mem_save_luid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8193                 NDR_PULL_SET_MEM_CTX(ndr, r->out.luid, LIBNDR_FLAG_REF_ALLOC);
8194                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, r->out.luid));
8195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_luid_0, LIBNDR_FLAG_REF_ALLOC);
8196                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8197         }
8198         return NDR_ERR_SUCCESS;
8199 }
8200
8201 _PUBLIC_ void ndr_print_lsa_LookupPrivValue(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivValue *r)
8202 {
8203         ndr_print_struct(ndr, name, "lsa_LookupPrivValue");
8204         ndr->depth++;
8205         if (flags & NDR_SET_VALUES) {
8206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8207         }
8208         if (flags & NDR_IN) {
8209                 ndr_print_struct(ndr, "in", "lsa_LookupPrivValue");
8210                 ndr->depth++;
8211                 ndr_print_ptr(ndr, "handle", r->in.handle);
8212                 ndr->depth++;
8213                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8214                 ndr->depth--;
8215                 ndr_print_ptr(ndr, "name", r->in.name);
8216                 ndr->depth++;
8217                 ndr_print_lsa_String(ndr, "name", r->in.name);
8218                 ndr->depth--;
8219                 ndr->depth--;
8220         }
8221         if (flags & NDR_OUT) {
8222                 ndr_print_struct(ndr, "out", "lsa_LookupPrivValue");
8223                 ndr->depth++;
8224                 ndr_print_ptr(ndr, "luid", r->out.luid);
8225                 ndr->depth++;
8226                 ndr_print_lsa_LUID(ndr, "luid", r->out.luid);
8227                 ndr->depth--;
8228                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8229                 ndr->depth--;
8230         }
8231         ndr->depth--;
8232 }
8233
8234 static enum ndr_err_code ndr_push_lsa_LookupPrivName(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivName *r)
8235 {
8236         if (flags & NDR_IN) {
8237                 if (r->in.handle == NULL) {
8238                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8239                 }
8240                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8241                 if (r->in.luid == NULL) {
8242                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8243                 }
8244                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, r->in.luid));
8245         }
8246         if (flags & NDR_OUT) {
8247                 if (r->out.name == NULL) {
8248                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8249                 }
8250                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.name));
8251                 if (*r->out.name) {
8252                         NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.name));
8253                 }
8254                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8255         }
8256         return NDR_ERR_SUCCESS;
8257 }
8258
8259 static enum ndr_err_code ndr_pull_lsa_LookupPrivName(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivName *r)
8260 {
8261         uint32_t _ptr_name;
8262         TALLOC_CTX *_mem_save_handle_0;
8263         TALLOC_CTX *_mem_save_luid_0;
8264         TALLOC_CTX *_mem_save_name_0;
8265         TALLOC_CTX *_mem_save_name_1;
8266         if (flags & NDR_IN) {
8267                 ZERO_STRUCT(r->out);
8268
8269                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8270                         NDR_PULL_ALLOC(ndr, r->in.handle);
8271                 }
8272                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8273                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8274                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8275                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8276                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8277                         NDR_PULL_ALLOC(ndr, r->in.luid);
8278                 }
8279                 _mem_save_luid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8280                 NDR_PULL_SET_MEM_CTX(ndr, r->in.luid, LIBNDR_FLAG_REF_ALLOC);
8281                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, r->in.luid));
8282                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_luid_0, LIBNDR_FLAG_REF_ALLOC);
8283                 NDR_PULL_ALLOC(ndr, r->out.name);
8284                 ZERO_STRUCTP(r->out.name);
8285         }
8286         if (flags & NDR_OUT) {
8287                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8288                         NDR_PULL_ALLOC(ndr, r->out.name);
8289                 }
8290                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8291                 NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);
8292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
8293                 if (_ptr_name) {
8294                         NDR_PULL_ALLOC(ndr, *r->out.name);
8295                 } else {
8296                         *r->out.name = NULL;
8297                 }
8298                 if (*r->out.name) {
8299                         _mem_save_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
8300                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.name, 0);
8301                         NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.name));
8302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_1, 0);
8303                 }
8304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
8305                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8306         }
8307         return NDR_ERR_SUCCESS;
8308 }
8309
8310 _PUBLIC_ void ndr_print_lsa_LookupPrivName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivName *r)
8311 {
8312         ndr_print_struct(ndr, name, "lsa_LookupPrivName");
8313         ndr->depth++;
8314         if (flags & NDR_SET_VALUES) {
8315                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8316         }
8317         if (flags & NDR_IN) {
8318                 ndr_print_struct(ndr, "in", "lsa_LookupPrivName");
8319                 ndr->depth++;
8320                 ndr_print_ptr(ndr, "handle", r->in.handle);
8321                 ndr->depth++;
8322                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8323                 ndr->depth--;
8324                 ndr_print_ptr(ndr, "luid", r->in.luid);
8325                 ndr->depth++;
8326                 ndr_print_lsa_LUID(ndr, "luid", r->in.luid);
8327                 ndr->depth--;
8328                 ndr->depth--;
8329         }
8330         if (flags & NDR_OUT) {
8331                 ndr_print_struct(ndr, "out", "lsa_LookupPrivName");
8332                 ndr->depth++;
8333                 ndr_print_ptr(ndr, "name", r->out.name);
8334                 ndr->depth++;
8335                 ndr_print_ptr(ndr, "name", *r->out.name);
8336                 ndr->depth++;
8337                 if (*r->out.name) {
8338                         ndr_print_lsa_StringLarge(ndr, "name", *r->out.name);
8339                 }
8340                 ndr->depth--;
8341                 ndr->depth--;
8342                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8343                 ndr->depth--;
8344         }
8345         ndr->depth--;
8346 }
8347
8348 static enum ndr_err_code ndr_push_lsa_LookupPrivDisplayName(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivDisplayName *r)
8349 {
8350         if (flags & NDR_IN) {
8351                 if (r->in.handle == NULL) {
8352                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8353                 }
8354                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8355                 if (r->in.name == NULL) {
8356                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8357                 }
8358                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
8359                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.language_id));
8360                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.language_id_sys));
8361         }
8362         if (flags & NDR_OUT) {
8363                 if (r->out.disp_name == NULL) {
8364                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8365                 }
8366                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.disp_name));
8367                 if (*r->out.disp_name) {
8368                         NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.disp_name));
8369                 }
8370                 if (r->out.returned_language_id == NULL) {
8371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8372                 }
8373                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->out.returned_language_id));
8374                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8375         }
8376         return NDR_ERR_SUCCESS;
8377 }
8378
8379 static enum ndr_err_code ndr_pull_lsa_LookupPrivDisplayName(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivDisplayName *r)
8380 {
8381         uint32_t _ptr_disp_name;
8382         TALLOC_CTX *_mem_save_handle_0;
8383         TALLOC_CTX *_mem_save_name_0;
8384         TALLOC_CTX *_mem_save_disp_name_0;
8385         TALLOC_CTX *_mem_save_disp_name_1;
8386         TALLOC_CTX *_mem_save_returned_language_id_0;
8387         if (flags & NDR_IN) {
8388                 ZERO_STRUCT(r->out);
8389
8390                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8391                         NDR_PULL_ALLOC(ndr, r->in.handle);
8392                 }
8393                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8394                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8395                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8396                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8397                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8398                         NDR_PULL_ALLOC(ndr, r->in.name);
8399                 }
8400                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8401                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
8402                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
8403                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
8404                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.language_id));
8405                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.language_id_sys));
8406                 NDR_PULL_ALLOC(ndr, r->out.disp_name);
8407                 ZERO_STRUCTP(r->out.disp_name);
8408                 NDR_PULL_ALLOC(ndr, r->out.returned_language_id);
8409                 ZERO_STRUCTP(r->out.returned_language_id);
8410         }
8411         if (flags & NDR_OUT) {
8412                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8413                         NDR_PULL_ALLOC(ndr, r->out.disp_name);
8414                 }
8415                 _mem_save_disp_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8416                 NDR_PULL_SET_MEM_CTX(ndr, r->out.disp_name, LIBNDR_FLAG_REF_ALLOC);
8417                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_disp_name));
8418                 if (_ptr_disp_name) {
8419                         NDR_PULL_ALLOC(ndr, *r->out.disp_name);
8420                 } else {
8421                         *r->out.disp_name = NULL;
8422                 }
8423                 if (*r->out.disp_name) {
8424                         _mem_save_disp_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
8425                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.disp_name, 0);
8426                         NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.disp_name));
8427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disp_name_1, 0);
8428                 }
8429                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disp_name_0, LIBNDR_FLAG_REF_ALLOC);
8430                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8431                         NDR_PULL_ALLOC(ndr, r->out.returned_language_id);
8432                 }
8433                 _mem_save_returned_language_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8434                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_language_id, LIBNDR_FLAG_REF_ALLOC);
8435                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->out.returned_language_id));
8436                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_language_id_0, LIBNDR_FLAG_REF_ALLOC);
8437                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8438         }
8439         return NDR_ERR_SUCCESS;
8440 }
8441
8442 _PUBLIC_ void ndr_print_lsa_LookupPrivDisplayName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivDisplayName *r)
8443 {
8444         ndr_print_struct(ndr, name, "lsa_LookupPrivDisplayName");
8445         ndr->depth++;
8446         if (flags & NDR_SET_VALUES) {
8447                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8448         }
8449         if (flags & NDR_IN) {
8450                 ndr_print_struct(ndr, "in", "lsa_LookupPrivDisplayName");
8451                 ndr->depth++;
8452                 ndr_print_ptr(ndr, "handle", r->in.handle);
8453                 ndr->depth++;
8454                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8455                 ndr->depth--;
8456                 ndr_print_ptr(ndr, "name", r->in.name);
8457                 ndr->depth++;
8458                 ndr_print_lsa_String(ndr, "name", r->in.name);
8459                 ndr->depth--;
8460                 ndr_print_uint16(ndr, "language_id", r->in.language_id);
8461                 ndr_print_uint16(ndr, "language_id_sys", r->in.language_id_sys);
8462                 ndr->depth--;
8463         }
8464         if (flags & NDR_OUT) {
8465                 ndr_print_struct(ndr, "out", "lsa_LookupPrivDisplayName");
8466                 ndr->depth++;
8467                 ndr_print_ptr(ndr, "disp_name", r->out.disp_name);
8468                 ndr->depth++;
8469                 ndr_print_ptr(ndr, "disp_name", *r->out.disp_name);
8470                 ndr->depth++;
8471                 if (*r->out.disp_name) {
8472                         ndr_print_lsa_StringLarge(ndr, "disp_name", *r->out.disp_name);
8473                 }
8474                 ndr->depth--;
8475                 ndr->depth--;
8476                 ndr_print_ptr(ndr, "returned_language_id", r->out.returned_language_id);
8477                 ndr->depth++;
8478                 ndr_print_uint16(ndr, "returned_language_id", *r->out.returned_language_id);
8479                 ndr->depth--;
8480                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8481                 ndr->depth--;
8482         }
8483         ndr->depth--;
8484 }
8485
8486 static enum ndr_err_code ndr_push_lsa_DeleteObject(struct ndr_push *ndr, int flags, const struct lsa_DeleteObject *r)
8487 {
8488         if (flags & NDR_IN) {
8489                 if (r->in.handle == NULL) {
8490                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8491                 }
8492                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8493         }
8494         if (flags & NDR_OUT) {
8495                 if (r->out.handle == NULL) {
8496                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8497                 }
8498                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
8499                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8500         }
8501         return NDR_ERR_SUCCESS;
8502 }
8503
8504 static enum ndr_err_code ndr_pull_lsa_DeleteObject(struct ndr_pull *ndr, int flags, struct lsa_DeleteObject *r)
8505 {
8506         TALLOC_CTX *_mem_save_handle_0;
8507         if (flags & NDR_IN) {
8508                 ZERO_STRUCT(r->out);
8509
8510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8511                         NDR_PULL_ALLOC(ndr, r->in.handle);
8512                 }
8513                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8514                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8515                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8517                 NDR_PULL_ALLOC(ndr, r->out.handle);
8518                 *r->out.handle = *r->in.handle;
8519         }
8520         if (flags & NDR_OUT) {
8521                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8522                         NDR_PULL_ALLOC(ndr, r->out.handle);
8523                 }
8524                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8525                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
8526                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
8527                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8528                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8529         }
8530         return NDR_ERR_SUCCESS;
8531 }
8532
8533 _PUBLIC_ void ndr_print_lsa_DeleteObject(struct ndr_print *ndr, const char *name, int flags, const struct lsa_DeleteObject *r)
8534 {
8535         ndr_print_struct(ndr, name, "lsa_DeleteObject");
8536         ndr->depth++;
8537         if (flags & NDR_SET_VALUES) {
8538                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8539         }
8540         if (flags & NDR_IN) {
8541                 ndr_print_struct(ndr, "in", "lsa_DeleteObject");
8542                 ndr->depth++;
8543                 ndr_print_ptr(ndr, "handle", r->in.handle);
8544                 ndr->depth++;
8545                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8546                 ndr->depth--;
8547                 ndr->depth--;
8548         }
8549         if (flags & NDR_OUT) {
8550                 ndr_print_struct(ndr, "out", "lsa_DeleteObject");
8551                 ndr->depth++;
8552                 ndr_print_ptr(ndr, "handle", r->out.handle);
8553                 ndr->depth++;
8554                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
8555                 ndr->depth--;
8556                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8557                 ndr->depth--;
8558         }
8559         ndr->depth--;
8560 }
8561
8562 static enum ndr_err_code ndr_push_lsa_EnumAccountsWithUserRight(struct ndr_push *ndr, int flags, const struct lsa_EnumAccountsWithUserRight *r)
8563 {
8564         if (flags & NDR_IN) {
8565                 if (r->in.handle == NULL) {
8566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8567                 }
8568                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8569                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
8570                 if (r->in.name) {
8571                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
8572                 }
8573         }
8574         if (flags & NDR_OUT) {
8575                 if (r->out.sids == NULL) {
8576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8577                 }
8578                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8579                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8580         }
8581         return NDR_ERR_SUCCESS;
8582 }
8583
8584 static enum ndr_err_code ndr_pull_lsa_EnumAccountsWithUserRight(struct ndr_pull *ndr, int flags, struct lsa_EnumAccountsWithUserRight *r)
8585 {
8586         uint32_t _ptr_name;
8587         TALLOC_CTX *_mem_save_handle_0;
8588         TALLOC_CTX *_mem_save_name_0;
8589         TALLOC_CTX *_mem_save_sids_0;
8590         if (flags & NDR_IN) {
8591                 ZERO_STRUCT(r->out);
8592
8593                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8594                         NDR_PULL_ALLOC(ndr, r->in.handle);
8595                 }
8596                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8597                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8598                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8599                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8600                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
8601                 if (_ptr_name) {
8602                         NDR_PULL_ALLOC(ndr, r->in.name);
8603                 } else {
8604                         r->in.name = NULL;
8605                 }
8606                 if (r->in.name) {
8607                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8608                         NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
8609                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
8610                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
8611                 }
8612                 NDR_PULL_ALLOC(ndr, r->out.sids);
8613                 ZERO_STRUCTP(r->out.sids);
8614         }
8615         if (flags & NDR_OUT) {
8616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8617                         NDR_PULL_ALLOC(ndr, r->out.sids);
8618                 }
8619                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8620                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
8621                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
8623                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8624         }
8625         return NDR_ERR_SUCCESS;
8626 }
8627
8628 _PUBLIC_ void ndr_print_lsa_EnumAccountsWithUserRight(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccountsWithUserRight *r)
8629 {
8630         ndr_print_struct(ndr, name, "lsa_EnumAccountsWithUserRight");
8631         ndr->depth++;
8632         if (flags & NDR_SET_VALUES) {
8633                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8634         }
8635         if (flags & NDR_IN) {
8636                 ndr_print_struct(ndr, "in", "lsa_EnumAccountsWithUserRight");
8637                 ndr->depth++;
8638                 ndr_print_ptr(ndr, "handle", r->in.handle);
8639                 ndr->depth++;
8640                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8641                 ndr->depth--;
8642                 ndr_print_ptr(ndr, "name", r->in.name);
8643                 ndr->depth++;
8644                 if (r->in.name) {
8645                         ndr_print_lsa_String(ndr, "name", r->in.name);
8646                 }
8647                 ndr->depth--;
8648                 ndr->depth--;
8649         }
8650         if (flags & NDR_OUT) {
8651                 ndr_print_struct(ndr, "out", "lsa_EnumAccountsWithUserRight");
8652                 ndr->depth++;
8653                 ndr_print_ptr(ndr, "sids", r->out.sids);
8654                 ndr->depth++;
8655                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
8656                 ndr->depth--;
8657                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8658                 ndr->depth--;
8659         }
8660         ndr->depth--;
8661 }
8662
8663 static enum ndr_err_code ndr_push_lsa_EnumAccountRights(struct ndr_push *ndr, int flags, const struct lsa_EnumAccountRights *r)
8664 {
8665         if (flags & NDR_IN) {
8666                 if (r->in.handle == NULL) {
8667                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8668                 }
8669                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8670                 if (r->in.sid == NULL) {
8671                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8672                 }
8673                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8674         }
8675         if (flags & NDR_OUT) {
8676                 if (r->out.rights == NULL) {
8677                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8678                 }
8679                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rights));
8680                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8681         }
8682         return NDR_ERR_SUCCESS;
8683 }
8684
8685 static enum ndr_err_code ndr_pull_lsa_EnumAccountRights(struct ndr_pull *ndr, int flags, struct lsa_EnumAccountRights *r)
8686 {
8687         TALLOC_CTX *_mem_save_handle_0;
8688         TALLOC_CTX *_mem_save_sid_0;
8689         TALLOC_CTX *_mem_save_rights_0;
8690         if (flags & NDR_IN) {
8691                 ZERO_STRUCT(r->out);
8692
8693                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8694                         NDR_PULL_ALLOC(ndr, r->in.handle);
8695                 }
8696                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8697                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8698                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8699                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8700                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8701                         NDR_PULL_ALLOC(ndr, r->in.sid);
8702                 }
8703                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8704                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8705                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8706                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8707                 NDR_PULL_ALLOC(ndr, r->out.rights);
8708                 ZERO_STRUCTP(r->out.rights);
8709         }
8710         if (flags & NDR_OUT) {
8711                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8712                         NDR_PULL_ALLOC(ndr, r->out.rights);
8713                 }
8714                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
8715                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rights, LIBNDR_FLAG_REF_ALLOC);
8716                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rights));
8717                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
8718                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8719         }
8720         return NDR_ERR_SUCCESS;
8721 }
8722
8723 _PUBLIC_ void ndr_print_lsa_EnumAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccountRights *r)
8724 {
8725         ndr_print_struct(ndr, name, "lsa_EnumAccountRights");
8726         ndr->depth++;
8727         if (flags & NDR_SET_VALUES) {
8728                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8729         }
8730         if (flags & NDR_IN) {
8731                 ndr_print_struct(ndr, "in", "lsa_EnumAccountRights");
8732                 ndr->depth++;
8733                 ndr_print_ptr(ndr, "handle", r->in.handle);
8734                 ndr->depth++;
8735                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8736                 ndr->depth--;
8737                 ndr_print_ptr(ndr, "sid", r->in.sid);
8738                 ndr->depth++;
8739                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8740                 ndr->depth--;
8741                 ndr->depth--;
8742         }
8743         if (flags & NDR_OUT) {
8744                 ndr_print_struct(ndr, "out", "lsa_EnumAccountRights");
8745                 ndr->depth++;
8746                 ndr_print_ptr(ndr, "rights", r->out.rights);
8747                 ndr->depth++;
8748                 ndr_print_lsa_RightSet(ndr, "rights", r->out.rights);
8749                 ndr->depth--;
8750                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8751                 ndr->depth--;
8752         }
8753         ndr->depth--;
8754 }
8755
8756 static enum ndr_err_code ndr_push_lsa_AddAccountRights(struct ndr_push *ndr, int flags, const struct lsa_AddAccountRights *r)
8757 {
8758         if (flags & NDR_IN) {
8759                 if (r->in.handle == NULL) {
8760                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8761                 }
8762                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8763                 if (r->in.sid == NULL) {
8764                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8765                 }
8766                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8767                 if (r->in.rights == NULL) {
8768                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8769                 }
8770                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
8771         }
8772         if (flags & NDR_OUT) {
8773                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8774         }
8775         return NDR_ERR_SUCCESS;
8776 }
8777
8778 static enum ndr_err_code ndr_pull_lsa_AddAccountRights(struct ndr_pull *ndr, int flags, struct lsa_AddAccountRights *r)
8779 {
8780         TALLOC_CTX *_mem_save_handle_0;
8781         TALLOC_CTX *_mem_save_sid_0;
8782         TALLOC_CTX *_mem_save_rights_0;
8783         if (flags & NDR_IN) {
8784                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8785                         NDR_PULL_ALLOC(ndr, r->in.handle);
8786                 }
8787                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8788                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8789                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8790                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8791                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8792                         NDR_PULL_ALLOC(ndr, r->in.sid);
8793                 }
8794                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8795                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8796                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8797                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8798                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8799                         NDR_PULL_ALLOC(ndr, r->in.rights);
8800                 }
8801                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
8802                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rights, LIBNDR_FLAG_REF_ALLOC);
8803                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
8804                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
8805         }
8806         if (flags & NDR_OUT) {
8807                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8808         }
8809         return NDR_ERR_SUCCESS;
8810 }
8811
8812 _PUBLIC_ void ndr_print_lsa_AddAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_AddAccountRights *r)
8813 {
8814         ndr_print_struct(ndr, name, "lsa_AddAccountRights");
8815         ndr->depth++;
8816         if (flags & NDR_SET_VALUES) {
8817                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8818         }
8819         if (flags & NDR_IN) {
8820                 ndr_print_struct(ndr, "in", "lsa_AddAccountRights");
8821                 ndr->depth++;
8822                 ndr_print_ptr(ndr, "handle", r->in.handle);
8823                 ndr->depth++;
8824                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8825                 ndr->depth--;
8826                 ndr_print_ptr(ndr, "sid", r->in.sid);
8827                 ndr->depth++;
8828                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8829                 ndr->depth--;
8830                 ndr_print_ptr(ndr, "rights", r->in.rights);
8831                 ndr->depth++;
8832                 ndr_print_lsa_RightSet(ndr, "rights", r->in.rights);
8833                 ndr->depth--;
8834                 ndr->depth--;
8835         }
8836         if (flags & NDR_OUT) {
8837                 ndr_print_struct(ndr, "out", "lsa_AddAccountRights");
8838                 ndr->depth++;
8839                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8840                 ndr->depth--;
8841         }
8842         ndr->depth--;
8843 }
8844
8845 static enum ndr_err_code ndr_push_lsa_RemoveAccountRights(struct ndr_push *ndr, int flags, const struct lsa_RemoveAccountRights *r)
8846 {
8847         if (flags & NDR_IN) {
8848                 if (r->in.handle == NULL) {
8849                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8850                 }
8851                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8852                 if (r->in.sid == NULL) {
8853                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8854                 }
8855                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8856                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.remove_all));
8857                 if (r->in.rights == NULL) {
8858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8859                 }
8860                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
8861         }
8862         if (flags & NDR_OUT) {
8863                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8864         }
8865         return NDR_ERR_SUCCESS;
8866 }
8867
8868 static enum ndr_err_code ndr_pull_lsa_RemoveAccountRights(struct ndr_pull *ndr, int flags, struct lsa_RemoveAccountRights *r)
8869 {
8870         TALLOC_CTX *_mem_save_handle_0;
8871         TALLOC_CTX *_mem_save_sid_0;
8872         TALLOC_CTX *_mem_save_rights_0;
8873         if (flags & NDR_IN) {
8874                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8875                         NDR_PULL_ALLOC(ndr, r->in.handle);
8876                 }
8877                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8878                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8879                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8880                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8881                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8882                         NDR_PULL_ALLOC(ndr, r->in.sid);
8883                 }
8884                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8885                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8886                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8887                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8888                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.remove_all));
8889                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8890                         NDR_PULL_ALLOC(ndr, r->in.rights);
8891                 }
8892                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
8893                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rights, LIBNDR_FLAG_REF_ALLOC);
8894                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
8895                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
8896         }
8897         if (flags & NDR_OUT) {
8898                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8899         }
8900         return NDR_ERR_SUCCESS;
8901 }
8902
8903 _PUBLIC_ void ndr_print_lsa_RemoveAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RemoveAccountRights *r)
8904 {
8905         ndr_print_struct(ndr, name, "lsa_RemoveAccountRights");
8906         ndr->depth++;
8907         if (flags & NDR_SET_VALUES) {
8908                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8909         }
8910         if (flags & NDR_IN) {
8911                 ndr_print_struct(ndr, "in", "lsa_RemoveAccountRights");
8912                 ndr->depth++;
8913                 ndr_print_ptr(ndr, "handle", r->in.handle);
8914                 ndr->depth++;
8915                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8916                 ndr->depth--;
8917                 ndr_print_ptr(ndr, "sid", r->in.sid);
8918                 ndr->depth++;
8919                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8920                 ndr->depth--;
8921                 ndr_print_uint8(ndr, "remove_all", r->in.remove_all);
8922                 ndr_print_ptr(ndr, "rights", r->in.rights);
8923                 ndr->depth++;
8924                 ndr_print_lsa_RightSet(ndr, "rights", r->in.rights);
8925                 ndr->depth--;
8926                 ndr->depth--;
8927         }
8928         if (flags & NDR_OUT) {
8929                 ndr_print_struct(ndr, "out", "lsa_RemoveAccountRights");
8930                 ndr->depth++;
8931                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8932                 ndr->depth--;
8933         }
8934         ndr->depth--;
8935 }
8936
8937 static enum ndr_err_code ndr_push_lsa_QueryTrustedDomainInfoBySid(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfoBySid *r)
8938 {
8939         if (flags & NDR_IN) {
8940                 if (r->in.handle == NULL) {
8941                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8942                 }
8943                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8944                 if (r->in.dom_sid == NULL) {
8945                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8946                 }
8947                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
8948                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
8949         }
8950         if (flags & NDR_OUT) {
8951                 if (r->out.info == NULL) {
8952                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8953                 }
8954                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8955                 if (*r->out.info) {
8956                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8957                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8958                 }
8959                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8960         }
8961         return NDR_ERR_SUCCESS;
8962 }
8963
8964 static enum ndr_err_code ndr_pull_lsa_QueryTrustedDomainInfoBySid(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfoBySid *r)
8965 {
8966         uint32_t _ptr_info;
8967         TALLOC_CTX *_mem_save_handle_0;
8968         TALLOC_CTX *_mem_save_dom_sid_0;
8969         TALLOC_CTX *_mem_save_info_0;
8970         TALLOC_CTX *_mem_save_info_1;
8971         if (flags & NDR_IN) {
8972                 ZERO_STRUCT(r->out);
8973
8974                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8975                         NDR_PULL_ALLOC(ndr, r->in.handle);
8976                 }
8977                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8978                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8979                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8980                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8981                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8982                         NDR_PULL_ALLOC(ndr, r->in.dom_sid);
8983                 }
8984                 _mem_save_dom_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8985                 NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_sid, LIBNDR_FLAG_REF_ALLOC);
8986                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
8987                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_sid_0, LIBNDR_FLAG_REF_ALLOC);
8988                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8989                 NDR_PULL_ALLOC(ndr, r->out.info);
8990                 ZERO_STRUCTP(r->out.info);
8991         }
8992         if (flags & NDR_OUT) {
8993                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8994                         NDR_PULL_ALLOC(ndr, r->out.info);
8995                 }
8996                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8997                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8999                 if (_ptr_info) {
9000                         NDR_PULL_ALLOC(ndr, *r->out.info);
9001                 } else {
9002                         *r->out.info = NULL;
9003                 }
9004                 if (*r->out.info) {
9005                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9006                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9007                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9008                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9009                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9010                 }
9011                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9012                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9013         }
9014         return NDR_ERR_SUCCESS;
9015 }
9016
9017 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfoBySid(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfoBySid *r)
9018 {
9019         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfoBySid");
9020         ndr->depth++;
9021         if (flags & NDR_SET_VALUES) {
9022                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9023         }
9024         if (flags & NDR_IN) {
9025                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfoBySid");
9026                 ndr->depth++;
9027                 ndr_print_ptr(ndr, "handle", r->in.handle);
9028                 ndr->depth++;
9029                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9030                 ndr->depth--;
9031                 ndr_print_ptr(ndr, "dom_sid", r->in.dom_sid);
9032                 ndr->depth++;
9033                 ndr_print_dom_sid2(ndr, "dom_sid", r->in.dom_sid);
9034                 ndr->depth--;
9035                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
9036                 ndr->depth--;
9037         }
9038         if (flags & NDR_OUT) {
9039                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfoBySid");
9040                 ndr->depth++;
9041                 ndr_print_ptr(ndr, "info", r->out.info);
9042                 ndr->depth++;
9043                 ndr_print_ptr(ndr, "info", *r->out.info);
9044                 ndr->depth++;
9045                 if (*r->out.info) {
9046                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9047                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", *r->out.info);
9048                 }
9049                 ndr->depth--;
9050                 ndr->depth--;
9051                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9052                 ndr->depth--;
9053         }
9054         ndr->depth--;
9055 }
9056
9057 static enum ndr_err_code ndr_push_lsa_SetTrustedDomainInfo(struct ndr_push *ndr, int flags, const struct lsa_SetTrustedDomainInfo *r)
9058 {
9059         if (flags & NDR_IN) {
9060                 if (r->in.handle == NULL) {
9061                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9062                 }
9063                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9064                 if (r->in.dom_sid == NULL) {
9065                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9066                 }
9067                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
9068                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
9069                 if (r->in.info == NULL) {
9070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9071                 }
9072                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
9073                 NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9074         }
9075         if (flags & NDR_OUT) {
9076                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9077         }
9078         return NDR_ERR_SUCCESS;
9079 }
9080
9081 static enum ndr_err_code ndr_pull_lsa_SetTrustedDomainInfo(struct ndr_pull *ndr, int flags, struct lsa_SetTrustedDomainInfo *r)
9082 {
9083         TALLOC_CTX *_mem_save_handle_0;
9084         TALLOC_CTX *_mem_save_dom_sid_0;
9085         TALLOC_CTX *_mem_save_info_0;
9086         if (flags & NDR_IN) {
9087                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9088                         NDR_PULL_ALLOC(ndr, r->in.handle);
9089                 }
9090                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9091                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9092                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9093                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9094                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9095                         NDR_PULL_ALLOC(ndr, r->in.dom_sid);
9096                 }
9097                 _mem_save_dom_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
9098                 NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_sid, LIBNDR_FLAG_REF_ALLOC);
9099                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
9100                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_sid_0, LIBNDR_FLAG_REF_ALLOC);
9101                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
9102                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9103                         NDR_PULL_ALLOC(ndr, r->in.info);
9104                 }
9105                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9106                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
9107                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
9108                 NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9109                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9110         }
9111         if (flags & NDR_OUT) {
9112                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9113         }
9114         return NDR_ERR_SUCCESS;
9115 }
9116
9117 _PUBLIC_ void ndr_print_lsa_SetTrustedDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetTrustedDomainInfo *r)
9118 {
9119         ndr_print_struct(ndr, name, "lsa_SetTrustedDomainInfo");
9120         ndr->depth++;
9121         if (flags & NDR_SET_VALUES) {
9122                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9123         }
9124         if (flags & NDR_IN) {
9125                 ndr_print_struct(ndr, "in", "lsa_SetTrustedDomainInfo");
9126                 ndr->depth++;
9127                 ndr_print_ptr(ndr, "handle", r->in.handle);
9128                 ndr->depth++;
9129                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9130                 ndr->depth--;
9131                 ndr_print_ptr(ndr, "dom_sid", r->in.dom_sid);
9132                 ndr->depth++;
9133                 ndr_print_dom_sid2(ndr, "dom_sid", r->in.dom_sid);
9134                 ndr->depth--;
9135                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
9136                 ndr_print_ptr(ndr, "info", r->in.info);
9137                 ndr->depth++;
9138                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9139                 ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->in.info);
9140                 ndr->depth--;
9141                 ndr->depth--;
9142         }
9143         if (flags & NDR_OUT) {
9144                 ndr_print_struct(ndr, "out", "lsa_SetTrustedDomainInfo");
9145                 ndr->depth++;
9146                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9147                 ndr->depth--;
9148         }
9149         ndr->depth--;
9150 }
9151
9152 static enum ndr_err_code ndr_push_lsa_DeleteTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_DeleteTrustedDomain *r)
9153 {
9154         if (flags & NDR_IN) {
9155                 if (r->in.handle == NULL) {
9156                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9157                 }
9158                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9159                 if (r->in.dom_sid == NULL) {
9160                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9161                 }
9162                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
9163         }
9164         if (flags & NDR_OUT) {
9165                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9166         }
9167         return NDR_ERR_SUCCESS;
9168 }
9169
9170 static enum ndr_err_code ndr_pull_lsa_DeleteTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_DeleteTrustedDomain *r)
9171 {
9172         TALLOC_CTX *_mem_save_handle_0;
9173         TALLOC_CTX *_mem_save_dom_sid_0;
9174         if (flags & NDR_IN) {
9175                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9176                         NDR_PULL_ALLOC(ndr, r->in.handle);
9177                 }
9178                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9179                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9180                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9181                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9182                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9183                         NDR_PULL_ALLOC(ndr, r->in.dom_sid);
9184                 }
9185                 _mem_save_dom_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
9186                 NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_sid, LIBNDR_FLAG_REF_ALLOC);
9187                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
9188                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_sid_0, LIBNDR_FLAG_REF_ALLOC);
9189         }
9190         if (flags & NDR_OUT) {
9191                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9192         }
9193         return NDR_ERR_SUCCESS;
9194 }
9195
9196 _PUBLIC_ void ndr_print_lsa_DeleteTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_DeleteTrustedDomain *r)
9197 {
9198         ndr_print_struct(ndr, name, "lsa_DeleteTrustedDomain");
9199         ndr->depth++;
9200         if (flags & NDR_SET_VALUES) {
9201                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9202         }
9203         if (flags & NDR_IN) {
9204                 ndr_print_struct(ndr, "in", "lsa_DeleteTrustedDomain");
9205                 ndr->depth++;
9206                 ndr_print_ptr(ndr, "handle", r->in.handle);
9207                 ndr->depth++;
9208                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9209                 ndr->depth--;
9210                 ndr_print_ptr(ndr, "dom_sid", r->in.dom_sid);
9211                 ndr->depth++;
9212                 ndr_print_dom_sid2(ndr, "dom_sid", r->in.dom_sid);
9213                 ndr->depth--;
9214                 ndr->depth--;
9215         }
9216         if (flags & NDR_OUT) {
9217                 ndr_print_struct(ndr, "out", "lsa_DeleteTrustedDomain");
9218                 ndr->depth++;
9219                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9220                 ndr->depth--;
9221         }
9222         ndr->depth--;
9223 }
9224
9225 static enum ndr_err_code ndr_push_lsa_StorePrivateData(struct ndr_push *ndr, int flags, const struct lsa_StorePrivateData *r)
9226 {
9227         if (flags & NDR_IN) {
9228                 if (r->in.handle == NULL) {
9229                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9230                 }
9231                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9232                 if (r->in.name == NULL) {
9233                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9234                 }
9235                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.val));
9237                 if (r->in.val) {
9238                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.val));
9239                 }
9240         }
9241         if (flags & NDR_OUT) {
9242                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9243         }
9244         return NDR_ERR_SUCCESS;
9245 }
9246
9247 static enum ndr_err_code ndr_pull_lsa_StorePrivateData(struct ndr_pull *ndr, int flags, struct lsa_StorePrivateData *r)
9248 {
9249         uint32_t _ptr_val;
9250         TALLOC_CTX *_mem_save_handle_0;
9251         TALLOC_CTX *_mem_save_name_0;
9252         TALLOC_CTX *_mem_save_val_0;
9253         if (flags & NDR_IN) {
9254                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9255                         NDR_PULL_ALLOC(ndr, r->in.handle);
9256                 }
9257                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9258                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9259                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9260                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9261                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9262                         NDR_PULL_ALLOC(ndr, r->in.name);
9263                 }
9264                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9265                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
9266                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9267                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
9268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_val));
9269                 if (_ptr_val) {
9270                         NDR_PULL_ALLOC(ndr, r->in.val);
9271                 } else {
9272                         r->in.val = NULL;
9273                 }
9274                 if (r->in.val) {
9275                         _mem_save_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
9276                         NDR_PULL_SET_MEM_CTX(ndr, r->in.val, 0);
9277                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.val));
9278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_val_0, 0);
9279                 }
9280         }
9281         if (flags & NDR_OUT) {
9282                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9283         }
9284         return NDR_ERR_SUCCESS;
9285 }
9286
9287 _PUBLIC_ void ndr_print_lsa_StorePrivateData(struct ndr_print *ndr, const char *name, int flags, const struct lsa_StorePrivateData *r)
9288 {
9289         ndr_print_struct(ndr, name, "lsa_StorePrivateData");
9290         ndr->depth++;
9291         if (flags & NDR_SET_VALUES) {
9292                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9293         }
9294         if (flags & NDR_IN) {
9295                 ndr_print_struct(ndr, "in", "lsa_StorePrivateData");
9296                 ndr->depth++;
9297                 ndr_print_ptr(ndr, "handle", r->in.handle);
9298                 ndr->depth++;
9299                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9300                 ndr->depth--;
9301                 ndr_print_ptr(ndr, "name", r->in.name);
9302                 ndr->depth++;
9303                 ndr_print_lsa_String(ndr, "name", r->in.name);
9304                 ndr->depth--;
9305                 ndr_print_ptr(ndr, "val", r->in.val);
9306                 ndr->depth++;
9307                 if (r->in.val) {
9308                         ndr_print_lsa_DATA_BUF(ndr, "val", r->in.val);
9309                 }
9310                 ndr->depth--;
9311                 ndr->depth--;
9312         }
9313         if (flags & NDR_OUT) {
9314                 ndr_print_struct(ndr, "out", "lsa_StorePrivateData");
9315                 ndr->depth++;
9316                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9317                 ndr->depth--;
9318         }
9319         ndr->depth--;
9320 }
9321
9322 static enum ndr_err_code ndr_push_lsa_RetrievePrivateData(struct ndr_push *ndr, int flags, const struct lsa_RetrievePrivateData *r)
9323 {
9324         if (flags & NDR_IN) {
9325                 if (r->in.handle == NULL) {
9326                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9327                 }
9328                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9329                 if (r->in.name == NULL) {
9330                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9331                 }
9332                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9333                 if (r->in.val == NULL) {
9334                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9335                 }
9336                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.val));
9337                 if (*r->in.val) {
9338                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.val));
9339                 }
9340         }
9341         if (flags & NDR_OUT) {
9342                 if (r->out.val == NULL) {
9343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9344                 }
9345                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.val));
9346                 if (*r->out.val) {
9347                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.val));
9348                 }
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_RetrievePrivateData(struct ndr_pull *ndr, int flags, struct lsa_RetrievePrivateData *r)
9355 {
9356         uint32_t _ptr_val;
9357         TALLOC_CTX *_mem_save_handle_0;
9358         TALLOC_CTX *_mem_save_name_0;
9359         TALLOC_CTX *_mem_save_val_0;
9360         TALLOC_CTX *_mem_save_val_1;
9361         if (flags & NDR_IN) {
9362                 ZERO_STRUCT(r->out);
9363
9364                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9365                         NDR_PULL_ALLOC(ndr, r->in.handle);
9366                 }
9367                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9368                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9369                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9370                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9371                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9372                         NDR_PULL_ALLOC(ndr, r->in.name);
9373                 }
9374                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9375                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
9376                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
9377                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
9378                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9379                         NDR_PULL_ALLOC(ndr, r->in.val);
9380                 }
9381                 _mem_save_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
9382                 NDR_PULL_SET_MEM_CTX(ndr, r->in.val, LIBNDR_FLAG_REF_ALLOC);
9383                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_val));
9384                 if (_ptr_val) {
9385                         NDR_PULL_ALLOC(ndr, *r->in.val);
9386                 } else {
9387                         *r->in.val = NULL;
9388                 }
9389                 if (*r->in.val) {
9390                         _mem_save_val_1 = NDR_PULL_GET_MEM_CTX(ndr);
9391                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.val, 0);
9392                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.val));
9393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_val_1, 0);
9394                 }
9395                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_val_0, LIBNDR_FLAG_REF_ALLOC);
9396                 NDR_PULL_ALLOC(ndr, r->out.val);
9397                 *r->out.val = *r->in.val;
9398         }
9399         if (flags & NDR_OUT) {
9400                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9401                         NDR_PULL_ALLOC(ndr, r->out.val);
9402                 }
9403                 _mem_save_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
9404                 NDR_PULL_SET_MEM_CTX(ndr, r->out.val, LIBNDR_FLAG_REF_ALLOC);
9405                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_val));
9406                 if (_ptr_val) {
9407                         NDR_PULL_ALLOC(ndr, *r->out.val);
9408                 } else {
9409                         *r->out.val = NULL;
9410                 }
9411                 if (*r->out.val) {
9412                         _mem_save_val_1 = NDR_PULL_GET_MEM_CTX(ndr);
9413                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.val, 0);
9414                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.val));
9415                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_val_1, 0);
9416                 }
9417                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_val_0, LIBNDR_FLAG_REF_ALLOC);
9418                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9419         }
9420         return NDR_ERR_SUCCESS;
9421 }
9422
9423 _PUBLIC_ void ndr_print_lsa_RetrievePrivateData(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RetrievePrivateData *r)
9424 {
9425         ndr_print_struct(ndr, name, "lsa_RetrievePrivateData");
9426         ndr->depth++;
9427         if (flags & NDR_SET_VALUES) {
9428                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9429         }
9430         if (flags & NDR_IN) {
9431                 ndr_print_struct(ndr, "in", "lsa_RetrievePrivateData");
9432                 ndr->depth++;
9433                 ndr_print_ptr(ndr, "handle", r->in.handle);
9434                 ndr->depth++;
9435                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9436                 ndr->depth--;
9437                 ndr_print_ptr(ndr, "name", r->in.name);
9438                 ndr->depth++;
9439                 ndr_print_lsa_String(ndr, "name", r->in.name);
9440                 ndr->depth--;
9441                 ndr_print_ptr(ndr, "val", r->in.val);
9442                 ndr->depth++;
9443                 ndr_print_ptr(ndr, "val", *r->in.val);
9444                 ndr->depth++;
9445                 if (*r->in.val) {
9446                         ndr_print_lsa_DATA_BUF(ndr, "val", *r->in.val);
9447                 }
9448                 ndr->depth--;
9449                 ndr->depth--;
9450                 ndr->depth--;
9451         }
9452         if (flags & NDR_OUT) {
9453                 ndr_print_struct(ndr, "out", "lsa_RetrievePrivateData");
9454                 ndr->depth++;
9455                 ndr_print_ptr(ndr, "val", r->out.val);
9456                 ndr->depth++;
9457                 ndr_print_ptr(ndr, "val", *r->out.val);
9458                 ndr->depth++;
9459                 if (*r->out.val) {
9460                         ndr_print_lsa_DATA_BUF(ndr, "val", *r->out.val);
9461                 }
9462                 ndr->depth--;
9463                 ndr->depth--;
9464                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9465                 ndr->depth--;
9466         }
9467         ndr->depth--;
9468 }
9469
9470 _PUBLIC_ enum ndr_err_code ndr_push_lsa_OpenPolicy2(struct ndr_push *ndr, int flags, const struct lsa_OpenPolicy2 *r)
9471 {
9472         if (flags & NDR_IN) {
9473                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
9474                 if (r->in.system_name) {
9475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
9476                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9477                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
9478                         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));
9479                 }
9480                 if (r->in.attr == NULL) {
9481                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9482                 }
9483                 NDR_CHECK(ndr_push_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
9484                 NDR_CHECK(ndr_push_lsa_PolicyAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
9485         }
9486         if (flags & NDR_OUT) {
9487                 if (r->out.handle == NULL) {
9488                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9489                 }
9490                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
9491                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9492         }
9493         return NDR_ERR_SUCCESS;
9494 }
9495
9496 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_OpenPolicy2(struct ndr_pull *ndr, int flags, struct lsa_OpenPolicy2 *r)
9497 {
9498         uint32_t _ptr_system_name;
9499         TALLOC_CTX *_mem_save_system_name_0;
9500         TALLOC_CTX *_mem_save_attr_0;
9501         TALLOC_CTX *_mem_save_handle_0;
9502         if (flags & NDR_IN) {
9503                 ZERO_STRUCT(r->out);
9504
9505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
9506                 if (_ptr_system_name) {
9507                         NDR_PULL_ALLOC(ndr, r->in.system_name);
9508                 } else {
9509                         r->in.system_name = NULL;
9510                 }
9511                 if (r->in.system_name) {
9512                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9513                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
9514                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
9515                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
9516                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
9517                                 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));
9518                         }
9519                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
9520                         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));
9521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
9522                 }
9523                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9524                         NDR_PULL_ALLOC(ndr, r->in.attr);
9525                 }
9526                 _mem_save_attr_0 = NDR_PULL_GET_MEM_CTX(ndr);
9527                 NDR_PULL_SET_MEM_CTX(ndr, r->in.attr, LIBNDR_FLAG_REF_ALLOC);
9528                 NDR_CHECK(ndr_pull_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
9529                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attr_0, LIBNDR_FLAG_REF_ALLOC);
9530                 NDR_CHECK(ndr_pull_lsa_PolicyAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
9531                 NDR_PULL_ALLOC(ndr, r->out.handle);
9532                 ZERO_STRUCTP(r->out.handle);
9533         }
9534         if (flags & NDR_OUT) {
9535                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9536                         NDR_PULL_ALLOC(ndr, r->out.handle);
9537                 }
9538                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9539                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
9540                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
9541                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9542                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9543         }
9544         return NDR_ERR_SUCCESS;
9545 }
9546
9547 _PUBLIC_ void ndr_print_lsa_OpenPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenPolicy2 *r)
9548 {
9549         ndr_print_struct(ndr, name, "lsa_OpenPolicy2");
9550         ndr->depth++;
9551         if (flags & NDR_SET_VALUES) {
9552                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9553         }
9554         if (flags & NDR_IN) {
9555                 ndr_print_struct(ndr, "in", "lsa_OpenPolicy2");
9556                 ndr->depth++;
9557                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
9558                 ndr->depth++;
9559                 if (r->in.system_name) {
9560                         ndr_print_string(ndr, "system_name", r->in.system_name);
9561                 }
9562                 ndr->depth--;
9563                 ndr_print_ptr(ndr, "attr", r->in.attr);
9564                 ndr->depth++;
9565                 ndr_print_lsa_ObjectAttribute(ndr, "attr", r->in.attr);
9566                 ndr->depth--;
9567                 ndr_print_lsa_PolicyAccessMask(ndr, "access_mask", r->in.access_mask);
9568                 ndr->depth--;
9569         }
9570         if (flags & NDR_OUT) {
9571                 ndr_print_struct(ndr, "out", "lsa_OpenPolicy2");
9572                 ndr->depth++;
9573                 ndr_print_ptr(ndr, "handle", r->out.handle);
9574                 ndr->depth++;
9575                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
9576                 ndr->depth--;
9577                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9578                 ndr->depth--;
9579         }
9580         ndr->depth--;
9581 }
9582
9583 static enum ndr_err_code ndr_push_lsa_GetUserName(struct ndr_push *ndr, int flags, const struct lsa_GetUserName *r)
9584 {
9585         if (flags & NDR_IN) {
9586                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
9587                 if (r->in.system_name) {
9588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
9589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
9591                         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));
9592                 }
9593                 if (r->in.account_name == NULL) {
9594                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9595                 }
9596                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.account_name));
9597                 if (*r->in.account_name) {
9598                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.account_name));
9599                 }
9600                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.authority_name));
9601                 if (r->in.authority_name) {
9602                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.authority_name));
9603                         if (*r->in.authority_name) {
9604                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.authority_name));
9605                         }
9606                 }
9607         }
9608         if (flags & NDR_OUT) {
9609                 if (r->out.account_name == NULL) {
9610                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9611                 }
9612                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.account_name));
9613                 if (*r->out.account_name) {
9614                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.account_name));
9615                 }
9616                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.authority_name));
9617                 if (r->out.authority_name) {
9618                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.authority_name));
9619                         if (*r->out.authority_name) {
9620                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.authority_name));
9621                         }
9622                 }
9623                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9624         }
9625         return NDR_ERR_SUCCESS;
9626 }
9627
9628 static enum ndr_err_code ndr_pull_lsa_GetUserName(struct ndr_pull *ndr, int flags, struct lsa_GetUserName *r)
9629 {
9630         uint32_t _ptr_system_name;
9631         uint32_t _ptr_account_name;
9632         uint32_t _ptr_authority_name;
9633         TALLOC_CTX *_mem_save_system_name_0;
9634         TALLOC_CTX *_mem_save_account_name_0;
9635         TALLOC_CTX *_mem_save_account_name_1;
9636         TALLOC_CTX *_mem_save_authority_name_0;
9637         TALLOC_CTX *_mem_save_authority_name_1;
9638         if (flags & NDR_IN) {
9639                 ZERO_STRUCT(r->out);
9640
9641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
9642                 if (_ptr_system_name) {
9643                         NDR_PULL_ALLOC(ndr, r->in.system_name);
9644                 } else {
9645                         r->in.system_name = NULL;
9646                 }
9647                 if (r->in.system_name) {
9648                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9649                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
9650                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
9651                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
9652                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
9653                                 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));
9654                         }
9655                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
9656                         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));
9657                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
9658                 }
9659                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9660                         NDR_PULL_ALLOC(ndr, r->in.account_name);
9661                 }
9662                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9663                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
9664                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
9665                 if (_ptr_account_name) {
9666                         NDR_PULL_ALLOC(ndr, *r->in.account_name);
9667                 } else {
9668                         *r->in.account_name = NULL;
9669                 }
9670                 if (*r->in.account_name) {
9671                         _mem_save_account_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
9672                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.account_name, 0);
9673                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.account_name));
9674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_1, 0);
9675                 }
9676                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
9677                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
9678                 if (_ptr_authority_name) {
9679                         NDR_PULL_ALLOC(ndr, r->in.authority_name);
9680                 } else {
9681                         r->in.authority_name = NULL;
9682                 }
9683                 if (r->in.authority_name) {
9684                         _mem_save_authority_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9685                         NDR_PULL_SET_MEM_CTX(ndr, r->in.authority_name, 0);
9686                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
9687                         if (_ptr_authority_name) {
9688                                 NDR_PULL_ALLOC(ndr, *r->in.authority_name);
9689                         } else {
9690                                 *r->in.authority_name = NULL;
9691                         }
9692                         if (*r->in.authority_name) {
9693                                 _mem_save_authority_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
9694                                 NDR_PULL_SET_MEM_CTX(ndr, *r->in.authority_name, 0);
9695                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.authority_name));
9696                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_1, 0);
9697                         }
9698                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_0, 0);
9699                 }
9700                 NDR_PULL_ALLOC(ndr, r->out.account_name);
9701                 *r->out.account_name = *r->in.account_name;
9702         }
9703         if (flags & NDR_OUT) {
9704                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9705                         NDR_PULL_ALLOC(ndr, r->out.account_name);
9706                 }
9707                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9708                 NDR_PULL_SET_MEM_CTX(ndr, r->out.account_name, LIBNDR_FLAG_REF_ALLOC);
9709                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
9710                 if (_ptr_account_name) {
9711                         NDR_PULL_ALLOC(ndr, *r->out.account_name);
9712                 } else {
9713                         *r->out.account_name = NULL;
9714                 }
9715                 if (*r->out.account_name) {
9716                         _mem_save_account_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
9717                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.account_name, 0);
9718                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.account_name));
9719                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_1, 0);
9720                 }
9721                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
9722                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
9723                 if (_ptr_authority_name) {
9724                         NDR_PULL_ALLOC(ndr, r->out.authority_name);
9725                 } else {
9726                         r->out.authority_name = NULL;
9727                 }
9728                 if (r->out.authority_name) {
9729                         _mem_save_authority_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9730                         NDR_PULL_SET_MEM_CTX(ndr, r->out.authority_name, 0);
9731                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
9732                         if (_ptr_authority_name) {
9733                                 NDR_PULL_ALLOC(ndr, *r->out.authority_name);
9734                         } else {
9735                                 *r->out.authority_name = NULL;
9736                         }
9737                         if (*r->out.authority_name) {
9738                                 _mem_save_authority_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
9739                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.authority_name, 0);
9740                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.authority_name));
9741                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_1, 0);
9742                         }
9743                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_0, 0);
9744                 }
9745                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9746         }
9747         return NDR_ERR_SUCCESS;
9748 }
9749
9750 _PUBLIC_ void ndr_print_lsa_GetUserName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetUserName *r)
9751 {
9752         ndr_print_struct(ndr, name, "lsa_GetUserName");
9753         ndr->depth++;
9754         if (flags & NDR_SET_VALUES) {
9755                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9756         }
9757         if (flags & NDR_IN) {
9758                 ndr_print_struct(ndr, "in", "lsa_GetUserName");
9759                 ndr->depth++;
9760                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
9761                 ndr->depth++;
9762                 if (r->in.system_name) {
9763                         ndr_print_string(ndr, "system_name", r->in.system_name);
9764                 }
9765                 ndr->depth--;
9766                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
9767                 ndr->depth++;
9768                 ndr_print_ptr(ndr, "account_name", *r->in.account_name);
9769                 ndr->depth++;
9770                 if (*r->in.account_name) {
9771                         ndr_print_lsa_String(ndr, "account_name", *r->in.account_name);
9772                 }
9773                 ndr->depth--;
9774                 ndr->depth--;
9775                 ndr_print_ptr(ndr, "authority_name", r->in.authority_name);
9776                 ndr->depth++;
9777                 if (r->in.authority_name) {
9778                         ndr_print_ptr(ndr, "authority_name", *r->in.authority_name);
9779                         ndr->depth++;
9780                         if (*r->in.authority_name) {
9781                                 ndr_print_lsa_String(ndr, "authority_name", *r->in.authority_name);
9782                         }
9783                         ndr->depth--;
9784                 }
9785                 ndr->depth--;
9786                 ndr->depth--;
9787         }
9788         if (flags & NDR_OUT) {
9789                 ndr_print_struct(ndr, "out", "lsa_GetUserName");
9790                 ndr->depth++;
9791                 ndr_print_ptr(ndr, "account_name", r->out.account_name);
9792                 ndr->depth++;
9793                 ndr_print_ptr(ndr, "account_name", *r->out.account_name);
9794                 ndr->depth++;
9795                 if (*r->out.account_name) {
9796                         ndr_print_lsa_String(ndr, "account_name", *r->out.account_name);
9797                 }
9798                 ndr->depth--;
9799                 ndr->depth--;
9800                 ndr_print_ptr(ndr, "authority_name", r->out.authority_name);
9801                 ndr->depth++;
9802                 if (r->out.authority_name) {
9803                         ndr_print_ptr(ndr, "authority_name", *r->out.authority_name);
9804                         ndr->depth++;
9805                         if (*r->out.authority_name) {
9806                                 ndr_print_lsa_String(ndr, "authority_name", *r->out.authority_name);
9807                         }
9808                         ndr->depth--;
9809                 }
9810                 ndr->depth--;
9811                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9812                 ndr->depth--;
9813         }
9814         ndr->depth--;
9815 }
9816
9817 static enum ndr_err_code ndr_push_lsa_QueryInfoPolicy2(struct ndr_push *ndr, int flags, const struct lsa_QueryInfoPolicy2 *r)
9818 {
9819         if (flags & NDR_IN) {
9820                 if (r->in.handle == NULL) {
9821                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9822                 }
9823                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9824                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
9825         }
9826         if (flags & NDR_OUT) {
9827                 if (r->out.info == NULL) {
9828                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9829                 }
9830                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9831                 if (*r->out.info) {
9832                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9833                         NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9834                 }
9835                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9836         }
9837         return NDR_ERR_SUCCESS;
9838 }
9839
9840 static enum ndr_err_code ndr_pull_lsa_QueryInfoPolicy2(struct ndr_pull *ndr, int flags, struct lsa_QueryInfoPolicy2 *r)
9841 {
9842         uint32_t _ptr_info;
9843         TALLOC_CTX *_mem_save_handle_0;
9844         TALLOC_CTX *_mem_save_info_0;
9845         TALLOC_CTX *_mem_save_info_1;
9846         if (flags & NDR_IN) {
9847                 ZERO_STRUCT(r->out);
9848
9849                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9850                         NDR_PULL_ALLOC(ndr, r->in.handle);
9851                 }
9852                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9853                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9854                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9856                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
9857                 NDR_PULL_ALLOC(ndr, r->out.info);
9858                 ZERO_STRUCTP(r->out.info);
9859         }
9860         if (flags & NDR_OUT) {
9861                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9862                         NDR_PULL_ALLOC(ndr, r->out.info);
9863                 }
9864                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9865                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9867                 if (_ptr_info) {
9868                         NDR_PULL_ALLOC(ndr, *r->out.info);
9869                 } else {
9870                         *r->out.info = NULL;
9871                 }
9872                 if (*r->out.info) {
9873                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9874                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9875                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9876                         NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9877                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9878                 }
9879                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9880                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9881         }
9882         return NDR_ERR_SUCCESS;
9883 }
9884
9885 _PUBLIC_ void ndr_print_lsa_QueryInfoPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryInfoPolicy2 *r)
9886 {
9887         ndr_print_struct(ndr, name, "lsa_QueryInfoPolicy2");
9888         ndr->depth++;
9889         if (flags & NDR_SET_VALUES) {
9890                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9891         }
9892         if (flags & NDR_IN) {
9893                 ndr_print_struct(ndr, "in", "lsa_QueryInfoPolicy2");
9894                 ndr->depth++;
9895                 ndr_print_ptr(ndr, "handle", r->in.handle);
9896                 ndr->depth++;
9897                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9898                 ndr->depth--;
9899                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
9900                 ndr->depth--;
9901         }
9902         if (flags & NDR_OUT) {
9903                 ndr_print_struct(ndr, "out", "lsa_QueryInfoPolicy2");
9904                 ndr->depth++;
9905                 ndr_print_ptr(ndr, "info", r->out.info);
9906                 ndr->depth++;
9907                 ndr_print_ptr(ndr, "info", *r->out.info);
9908                 ndr->depth++;
9909                 if (*r->out.info) {
9910                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9911                         ndr_print_lsa_PolicyInformation(ndr, "info", *r->out.info);
9912                 }
9913                 ndr->depth--;
9914                 ndr->depth--;
9915                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9916                 ndr->depth--;
9917         }
9918         ndr->depth--;
9919 }
9920
9921 static enum ndr_err_code ndr_push_lsa_SetInfoPolicy2(struct ndr_push *ndr, int flags, const struct lsa_SetInfoPolicy2 *r)
9922 {
9923         if (flags & NDR_IN) {
9924                 if (r->in.handle == NULL) {
9925                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9926                 }
9927                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9928                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
9929                 if (r->in.info == NULL) {
9930                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9931                 }
9932                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
9933                 NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9934         }
9935         if (flags & NDR_OUT) {
9936                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9937         }
9938         return NDR_ERR_SUCCESS;
9939 }
9940
9941 static enum ndr_err_code ndr_pull_lsa_SetInfoPolicy2(struct ndr_pull *ndr, int flags, struct lsa_SetInfoPolicy2 *r)
9942 {
9943         TALLOC_CTX *_mem_save_handle_0;
9944         TALLOC_CTX *_mem_save_info_0;
9945         if (flags & NDR_IN) {
9946                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9947                         NDR_PULL_ALLOC(ndr, r->in.handle);
9948                 }
9949                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9950                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9951                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9952                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9953                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
9954                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9955                         NDR_PULL_ALLOC(ndr, r->in.info);
9956                 }
9957                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9958                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
9959                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
9960                 NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9961                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9962         }
9963         if (flags & NDR_OUT) {
9964                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9965         }
9966         return NDR_ERR_SUCCESS;
9967 }
9968
9969 _PUBLIC_ void ndr_print_lsa_SetInfoPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInfoPolicy2 *r)
9970 {
9971         ndr_print_struct(ndr, name, "lsa_SetInfoPolicy2");
9972         ndr->depth++;
9973         if (flags & NDR_SET_VALUES) {
9974                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9975         }
9976         if (flags & NDR_IN) {
9977                 ndr_print_struct(ndr, "in", "lsa_SetInfoPolicy2");
9978                 ndr->depth++;
9979                 ndr_print_ptr(ndr, "handle", r->in.handle);
9980                 ndr->depth++;
9981                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9982                 ndr->depth--;
9983                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
9984                 ndr_print_ptr(ndr, "info", r->in.info);
9985                 ndr->depth++;
9986                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9987                 ndr_print_lsa_PolicyInformation(ndr, "info", r->in.info);
9988                 ndr->depth--;
9989                 ndr->depth--;
9990         }
9991         if (flags & NDR_OUT) {
9992                 ndr_print_struct(ndr, "out", "lsa_SetInfoPolicy2");
9993                 ndr->depth++;
9994                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9995                 ndr->depth--;
9996         }
9997         ndr->depth--;
9998 }
9999
10000 static enum ndr_err_code ndr_push_lsa_QueryTrustedDomainInfoByName(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfoByName *r)
10001 {
10002         if (flags & NDR_IN) {
10003                 if (r->in.handle == NULL) {
10004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10005                 }
10006                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10007                 if (r->in.trusted_domain == NULL) {
10008                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10009                 }
10010                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain));
10011                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
10012         }
10013         if (flags & NDR_OUT) {
10014                 if (r->out.info == NULL) {
10015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10016                 }
10017                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
10018                 if (*r->out.info) {
10019                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
10020                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10021                 }
10022                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10023         }
10024         return NDR_ERR_SUCCESS;
10025 }
10026
10027 static enum ndr_err_code ndr_pull_lsa_QueryTrustedDomainInfoByName(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfoByName *r)
10028 {
10029         uint32_t _ptr_info;
10030         TALLOC_CTX *_mem_save_handle_0;
10031         TALLOC_CTX *_mem_save_trusted_domain_0;
10032         TALLOC_CTX *_mem_save_info_0;
10033         TALLOC_CTX *_mem_save_info_1;
10034         if (flags & NDR_IN) {
10035                 ZERO_STRUCT(r->out);
10036
10037                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10038                         NDR_PULL_ALLOC(ndr, r->in.handle);
10039                 }
10040                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10041                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10042                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10043                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10044                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10045                         NDR_PULL_ALLOC(ndr, r->in.trusted_domain);
10046                 }
10047                 _mem_save_trusted_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
10048                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trusted_domain, LIBNDR_FLAG_REF_ALLOC);
10049                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain));
10050                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trusted_domain_0, LIBNDR_FLAG_REF_ALLOC);
10051                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
10052                 NDR_PULL_ALLOC(ndr, r->out.info);
10053                 ZERO_STRUCTP(r->out.info);
10054         }
10055         if (flags & NDR_OUT) {
10056                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10057                         NDR_PULL_ALLOC(ndr, r->out.info);
10058                 }
10059                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10060                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10061                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10062                 if (_ptr_info) {
10063                         NDR_PULL_ALLOC(ndr, *r->out.info);
10064                 } else {
10065                         *r->out.info = NULL;
10066                 }
10067                 if (*r->out.info) {
10068                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
10069                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
10070                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
10071                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10072                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
10073                 }
10074                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10075                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10076         }
10077         return NDR_ERR_SUCCESS;
10078 }
10079
10080 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfoByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfoByName *r)
10081 {
10082         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfoByName");
10083         ndr->depth++;
10084         if (flags & NDR_SET_VALUES) {
10085                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10086         }
10087         if (flags & NDR_IN) {
10088                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfoByName");
10089                 ndr->depth++;
10090                 ndr_print_ptr(ndr, "handle", r->in.handle);
10091                 ndr->depth++;
10092                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10093                 ndr->depth--;
10094                 ndr_print_ptr(ndr, "trusted_domain", r->in.trusted_domain);
10095                 ndr->depth++;
10096                 ndr_print_lsa_String(ndr, "trusted_domain", r->in.trusted_domain);
10097                 ndr->depth--;
10098                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
10099                 ndr->depth--;
10100         }
10101         if (flags & NDR_OUT) {
10102                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfoByName");
10103                 ndr->depth++;
10104                 ndr_print_ptr(ndr, "info", r->out.info);
10105                 ndr->depth++;
10106                 ndr_print_ptr(ndr, "info", *r->out.info);
10107                 ndr->depth++;
10108                 if (*r->out.info) {
10109                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
10110                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", *r->out.info);
10111                 }
10112                 ndr->depth--;
10113                 ndr->depth--;
10114                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10115                 ndr->depth--;
10116         }
10117         ndr->depth--;
10118 }
10119
10120 static enum ndr_err_code ndr_push_lsa_SetTrustedDomainInfoByName(struct ndr_push *ndr, int flags, const struct lsa_SetTrustedDomainInfoByName *r)
10121 {
10122         if (flags & NDR_IN) {
10123                 if (r->in.handle == NULL) {
10124                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10125                 }
10126                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10127                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
10128                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
10129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
10130                 if (r->in.info) {
10131                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
10132                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
10133                 }
10134         }
10135         if (flags & NDR_OUT) {
10136                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10137         }
10138         return NDR_ERR_SUCCESS;
10139 }
10140
10141 static enum ndr_err_code ndr_pull_lsa_SetTrustedDomainInfoByName(struct ndr_pull *ndr, int flags, struct lsa_SetTrustedDomainInfoByName *r)
10142 {
10143         uint32_t _ptr_info;
10144         TALLOC_CTX *_mem_save_handle_0;
10145         TALLOC_CTX *_mem_save_info_0;
10146         if (flags & NDR_IN) {
10147                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10148                         NDR_PULL_ALLOC(ndr, r->in.handle);
10149                 }
10150                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10151                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10152                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10154                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
10155                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
10156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10157                 if (_ptr_info) {
10158                         NDR_PULL_ALLOC(ndr, r->in.info);
10159                 } else {
10160                         r->in.info = NULL;
10161                 }
10162                 if (r->in.info) {
10163                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10164                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
10165                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
10166                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
10167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10168                 }
10169         }
10170         if (flags & NDR_OUT) {
10171                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10172         }
10173         return NDR_ERR_SUCCESS;
10174 }
10175
10176 _PUBLIC_ void ndr_print_lsa_SetTrustedDomainInfoByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetTrustedDomainInfoByName *r)
10177 {
10178         ndr_print_struct(ndr, name, "lsa_SetTrustedDomainInfoByName");
10179         ndr->depth++;
10180         if (flags & NDR_SET_VALUES) {
10181                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10182         }
10183         if (flags & NDR_IN) {
10184                 ndr_print_struct(ndr, "in", "lsa_SetTrustedDomainInfoByName");
10185                 ndr->depth++;
10186                 ndr_print_ptr(ndr, "handle", r->in.handle);
10187                 ndr->depth++;
10188                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10189                 ndr->depth--;
10190                 ndr_print_lsa_String(ndr, "trusted_domain", &r->in.trusted_domain);
10191                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
10192                 ndr_print_ptr(ndr, "info", r->in.info);
10193                 ndr->depth++;
10194                 if (r->in.info) {
10195                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
10196                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->in.info);
10197                 }
10198                 ndr->depth--;
10199                 ndr->depth--;
10200         }
10201         if (flags & NDR_OUT) {
10202                 ndr_print_struct(ndr, "out", "lsa_SetTrustedDomainInfoByName");
10203                 ndr->depth++;
10204                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10205                 ndr->depth--;
10206         }
10207         ndr->depth--;
10208 }
10209
10210 static enum ndr_err_code ndr_push_lsa_EnumTrustedDomainsEx(struct ndr_push *ndr, int flags, const struct lsa_EnumTrustedDomainsEx *r)
10211 {
10212         if (flags & NDR_IN) {
10213                 if (r->in.handle == NULL) {
10214                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10215                 }
10216                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10217                 if (r->in.resume_handle == NULL) {
10218                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10219                 }
10220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
10221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
10222         }
10223         if (flags & NDR_OUT) {
10224                 if (r->out.resume_handle == NULL) {
10225                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10226                 }
10227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
10228                 if (r->out.domains == NULL) {
10229                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10230                 }
10231                 NDR_CHECK(ndr_push_lsa_DomainListEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
10232                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10233         }
10234         return NDR_ERR_SUCCESS;
10235 }
10236
10237 static enum ndr_err_code ndr_pull_lsa_EnumTrustedDomainsEx(struct ndr_pull *ndr, int flags, struct lsa_EnumTrustedDomainsEx *r)
10238 {
10239         TALLOC_CTX *_mem_save_handle_0;
10240         TALLOC_CTX *_mem_save_resume_handle_0;
10241         TALLOC_CTX *_mem_save_domains_0;
10242         if (flags & NDR_IN) {
10243                 ZERO_STRUCT(r->out);
10244
10245                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10246                         NDR_PULL_ALLOC(ndr, r->in.handle);
10247                 }
10248                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10249                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10250                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10251                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10252                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10253                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
10254                 }
10255                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10256                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
10257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
10258                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
10259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
10260                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
10261                 *r->out.resume_handle = *r->in.resume_handle;
10262                 NDR_PULL_ALLOC(ndr, r->out.domains);
10263                 ZERO_STRUCTP(r->out.domains);
10264         }
10265         if (flags & NDR_OUT) {
10266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10267                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
10268                 }
10269                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10270                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
10271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
10272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
10273                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10274                         NDR_PULL_ALLOC(ndr, r->out.domains);
10275                 }
10276                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
10277                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
10278                 NDR_CHECK(ndr_pull_lsa_DomainListEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
10279                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
10280                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10281         }
10282         return NDR_ERR_SUCCESS;
10283 }
10284
10285 _PUBLIC_ void ndr_print_lsa_EnumTrustedDomainsEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumTrustedDomainsEx *r)
10286 {
10287         ndr_print_struct(ndr, name, "lsa_EnumTrustedDomainsEx");
10288         ndr->depth++;
10289         if (flags & NDR_SET_VALUES) {
10290                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10291         }
10292         if (flags & NDR_IN) {
10293                 ndr_print_struct(ndr, "in", "lsa_EnumTrustedDomainsEx");
10294                 ndr->depth++;
10295                 ndr_print_ptr(ndr, "handle", r->in.handle);
10296                 ndr->depth++;
10297                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10298                 ndr->depth--;
10299                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
10300                 ndr->depth++;
10301                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
10302                 ndr->depth--;
10303                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
10304                 ndr->depth--;
10305         }
10306         if (flags & NDR_OUT) {
10307                 ndr_print_struct(ndr, "out", "lsa_EnumTrustedDomainsEx");
10308                 ndr->depth++;
10309                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
10310                 ndr->depth++;
10311                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
10312                 ndr->depth--;
10313                 ndr_print_ptr(ndr, "domains", r->out.domains);
10314                 ndr->depth++;
10315                 ndr_print_lsa_DomainListEx(ndr, "domains", r->out.domains);
10316                 ndr->depth--;
10317                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10318                 ndr->depth--;
10319         }
10320         ndr->depth--;
10321 }
10322
10323 static enum ndr_err_code ndr_push_lsa_CreateTrustedDomainEx(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomainEx *r)
10324 {
10325         if (flags & NDR_IN) {
10326                 if (r->in.policy_handle == NULL) {
10327                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10328                 }
10329                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.policy_handle));
10330                 if (r->in.info == NULL) {
10331                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10332                 }
10333                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
10334                 if (r->in.auth_info == NULL) {
10335                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10336                 }
10337                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.auth_info));
10338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
10339         }
10340         if (flags & NDR_OUT) {
10341                 if (r->out.trustdom_handle == NULL) {
10342                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10343                 }
10344                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
10345                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10346         }
10347         return NDR_ERR_SUCCESS;
10348 }
10349
10350 static enum ndr_err_code ndr_pull_lsa_CreateTrustedDomainEx(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomainEx *r)
10351 {
10352         TALLOC_CTX *_mem_save_policy_handle_0;
10353         TALLOC_CTX *_mem_save_info_0;
10354         TALLOC_CTX *_mem_save_auth_info_0;
10355         TALLOC_CTX *_mem_save_trustdom_handle_0;
10356         if (flags & NDR_IN) {
10357                 ZERO_STRUCT(r->out);
10358
10359                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10360                         NDR_PULL_ALLOC(ndr, r->in.policy_handle);
10361                 }
10362                 _mem_save_policy_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10363                 NDR_PULL_SET_MEM_CTX(ndr, r->in.policy_handle, LIBNDR_FLAG_REF_ALLOC);
10364                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.policy_handle));
10365                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_policy_handle_0, LIBNDR_FLAG_REF_ALLOC);
10366                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10367                         NDR_PULL_ALLOC(ndr, r->in.info);
10368                 }
10369                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10370                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
10371                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
10372                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10373                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10374                         NDR_PULL_ALLOC(ndr, r->in.auth_info);
10375                 }
10376                 _mem_save_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10377                 NDR_PULL_SET_MEM_CTX(ndr, r->in.auth_info, LIBNDR_FLAG_REF_ALLOC);
10378                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.auth_info));
10379                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_auth_info_0, LIBNDR_FLAG_REF_ALLOC);
10380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
10381                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
10382                 ZERO_STRUCTP(r->out.trustdom_handle);
10383         }
10384         if (flags & NDR_OUT) {
10385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10386                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
10387                 }
10388                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10389                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
10390                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
10391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
10392                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10393         }
10394         return NDR_ERR_SUCCESS;
10395 }
10396
10397 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomainEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomainEx *r)
10398 {
10399         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomainEx");
10400         ndr->depth++;
10401         if (flags & NDR_SET_VALUES) {
10402                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10403         }
10404         if (flags & NDR_IN) {
10405                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomainEx");
10406                 ndr->depth++;
10407                 ndr_print_ptr(ndr, "policy_handle", r->in.policy_handle);
10408                 ndr->depth++;
10409                 ndr_print_policy_handle(ndr, "policy_handle", r->in.policy_handle);
10410                 ndr->depth--;
10411                 ndr_print_ptr(ndr, "info", r->in.info);
10412                 ndr->depth++;
10413                 ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info", r->in.info);
10414                 ndr->depth--;
10415                 ndr_print_ptr(ndr, "auth_info", r->in.auth_info);
10416                 ndr->depth++;
10417                 ndr_print_lsa_TrustDomainInfoAuthInfoInternal(ndr, "auth_info", r->in.auth_info);
10418                 ndr->depth--;
10419                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
10420                 ndr->depth--;
10421         }
10422         if (flags & NDR_OUT) {
10423                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomainEx");
10424                 ndr->depth++;
10425                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
10426                 ndr->depth++;
10427                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
10428                 ndr->depth--;
10429                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10430                 ndr->depth--;
10431         }
10432         ndr->depth--;
10433 }
10434
10435 static enum ndr_err_code ndr_push_lsa_CloseTrustedDomainEx(struct ndr_push *ndr, int flags, const struct lsa_CloseTrustedDomainEx *r)
10436 {
10437         if (flags & NDR_IN) {
10438                 if (r->in.handle == NULL) {
10439                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10440                 }
10441                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10442         }
10443         if (flags & NDR_OUT) {
10444                 if (r->out.handle == NULL) {
10445                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10446                 }
10447                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
10448                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10449         }
10450         return NDR_ERR_SUCCESS;
10451 }
10452
10453 static enum ndr_err_code ndr_pull_lsa_CloseTrustedDomainEx(struct ndr_pull *ndr, int flags, struct lsa_CloseTrustedDomainEx *r)
10454 {
10455         TALLOC_CTX *_mem_save_handle_0;
10456         if (flags & NDR_IN) {
10457                 ZERO_STRUCT(r->out);
10458
10459                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10460                         NDR_PULL_ALLOC(ndr, r->in.handle);
10461                 }
10462                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10463                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10464                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10465                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10466                 NDR_PULL_ALLOC(ndr, r->out.handle);
10467                 *r->out.handle = *r->in.handle;
10468         }
10469         if (flags & NDR_OUT) {
10470                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10471                         NDR_PULL_ALLOC(ndr, r->out.handle);
10472                 }
10473                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10474                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
10475                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
10476                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10477                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10478         }
10479         return NDR_ERR_SUCCESS;
10480 }
10481
10482 _PUBLIC_ void ndr_print_lsa_CloseTrustedDomainEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CloseTrustedDomainEx *r)
10483 {
10484         ndr_print_struct(ndr, name, "lsa_CloseTrustedDomainEx");
10485         ndr->depth++;
10486         if (flags & NDR_SET_VALUES) {
10487                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10488         }
10489         if (flags & NDR_IN) {
10490                 ndr_print_struct(ndr, "in", "lsa_CloseTrustedDomainEx");
10491                 ndr->depth++;
10492                 ndr_print_ptr(ndr, "handle", r->in.handle);
10493                 ndr->depth++;
10494                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10495                 ndr->depth--;
10496                 ndr->depth--;
10497         }
10498         if (flags & NDR_OUT) {
10499                 ndr_print_struct(ndr, "out", "lsa_CloseTrustedDomainEx");
10500                 ndr->depth++;
10501                 ndr_print_ptr(ndr, "handle", r->out.handle);
10502                 ndr->depth++;
10503                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
10504                 ndr->depth--;
10505                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10506                 ndr->depth--;
10507         }
10508         ndr->depth--;
10509 }
10510
10511 static enum ndr_err_code ndr_push_lsa_QueryDomainInformationPolicy(struct ndr_push *ndr, int flags, const struct lsa_QueryDomainInformationPolicy *r)
10512 {
10513         if (flags & NDR_IN) {
10514                 if (r->in.handle == NULL) {
10515                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10516                 }
10517                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10518                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10519         }
10520         if (flags & NDR_OUT) {
10521                 if (r->out.info == NULL) {
10522                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10523                 }
10524                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
10525                 if (*r->out.info) {
10526                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
10527                         NDR_CHECK(ndr_push_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10528                 }
10529                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10530         }
10531         return NDR_ERR_SUCCESS;
10532 }
10533
10534 static enum ndr_err_code ndr_pull_lsa_QueryDomainInformationPolicy(struct ndr_pull *ndr, int flags, struct lsa_QueryDomainInformationPolicy *r)
10535 {
10536         uint32_t _ptr_info;
10537         TALLOC_CTX *_mem_save_handle_0;
10538         TALLOC_CTX *_mem_save_info_0;
10539         TALLOC_CTX *_mem_save_info_1;
10540         if (flags & NDR_IN) {
10541                 ZERO_STRUCT(r->out);
10542
10543                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10544                         NDR_PULL_ALLOC(ndr, r->in.handle);
10545                 }
10546                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10547                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10548                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10549                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10550                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10551                 NDR_PULL_ALLOC(ndr, r->out.info);
10552                 ZERO_STRUCTP(r->out.info);
10553         }
10554         if (flags & NDR_OUT) {
10555                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10556                         NDR_PULL_ALLOC(ndr, r->out.info);
10557                 }
10558                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10559                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10560                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10561                 if (_ptr_info) {
10562                         NDR_PULL_ALLOC(ndr, *r->out.info);
10563                 } else {
10564                         *r->out.info = NULL;
10565                 }
10566                 if (*r->out.info) {
10567                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
10568                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
10569                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
10570                         NDR_CHECK(ndr_pull_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
10572                 }
10573                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10574                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10575         }
10576         return NDR_ERR_SUCCESS;
10577 }
10578
10579 _PUBLIC_ void ndr_print_lsa_QueryDomainInformationPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryDomainInformationPolicy *r)
10580 {
10581         ndr_print_struct(ndr, name, "lsa_QueryDomainInformationPolicy");
10582         ndr->depth++;
10583         if (flags & NDR_SET_VALUES) {
10584                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10585         }
10586         if (flags & NDR_IN) {
10587                 ndr_print_struct(ndr, "in", "lsa_QueryDomainInformationPolicy");
10588                 ndr->depth++;
10589                 ndr_print_ptr(ndr, "handle", r->in.handle);
10590                 ndr->depth++;
10591                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10592                 ndr->depth--;
10593                 ndr_print_uint16(ndr, "level", r->in.level);
10594                 ndr->depth--;
10595         }
10596         if (flags & NDR_OUT) {
10597                 ndr_print_struct(ndr, "out", "lsa_QueryDomainInformationPolicy");
10598                 ndr->depth++;
10599                 ndr_print_ptr(ndr, "info", r->out.info);
10600                 ndr->depth++;
10601                 ndr_print_ptr(ndr, "info", *r->out.info);
10602                 ndr->depth++;
10603                 if (*r->out.info) {
10604                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
10605                         ndr_print_lsa_DomainInformationPolicy(ndr, "info", *r->out.info);
10606                 }
10607                 ndr->depth--;
10608                 ndr->depth--;
10609                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10610                 ndr->depth--;
10611         }
10612         ndr->depth--;
10613 }
10614
10615 static enum ndr_err_code ndr_push_lsa_SetDomainInformationPolicy(struct ndr_push *ndr, int flags, const struct lsa_SetDomainInformationPolicy *r)
10616 {
10617         if (flags & NDR_IN) {
10618                 if (r->in.handle == NULL) {
10619                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10620                 }
10621                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10622                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
10624                 if (r->in.info) {
10625                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
10626                         NDR_CHECK(ndr_push_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
10627                 }
10628         }
10629         if (flags & NDR_OUT) {
10630                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10631         }
10632         return NDR_ERR_SUCCESS;
10633 }
10634
10635 static enum ndr_err_code ndr_pull_lsa_SetDomainInformationPolicy(struct ndr_pull *ndr, int flags, struct lsa_SetDomainInformationPolicy *r)
10636 {
10637         uint32_t _ptr_info;
10638         TALLOC_CTX *_mem_save_handle_0;
10639         TALLOC_CTX *_mem_save_info_0;
10640         if (flags & NDR_IN) {
10641                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10642                         NDR_PULL_ALLOC(ndr, r->in.handle);
10643                 }
10644                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10645                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10646                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10647                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10648                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10649                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10650                 if (_ptr_info) {
10651                         NDR_PULL_ALLOC(ndr, r->in.info);
10652                 } else {
10653                         r->in.info = NULL;
10654                 }
10655                 if (r->in.info) {
10656                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10657                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
10658                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
10659                         NDR_CHECK(ndr_pull_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
10660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10661                 }
10662         }
10663         if (flags & NDR_OUT) {
10664                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10665         }
10666         return NDR_ERR_SUCCESS;
10667 }
10668
10669 _PUBLIC_ void ndr_print_lsa_SetDomainInformationPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetDomainInformationPolicy *r)
10670 {
10671         ndr_print_struct(ndr, name, "lsa_SetDomainInformationPolicy");
10672         ndr->depth++;
10673         if (flags & NDR_SET_VALUES) {
10674                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10675         }
10676         if (flags & NDR_IN) {
10677                 ndr_print_struct(ndr, "in", "lsa_SetDomainInformationPolicy");
10678                 ndr->depth++;
10679                 ndr_print_ptr(ndr, "handle", r->in.handle);
10680                 ndr->depth++;
10681                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10682                 ndr->depth--;
10683                 ndr_print_uint16(ndr, "level", r->in.level);
10684                 ndr_print_ptr(ndr, "info", r->in.info);
10685                 ndr->depth++;
10686                 if (r->in.info) {
10687                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
10688                         ndr_print_lsa_DomainInformationPolicy(ndr, "info", r->in.info);
10689                 }
10690                 ndr->depth--;
10691                 ndr->depth--;
10692         }
10693         if (flags & NDR_OUT) {
10694                 ndr_print_struct(ndr, "out", "lsa_SetDomainInformationPolicy");
10695                 ndr->depth++;
10696                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10697                 ndr->depth--;
10698         }
10699         ndr->depth--;
10700 }
10701
10702 static enum ndr_err_code ndr_push_lsa_OpenTrustedDomainByName(struct ndr_push *ndr, int flags, const struct lsa_OpenTrustedDomainByName *r)
10703 {
10704         if (flags & NDR_IN) {
10705                 if (r->in.handle == NULL) {
10706                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10707                 }
10708                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10709                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
10710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
10711         }
10712         if (flags & NDR_OUT) {
10713                 if (r->out.trustdom_handle == NULL) {
10714                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10715                 }
10716                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
10717                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10718         }
10719         return NDR_ERR_SUCCESS;
10720 }
10721
10722 static enum ndr_err_code ndr_pull_lsa_OpenTrustedDomainByName(struct ndr_pull *ndr, int flags, struct lsa_OpenTrustedDomainByName *r)
10723 {
10724         TALLOC_CTX *_mem_save_handle_0;
10725         TALLOC_CTX *_mem_save_trustdom_handle_0;
10726         if (flags & NDR_IN) {
10727                 ZERO_STRUCT(r->out);
10728
10729                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10730                         NDR_PULL_ALLOC(ndr, r->in.handle);
10731                 }
10732                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10733                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10734                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10735                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10736                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
10737                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
10738                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
10739                 ZERO_STRUCTP(r->out.trustdom_handle);
10740         }
10741         if (flags & NDR_OUT) {
10742                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10743                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
10744                 }
10745                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10746                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
10747                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
10748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
10749                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10750         }
10751         return NDR_ERR_SUCCESS;
10752 }
10753
10754 _PUBLIC_ void ndr_print_lsa_OpenTrustedDomainByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenTrustedDomainByName *r)
10755 {
10756         ndr_print_struct(ndr, name, "lsa_OpenTrustedDomainByName");
10757         ndr->depth++;
10758         if (flags & NDR_SET_VALUES) {
10759                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10760         }
10761         if (flags & NDR_IN) {
10762                 ndr_print_struct(ndr, "in", "lsa_OpenTrustedDomainByName");
10763                 ndr->depth++;
10764                 ndr_print_ptr(ndr, "handle", r->in.handle);
10765                 ndr->depth++;
10766                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10767                 ndr->depth--;
10768                 ndr_print_lsa_String(ndr, "name", &r->in.name);
10769                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
10770                 ndr->depth--;
10771         }
10772         if (flags & NDR_OUT) {
10773                 ndr_print_struct(ndr, "out", "lsa_OpenTrustedDomainByName");
10774                 ndr->depth++;
10775                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
10776                 ndr->depth++;
10777                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
10778                 ndr->depth--;
10779                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10780                 ndr->depth--;
10781         }
10782         ndr->depth--;
10783 }
10784
10785 static enum ndr_err_code ndr_push_lsa_TestCall(struct ndr_push *ndr, int flags, const struct lsa_TestCall *r)
10786 {
10787         if (flags & NDR_IN) {
10788         }
10789         if (flags & NDR_OUT) {
10790                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10791         }
10792         return NDR_ERR_SUCCESS;
10793 }
10794
10795 static enum ndr_err_code ndr_pull_lsa_TestCall(struct ndr_pull *ndr, int flags, struct lsa_TestCall *r)
10796 {
10797         if (flags & NDR_IN) {
10798         }
10799         if (flags & NDR_OUT) {
10800                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10801         }
10802         return NDR_ERR_SUCCESS;
10803 }
10804
10805 _PUBLIC_ void ndr_print_lsa_TestCall(struct ndr_print *ndr, const char *name, int flags, const struct lsa_TestCall *r)
10806 {
10807         ndr_print_struct(ndr, name, "lsa_TestCall");
10808         ndr->depth++;
10809         if (flags & NDR_SET_VALUES) {
10810                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10811         }
10812         if (flags & NDR_IN) {
10813                 ndr_print_struct(ndr, "in", "lsa_TestCall");
10814                 ndr->depth++;
10815                 ndr->depth--;
10816         }
10817         if (flags & NDR_OUT) {
10818                 ndr_print_struct(ndr, "out", "lsa_TestCall");
10819                 ndr->depth++;
10820                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10821                 ndr->depth--;
10822         }
10823         ndr->depth--;
10824 }
10825
10826 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupSids2(struct ndr_push *ndr, int flags, const struct lsa_LookupSids2 *r)
10827 {
10828         if (flags & NDR_IN) {
10829                 if (r->in.handle == NULL) {
10830                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10831                 }
10832                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10833                 if (r->in.sids == NULL) {
10834                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10835                 }
10836                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10837                 if (r->in.names == NULL) {
10838                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10839                 }
10840                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
10841                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10842                 if (r->in.count == NULL) {
10843                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10844                 }
10845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
10846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
10847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
10848         }
10849         if (flags & NDR_OUT) {
10850                 if (r->out.domains == NULL) {
10851                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10852                 }
10853                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
10854                 if (*r->out.domains) {
10855                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10856                 }
10857                 if (r->out.names == NULL) {
10858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10859                 }
10860                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
10861                 if (r->out.count == NULL) {
10862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10863                 }
10864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
10865                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10866         }
10867         return NDR_ERR_SUCCESS;
10868 }
10869
10870 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupSids2(struct ndr_pull *ndr, int flags, struct lsa_LookupSids2 *r)
10871 {
10872         uint32_t _ptr_domains;
10873         TALLOC_CTX *_mem_save_handle_0;
10874         TALLOC_CTX *_mem_save_sids_0;
10875         TALLOC_CTX *_mem_save_domains_0;
10876         TALLOC_CTX *_mem_save_domains_1;
10877         TALLOC_CTX *_mem_save_names_0;
10878         TALLOC_CTX *_mem_save_count_0;
10879         if (flags & NDR_IN) {
10880                 ZERO_STRUCT(r->out);
10881
10882                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10883                         NDR_PULL_ALLOC(ndr, r->in.handle);
10884                 }
10885                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10886                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10887                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10888                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10889                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10890                         NDR_PULL_ALLOC(ndr, r->in.sids);
10891                 }
10892                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10893                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10894                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10895                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10896                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10897                         NDR_PULL_ALLOC(ndr, r->in.names);
10898                 }
10899                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10900                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
10901                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
10902                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
10903                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10904                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10905                         NDR_PULL_ALLOC(ndr, r->in.count);
10906                 }
10907                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10908                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
10909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
10910                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
10912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
10913                 NDR_PULL_ALLOC(ndr, r->out.domains);
10914                 ZERO_STRUCTP(r->out.domains);
10915                 NDR_PULL_ALLOC(ndr, r->out.names);
10916                 *r->out.names = *r->in.names;
10917                 NDR_PULL_ALLOC(ndr, r->out.count);
10918                 *r->out.count = *r->in.count;
10919         }
10920         if (flags & NDR_OUT) {
10921                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10922                         NDR_PULL_ALLOC(ndr, r->out.domains);
10923                 }
10924                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
10925                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
10926                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
10927                 if (_ptr_domains) {
10928                         NDR_PULL_ALLOC(ndr, *r->out.domains);
10929                 } else {
10930                         *r->out.domains = NULL;
10931                 }
10932                 if (*r->out.domains) {
10933                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
10934                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
10935                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
10937                 }
10938                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
10939                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10940                         NDR_PULL_ALLOC(ndr, r->out.names);
10941                 }
10942                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10943                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
10944                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
10945                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
10946                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10947                         NDR_PULL_ALLOC(ndr, r->out.count);
10948                 }
10949                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10950                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
10951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
10952                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10953                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10954         }
10955         return NDR_ERR_SUCCESS;
10956 }
10957
10958 _PUBLIC_ void ndr_print_lsa_LookupSids2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids2 *r)
10959 {
10960         ndr_print_struct(ndr, name, "lsa_LookupSids2");
10961         ndr->depth++;
10962         if (flags & NDR_SET_VALUES) {
10963                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10964         }
10965         if (flags & NDR_IN) {
10966                 ndr_print_struct(ndr, "in", "lsa_LookupSids2");
10967                 ndr->depth++;
10968                 ndr_print_ptr(ndr, "handle", r->in.handle);
10969                 ndr->depth++;
10970                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10971                 ndr->depth--;
10972                 ndr_print_ptr(ndr, "sids", r->in.sids);
10973                 ndr->depth++;
10974                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10975                 ndr->depth--;
10976                 ndr_print_ptr(ndr, "names", r->in.names);
10977                 ndr->depth++;
10978                 ndr_print_lsa_TransNameArray2(ndr, "names", r->in.names);
10979                 ndr->depth--;
10980                 ndr_print_uint16(ndr, "level", r->in.level);
10981                 ndr_print_ptr(ndr, "count", r->in.count);
10982                 ndr->depth++;
10983                 ndr_print_uint32(ndr, "count", *r->in.count);
10984                 ndr->depth--;
10985                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
10986                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
10987                 ndr->depth--;
10988         }
10989         if (flags & NDR_OUT) {
10990                 ndr_print_struct(ndr, "out", "lsa_LookupSids2");
10991                 ndr->depth++;
10992                 ndr_print_ptr(ndr, "domains", r->out.domains);
10993                 ndr->depth++;
10994                 ndr_print_ptr(ndr, "domains", *r->out.domains);
10995                 ndr->depth++;
10996                 if (*r->out.domains) {
10997                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
10998                 }
10999                 ndr->depth--;
11000                 ndr->depth--;
11001                 ndr_print_ptr(ndr, "names", r->out.names);
11002                 ndr->depth++;
11003                 ndr_print_lsa_TransNameArray2(ndr, "names", r->out.names);
11004                 ndr->depth--;
11005                 ndr_print_ptr(ndr, "count", r->out.count);
11006                 ndr->depth++;
11007                 ndr_print_uint32(ndr, "count", *r->out.count);
11008                 ndr->depth--;
11009                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11010                 ndr->depth--;
11011         }
11012         ndr->depth--;
11013 }
11014
11015 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupNames2(struct ndr_push *ndr, int flags, const struct lsa_LookupNames2 *r)
11016 {
11017         uint32_t cntr_names_0;
11018         if (flags & NDR_IN) {
11019                 if (r->in.handle == NULL) {
11020                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11021                 }
11022                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
11024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
11025                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11026                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
11027                 }
11028                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11029                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
11030                 }
11031                 if (r->in.sids == NULL) {
11032                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11033                 }
11034                 NDR_CHECK(ndr_push_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11035                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
11036                 if (r->in.count == NULL) {
11037                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11038                 }
11039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
11040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.lookup_options));
11041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_revision));
11042         }
11043         if (flags & NDR_OUT) {
11044                 if (r->out.domains == NULL) {
11045                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11046                 }
11047                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
11048                 if (*r->out.domains) {
11049                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11050                 }
11051                 if (r->out.sids == NULL) {
11052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11053                 }
11054                 NDR_CHECK(ndr_push_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
11055                 if (r->out.count == NULL) {
11056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11057                 }
11058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
11059                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11060         }
11061         return NDR_ERR_SUCCESS;
11062 }
11063
11064 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupNames2(struct ndr_pull *ndr, int flags, struct lsa_LookupNames2 *r)
11065 {
11066         uint32_t cntr_names_0;
11067         uint32_t _ptr_domains;
11068         TALLOC_CTX *_mem_save_handle_0;
11069         TALLOC_CTX *_mem_save_names_0;
11070         TALLOC_CTX *_mem_save_domains_0;
11071         TALLOC_CTX *_mem_save_domains_1;
11072         TALLOC_CTX *_mem_save_sids_0;
11073         TALLOC_CTX *_mem_save_count_0;
11074         if (flags & NDR_IN) {
11075                 ZERO_STRUCT(r->out);
11076
11077                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11078                         NDR_PULL_ALLOC(ndr, r->in.handle);
11079                 }
11080                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11081                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11082                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11083                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
11085                 if (r->in.num_names > 1000) {
11086                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11087                 }
11088                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
11089                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
11090                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11091                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
11092                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11093                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
11094                 }
11095                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11096                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
11097                 }
11098                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
11099                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11100                         NDR_PULL_ALLOC(ndr, r->in.sids);
11101                 }
11102                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11103                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
11104                 NDR_CHECK(ndr_pull_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11105                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11106                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
11107                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11108                         NDR_PULL_ALLOC(ndr, r->in.count);
11109                 }
11110                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11111                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
11112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
11113                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.lookup_options));
11115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_revision));
11116                 NDR_PULL_ALLOC(ndr, r->out.domains);
11117                 ZERO_STRUCTP(r->out.domains);
11118                 NDR_PULL_ALLOC(ndr, r->out.sids);
11119                 *r->out.sids = *r->in.sids;
11120                 NDR_PULL_ALLOC(ndr, r->out.count);
11121                 *r->out.count = *r->in.count;
11122                 if (r->in.names) {
11123                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
11124                 }
11125         }
11126         if (flags & NDR_OUT) {
11127                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11128                         NDR_PULL_ALLOC(ndr, r->out.domains);
11129                 }
11130                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
11131                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
11132                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
11133                 if (_ptr_domains) {
11134                         NDR_PULL_ALLOC(ndr, *r->out.domains);
11135                 } else {
11136                         *r->out.domains = NULL;
11137                 }
11138                 if (*r->out.domains) {
11139                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
11140                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
11141                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11142                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
11143                 }
11144                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
11145                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11146                         NDR_PULL_ALLOC(ndr, r->out.sids);
11147                 }
11148                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11149                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
11150                 NDR_CHECK(ndr_pull_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
11151                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11152                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11153                         NDR_PULL_ALLOC(ndr, r->out.count);
11154                 }
11155                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11156                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
11157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
11158                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11159                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11160         }
11161         return NDR_ERR_SUCCESS;
11162 }
11163
11164 _PUBLIC_ void ndr_print_lsa_LookupNames2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames2 *r)
11165 {
11166         uint32_t cntr_names_0;
11167         ndr_print_struct(ndr, name, "lsa_LookupNames2");
11168         ndr->depth++;
11169         if (flags & NDR_SET_VALUES) {
11170                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11171         }
11172         if (flags & NDR_IN) {
11173                 ndr_print_struct(ndr, "in", "lsa_LookupNames2");
11174                 ndr->depth++;
11175                 ndr_print_ptr(ndr, "handle", r->in.handle);
11176                 ndr->depth++;
11177                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11178                 ndr->depth--;
11179                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
11180                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
11181                 ndr->depth++;
11182                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
11183                         char *idx_0=NULL;
11184                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
11185                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
11186                                 free(idx_0);
11187                         }
11188                 }
11189                 ndr->depth--;
11190                 ndr_print_ptr(ndr, "sids", r->in.sids);
11191                 ndr->depth++;
11192                 ndr_print_lsa_TransSidArray2(ndr, "sids", r->in.sids);
11193                 ndr->depth--;
11194                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
11195                 ndr_print_ptr(ndr, "count", r->in.count);
11196                 ndr->depth++;
11197                 ndr_print_uint32(ndr, "count", *r->in.count);
11198                 ndr->depth--;
11199                 ndr_print_uint32(ndr, "lookup_options", r->in.lookup_options);
11200                 ndr_print_uint32(ndr, "client_revision", r->in.client_revision);
11201                 ndr->depth--;
11202         }
11203         if (flags & NDR_OUT) {
11204                 ndr_print_struct(ndr, "out", "lsa_LookupNames2");
11205                 ndr->depth++;
11206                 ndr_print_ptr(ndr, "domains", r->out.domains);
11207                 ndr->depth++;
11208                 ndr_print_ptr(ndr, "domains", *r->out.domains);
11209                 ndr->depth++;
11210                 if (*r->out.domains) {
11211                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
11212                 }
11213                 ndr->depth--;
11214                 ndr->depth--;
11215                 ndr_print_ptr(ndr, "sids", r->out.sids);
11216                 ndr->depth++;
11217                 ndr_print_lsa_TransSidArray2(ndr, "sids", r->out.sids);
11218                 ndr->depth--;
11219                 ndr_print_ptr(ndr, "count", r->out.count);
11220                 ndr->depth++;
11221                 ndr_print_uint32(ndr, "count", *r->out.count);
11222                 ndr->depth--;
11223                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11224                 ndr->depth--;
11225         }
11226         ndr->depth--;
11227 }
11228
11229 static enum ndr_err_code ndr_push_lsa_CreateTrustedDomainEx2(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomainEx2 *r)
11230 {
11231         if (flags & NDR_IN) {
11232                 if (r->in.policy_handle == NULL) {
11233                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11234                 }
11235                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.policy_handle));
11236                 if (r->in.info == NULL) {
11237                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11238                 }
11239                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11240                 if (r->in.auth_info == NULL) {
11241                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11242                 }
11243                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.auth_info));
11244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
11245         }
11246         if (flags & NDR_OUT) {
11247                 if (r->out.trustdom_handle == NULL) {
11248                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11249                 }
11250                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
11251                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11252         }
11253         return NDR_ERR_SUCCESS;
11254 }
11255
11256 static enum ndr_err_code ndr_pull_lsa_CreateTrustedDomainEx2(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomainEx2 *r)
11257 {
11258         TALLOC_CTX *_mem_save_policy_handle_0;
11259         TALLOC_CTX *_mem_save_info_0;
11260         TALLOC_CTX *_mem_save_auth_info_0;
11261         TALLOC_CTX *_mem_save_trustdom_handle_0;
11262         if (flags & NDR_IN) {
11263                 ZERO_STRUCT(r->out);
11264
11265                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11266                         NDR_PULL_ALLOC(ndr, r->in.policy_handle);
11267                 }
11268                 _mem_save_policy_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11269                 NDR_PULL_SET_MEM_CTX(ndr, r->in.policy_handle, LIBNDR_FLAG_REF_ALLOC);
11270                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.policy_handle));
11271                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_policy_handle_0, LIBNDR_FLAG_REF_ALLOC);
11272                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11273                         NDR_PULL_ALLOC(ndr, r->in.info);
11274                 }
11275                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11276                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
11277                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11278                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11279                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11280                         NDR_PULL_ALLOC(ndr, r->in.auth_info);
11281                 }
11282                 _mem_save_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11283                 NDR_PULL_SET_MEM_CTX(ndr, r->in.auth_info, LIBNDR_FLAG_REF_ALLOC);
11284                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.auth_info));
11285                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_auth_info_0, LIBNDR_FLAG_REF_ALLOC);
11286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
11287                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
11288                 ZERO_STRUCTP(r->out.trustdom_handle);
11289         }
11290         if (flags & NDR_OUT) {
11291                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11292                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
11293                 }
11294                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11295                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
11296                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
11297                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
11298                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11299         }
11300         return NDR_ERR_SUCCESS;
11301 }
11302
11303 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomainEx2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomainEx2 *r)
11304 {
11305         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomainEx2");
11306         ndr->depth++;
11307         if (flags & NDR_SET_VALUES) {
11308                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11309         }
11310         if (flags & NDR_IN) {
11311                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomainEx2");
11312                 ndr->depth++;
11313                 ndr_print_ptr(ndr, "policy_handle", r->in.policy_handle);
11314                 ndr->depth++;
11315                 ndr_print_policy_handle(ndr, "policy_handle", r->in.policy_handle);
11316                 ndr->depth--;
11317                 ndr_print_ptr(ndr, "info", r->in.info);
11318                 ndr->depth++;
11319                 ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info", r->in.info);
11320                 ndr->depth--;
11321                 ndr_print_ptr(ndr, "auth_info", r->in.auth_info);
11322                 ndr->depth++;
11323                 ndr_print_lsa_TrustDomainInfoAuthInfoInternal(ndr, "auth_info", r->in.auth_info);
11324                 ndr->depth--;
11325                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
11326                 ndr->depth--;
11327         }
11328         if (flags & NDR_OUT) {
11329                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomainEx2");
11330                 ndr->depth++;
11331                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
11332                 ndr->depth++;
11333                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
11334                 ndr->depth--;
11335                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11336                 ndr->depth--;
11337         }
11338         ndr->depth--;
11339 }
11340
11341 static enum ndr_err_code ndr_push_lsa_CREDRWRITE(struct ndr_push *ndr, int flags, const struct lsa_CREDRWRITE *r)
11342 {
11343         if (flags & NDR_IN) {
11344         }
11345         if (flags & NDR_OUT) {
11346                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11347         }
11348         return NDR_ERR_SUCCESS;
11349 }
11350
11351 static enum ndr_err_code ndr_pull_lsa_CREDRWRITE(struct ndr_pull *ndr, int flags, struct lsa_CREDRWRITE *r)
11352 {
11353         if (flags & NDR_IN) {
11354         }
11355         if (flags & NDR_OUT) {
11356                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11357         }
11358         return NDR_ERR_SUCCESS;
11359 }
11360
11361 _PUBLIC_ void ndr_print_lsa_CREDRWRITE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRWRITE *r)
11362 {
11363         ndr_print_struct(ndr, name, "lsa_CREDRWRITE");
11364         ndr->depth++;
11365         if (flags & NDR_SET_VALUES) {
11366                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11367         }
11368         if (flags & NDR_IN) {
11369                 ndr_print_struct(ndr, "in", "lsa_CREDRWRITE");
11370                 ndr->depth++;
11371                 ndr->depth--;
11372         }
11373         if (flags & NDR_OUT) {
11374                 ndr_print_struct(ndr, "out", "lsa_CREDRWRITE");
11375                 ndr->depth++;
11376                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11377                 ndr->depth--;
11378         }
11379         ndr->depth--;
11380 }
11381
11382 static enum ndr_err_code ndr_push_lsa_CREDRREAD(struct ndr_push *ndr, int flags, const struct lsa_CREDRREAD *r)
11383 {
11384         if (flags & NDR_IN) {
11385         }
11386         if (flags & NDR_OUT) {
11387                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11388         }
11389         return NDR_ERR_SUCCESS;
11390 }
11391
11392 static enum ndr_err_code ndr_pull_lsa_CREDRREAD(struct ndr_pull *ndr, int flags, struct lsa_CREDRREAD *r)
11393 {
11394         if (flags & NDR_IN) {
11395         }
11396         if (flags & NDR_OUT) {
11397                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11398         }
11399         return NDR_ERR_SUCCESS;
11400 }
11401
11402 _PUBLIC_ void ndr_print_lsa_CREDRREAD(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRREAD *r)
11403 {
11404         ndr_print_struct(ndr, name, "lsa_CREDRREAD");
11405         ndr->depth++;
11406         if (flags & NDR_SET_VALUES) {
11407                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11408         }
11409         if (flags & NDR_IN) {
11410                 ndr_print_struct(ndr, "in", "lsa_CREDRREAD");
11411                 ndr->depth++;
11412                 ndr->depth--;
11413         }
11414         if (flags & NDR_OUT) {
11415                 ndr_print_struct(ndr, "out", "lsa_CREDRREAD");
11416                 ndr->depth++;
11417                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11418                 ndr->depth--;
11419         }
11420         ndr->depth--;
11421 }
11422
11423 static enum ndr_err_code ndr_push_lsa_CREDRENUMERATE(struct ndr_push *ndr, int flags, const struct lsa_CREDRENUMERATE *r)
11424 {
11425         if (flags & NDR_IN) {
11426         }
11427         if (flags & NDR_OUT) {
11428                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11429         }
11430         return NDR_ERR_SUCCESS;
11431 }
11432
11433 static enum ndr_err_code ndr_pull_lsa_CREDRENUMERATE(struct ndr_pull *ndr, int flags, struct lsa_CREDRENUMERATE *r)
11434 {
11435         if (flags & NDR_IN) {
11436         }
11437         if (flags & NDR_OUT) {
11438                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11439         }
11440         return NDR_ERR_SUCCESS;
11441 }
11442
11443 _PUBLIC_ void ndr_print_lsa_CREDRENUMERATE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRENUMERATE *r)
11444 {
11445         ndr_print_struct(ndr, name, "lsa_CREDRENUMERATE");
11446         ndr->depth++;
11447         if (flags & NDR_SET_VALUES) {
11448                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11449         }
11450         if (flags & NDR_IN) {
11451                 ndr_print_struct(ndr, "in", "lsa_CREDRENUMERATE");
11452                 ndr->depth++;
11453                 ndr->depth--;
11454         }
11455         if (flags & NDR_OUT) {
11456                 ndr_print_struct(ndr, "out", "lsa_CREDRENUMERATE");
11457                 ndr->depth++;
11458                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11459                 ndr->depth--;
11460         }
11461         ndr->depth--;
11462 }
11463
11464 static enum ndr_err_code ndr_push_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_push *ndr, int flags, const struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
11465 {
11466         if (flags & NDR_IN) {
11467         }
11468         if (flags & NDR_OUT) {
11469                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11470         }
11471         return NDR_ERR_SUCCESS;
11472 }
11473
11474 static enum ndr_err_code ndr_pull_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_pull *ndr, int flags, struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
11475 {
11476         if (flags & NDR_IN) {
11477         }
11478         if (flags & NDR_OUT) {
11479                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11480         }
11481         return NDR_ERR_SUCCESS;
11482 }
11483
11484 _PUBLIC_ void ndr_print_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
11485 {
11486         ndr_print_struct(ndr, name, "lsa_CREDRWRITEDOMAINCREDENTIALS");
11487         ndr->depth++;
11488         if (flags & NDR_SET_VALUES) {
11489                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11490         }
11491         if (flags & NDR_IN) {
11492                 ndr_print_struct(ndr, "in", "lsa_CREDRWRITEDOMAINCREDENTIALS");
11493                 ndr->depth++;
11494                 ndr->depth--;
11495         }
11496         if (flags & NDR_OUT) {
11497                 ndr_print_struct(ndr, "out", "lsa_CREDRWRITEDOMAINCREDENTIALS");
11498                 ndr->depth++;
11499                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11500                 ndr->depth--;
11501         }
11502         ndr->depth--;
11503 }
11504
11505 static enum ndr_err_code ndr_push_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_push *ndr, int flags, const struct lsa_CREDRREADDOMAINCREDENTIALS *r)
11506 {
11507         if (flags & NDR_IN) {
11508         }
11509         if (flags & NDR_OUT) {
11510                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11511         }
11512         return NDR_ERR_SUCCESS;
11513 }
11514
11515 static enum ndr_err_code ndr_pull_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_pull *ndr, int flags, struct lsa_CREDRREADDOMAINCREDENTIALS *r)
11516 {
11517         if (flags & NDR_IN) {
11518         }
11519         if (flags & NDR_OUT) {
11520                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11521         }
11522         return NDR_ERR_SUCCESS;
11523 }
11524
11525 _PUBLIC_ void ndr_print_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRREADDOMAINCREDENTIALS *r)
11526 {
11527         ndr_print_struct(ndr, name, "lsa_CREDRREADDOMAINCREDENTIALS");
11528         ndr->depth++;
11529         if (flags & NDR_SET_VALUES) {
11530                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11531         }
11532         if (flags & NDR_IN) {
11533                 ndr_print_struct(ndr, "in", "lsa_CREDRREADDOMAINCREDENTIALS");
11534                 ndr->depth++;
11535                 ndr->depth--;
11536         }
11537         if (flags & NDR_OUT) {
11538                 ndr_print_struct(ndr, "out", "lsa_CREDRREADDOMAINCREDENTIALS");
11539                 ndr->depth++;
11540                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11541                 ndr->depth--;
11542         }
11543         ndr->depth--;
11544 }
11545
11546 static enum ndr_err_code ndr_push_lsa_CREDRDELETE(struct ndr_push *ndr, int flags, const struct lsa_CREDRDELETE *r)
11547 {
11548         if (flags & NDR_IN) {
11549         }
11550         if (flags & NDR_OUT) {
11551                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11552         }
11553         return NDR_ERR_SUCCESS;
11554 }
11555
11556 static enum ndr_err_code ndr_pull_lsa_CREDRDELETE(struct ndr_pull *ndr, int flags, struct lsa_CREDRDELETE *r)
11557 {
11558         if (flags & NDR_IN) {
11559         }
11560         if (flags & NDR_OUT) {
11561                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11562         }
11563         return NDR_ERR_SUCCESS;
11564 }
11565
11566 _PUBLIC_ void ndr_print_lsa_CREDRDELETE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRDELETE *r)
11567 {
11568         ndr_print_struct(ndr, name, "lsa_CREDRDELETE");
11569         ndr->depth++;
11570         if (flags & NDR_SET_VALUES) {
11571                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11572         }
11573         if (flags & NDR_IN) {
11574                 ndr_print_struct(ndr, "in", "lsa_CREDRDELETE");
11575                 ndr->depth++;
11576                 ndr->depth--;
11577         }
11578         if (flags & NDR_OUT) {
11579                 ndr_print_struct(ndr, "out", "lsa_CREDRDELETE");
11580                 ndr->depth++;
11581                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11582                 ndr->depth--;
11583         }
11584         ndr->depth--;
11585 }
11586
11587 static enum ndr_err_code ndr_push_lsa_CREDRGETTARGETINFO(struct ndr_push *ndr, int flags, const struct lsa_CREDRGETTARGETINFO *r)
11588 {
11589         if (flags & NDR_IN) {
11590         }
11591         if (flags & NDR_OUT) {
11592                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11593         }
11594         return NDR_ERR_SUCCESS;
11595 }
11596
11597 static enum ndr_err_code ndr_pull_lsa_CREDRGETTARGETINFO(struct ndr_pull *ndr, int flags, struct lsa_CREDRGETTARGETINFO *r)
11598 {
11599         if (flags & NDR_IN) {
11600         }
11601         if (flags & NDR_OUT) {
11602                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11603         }
11604         return NDR_ERR_SUCCESS;
11605 }
11606
11607 _PUBLIC_ void ndr_print_lsa_CREDRGETTARGETINFO(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRGETTARGETINFO *r)
11608 {
11609         ndr_print_struct(ndr, name, "lsa_CREDRGETTARGETINFO");
11610         ndr->depth++;
11611         if (flags & NDR_SET_VALUES) {
11612                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11613         }
11614         if (flags & NDR_IN) {
11615                 ndr_print_struct(ndr, "in", "lsa_CREDRGETTARGETINFO");
11616                 ndr->depth++;
11617                 ndr->depth--;
11618         }
11619         if (flags & NDR_OUT) {
11620                 ndr_print_struct(ndr, "out", "lsa_CREDRGETTARGETINFO");
11621                 ndr->depth++;
11622                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11623                 ndr->depth--;
11624         }
11625         ndr->depth--;
11626 }
11627
11628 static enum ndr_err_code ndr_push_lsa_CREDRPROFILELOADED(struct ndr_push *ndr, int flags, const struct lsa_CREDRPROFILELOADED *r)
11629 {
11630         if (flags & NDR_IN) {
11631         }
11632         if (flags & NDR_OUT) {
11633                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11634         }
11635         return NDR_ERR_SUCCESS;
11636 }
11637
11638 static enum ndr_err_code ndr_pull_lsa_CREDRPROFILELOADED(struct ndr_pull *ndr, int flags, struct lsa_CREDRPROFILELOADED *r)
11639 {
11640         if (flags & NDR_IN) {
11641         }
11642         if (flags & NDR_OUT) {
11643                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11644         }
11645         return NDR_ERR_SUCCESS;
11646 }
11647
11648 _PUBLIC_ void ndr_print_lsa_CREDRPROFILELOADED(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRPROFILELOADED *r)
11649 {
11650         ndr_print_struct(ndr, name, "lsa_CREDRPROFILELOADED");
11651         ndr->depth++;
11652         if (flags & NDR_SET_VALUES) {
11653                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11654         }
11655         if (flags & NDR_IN) {
11656                 ndr_print_struct(ndr, "in", "lsa_CREDRPROFILELOADED");
11657                 ndr->depth++;
11658                 ndr->depth--;
11659         }
11660         if (flags & NDR_OUT) {
11661                 ndr_print_struct(ndr, "out", "lsa_CREDRPROFILELOADED");
11662                 ndr->depth++;
11663                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11664                 ndr->depth--;
11665         }
11666         ndr->depth--;
11667 }
11668
11669 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupNames3(struct ndr_push *ndr, int flags, const struct lsa_LookupNames3 *r)
11670 {
11671         uint32_t cntr_names_0;
11672         if (flags & NDR_IN) {
11673                 if (r->in.handle == NULL) {
11674                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11675                 }
11676                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
11678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
11679                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11680                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
11681                 }
11682                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11683                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
11684                 }
11685                 if (r->in.sids == NULL) {
11686                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11687                 }
11688                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11689                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
11690                 if (r->in.count == NULL) {
11691                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11692                 }
11693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
11694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.lookup_options));
11695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_revision));
11696         }
11697         if (flags & NDR_OUT) {
11698                 if (r->out.domains == NULL) {
11699                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11700                 }
11701                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
11702                 if (*r->out.domains) {
11703                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11704                 }
11705                 if (r->out.sids == NULL) {
11706                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11707                 }
11708                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
11709                 if (r->out.count == NULL) {
11710                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11711                 }
11712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
11713                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11714         }
11715         return NDR_ERR_SUCCESS;
11716 }
11717
11718 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupNames3(struct ndr_pull *ndr, int flags, struct lsa_LookupNames3 *r)
11719 {
11720         uint32_t cntr_names_0;
11721         uint32_t _ptr_domains;
11722         TALLOC_CTX *_mem_save_handle_0;
11723         TALLOC_CTX *_mem_save_names_0;
11724         TALLOC_CTX *_mem_save_domains_0;
11725         TALLOC_CTX *_mem_save_domains_1;
11726         TALLOC_CTX *_mem_save_sids_0;
11727         TALLOC_CTX *_mem_save_count_0;
11728         if (flags & NDR_IN) {
11729                 ZERO_STRUCT(r->out);
11730
11731                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11732                         NDR_PULL_ALLOC(ndr, r->in.handle);
11733                 }
11734                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11735                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11736                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
11739                 if (r->in.num_names > 1000) {
11740                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11741                 }
11742                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
11743                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
11744                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11745                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
11746                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11747                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
11748                 }
11749                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11750                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
11751                 }
11752                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
11753                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11754                         NDR_PULL_ALLOC(ndr, r->in.sids);
11755                 }
11756                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11757                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
11758                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11759                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11760                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
11761                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11762                         NDR_PULL_ALLOC(ndr, r->in.count);
11763                 }
11764                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11765                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
11766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
11767                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11768                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.lookup_options));
11769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_revision));
11770                 NDR_PULL_ALLOC(ndr, r->out.domains);
11771                 ZERO_STRUCTP(r->out.domains);
11772                 NDR_PULL_ALLOC(ndr, r->out.sids);
11773                 *r->out.sids = *r->in.sids;
11774                 NDR_PULL_ALLOC(ndr, r->out.count);
11775                 *r->out.count = *r->in.count;
11776                 if (r->in.names) {
11777                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
11778                 }
11779         }
11780         if (flags & NDR_OUT) {
11781                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11782                         NDR_PULL_ALLOC(ndr, r->out.domains);
11783                 }
11784                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
11785                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
11786                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
11787                 if (_ptr_domains) {
11788                         NDR_PULL_ALLOC(ndr, *r->out.domains);
11789                 } else {
11790                         *r->out.domains = NULL;
11791                 }
11792                 if (*r->out.domains) {
11793                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
11794                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
11795                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11796                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
11797                 }
11798                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
11799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11800                         NDR_PULL_ALLOC(ndr, r->out.sids);
11801                 }
11802                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11803                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
11804                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
11805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11807                         NDR_PULL_ALLOC(ndr, r->out.count);
11808                 }
11809                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11810                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
11811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
11812                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11813                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11814         }
11815         return NDR_ERR_SUCCESS;
11816 }
11817
11818 _PUBLIC_ void ndr_print_lsa_LookupNames3(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames3 *r)
11819 {
11820         uint32_t cntr_names_0;
11821         ndr_print_struct(ndr, name, "lsa_LookupNames3");
11822         ndr->depth++;
11823         if (flags & NDR_SET_VALUES) {
11824                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11825         }
11826         if (flags & NDR_IN) {
11827                 ndr_print_struct(ndr, "in", "lsa_LookupNames3");
11828                 ndr->depth++;
11829                 ndr_print_ptr(ndr, "handle", r->in.handle);
11830                 ndr->depth++;
11831                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11832                 ndr->depth--;
11833                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
11834                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
11835                 ndr->depth++;
11836                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
11837                         char *idx_0=NULL;
11838                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
11839                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
11840                                 free(idx_0);
11841                         }
11842                 }
11843                 ndr->depth--;
11844                 ndr_print_ptr(ndr, "sids", r->in.sids);
11845                 ndr->depth++;
11846                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->in.sids);
11847                 ndr->depth--;
11848                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
11849                 ndr_print_ptr(ndr, "count", r->in.count);
11850                 ndr->depth++;
11851                 ndr_print_uint32(ndr, "count", *r->in.count);
11852                 ndr->depth--;
11853                 ndr_print_uint32(ndr, "lookup_options", r->in.lookup_options);
11854                 ndr_print_uint32(ndr, "client_revision", r->in.client_revision);
11855                 ndr->depth--;
11856         }
11857         if (flags & NDR_OUT) {
11858                 ndr_print_struct(ndr, "out", "lsa_LookupNames3");
11859                 ndr->depth++;
11860                 ndr_print_ptr(ndr, "domains", r->out.domains);
11861                 ndr->depth++;
11862                 ndr_print_ptr(ndr, "domains", *r->out.domains);
11863                 ndr->depth++;
11864                 if (*r->out.domains) {
11865                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
11866                 }
11867                 ndr->depth--;
11868                 ndr->depth--;
11869                 ndr_print_ptr(ndr, "sids", r->out.sids);
11870                 ndr->depth++;
11871                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->out.sids);
11872                 ndr->depth--;
11873                 ndr_print_ptr(ndr, "count", r->out.count);
11874                 ndr->depth++;
11875                 ndr_print_uint32(ndr, "count", *r->out.count);
11876                 ndr->depth--;
11877                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11878                 ndr->depth--;
11879         }
11880         ndr->depth--;
11881 }
11882
11883 static enum ndr_err_code ndr_push_lsa_CREDRGETSESSIONTYPES(struct ndr_push *ndr, int flags, const struct lsa_CREDRGETSESSIONTYPES *r)
11884 {
11885         if (flags & NDR_IN) {
11886         }
11887         if (flags & NDR_OUT) {
11888                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11889         }
11890         return NDR_ERR_SUCCESS;
11891 }
11892
11893 static enum ndr_err_code ndr_pull_lsa_CREDRGETSESSIONTYPES(struct ndr_pull *ndr, int flags, struct lsa_CREDRGETSESSIONTYPES *r)
11894 {
11895         if (flags & NDR_IN) {
11896         }
11897         if (flags & NDR_OUT) {
11898                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11899         }
11900         return NDR_ERR_SUCCESS;
11901 }
11902
11903 _PUBLIC_ void ndr_print_lsa_CREDRGETSESSIONTYPES(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRGETSESSIONTYPES *r)
11904 {
11905         ndr_print_struct(ndr, name, "lsa_CREDRGETSESSIONTYPES");
11906         ndr->depth++;
11907         if (flags & NDR_SET_VALUES) {
11908                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11909         }
11910         if (flags & NDR_IN) {
11911                 ndr_print_struct(ndr, "in", "lsa_CREDRGETSESSIONTYPES");
11912                 ndr->depth++;
11913                 ndr->depth--;
11914         }
11915         if (flags & NDR_OUT) {
11916                 ndr_print_struct(ndr, "out", "lsa_CREDRGETSESSIONTYPES");
11917                 ndr->depth++;
11918                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11919                 ndr->depth--;
11920         }
11921         ndr->depth--;
11922 }
11923
11924 static enum ndr_err_code ndr_push_lsa_LSARREGISTERAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARREGISTERAUDITEVENT *r)
11925 {
11926         if (flags & NDR_IN) {
11927         }
11928         if (flags & NDR_OUT) {
11929                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11930         }
11931         return NDR_ERR_SUCCESS;
11932 }
11933
11934 static enum ndr_err_code ndr_pull_lsa_LSARREGISTERAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARREGISTERAUDITEVENT *r)
11935 {
11936         if (flags & NDR_IN) {
11937         }
11938         if (flags & NDR_OUT) {
11939                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11940         }
11941         return NDR_ERR_SUCCESS;
11942 }
11943
11944 _PUBLIC_ void ndr_print_lsa_LSARREGISTERAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARREGISTERAUDITEVENT *r)
11945 {
11946         ndr_print_struct(ndr, name, "lsa_LSARREGISTERAUDITEVENT");
11947         ndr->depth++;
11948         if (flags & NDR_SET_VALUES) {
11949                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11950         }
11951         if (flags & NDR_IN) {
11952                 ndr_print_struct(ndr, "in", "lsa_LSARREGISTERAUDITEVENT");
11953                 ndr->depth++;
11954                 ndr->depth--;
11955         }
11956         if (flags & NDR_OUT) {
11957                 ndr_print_struct(ndr, "out", "lsa_LSARREGISTERAUDITEVENT");
11958                 ndr->depth++;
11959                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11960                 ndr->depth--;
11961         }
11962         ndr->depth--;
11963 }
11964
11965 static enum ndr_err_code ndr_push_lsa_LSARGENAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARGENAUDITEVENT *r)
11966 {
11967         if (flags & NDR_IN) {
11968         }
11969         if (flags & NDR_OUT) {
11970                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11971         }
11972         return NDR_ERR_SUCCESS;
11973 }
11974
11975 static enum ndr_err_code ndr_pull_lsa_LSARGENAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARGENAUDITEVENT *r)
11976 {
11977         if (flags & NDR_IN) {
11978         }
11979         if (flags & NDR_OUT) {
11980                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11981         }
11982         return NDR_ERR_SUCCESS;
11983 }
11984
11985 _PUBLIC_ void ndr_print_lsa_LSARGENAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARGENAUDITEVENT *r)
11986 {
11987         ndr_print_struct(ndr, name, "lsa_LSARGENAUDITEVENT");
11988         ndr->depth++;
11989         if (flags & NDR_SET_VALUES) {
11990                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11991         }
11992         if (flags & NDR_IN) {
11993                 ndr_print_struct(ndr, "in", "lsa_LSARGENAUDITEVENT");
11994                 ndr->depth++;
11995                 ndr->depth--;
11996         }
11997         if (flags & NDR_OUT) {
11998                 ndr_print_struct(ndr, "out", "lsa_LSARGENAUDITEVENT");
11999                 ndr->depth++;
12000                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12001                 ndr->depth--;
12002         }
12003         ndr->depth--;
12004 }
12005
12006 static enum ndr_err_code ndr_push_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARUNREGISTERAUDITEVENT *r)
12007 {
12008         if (flags & NDR_IN) {
12009         }
12010         if (flags & NDR_OUT) {
12011                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12012         }
12013         return NDR_ERR_SUCCESS;
12014 }
12015
12016 static enum ndr_err_code ndr_pull_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARUNREGISTERAUDITEVENT *r)
12017 {
12018         if (flags & NDR_IN) {
12019         }
12020         if (flags & NDR_OUT) {
12021                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12022         }
12023         return NDR_ERR_SUCCESS;
12024 }
12025
12026 _PUBLIC_ void ndr_print_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARUNREGISTERAUDITEVENT *r)
12027 {
12028         ndr_print_struct(ndr, name, "lsa_LSARUNREGISTERAUDITEVENT");
12029         ndr->depth++;
12030         if (flags & NDR_SET_VALUES) {
12031                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12032         }
12033         if (flags & NDR_IN) {
12034                 ndr_print_struct(ndr, "in", "lsa_LSARUNREGISTERAUDITEVENT");
12035                 ndr->depth++;
12036                 ndr->depth--;
12037         }
12038         if (flags & NDR_OUT) {
12039                 ndr_print_struct(ndr, "out", "lsa_LSARUNREGISTERAUDITEVENT");
12040                 ndr->depth++;
12041                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12042                 ndr->depth--;
12043         }
12044         ndr->depth--;
12045 }
12046
12047 static enum ndr_err_code ndr_push_lsa_lsaRQueryForestTrustInformation(struct ndr_push *ndr, int flags, const struct lsa_lsaRQueryForestTrustInformation *r)
12048 {
12049         if (flags & NDR_IN) {
12050                 if (r->in.handle == NULL) {
12051                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12052                 }
12053                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12054                 if (r->in.trusted_domain_name == NULL) {
12055                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12056                 }
12057                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain_name));
12058                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.unknown));
12059         }
12060         if (flags & NDR_OUT) {
12061                 if (r->out.forest_trust_info == NULL) {
12062                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12063                 }
12064                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.forest_trust_info));
12065                 if (*r->out.forest_trust_info) {
12066                         NDR_CHECK(ndr_push_lsa_ForestTrustInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.forest_trust_info));
12067                 }
12068                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12069         }
12070         return NDR_ERR_SUCCESS;
12071 }
12072
12073 static enum ndr_err_code ndr_pull_lsa_lsaRQueryForestTrustInformation(struct ndr_pull *ndr, int flags, struct lsa_lsaRQueryForestTrustInformation *r)
12074 {
12075         uint32_t _ptr_forest_trust_info;
12076         TALLOC_CTX *_mem_save_handle_0;
12077         TALLOC_CTX *_mem_save_trusted_domain_name_0;
12078         TALLOC_CTX *_mem_save_forest_trust_info_0;
12079         TALLOC_CTX *_mem_save_forest_trust_info_1;
12080         if (flags & NDR_IN) {
12081                 ZERO_STRUCT(r->out);
12082
12083                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12084                         NDR_PULL_ALLOC(ndr, r->in.handle);
12085                 }
12086                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12087                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12088                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12090                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12091                         NDR_PULL_ALLOC(ndr, r->in.trusted_domain_name);
12092                 }
12093                 _mem_save_trusted_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12094                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trusted_domain_name, LIBNDR_FLAG_REF_ALLOC);
12095                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain_name));
12096                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trusted_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
12097                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.unknown));
12098                 NDR_PULL_ALLOC(ndr, r->out.forest_trust_info);
12099                 ZERO_STRUCTP(r->out.forest_trust_info);
12100         }
12101         if (flags & NDR_OUT) {
12102                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12103                         NDR_PULL_ALLOC(ndr, r->out.forest_trust_info);
12104                 }
12105                 _mem_save_forest_trust_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12106                 NDR_PULL_SET_MEM_CTX(ndr, r->out.forest_trust_info, LIBNDR_FLAG_REF_ALLOC);
12107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_forest_trust_info));
12108                 if (_ptr_forest_trust_info) {
12109                         NDR_PULL_ALLOC(ndr, *r->out.forest_trust_info);
12110                 } else {
12111                         *r->out.forest_trust_info = NULL;
12112                 }
12113                 if (*r->out.forest_trust_info) {
12114                         _mem_save_forest_trust_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12115                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.forest_trust_info, 0);
12116                         NDR_CHECK(ndr_pull_lsa_ForestTrustInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.forest_trust_info));
12117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_forest_trust_info_1, 0);
12118                 }
12119                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_forest_trust_info_0, LIBNDR_FLAG_REF_ALLOC);
12120                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12121         }
12122         return NDR_ERR_SUCCESS;
12123 }
12124
12125 _PUBLIC_ void ndr_print_lsa_lsaRQueryForestTrustInformation(struct ndr_print *ndr, const char *name, int flags, const struct lsa_lsaRQueryForestTrustInformation *r)
12126 {
12127         ndr_print_struct(ndr, name, "lsa_lsaRQueryForestTrustInformation");
12128         ndr->depth++;
12129         if (flags & NDR_SET_VALUES) {
12130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12131         }
12132         if (flags & NDR_IN) {
12133                 ndr_print_struct(ndr, "in", "lsa_lsaRQueryForestTrustInformation");
12134                 ndr->depth++;
12135                 ndr_print_ptr(ndr, "handle", r->in.handle);
12136                 ndr->depth++;
12137                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12138                 ndr->depth--;
12139                 ndr_print_ptr(ndr, "trusted_domain_name", r->in.trusted_domain_name);
12140                 ndr->depth++;
12141                 ndr_print_lsa_String(ndr, "trusted_domain_name", r->in.trusted_domain_name);
12142                 ndr->depth--;
12143                 ndr_print_uint16(ndr, "unknown", r->in.unknown);
12144                 ndr->depth--;
12145         }
12146         if (flags & NDR_OUT) {
12147                 ndr_print_struct(ndr, "out", "lsa_lsaRQueryForestTrustInformation");
12148                 ndr->depth++;
12149                 ndr_print_ptr(ndr, "forest_trust_info", r->out.forest_trust_info);
12150                 ndr->depth++;
12151                 ndr_print_ptr(ndr, "forest_trust_info", *r->out.forest_trust_info);
12152                 ndr->depth++;
12153                 if (*r->out.forest_trust_info) {
12154                         ndr_print_lsa_ForestTrustInformation(ndr, "forest_trust_info", *r->out.forest_trust_info);
12155                 }
12156                 ndr->depth--;
12157                 ndr->depth--;
12158                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12159                 ndr->depth--;
12160         }
12161         ndr->depth--;
12162 }
12163
12164 static enum ndr_err_code ndr_push_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_push *ndr, int flags, const struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
12165 {
12166         if (flags & NDR_IN) {
12167         }
12168         if (flags & NDR_OUT) {
12169                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12170         }
12171         return NDR_ERR_SUCCESS;
12172 }
12173
12174 static enum ndr_err_code ndr_pull_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_pull *ndr, int flags, struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
12175 {
12176         if (flags & NDR_IN) {
12177         }
12178         if (flags & NDR_OUT) {
12179                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12180         }
12181         return NDR_ERR_SUCCESS;
12182 }
12183
12184 _PUBLIC_ void ndr_print_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
12185 {
12186         ndr_print_struct(ndr, name, "lsa_LSARSETFORESTTRUSTINFORMATION");
12187         ndr->depth++;
12188         if (flags & NDR_SET_VALUES) {
12189                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12190         }
12191         if (flags & NDR_IN) {
12192                 ndr_print_struct(ndr, "in", "lsa_LSARSETFORESTTRUSTINFORMATION");
12193                 ndr->depth++;
12194                 ndr->depth--;
12195         }
12196         if (flags & NDR_OUT) {
12197                 ndr_print_struct(ndr, "out", "lsa_LSARSETFORESTTRUSTINFORMATION");
12198                 ndr->depth++;
12199                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12200                 ndr->depth--;
12201         }
12202         ndr->depth--;
12203 }
12204
12205 static enum ndr_err_code ndr_push_lsa_CREDRRENAME(struct ndr_push *ndr, int flags, const struct lsa_CREDRRENAME *r)
12206 {
12207         if (flags & NDR_IN) {
12208         }
12209         if (flags & NDR_OUT) {
12210                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12211         }
12212         return NDR_ERR_SUCCESS;
12213 }
12214
12215 static enum ndr_err_code ndr_pull_lsa_CREDRRENAME(struct ndr_pull *ndr, int flags, struct lsa_CREDRRENAME *r)
12216 {
12217         if (flags & NDR_IN) {
12218         }
12219         if (flags & NDR_OUT) {
12220                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12221         }
12222         return NDR_ERR_SUCCESS;
12223 }
12224
12225 _PUBLIC_ void ndr_print_lsa_CREDRRENAME(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRRENAME *r)
12226 {
12227         ndr_print_struct(ndr, name, "lsa_CREDRRENAME");
12228         ndr->depth++;
12229         if (flags & NDR_SET_VALUES) {
12230                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12231         }
12232         if (flags & NDR_IN) {
12233                 ndr_print_struct(ndr, "in", "lsa_CREDRRENAME");
12234                 ndr->depth++;
12235                 ndr->depth--;
12236         }
12237         if (flags & NDR_OUT) {
12238                 ndr_print_struct(ndr, "out", "lsa_CREDRRENAME");
12239                 ndr->depth++;
12240                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12241                 ndr->depth--;
12242         }
12243         ndr->depth--;
12244 }
12245
12246 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupSids3(struct ndr_push *ndr, int flags, const struct lsa_LookupSids3 *r)
12247 {
12248         if (flags & NDR_IN) {
12249                 if (r->in.sids == NULL) {
12250                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12251                 }
12252                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
12253                 if (r->in.names == NULL) {
12254                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12255                 }
12256                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
12257                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
12258                 if (r->in.count == NULL) {
12259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12260                 }
12261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
12262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
12263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
12264         }
12265         if (flags & NDR_OUT) {
12266                 if (r->out.domains == NULL) {
12267                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12268                 }
12269                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
12270                 if (*r->out.domains) {
12271                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
12272                 }
12273                 if (r->out.names == NULL) {
12274                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12275                 }
12276                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
12277                 if (r->out.count == NULL) {
12278                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12279                 }
12280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
12281                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12282         }
12283         return NDR_ERR_SUCCESS;
12284 }
12285
12286 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupSids3(struct ndr_pull *ndr, int flags, struct lsa_LookupSids3 *r)
12287 {
12288         uint32_t _ptr_domains;
12289         TALLOC_CTX *_mem_save_sids_0;
12290         TALLOC_CTX *_mem_save_domains_0;
12291         TALLOC_CTX *_mem_save_domains_1;
12292         TALLOC_CTX *_mem_save_names_0;
12293         TALLOC_CTX *_mem_save_count_0;
12294         if (flags & NDR_IN) {
12295                 ZERO_STRUCT(r->out);
12296
12297                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12298                         NDR_PULL_ALLOC(ndr, r->in.sids);
12299                 }
12300                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
12301                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
12302                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
12303                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
12304                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12305                         NDR_PULL_ALLOC(ndr, r->in.names);
12306                 }
12307                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12308                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
12309                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
12310                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
12311                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
12312                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12313                         NDR_PULL_ALLOC(ndr, r->in.count);
12314                 }
12315                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
12316                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
12317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
12318                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
12319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
12320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
12321                 NDR_PULL_ALLOC(ndr, r->out.domains);
12322                 ZERO_STRUCTP(r->out.domains);
12323                 NDR_PULL_ALLOC(ndr, r->out.names);
12324                 *r->out.names = *r->in.names;
12325                 NDR_PULL_ALLOC(ndr, r->out.count);
12326                 *r->out.count = *r->in.count;
12327         }
12328         if (flags & NDR_OUT) {
12329                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12330                         NDR_PULL_ALLOC(ndr, r->out.domains);
12331                 }
12332                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
12333                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
12334                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
12335                 if (_ptr_domains) {
12336                         NDR_PULL_ALLOC(ndr, *r->out.domains);
12337                 } else {
12338                         *r->out.domains = NULL;
12339                 }
12340                 if (*r->out.domains) {
12341                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
12342                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
12343                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
12344                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
12345                 }
12346                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
12347                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12348                         NDR_PULL_ALLOC(ndr, r->out.names);
12349                 }
12350                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12351                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
12352                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
12353                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
12354                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12355                         NDR_PULL_ALLOC(ndr, r->out.count);
12356                 }
12357                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
12358                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
12359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
12360                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
12361                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12362         }
12363         return NDR_ERR_SUCCESS;
12364 }
12365
12366 _PUBLIC_ void ndr_print_lsa_LookupSids3(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids3 *r)
12367 {
12368         ndr_print_struct(ndr, name, "lsa_LookupSids3");
12369         ndr->depth++;
12370         if (flags & NDR_SET_VALUES) {
12371                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12372         }
12373         if (flags & NDR_IN) {
12374                 ndr_print_struct(ndr, "in", "lsa_LookupSids3");
12375                 ndr->depth++;
12376                 ndr_print_ptr(ndr, "sids", r->in.sids);
12377                 ndr->depth++;
12378                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
12379                 ndr->depth--;
12380                 ndr_print_ptr(ndr, "names", r->in.names);
12381                 ndr->depth++;
12382                 ndr_print_lsa_TransNameArray2(ndr, "names", r->in.names);
12383                 ndr->depth--;
12384                 ndr_print_uint16(ndr, "level", r->in.level);
12385                 ndr_print_ptr(ndr, "count", r->in.count);
12386                 ndr->depth++;
12387                 ndr_print_uint32(ndr, "count", *r->in.count);
12388                 ndr->depth--;
12389                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
12390                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
12391                 ndr->depth--;
12392         }
12393         if (flags & NDR_OUT) {
12394                 ndr_print_struct(ndr, "out", "lsa_LookupSids3");
12395                 ndr->depth++;
12396                 ndr_print_ptr(ndr, "domains", r->out.domains);
12397                 ndr->depth++;
12398                 ndr_print_ptr(ndr, "domains", *r->out.domains);
12399                 ndr->depth++;
12400                 if (*r->out.domains) {
12401                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
12402                 }
12403                 ndr->depth--;
12404                 ndr->depth--;
12405                 ndr_print_ptr(ndr, "names", r->out.names);
12406                 ndr->depth++;
12407                 ndr_print_lsa_TransNameArray2(ndr, "names", r->out.names);
12408                 ndr->depth--;
12409                 ndr_print_ptr(ndr, "count", r->out.count);
12410                 ndr->depth++;
12411                 ndr_print_uint32(ndr, "count", *r->out.count);
12412                 ndr->depth--;
12413                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12414                 ndr->depth--;
12415         }
12416         ndr->depth--;
12417 }
12418
12419 static enum ndr_err_code ndr_push_lsa_LookupNames4(struct ndr_push *ndr, int flags, const struct lsa_LookupNames4 *r)
12420 {
12421         uint32_t cntr_names_0;
12422         if (flags & NDR_IN) {
12423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
12424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
12425                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
12426                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
12427                 }
12428                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
12429                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
12430                 }
12431                 if (r->in.sids == NULL) {
12432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12433                 }
12434                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
12435                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
12436                 if (r->in.count == NULL) {
12437                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12438                 }
12439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
12440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.lookup_options));
12441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_revision));
12442         }
12443         if (flags & NDR_OUT) {
12444                 if (r->out.domains == NULL) {
12445                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12446                 }
12447                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
12448                 if (*r->out.domains) {
12449                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
12450                 }
12451                 if (r->out.sids == NULL) {
12452                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12453                 }
12454                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
12455                 if (r->out.count == NULL) {
12456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12457                 }
12458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
12459                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12460         }
12461         return NDR_ERR_SUCCESS;
12462 }
12463
12464 static enum ndr_err_code ndr_pull_lsa_LookupNames4(struct ndr_pull *ndr, int flags, struct lsa_LookupNames4 *r)
12465 {
12466         uint32_t cntr_names_0;
12467         uint32_t _ptr_domains;
12468         TALLOC_CTX *_mem_save_names_0;
12469         TALLOC_CTX *_mem_save_domains_0;
12470         TALLOC_CTX *_mem_save_domains_1;
12471         TALLOC_CTX *_mem_save_sids_0;
12472         TALLOC_CTX *_mem_save_count_0;
12473         if (flags & NDR_IN) {
12474                 ZERO_STRUCT(r->out);
12475
12476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
12477                 if (r->in.num_names > 1000) {
12478                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12479                 }
12480                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
12481                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
12482                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12483                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
12484                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
12485                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
12486                 }
12487                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
12488                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
12489                 }
12490                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
12491                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12492                         NDR_PULL_ALLOC(ndr, r->in.sids);
12493                 }
12494                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
12495                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
12496                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
12497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
12498                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
12499                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12500                         NDR_PULL_ALLOC(ndr, r->in.count);
12501                 }
12502                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
12503                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
12504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
12505                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
12506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.lookup_options));
12507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_revision));
12508                 NDR_PULL_ALLOC(ndr, r->out.domains);
12509                 ZERO_STRUCTP(r->out.domains);
12510                 NDR_PULL_ALLOC(ndr, r->out.sids);
12511                 *r->out.sids = *r->in.sids;
12512                 NDR_PULL_ALLOC(ndr, r->out.count);
12513                 *r->out.count = *r->in.count;
12514                 if (r->in.names) {
12515                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
12516                 }
12517         }
12518         if (flags & NDR_OUT) {
12519                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12520                         NDR_PULL_ALLOC(ndr, r->out.domains);
12521                 }
12522                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
12523                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
12524                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
12525                 if (_ptr_domains) {
12526                         NDR_PULL_ALLOC(ndr, *r->out.domains);
12527                 } else {
12528                         *r->out.domains = NULL;
12529                 }
12530                 if (*r->out.domains) {
12531                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
12532                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
12533                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
12534                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
12535                 }
12536                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
12537                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12538                         NDR_PULL_ALLOC(ndr, r->out.sids);
12539                 }
12540                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
12541                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
12542                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
12543                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
12544                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12545                         NDR_PULL_ALLOC(ndr, r->out.count);
12546                 }
12547                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
12548                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
12549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
12550                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
12551                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12552         }
12553         return NDR_ERR_SUCCESS;
12554 }
12555
12556 _PUBLIC_ void ndr_print_lsa_LookupNames4(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames4 *r)
12557 {
12558         uint32_t cntr_names_0;
12559         ndr_print_struct(ndr, name, "lsa_LookupNames4");
12560         ndr->depth++;
12561         if (flags & NDR_SET_VALUES) {
12562                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12563         }
12564         if (flags & NDR_IN) {
12565                 ndr_print_struct(ndr, "in", "lsa_LookupNames4");
12566                 ndr->depth++;
12567                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
12568                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
12569                 ndr->depth++;
12570                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
12571                         char *idx_0=NULL;
12572                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
12573                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
12574                                 free(idx_0);
12575                         }
12576                 }
12577                 ndr->depth--;
12578                 ndr_print_ptr(ndr, "sids", r->in.sids);
12579                 ndr->depth++;
12580                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->in.sids);
12581                 ndr->depth--;
12582                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
12583                 ndr_print_ptr(ndr, "count", r->in.count);
12584                 ndr->depth++;
12585                 ndr_print_uint32(ndr, "count", *r->in.count);
12586                 ndr->depth--;
12587                 ndr_print_uint32(ndr, "lookup_options", r->in.lookup_options);
12588                 ndr_print_uint32(ndr, "client_revision", r->in.client_revision);
12589                 ndr->depth--;
12590         }
12591         if (flags & NDR_OUT) {
12592                 ndr_print_struct(ndr, "out", "lsa_LookupNames4");
12593                 ndr->depth++;
12594                 ndr_print_ptr(ndr, "domains", r->out.domains);
12595                 ndr->depth++;
12596                 ndr_print_ptr(ndr, "domains", *r->out.domains);
12597                 ndr->depth++;
12598                 if (*r->out.domains) {
12599                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
12600                 }
12601                 ndr->depth--;
12602                 ndr->depth--;
12603                 ndr_print_ptr(ndr, "sids", r->out.sids);
12604                 ndr->depth++;
12605                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->out.sids);
12606                 ndr->depth--;
12607                 ndr_print_ptr(ndr, "count", r->out.count);
12608                 ndr->depth++;
12609                 ndr_print_uint32(ndr, "count", *r->out.count);
12610                 ndr->depth--;
12611                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12612                 ndr->depth--;
12613         }
12614         ndr->depth--;
12615 }
12616
12617 static enum ndr_err_code ndr_push_lsa_LSAROPENPOLICYSCE(struct ndr_push *ndr, int flags, const struct lsa_LSAROPENPOLICYSCE *r)
12618 {
12619         if (flags & NDR_IN) {
12620         }
12621         if (flags & NDR_OUT) {
12622                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12623         }
12624         return NDR_ERR_SUCCESS;
12625 }
12626
12627 static enum ndr_err_code ndr_pull_lsa_LSAROPENPOLICYSCE(struct ndr_pull *ndr, int flags, struct lsa_LSAROPENPOLICYSCE *r)
12628 {
12629         if (flags & NDR_IN) {
12630         }
12631         if (flags & NDR_OUT) {
12632                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12633         }
12634         return NDR_ERR_SUCCESS;
12635 }
12636
12637 _PUBLIC_ void ndr_print_lsa_LSAROPENPOLICYSCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSAROPENPOLICYSCE *r)
12638 {
12639         ndr_print_struct(ndr, name, "lsa_LSAROPENPOLICYSCE");
12640         ndr->depth++;
12641         if (flags & NDR_SET_VALUES) {
12642                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12643         }
12644         if (flags & NDR_IN) {
12645                 ndr_print_struct(ndr, "in", "lsa_LSAROPENPOLICYSCE");
12646                 ndr->depth++;
12647                 ndr->depth--;
12648         }
12649         if (flags & NDR_OUT) {
12650                 ndr_print_struct(ndr, "out", "lsa_LSAROPENPOLICYSCE");
12651                 ndr->depth++;
12652                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12653                 ndr->depth--;
12654         }
12655         ndr->depth--;
12656 }
12657
12658 static enum ndr_err_code ndr_push_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_push *ndr, int flags, const struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
12659 {
12660         if (flags & NDR_IN) {
12661         }
12662         if (flags & NDR_OUT) {
12663                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12664         }
12665         return NDR_ERR_SUCCESS;
12666 }
12667
12668 static enum ndr_err_code ndr_pull_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_pull *ndr, int flags, struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
12669 {
12670         if (flags & NDR_IN) {
12671         }
12672         if (flags & NDR_OUT) {
12673                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12674         }
12675         return NDR_ERR_SUCCESS;
12676 }
12677
12678 _PUBLIC_ void ndr_print_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
12679 {
12680         ndr_print_struct(ndr, name, "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
12681         ndr->depth++;
12682         if (flags & NDR_SET_VALUES) {
12683                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12684         }
12685         if (flags & NDR_IN) {
12686                 ndr_print_struct(ndr, "in", "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
12687                 ndr->depth++;
12688                 ndr->depth--;
12689         }
12690         if (flags & NDR_OUT) {
12691                 ndr_print_struct(ndr, "out", "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
12692                 ndr->depth++;
12693                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12694                 ndr->depth--;
12695         }
12696         ndr->depth--;
12697 }
12698
12699 static enum ndr_err_code ndr_push_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_push *ndr, int flags, const struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
12700 {
12701         if (flags & NDR_IN) {
12702         }
12703         if (flags & NDR_OUT) {
12704                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12705         }
12706         return NDR_ERR_SUCCESS;
12707 }
12708
12709 static enum ndr_err_code ndr_pull_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_pull *ndr, int flags, struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
12710 {
12711         if (flags & NDR_IN) {
12712         }
12713         if (flags & NDR_OUT) {
12714                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12715         }
12716         return NDR_ERR_SUCCESS;
12717 }
12718
12719 _PUBLIC_ void ndr_print_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
12720 {
12721         ndr_print_struct(ndr, name, "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
12722         ndr->depth++;
12723         if (flags & NDR_SET_VALUES) {
12724                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12725         }
12726         if (flags & NDR_IN) {
12727                 ndr_print_struct(ndr, "in", "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
12728                 ndr->depth++;
12729                 ndr->depth--;
12730         }
12731         if (flags & NDR_OUT) {
12732                 ndr_print_struct(ndr, "out", "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
12733                 ndr->depth++;
12734                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12735                 ndr->depth--;
12736         }
12737         ndr->depth--;
12738 }
12739
12740 static enum ndr_err_code ndr_push_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARADTREPORTSECURITYEVENT *r)
12741 {
12742         if (flags & NDR_IN) {
12743         }
12744         if (flags & NDR_OUT) {
12745                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12746         }
12747         return NDR_ERR_SUCCESS;
12748 }
12749
12750 static enum ndr_err_code ndr_pull_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARADTREPORTSECURITYEVENT *r)
12751 {
12752         if (flags & NDR_IN) {
12753         }
12754         if (flags & NDR_OUT) {
12755                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12756         }
12757         return NDR_ERR_SUCCESS;
12758 }
12759
12760 _PUBLIC_ void ndr_print_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTREPORTSECURITYEVENT *r)
12761 {
12762         ndr_print_struct(ndr, name, "lsa_LSARADTREPORTSECURITYEVENT");
12763         ndr->depth++;
12764         if (flags & NDR_SET_VALUES) {
12765                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12766         }
12767         if (flags & NDR_IN) {
12768                 ndr_print_struct(ndr, "in", "lsa_LSARADTREPORTSECURITYEVENT");
12769                 ndr->depth++;
12770                 ndr->depth--;
12771         }
12772         if (flags & NDR_OUT) {
12773                 ndr_print_struct(ndr, "out", "lsa_LSARADTREPORTSECURITYEVENT");
12774                 ndr->depth++;
12775                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12776                 ndr->depth--;
12777         }
12778         ndr->depth--;
12779 }
12780
12781 static const struct ndr_interface_call lsarpc_calls[] = {
12782         {
12783                 "lsa_Close",
12784                 sizeof(struct lsa_Close),
12785                 (ndr_push_flags_fn_t) ndr_push_lsa_Close,
12786                 (ndr_pull_flags_fn_t) ndr_pull_lsa_Close,
12787                 (ndr_print_function_t) ndr_print_lsa_Close,
12788                 false,
12789         },
12790         {
12791                 "lsa_Delete",
12792                 sizeof(struct lsa_Delete),
12793                 (ndr_push_flags_fn_t) ndr_push_lsa_Delete,
12794                 (ndr_pull_flags_fn_t) ndr_pull_lsa_Delete,
12795                 (ndr_print_function_t) ndr_print_lsa_Delete,
12796                 false,
12797         },
12798         {
12799                 "lsa_EnumPrivs",
12800                 sizeof(struct lsa_EnumPrivs),
12801                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumPrivs,
12802                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumPrivs,
12803                 (ndr_print_function_t) ndr_print_lsa_EnumPrivs,
12804                 false,
12805         },
12806         {
12807                 "lsa_QuerySecurity",
12808                 sizeof(struct lsa_QuerySecurity),
12809                 (ndr_push_flags_fn_t) ndr_push_lsa_QuerySecurity,
12810                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QuerySecurity,
12811                 (ndr_print_function_t) ndr_print_lsa_QuerySecurity,
12812                 false,
12813         },
12814         {
12815                 "lsa_SetSecObj",
12816                 sizeof(struct lsa_SetSecObj),
12817                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSecObj,
12818                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSecObj,
12819                 (ndr_print_function_t) ndr_print_lsa_SetSecObj,
12820                 false,
12821         },
12822         {
12823                 "lsa_ChangePassword",
12824                 sizeof(struct lsa_ChangePassword),
12825                 (ndr_push_flags_fn_t) ndr_push_lsa_ChangePassword,
12826                 (ndr_pull_flags_fn_t) ndr_pull_lsa_ChangePassword,
12827                 (ndr_print_function_t) ndr_print_lsa_ChangePassword,
12828                 false,
12829         },
12830         {
12831                 "lsa_OpenPolicy",
12832                 sizeof(struct lsa_OpenPolicy),
12833                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenPolicy,
12834                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenPolicy,
12835                 (ndr_print_function_t) ndr_print_lsa_OpenPolicy,
12836                 false,
12837         },
12838         {
12839                 "lsa_QueryInfoPolicy",
12840                 sizeof(struct lsa_QueryInfoPolicy),
12841                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryInfoPolicy,
12842                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryInfoPolicy,
12843                 (ndr_print_function_t) ndr_print_lsa_QueryInfoPolicy,
12844                 false,
12845         },
12846         {
12847                 "lsa_SetInfoPolicy",
12848                 sizeof(struct lsa_SetInfoPolicy),
12849                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInfoPolicy,
12850                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInfoPolicy,
12851                 (ndr_print_function_t) ndr_print_lsa_SetInfoPolicy,
12852                 false,
12853         },
12854         {
12855                 "lsa_ClearAuditLog",
12856                 sizeof(struct lsa_ClearAuditLog),
12857                 (ndr_push_flags_fn_t) ndr_push_lsa_ClearAuditLog,
12858                 (ndr_pull_flags_fn_t) ndr_pull_lsa_ClearAuditLog,
12859                 (ndr_print_function_t) ndr_print_lsa_ClearAuditLog,
12860                 false,
12861         },
12862         {
12863                 "lsa_CreateAccount",
12864                 sizeof(struct lsa_CreateAccount),
12865                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateAccount,
12866                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateAccount,
12867                 (ndr_print_function_t) ndr_print_lsa_CreateAccount,
12868                 false,
12869         },
12870         {
12871                 "lsa_EnumAccounts",
12872                 sizeof(struct lsa_EnumAccounts),
12873                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccounts,
12874                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccounts,
12875                 (ndr_print_function_t) ndr_print_lsa_EnumAccounts,
12876                 false,
12877         },
12878         {
12879                 "lsa_CreateTrustedDomain",
12880                 sizeof(struct lsa_CreateTrustedDomain),
12881                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomain,
12882                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomain,
12883                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomain,
12884                 false,
12885         },
12886         {
12887                 "lsa_EnumTrustDom",
12888                 sizeof(struct lsa_EnumTrustDom),
12889                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumTrustDom,
12890                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumTrustDom,
12891                 (ndr_print_function_t) ndr_print_lsa_EnumTrustDom,
12892                 false,
12893         },
12894         {
12895                 "lsa_LookupNames",
12896                 sizeof(struct lsa_LookupNames),
12897                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames,
12898                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames,
12899                 (ndr_print_function_t) ndr_print_lsa_LookupNames,
12900                 false,
12901         },
12902         {
12903                 "lsa_LookupSids",
12904                 sizeof(struct lsa_LookupSids),
12905                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids,
12906                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids,
12907                 (ndr_print_function_t) ndr_print_lsa_LookupSids,
12908                 false,
12909         },
12910         {
12911                 "lsa_CreateSecret",
12912                 sizeof(struct lsa_CreateSecret),
12913                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateSecret,
12914                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateSecret,
12915                 (ndr_print_function_t) ndr_print_lsa_CreateSecret,
12916                 false,
12917         },
12918         {
12919                 "lsa_OpenAccount",
12920                 sizeof(struct lsa_OpenAccount),
12921                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenAccount,
12922                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenAccount,
12923                 (ndr_print_function_t) ndr_print_lsa_OpenAccount,
12924                 false,
12925         },
12926         {
12927                 "lsa_EnumPrivsAccount",
12928                 sizeof(struct lsa_EnumPrivsAccount),
12929                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumPrivsAccount,
12930                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumPrivsAccount,
12931                 (ndr_print_function_t) ndr_print_lsa_EnumPrivsAccount,
12932                 false,
12933         },
12934         {
12935                 "lsa_AddPrivilegesToAccount",
12936                 sizeof(struct lsa_AddPrivilegesToAccount),
12937                 (ndr_push_flags_fn_t) ndr_push_lsa_AddPrivilegesToAccount,
12938                 (ndr_pull_flags_fn_t) ndr_pull_lsa_AddPrivilegesToAccount,
12939                 (ndr_print_function_t) ndr_print_lsa_AddPrivilegesToAccount,
12940                 false,
12941         },
12942         {
12943                 "lsa_RemovePrivilegesFromAccount",
12944                 sizeof(struct lsa_RemovePrivilegesFromAccount),
12945                 (ndr_push_flags_fn_t) ndr_push_lsa_RemovePrivilegesFromAccount,
12946                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RemovePrivilegesFromAccount,
12947                 (ndr_print_function_t) ndr_print_lsa_RemovePrivilegesFromAccount,
12948                 false,
12949         },
12950         {
12951                 "lsa_GetQuotasForAccount",
12952                 sizeof(struct lsa_GetQuotasForAccount),
12953                 (ndr_push_flags_fn_t) ndr_push_lsa_GetQuotasForAccount,
12954                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetQuotasForAccount,
12955                 (ndr_print_function_t) ndr_print_lsa_GetQuotasForAccount,
12956                 false,
12957         },
12958         {
12959                 "lsa_SetQuotasForAccount",
12960                 sizeof(struct lsa_SetQuotasForAccount),
12961                 (ndr_push_flags_fn_t) ndr_push_lsa_SetQuotasForAccount,
12962                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetQuotasForAccount,
12963                 (ndr_print_function_t) ndr_print_lsa_SetQuotasForAccount,
12964                 false,
12965         },
12966         {
12967                 "lsa_GetSystemAccessAccount",
12968                 sizeof(struct lsa_GetSystemAccessAccount),
12969                 (ndr_push_flags_fn_t) ndr_push_lsa_GetSystemAccessAccount,
12970                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetSystemAccessAccount,
12971                 (ndr_print_function_t) ndr_print_lsa_GetSystemAccessAccount,
12972                 false,
12973         },
12974         {
12975                 "lsa_SetSystemAccessAccount",
12976                 sizeof(struct lsa_SetSystemAccessAccount),
12977                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSystemAccessAccount,
12978                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSystemAccessAccount,
12979                 (ndr_print_function_t) ndr_print_lsa_SetSystemAccessAccount,
12980                 false,
12981         },
12982         {
12983                 "lsa_OpenTrustedDomain",
12984                 sizeof(struct lsa_OpenTrustedDomain),
12985                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenTrustedDomain,
12986                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenTrustedDomain,
12987                 (ndr_print_function_t) ndr_print_lsa_OpenTrustedDomain,
12988                 false,
12989         },
12990         {
12991                 "lsa_QueryTrustedDomainInfo",
12992                 sizeof(struct lsa_QueryTrustedDomainInfo),
12993                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfo,
12994                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfo,
12995                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfo,
12996                 false,
12997         },
12998         {
12999                 "lsa_SetInformationTrustedDomain",
13000                 sizeof(struct lsa_SetInformationTrustedDomain),
13001                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInformationTrustedDomain,
13002                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInformationTrustedDomain,
13003                 (ndr_print_function_t) ndr_print_lsa_SetInformationTrustedDomain,
13004                 false,
13005         },
13006         {
13007                 "lsa_OpenSecret",
13008                 sizeof(struct lsa_OpenSecret),
13009                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenSecret,
13010                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenSecret,
13011                 (ndr_print_function_t) ndr_print_lsa_OpenSecret,
13012                 false,
13013         },
13014         {
13015                 "lsa_SetSecret",
13016                 sizeof(struct lsa_SetSecret),
13017                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSecret,
13018                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSecret,
13019                 (ndr_print_function_t) ndr_print_lsa_SetSecret,
13020                 false,
13021         },
13022         {
13023                 "lsa_QuerySecret",
13024                 sizeof(struct lsa_QuerySecret),
13025                 (ndr_push_flags_fn_t) ndr_push_lsa_QuerySecret,
13026                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QuerySecret,
13027                 (ndr_print_function_t) ndr_print_lsa_QuerySecret,
13028                 false,
13029         },
13030         {
13031                 "lsa_LookupPrivValue",
13032                 sizeof(struct lsa_LookupPrivValue),
13033                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivValue,
13034                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivValue,
13035                 (ndr_print_function_t) ndr_print_lsa_LookupPrivValue,
13036                 false,
13037         },
13038         {
13039                 "lsa_LookupPrivName",
13040                 sizeof(struct lsa_LookupPrivName),
13041                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivName,
13042                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivName,
13043                 (ndr_print_function_t) ndr_print_lsa_LookupPrivName,
13044                 false,
13045         },
13046         {
13047                 "lsa_LookupPrivDisplayName",
13048                 sizeof(struct lsa_LookupPrivDisplayName),
13049                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivDisplayName,
13050                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivDisplayName,
13051                 (ndr_print_function_t) ndr_print_lsa_LookupPrivDisplayName,
13052                 false,
13053         },
13054         {
13055                 "lsa_DeleteObject",
13056                 sizeof(struct lsa_DeleteObject),
13057                 (ndr_push_flags_fn_t) ndr_push_lsa_DeleteObject,
13058                 (ndr_pull_flags_fn_t) ndr_pull_lsa_DeleteObject,
13059                 (ndr_print_function_t) ndr_print_lsa_DeleteObject,
13060                 false,
13061         },
13062         {
13063                 "lsa_EnumAccountsWithUserRight",
13064                 sizeof(struct lsa_EnumAccountsWithUserRight),
13065                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccountsWithUserRight,
13066                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccountsWithUserRight,
13067                 (ndr_print_function_t) ndr_print_lsa_EnumAccountsWithUserRight,
13068                 false,
13069         },
13070         {
13071                 "lsa_EnumAccountRights",
13072                 sizeof(struct lsa_EnumAccountRights),
13073                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccountRights,
13074                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccountRights,
13075                 (ndr_print_function_t) ndr_print_lsa_EnumAccountRights,
13076                 false,
13077         },
13078         {
13079                 "lsa_AddAccountRights",
13080                 sizeof(struct lsa_AddAccountRights),
13081                 (ndr_push_flags_fn_t) ndr_push_lsa_AddAccountRights,
13082                 (ndr_pull_flags_fn_t) ndr_pull_lsa_AddAccountRights,
13083                 (ndr_print_function_t) ndr_print_lsa_AddAccountRights,
13084                 false,
13085         },
13086         {
13087                 "lsa_RemoveAccountRights",
13088                 sizeof(struct lsa_RemoveAccountRights),
13089                 (ndr_push_flags_fn_t) ndr_push_lsa_RemoveAccountRights,
13090                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RemoveAccountRights,
13091                 (ndr_print_function_t) ndr_print_lsa_RemoveAccountRights,
13092                 false,
13093         },
13094         {
13095                 "lsa_QueryTrustedDomainInfoBySid",
13096                 sizeof(struct lsa_QueryTrustedDomainInfoBySid),
13097                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfoBySid,
13098                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfoBySid,
13099                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfoBySid,
13100                 false,
13101         },
13102         {
13103                 "lsa_SetTrustedDomainInfo",
13104                 sizeof(struct lsa_SetTrustedDomainInfo),
13105                 (ndr_push_flags_fn_t) ndr_push_lsa_SetTrustedDomainInfo,
13106                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetTrustedDomainInfo,
13107                 (ndr_print_function_t) ndr_print_lsa_SetTrustedDomainInfo,
13108                 false,
13109         },
13110         {
13111                 "lsa_DeleteTrustedDomain",
13112                 sizeof(struct lsa_DeleteTrustedDomain),
13113                 (ndr_push_flags_fn_t) ndr_push_lsa_DeleteTrustedDomain,
13114                 (ndr_pull_flags_fn_t) ndr_pull_lsa_DeleteTrustedDomain,
13115                 (ndr_print_function_t) ndr_print_lsa_DeleteTrustedDomain,
13116                 false,
13117         },
13118         {
13119                 "lsa_StorePrivateData",
13120                 sizeof(struct lsa_StorePrivateData),
13121                 (ndr_push_flags_fn_t) ndr_push_lsa_StorePrivateData,
13122                 (ndr_pull_flags_fn_t) ndr_pull_lsa_StorePrivateData,
13123                 (ndr_print_function_t) ndr_print_lsa_StorePrivateData,
13124                 false,
13125         },
13126         {
13127                 "lsa_RetrievePrivateData",
13128                 sizeof(struct lsa_RetrievePrivateData),
13129                 (ndr_push_flags_fn_t) ndr_push_lsa_RetrievePrivateData,
13130                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RetrievePrivateData,
13131                 (ndr_print_function_t) ndr_print_lsa_RetrievePrivateData,
13132                 false,
13133         },
13134         {
13135                 "lsa_OpenPolicy2",
13136                 sizeof(struct lsa_OpenPolicy2),
13137                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenPolicy2,
13138                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenPolicy2,
13139                 (ndr_print_function_t) ndr_print_lsa_OpenPolicy2,
13140                 false,
13141         },
13142         {
13143                 "lsa_GetUserName",
13144                 sizeof(struct lsa_GetUserName),
13145                 (ndr_push_flags_fn_t) ndr_push_lsa_GetUserName,
13146                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetUserName,
13147                 (ndr_print_function_t) ndr_print_lsa_GetUserName,
13148                 false,
13149         },
13150         {
13151                 "lsa_QueryInfoPolicy2",
13152                 sizeof(struct lsa_QueryInfoPolicy2),
13153                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryInfoPolicy2,
13154                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryInfoPolicy2,
13155                 (ndr_print_function_t) ndr_print_lsa_QueryInfoPolicy2,
13156                 false,
13157         },
13158         {
13159                 "lsa_SetInfoPolicy2",
13160                 sizeof(struct lsa_SetInfoPolicy2),
13161                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInfoPolicy2,
13162                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInfoPolicy2,
13163                 (ndr_print_function_t) ndr_print_lsa_SetInfoPolicy2,
13164                 false,
13165         },
13166         {
13167                 "lsa_QueryTrustedDomainInfoByName",
13168                 sizeof(struct lsa_QueryTrustedDomainInfoByName),
13169                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfoByName,
13170                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfoByName,
13171                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfoByName,
13172                 false,
13173         },
13174         {
13175                 "lsa_SetTrustedDomainInfoByName",
13176                 sizeof(struct lsa_SetTrustedDomainInfoByName),
13177                 (ndr_push_flags_fn_t) ndr_push_lsa_SetTrustedDomainInfoByName,
13178                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetTrustedDomainInfoByName,
13179                 (ndr_print_function_t) ndr_print_lsa_SetTrustedDomainInfoByName,
13180                 false,
13181         },
13182         {
13183                 "lsa_EnumTrustedDomainsEx",
13184                 sizeof(struct lsa_EnumTrustedDomainsEx),
13185                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumTrustedDomainsEx,
13186                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumTrustedDomainsEx,
13187                 (ndr_print_function_t) ndr_print_lsa_EnumTrustedDomainsEx,
13188                 false,
13189         },
13190         {
13191                 "lsa_CreateTrustedDomainEx",
13192                 sizeof(struct lsa_CreateTrustedDomainEx),
13193                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomainEx,
13194                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomainEx,
13195                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomainEx,
13196                 false,
13197         },
13198         {
13199                 "lsa_CloseTrustedDomainEx",
13200                 sizeof(struct lsa_CloseTrustedDomainEx),
13201                 (ndr_push_flags_fn_t) ndr_push_lsa_CloseTrustedDomainEx,
13202                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CloseTrustedDomainEx,
13203                 (ndr_print_function_t) ndr_print_lsa_CloseTrustedDomainEx,
13204                 false,
13205         },
13206         {
13207                 "lsa_QueryDomainInformationPolicy",
13208                 sizeof(struct lsa_QueryDomainInformationPolicy),
13209                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryDomainInformationPolicy,
13210                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryDomainInformationPolicy,
13211                 (ndr_print_function_t) ndr_print_lsa_QueryDomainInformationPolicy,
13212                 false,
13213         },
13214         {
13215                 "lsa_SetDomainInformationPolicy",
13216                 sizeof(struct lsa_SetDomainInformationPolicy),
13217                 (ndr_push_flags_fn_t) ndr_push_lsa_SetDomainInformationPolicy,
13218                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetDomainInformationPolicy,
13219                 (ndr_print_function_t) ndr_print_lsa_SetDomainInformationPolicy,
13220                 false,
13221         },
13222         {
13223                 "lsa_OpenTrustedDomainByName",
13224                 sizeof(struct lsa_OpenTrustedDomainByName),
13225                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenTrustedDomainByName,
13226                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenTrustedDomainByName,
13227                 (ndr_print_function_t) ndr_print_lsa_OpenTrustedDomainByName,
13228                 false,
13229         },
13230         {
13231                 "lsa_TestCall",
13232                 sizeof(struct lsa_TestCall),
13233                 (ndr_push_flags_fn_t) ndr_push_lsa_TestCall,
13234                 (ndr_pull_flags_fn_t) ndr_pull_lsa_TestCall,
13235                 (ndr_print_function_t) ndr_print_lsa_TestCall,
13236                 false,
13237         },
13238         {
13239                 "lsa_LookupSids2",
13240                 sizeof(struct lsa_LookupSids2),
13241                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids2,
13242                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids2,
13243                 (ndr_print_function_t) ndr_print_lsa_LookupSids2,
13244                 false,
13245         },
13246         {
13247                 "lsa_LookupNames2",
13248                 sizeof(struct lsa_LookupNames2),
13249                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames2,
13250                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames2,
13251                 (ndr_print_function_t) ndr_print_lsa_LookupNames2,
13252                 false,
13253         },
13254         {
13255                 "lsa_CreateTrustedDomainEx2",
13256                 sizeof(struct lsa_CreateTrustedDomainEx2),
13257                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomainEx2,
13258                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomainEx2,
13259                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomainEx2,
13260                 false,
13261         },
13262         {
13263                 "lsa_CREDRWRITE",
13264                 sizeof(struct lsa_CREDRWRITE),
13265                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRWRITE,
13266                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRWRITE,
13267                 (ndr_print_function_t) ndr_print_lsa_CREDRWRITE,
13268                 false,
13269         },
13270         {
13271                 "lsa_CREDRREAD",
13272                 sizeof(struct lsa_CREDRREAD),
13273                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRREAD,
13274                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRREAD,
13275                 (ndr_print_function_t) ndr_print_lsa_CREDRREAD,
13276                 false,
13277         },
13278         {
13279                 "lsa_CREDRENUMERATE",
13280                 sizeof(struct lsa_CREDRENUMERATE),
13281                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRENUMERATE,
13282                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRENUMERATE,
13283                 (ndr_print_function_t) ndr_print_lsa_CREDRENUMERATE,
13284                 false,
13285         },
13286         {
13287                 "lsa_CREDRWRITEDOMAINCREDENTIALS",
13288                 sizeof(struct lsa_CREDRWRITEDOMAINCREDENTIALS),
13289                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRWRITEDOMAINCREDENTIALS,
13290                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRWRITEDOMAINCREDENTIALS,
13291                 (ndr_print_function_t) ndr_print_lsa_CREDRWRITEDOMAINCREDENTIALS,
13292                 false,
13293         },
13294         {
13295                 "lsa_CREDRREADDOMAINCREDENTIALS",
13296                 sizeof(struct lsa_CREDRREADDOMAINCREDENTIALS),
13297                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRREADDOMAINCREDENTIALS,
13298                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRREADDOMAINCREDENTIALS,
13299                 (ndr_print_function_t) ndr_print_lsa_CREDRREADDOMAINCREDENTIALS,
13300                 false,
13301         },
13302         {
13303                 "lsa_CREDRDELETE",
13304                 sizeof(struct lsa_CREDRDELETE),
13305                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRDELETE,
13306                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRDELETE,
13307                 (ndr_print_function_t) ndr_print_lsa_CREDRDELETE,
13308                 false,
13309         },
13310         {
13311                 "lsa_CREDRGETTARGETINFO",
13312                 sizeof(struct lsa_CREDRGETTARGETINFO),
13313                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRGETTARGETINFO,
13314                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRGETTARGETINFO,
13315                 (ndr_print_function_t) ndr_print_lsa_CREDRGETTARGETINFO,
13316                 false,
13317         },
13318         {
13319                 "lsa_CREDRPROFILELOADED",
13320                 sizeof(struct lsa_CREDRPROFILELOADED),
13321                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRPROFILELOADED,
13322                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRPROFILELOADED,
13323                 (ndr_print_function_t) ndr_print_lsa_CREDRPROFILELOADED,
13324                 false,
13325         },
13326         {
13327                 "lsa_LookupNames3",
13328                 sizeof(struct lsa_LookupNames3),
13329                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames3,
13330                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames3,
13331                 (ndr_print_function_t) ndr_print_lsa_LookupNames3,
13332                 false,
13333         },
13334         {
13335                 "lsa_CREDRGETSESSIONTYPES",
13336                 sizeof(struct lsa_CREDRGETSESSIONTYPES),
13337                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRGETSESSIONTYPES,
13338                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRGETSESSIONTYPES,
13339                 (ndr_print_function_t) ndr_print_lsa_CREDRGETSESSIONTYPES,
13340                 false,
13341         },
13342         {
13343                 "lsa_LSARREGISTERAUDITEVENT",
13344                 sizeof(struct lsa_LSARREGISTERAUDITEVENT),
13345                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARREGISTERAUDITEVENT,
13346                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARREGISTERAUDITEVENT,
13347                 (ndr_print_function_t) ndr_print_lsa_LSARREGISTERAUDITEVENT,
13348                 false,
13349         },
13350         {
13351                 "lsa_LSARGENAUDITEVENT",
13352                 sizeof(struct lsa_LSARGENAUDITEVENT),
13353                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARGENAUDITEVENT,
13354                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARGENAUDITEVENT,
13355                 (ndr_print_function_t) ndr_print_lsa_LSARGENAUDITEVENT,
13356                 false,
13357         },
13358         {
13359                 "lsa_LSARUNREGISTERAUDITEVENT",
13360                 sizeof(struct lsa_LSARUNREGISTERAUDITEVENT),
13361                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARUNREGISTERAUDITEVENT,
13362                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARUNREGISTERAUDITEVENT,
13363                 (ndr_print_function_t) ndr_print_lsa_LSARUNREGISTERAUDITEVENT,
13364                 false,
13365         },
13366         {
13367                 "lsa_lsaRQueryForestTrustInformation",
13368                 sizeof(struct lsa_lsaRQueryForestTrustInformation),
13369                 (ndr_push_flags_fn_t) ndr_push_lsa_lsaRQueryForestTrustInformation,
13370                 (ndr_pull_flags_fn_t) ndr_pull_lsa_lsaRQueryForestTrustInformation,
13371                 (ndr_print_function_t) ndr_print_lsa_lsaRQueryForestTrustInformation,
13372                 false,
13373         },
13374         {
13375                 "lsa_LSARSETFORESTTRUSTINFORMATION",
13376                 sizeof(struct lsa_LSARSETFORESTTRUSTINFORMATION),
13377                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARSETFORESTTRUSTINFORMATION,
13378                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARSETFORESTTRUSTINFORMATION,
13379                 (ndr_print_function_t) ndr_print_lsa_LSARSETFORESTTRUSTINFORMATION,
13380                 false,
13381         },
13382         {
13383                 "lsa_CREDRRENAME",
13384                 sizeof(struct lsa_CREDRRENAME),
13385                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRRENAME,
13386                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRRENAME,
13387                 (ndr_print_function_t) ndr_print_lsa_CREDRRENAME,
13388                 false,
13389         },
13390         {
13391                 "lsa_LookupSids3",
13392                 sizeof(struct lsa_LookupSids3),
13393                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids3,
13394                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids3,
13395                 (ndr_print_function_t) ndr_print_lsa_LookupSids3,
13396                 false,
13397         },
13398         {
13399                 "lsa_LookupNames4",
13400                 sizeof(struct lsa_LookupNames4),
13401                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames4,
13402                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames4,
13403                 (ndr_print_function_t) ndr_print_lsa_LookupNames4,
13404                 false,
13405         },
13406         {
13407                 "lsa_LSAROPENPOLICYSCE",
13408                 sizeof(struct lsa_LSAROPENPOLICYSCE),
13409                 (ndr_push_flags_fn_t) ndr_push_lsa_LSAROPENPOLICYSCE,
13410                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSAROPENPOLICYSCE,
13411                 (ndr_print_function_t) ndr_print_lsa_LSAROPENPOLICYSCE,
13412                 false,
13413         },
13414         {
13415                 "lsa_LSARADTREGISTERSECURITYEVENTSOURCE",
13416                 sizeof(struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE),
13417                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
13418                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
13419                 (ndr_print_function_t) ndr_print_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
13420                 false,
13421         },
13422         {
13423                 "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE",
13424                 sizeof(struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE),
13425                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
13426                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
13427                 (ndr_print_function_t) ndr_print_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
13428                 false,
13429         },
13430         {
13431                 "lsa_LSARADTREPORTSECURITYEVENT",
13432                 sizeof(struct lsa_LSARADTREPORTSECURITYEVENT),
13433                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTREPORTSECURITYEVENT,
13434                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTREPORTSECURITYEVENT,
13435                 (ndr_print_function_t) ndr_print_lsa_LSARADTREPORTSECURITYEVENT,
13436                 false,
13437         },
13438         { NULL, 0, NULL, NULL, NULL, false }
13439 };
13440
13441 static const char * const lsarpc_endpoint_strings[] = {
13442         "ncacn_np:[\\pipe\\lsarpc]",
13443         "ncacn_np:[\\pipe\\netlogon]",
13444         "ncacn_np:[\\pipe\\lsass]",
13445         "ncacn_ip_tcp:",
13446         "ncalrpc:",
13447 };
13448
13449 static const struct ndr_interface_string_array lsarpc_endpoints = {
13450         .count  = 5,
13451         .names  = lsarpc_endpoint_strings
13452 };
13453
13454 static const char * const lsarpc_authservice_strings[] = {
13455         "host",
13456 };
13457
13458 static const struct ndr_interface_string_array lsarpc_authservices = {
13459         .count  = 1,
13460         .names  = lsarpc_authservice_strings
13461 };
13462
13463
13464 const struct ndr_interface_table ndr_table_lsarpc = {
13465         .name           = "lsarpc",
13466         .syntax_id      = {
13467                 {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
13468                 NDR_LSARPC_VERSION
13469         },
13470         .helpstring     = NDR_LSARPC_HELPSTRING,
13471         .num_calls      = 82,
13472         .calls          = lsarpc_calls,
13473         .endpoints      = &lsarpc_endpoints,
13474         .authservices   = &lsarpc_authservices
13475 };
13476