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         }
9229         if (flags & NDR_OUT) {
9230                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9231         }
9232         return NDR_ERR_SUCCESS;
9233 }
9234
9235 static enum ndr_err_code ndr_pull_lsa_StorePrivateData(struct ndr_pull *ndr, int flags, struct lsa_StorePrivateData *r)
9236 {
9237         if (flags & NDR_IN) {
9238         }
9239         if (flags & NDR_OUT) {
9240                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9241         }
9242         return NDR_ERR_SUCCESS;
9243 }
9244
9245 _PUBLIC_ void ndr_print_lsa_StorePrivateData(struct ndr_print *ndr, const char *name, int flags, const struct lsa_StorePrivateData *r)
9246 {
9247         ndr_print_struct(ndr, name, "lsa_StorePrivateData");
9248         ndr->depth++;
9249         if (flags & NDR_SET_VALUES) {
9250                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9251         }
9252         if (flags & NDR_IN) {
9253                 ndr_print_struct(ndr, "in", "lsa_StorePrivateData");
9254                 ndr->depth++;
9255                 ndr->depth--;
9256         }
9257         if (flags & NDR_OUT) {
9258                 ndr_print_struct(ndr, "out", "lsa_StorePrivateData");
9259                 ndr->depth++;
9260                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9261                 ndr->depth--;
9262         }
9263         ndr->depth--;
9264 }
9265
9266 static enum ndr_err_code ndr_push_lsa_RetrievePrivateData(struct ndr_push *ndr, int flags, const struct lsa_RetrievePrivateData *r)
9267 {
9268         if (flags & NDR_IN) {
9269         }
9270         if (flags & NDR_OUT) {
9271                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9272         }
9273         return NDR_ERR_SUCCESS;
9274 }
9275
9276 static enum ndr_err_code ndr_pull_lsa_RetrievePrivateData(struct ndr_pull *ndr, int flags, struct lsa_RetrievePrivateData *r)
9277 {
9278         if (flags & NDR_IN) {
9279         }
9280         if (flags & NDR_OUT) {
9281                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9282         }
9283         return NDR_ERR_SUCCESS;
9284 }
9285
9286 _PUBLIC_ void ndr_print_lsa_RetrievePrivateData(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RetrievePrivateData *r)
9287 {
9288         ndr_print_struct(ndr, name, "lsa_RetrievePrivateData");
9289         ndr->depth++;
9290         if (flags & NDR_SET_VALUES) {
9291                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9292         }
9293         if (flags & NDR_IN) {
9294                 ndr_print_struct(ndr, "in", "lsa_RetrievePrivateData");
9295                 ndr->depth++;
9296                 ndr->depth--;
9297         }
9298         if (flags & NDR_OUT) {
9299                 ndr_print_struct(ndr, "out", "lsa_RetrievePrivateData");
9300                 ndr->depth++;
9301                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9302                 ndr->depth--;
9303         }
9304         ndr->depth--;
9305 }
9306
9307 _PUBLIC_ enum ndr_err_code ndr_push_lsa_OpenPolicy2(struct ndr_push *ndr, int flags, const struct lsa_OpenPolicy2 *r)
9308 {
9309         if (flags & NDR_IN) {
9310                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
9311                 if (r->in.system_name) {
9312                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
9313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9314                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
9315                         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));
9316                 }
9317                 if (r->in.attr == NULL) {
9318                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9319                 }
9320                 NDR_CHECK(ndr_push_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
9321                 NDR_CHECK(ndr_push_lsa_PolicyAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
9322         }
9323         if (flags & NDR_OUT) {
9324                 if (r->out.handle == NULL) {
9325                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9326                 }
9327                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
9328                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9329         }
9330         return NDR_ERR_SUCCESS;
9331 }
9332
9333 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_OpenPolicy2(struct ndr_pull *ndr, int flags, struct lsa_OpenPolicy2 *r)
9334 {
9335         uint32_t _ptr_system_name;
9336         TALLOC_CTX *_mem_save_system_name_0;
9337         TALLOC_CTX *_mem_save_attr_0;
9338         TALLOC_CTX *_mem_save_handle_0;
9339         if (flags & NDR_IN) {
9340                 ZERO_STRUCT(r->out);
9341
9342                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
9343                 if (_ptr_system_name) {
9344                         NDR_PULL_ALLOC(ndr, r->in.system_name);
9345                 } else {
9346                         r->in.system_name = NULL;
9347                 }
9348                 if (r->in.system_name) {
9349                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9350                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
9351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
9352                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
9353                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
9354                                 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));
9355                         }
9356                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
9357                         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));
9358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
9359                 }
9360                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9361                         NDR_PULL_ALLOC(ndr, r->in.attr);
9362                 }
9363                 _mem_save_attr_0 = NDR_PULL_GET_MEM_CTX(ndr);
9364                 NDR_PULL_SET_MEM_CTX(ndr, r->in.attr, LIBNDR_FLAG_REF_ALLOC);
9365                 NDR_CHECK(ndr_pull_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
9366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attr_0, LIBNDR_FLAG_REF_ALLOC);
9367                 NDR_CHECK(ndr_pull_lsa_PolicyAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
9368                 NDR_PULL_ALLOC(ndr, r->out.handle);
9369                 ZERO_STRUCTP(r->out.handle);
9370         }
9371         if (flags & NDR_OUT) {
9372                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9373                         NDR_PULL_ALLOC(ndr, r->out.handle);
9374                 }
9375                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9376                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
9377                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
9378                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9379                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9380         }
9381         return NDR_ERR_SUCCESS;
9382 }
9383
9384 _PUBLIC_ void ndr_print_lsa_OpenPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenPolicy2 *r)
9385 {
9386         ndr_print_struct(ndr, name, "lsa_OpenPolicy2");
9387         ndr->depth++;
9388         if (flags & NDR_SET_VALUES) {
9389                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9390         }
9391         if (flags & NDR_IN) {
9392                 ndr_print_struct(ndr, "in", "lsa_OpenPolicy2");
9393                 ndr->depth++;
9394                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
9395                 ndr->depth++;
9396                 if (r->in.system_name) {
9397                         ndr_print_string(ndr, "system_name", r->in.system_name);
9398                 }
9399                 ndr->depth--;
9400                 ndr_print_ptr(ndr, "attr", r->in.attr);
9401                 ndr->depth++;
9402                 ndr_print_lsa_ObjectAttribute(ndr, "attr", r->in.attr);
9403                 ndr->depth--;
9404                 ndr_print_lsa_PolicyAccessMask(ndr, "access_mask", r->in.access_mask);
9405                 ndr->depth--;
9406         }
9407         if (flags & NDR_OUT) {
9408                 ndr_print_struct(ndr, "out", "lsa_OpenPolicy2");
9409                 ndr->depth++;
9410                 ndr_print_ptr(ndr, "handle", r->out.handle);
9411                 ndr->depth++;
9412                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
9413                 ndr->depth--;
9414                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9415                 ndr->depth--;
9416         }
9417         ndr->depth--;
9418 }
9419
9420 static enum ndr_err_code ndr_push_lsa_GetUserName(struct ndr_push *ndr, int flags, const struct lsa_GetUserName *r)
9421 {
9422         if (flags & NDR_IN) {
9423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
9424                 if (r->in.system_name) {
9425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
9426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9427                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
9428                         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));
9429                 }
9430                 if (r->in.account_name == NULL) {
9431                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9432                 }
9433                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.account_name));
9434                 if (*r->in.account_name) {
9435                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.account_name));
9436                 }
9437                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.authority_name));
9438                 if (r->in.authority_name) {
9439                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.authority_name));
9440                         if (*r->in.authority_name) {
9441                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.authority_name));
9442                         }
9443                 }
9444         }
9445         if (flags & NDR_OUT) {
9446                 if (r->out.account_name == NULL) {
9447                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9448                 }
9449                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.account_name));
9450                 if (*r->out.account_name) {
9451                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.account_name));
9452                 }
9453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.authority_name));
9454                 if (r->out.authority_name) {
9455                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.authority_name));
9456                         if (*r->out.authority_name) {
9457                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.authority_name));
9458                         }
9459                 }
9460                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9461         }
9462         return NDR_ERR_SUCCESS;
9463 }
9464
9465 static enum ndr_err_code ndr_pull_lsa_GetUserName(struct ndr_pull *ndr, int flags, struct lsa_GetUserName *r)
9466 {
9467         uint32_t _ptr_system_name;
9468         uint32_t _ptr_account_name;
9469         uint32_t _ptr_authority_name;
9470         TALLOC_CTX *_mem_save_system_name_0;
9471         TALLOC_CTX *_mem_save_account_name_0;
9472         TALLOC_CTX *_mem_save_account_name_1;
9473         TALLOC_CTX *_mem_save_authority_name_0;
9474         TALLOC_CTX *_mem_save_authority_name_1;
9475         if (flags & NDR_IN) {
9476                 ZERO_STRUCT(r->out);
9477
9478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
9479                 if (_ptr_system_name) {
9480                         NDR_PULL_ALLOC(ndr, r->in.system_name);
9481                 } else {
9482                         r->in.system_name = NULL;
9483                 }
9484                 if (r->in.system_name) {
9485                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9486                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
9487                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
9488                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
9489                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
9490                                 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));
9491                         }
9492                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
9493                         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));
9494                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
9495                 }
9496                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9497                         NDR_PULL_ALLOC(ndr, r->in.account_name);
9498                 }
9499                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9500                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
9501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
9502                 if (_ptr_account_name) {
9503                         NDR_PULL_ALLOC(ndr, *r->in.account_name);
9504                 } else {
9505                         *r->in.account_name = NULL;
9506                 }
9507                 if (*r->in.account_name) {
9508                         _mem_save_account_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
9509                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.account_name, 0);
9510                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.account_name));
9511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_1, 0);
9512                 }
9513                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
9514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
9515                 if (_ptr_authority_name) {
9516                         NDR_PULL_ALLOC(ndr, r->in.authority_name);
9517                 } else {
9518                         r->in.authority_name = NULL;
9519                 }
9520                 if (r->in.authority_name) {
9521                         _mem_save_authority_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9522                         NDR_PULL_SET_MEM_CTX(ndr, r->in.authority_name, 0);
9523                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
9524                         if (_ptr_authority_name) {
9525                                 NDR_PULL_ALLOC(ndr, *r->in.authority_name);
9526                         } else {
9527                                 *r->in.authority_name = NULL;
9528                         }
9529                         if (*r->in.authority_name) {
9530                                 _mem_save_authority_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
9531                                 NDR_PULL_SET_MEM_CTX(ndr, *r->in.authority_name, 0);
9532                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.authority_name));
9533                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_1, 0);
9534                         }
9535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_0, 0);
9536                 }
9537                 NDR_PULL_ALLOC(ndr, r->out.account_name);
9538                 *r->out.account_name = *r->in.account_name;
9539         }
9540         if (flags & NDR_OUT) {
9541                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9542                         NDR_PULL_ALLOC(ndr, r->out.account_name);
9543                 }
9544                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9545                 NDR_PULL_SET_MEM_CTX(ndr, r->out.account_name, LIBNDR_FLAG_REF_ALLOC);
9546                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
9547                 if (_ptr_account_name) {
9548                         NDR_PULL_ALLOC(ndr, *r->out.account_name);
9549                 } else {
9550                         *r->out.account_name = NULL;
9551                 }
9552                 if (*r->out.account_name) {
9553                         _mem_save_account_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
9554                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.account_name, 0);
9555                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.account_name));
9556                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_1, 0);
9557                 }
9558                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
9559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
9560                 if (_ptr_authority_name) {
9561                         NDR_PULL_ALLOC(ndr, r->out.authority_name);
9562                 } else {
9563                         r->out.authority_name = NULL;
9564                 }
9565                 if (r->out.authority_name) {
9566                         _mem_save_authority_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9567                         NDR_PULL_SET_MEM_CTX(ndr, r->out.authority_name, 0);
9568                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
9569                         if (_ptr_authority_name) {
9570                                 NDR_PULL_ALLOC(ndr, *r->out.authority_name);
9571                         } else {
9572                                 *r->out.authority_name = NULL;
9573                         }
9574                         if (*r->out.authority_name) {
9575                                 _mem_save_authority_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
9576                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.authority_name, 0);
9577                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.authority_name));
9578                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_1, 0);
9579                         }
9580                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_0, 0);
9581                 }
9582                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9583         }
9584         return NDR_ERR_SUCCESS;
9585 }
9586
9587 _PUBLIC_ void ndr_print_lsa_GetUserName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetUserName *r)
9588 {
9589         ndr_print_struct(ndr, name, "lsa_GetUserName");
9590         ndr->depth++;
9591         if (flags & NDR_SET_VALUES) {
9592                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9593         }
9594         if (flags & NDR_IN) {
9595                 ndr_print_struct(ndr, "in", "lsa_GetUserName");
9596                 ndr->depth++;
9597                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
9598                 ndr->depth++;
9599                 if (r->in.system_name) {
9600                         ndr_print_string(ndr, "system_name", r->in.system_name);
9601                 }
9602                 ndr->depth--;
9603                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
9604                 ndr->depth++;
9605                 ndr_print_ptr(ndr, "account_name", *r->in.account_name);
9606                 ndr->depth++;
9607                 if (*r->in.account_name) {
9608                         ndr_print_lsa_String(ndr, "account_name", *r->in.account_name);
9609                 }
9610                 ndr->depth--;
9611                 ndr->depth--;
9612                 ndr_print_ptr(ndr, "authority_name", r->in.authority_name);
9613                 ndr->depth++;
9614                 if (r->in.authority_name) {
9615                         ndr_print_ptr(ndr, "authority_name", *r->in.authority_name);
9616                         ndr->depth++;
9617                         if (*r->in.authority_name) {
9618                                 ndr_print_lsa_String(ndr, "authority_name", *r->in.authority_name);
9619                         }
9620                         ndr->depth--;
9621                 }
9622                 ndr->depth--;
9623                 ndr->depth--;
9624         }
9625         if (flags & NDR_OUT) {
9626                 ndr_print_struct(ndr, "out", "lsa_GetUserName");
9627                 ndr->depth++;
9628                 ndr_print_ptr(ndr, "account_name", r->out.account_name);
9629                 ndr->depth++;
9630                 ndr_print_ptr(ndr, "account_name", *r->out.account_name);
9631                 ndr->depth++;
9632                 if (*r->out.account_name) {
9633                         ndr_print_lsa_String(ndr, "account_name", *r->out.account_name);
9634                 }
9635                 ndr->depth--;
9636                 ndr->depth--;
9637                 ndr_print_ptr(ndr, "authority_name", r->out.authority_name);
9638                 ndr->depth++;
9639                 if (r->out.authority_name) {
9640                         ndr_print_ptr(ndr, "authority_name", *r->out.authority_name);
9641                         ndr->depth++;
9642                         if (*r->out.authority_name) {
9643                                 ndr_print_lsa_String(ndr, "authority_name", *r->out.authority_name);
9644                         }
9645                         ndr->depth--;
9646                 }
9647                 ndr->depth--;
9648                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9649                 ndr->depth--;
9650         }
9651         ndr->depth--;
9652 }
9653
9654 static enum ndr_err_code ndr_push_lsa_QueryInfoPolicy2(struct ndr_push *ndr, int flags, const struct lsa_QueryInfoPolicy2 *r)
9655 {
9656         if (flags & NDR_IN) {
9657                 if (r->in.handle == NULL) {
9658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9659                 }
9660                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9661                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
9662         }
9663         if (flags & NDR_OUT) {
9664                 if (r->out.info == NULL) {
9665                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9666                 }
9667                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9668                 if (*r->out.info) {
9669                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9670                         NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9671                 }
9672                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9673         }
9674         return NDR_ERR_SUCCESS;
9675 }
9676
9677 static enum ndr_err_code ndr_pull_lsa_QueryInfoPolicy2(struct ndr_pull *ndr, int flags, struct lsa_QueryInfoPolicy2 *r)
9678 {
9679         uint32_t _ptr_info;
9680         TALLOC_CTX *_mem_save_handle_0;
9681         TALLOC_CTX *_mem_save_info_0;
9682         TALLOC_CTX *_mem_save_info_1;
9683         if (flags & NDR_IN) {
9684                 ZERO_STRUCT(r->out);
9685
9686                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9687                         NDR_PULL_ALLOC(ndr, r->in.handle);
9688                 }
9689                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9690                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9691                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9692                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9693                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
9694                 NDR_PULL_ALLOC(ndr, r->out.info);
9695                 ZERO_STRUCTP(r->out.info);
9696         }
9697         if (flags & NDR_OUT) {
9698                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9699                         NDR_PULL_ALLOC(ndr, r->out.info);
9700                 }
9701                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9702                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9704                 if (_ptr_info) {
9705                         NDR_PULL_ALLOC(ndr, *r->out.info);
9706                 } else {
9707                         *r->out.info = NULL;
9708                 }
9709                 if (*r->out.info) {
9710                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9711                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9712                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9713                         NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9714                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9715                 }
9716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9717                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9718         }
9719         return NDR_ERR_SUCCESS;
9720 }
9721
9722 _PUBLIC_ void ndr_print_lsa_QueryInfoPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryInfoPolicy2 *r)
9723 {
9724         ndr_print_struct(ndr, name, "lsa_QueryInfoPolicy2");
9725         ndr->depth++;
9726         if (flags & NDR_SET_VALUES) {
9727                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9728         }
9729         if (flags & NDR_IN) {
9730                 ndr_print_struct(ndr, "in", "lsa_QueryInfoPolicy2");
9731                 ndr->depth++;
9732                 ndr_print_ptr(ndr, "handle", r->in.handle);
9733                 ndr->depth++;
9734                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9735                 ndr->depth--;
9736                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
9737                 ndr->depth--;
9738         }
9739         if (flags & NDR_OUT) {
9740                 ndr_print_struct(ndr, "out", "lsa_QueryInfoPolicy2");
9741                 ndr->depth++;
9742                 ndr_print_ptr(ndr, "info", r->out.info);
9743                 ndr->depth++;
9744                 ndr_print_ptr(ndr, "info", *r->out.info);
9745                 ndr->depth++;
9746                 if (*r->out.info) {
9747                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9748                         ndr_print_lsa_PolicyInformation(ndr, "info", *r->out.info);
9749                 }
9750                 ndr->depth--;
9751                 ndr->depth--;
9752                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9753                 ndr->depth--;
9754         }
9755         ndr->depth--;
9756 }
9757
9758 static enum ndr_err_code ndr_push_lsa_SetInfoPolicy2(struct ndr_push *ndr, int flags, const struct lsa_SetInfoPolicy2 *r)
9759 {
9760         if (flags & NDR_IN) {
9761                 if (r->in.handle == NULL) {
9762                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9763                 }
9764                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9765                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
9766                 if (r->in.info == NULL) {
9767                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9768                 }
9769                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
9770                 NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9771         }
9772         if (flags & NDR_OUT) {
9773                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9774         }
9775         return NDR_ERR_SUCCESS;
9776 }
9777
9778 static enum ndr_err_code ndr_pull_lsa_SetInfoPolicy2(struct ndr_pull *ndr, int flags, struct lsa_SetInfoPolicy2 *r)
9779 {
9780         TALLOC_CTX *_mem_save_handle_0;
9781         TALLOC_CTX *_mem_save_info_0;
9782         if (flags & NDR_IN) {
9783                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9784                         NDR_PULL_ALLOC(ndr, r->in.handle);
9785                 }
9786                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9787                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9788                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9789                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9790                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
9791                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9792                         NDR_PULL_ALLOC(ndr, r->in.info);
9793                 }
9794                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9795                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
9796                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
9797                 NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9798                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9799         }
9800         if (flags & NDR_OUT) {
9801                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9802         }
9803         return NDR_ERR_SUCCESS;
9804 }
9805
9806 _PUBLIC_ void ndr_print_lsa_SetInfoPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInfoPolicy2 *r)
9807 {
9808         ndr_print_struct(ndr, name, "lsa_SetInfoPolicy2");
9809         ndr->depth++;
9810         if (flags & NDR_SET_VALUES) {
9811                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9812         }
9813         if (flags & NDR_IN) {
9814                 ndr_print_struct(ndr, "in", "lsa_SetInfoPolicy2");
9815                 ndr->depth++;
9816                 ndr_print_ptr(ndr, "handle", r->in.handle);
9817                 ndr->depth++;
9818                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9819                 ndr->depth--;
9820                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
9821                 ndr_print_ptr(ndr, "info", r->in.info);
9822                 ndr->depth++;
9823                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9824                 ndr_print_lsa_PolicyInformation(ndr, "info", r->in.info);
9825                 ndr->depth--;
9826                 ndr->depth--;
9827         }
9828         if (flags & NDR_OUT) {
9829                 ndr_print_struct(ndr, "out", "lsa_SetInfoPolicy2");
9830                 ndr->depth++;
9831                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9832                 ndr->depth--;
9833         }
9834         ndr->depth--;
9835 }
9836
9837 static enum ndr_err_code ndr_push_lsa_QueryTrustedDomainInfoByName(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfoByName *r)
9838 {
9839         if (flags & NDR_IN) {
9840                 if (r->in.handle == NULL) {
9841                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9842                 }
9843                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9844                 if (r->in.trusted_domain == NULL) {
9845                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9846                 }
9847                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain));
9848                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
9849         }
9850         if (flags & NDR_OUT) {
9851                 if (r->out.info == NULL) {
9852                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9853                 }
9854                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
9855                 if (*r->out.info) {
9856                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
9857                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9858                 }
9859                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9860         }
9861         return NDR_ERR_SUCCESS;
9862 }
9863
9864 static enum ndr_err_code ndr_pull_lsa_QueryTrustedDomainInfoByName(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfoByName *r)
9865 {
9866         uint32_t _ptr_info;
9867         TALLOC_CTX *_mem_save_handle_0;
9868         TALLOC_CTX *_mem_save_trusted_domain_0;
9869         TALLOC_CTX *_mem_save_info_0;
9870         TALLOC_CTX *_mem_save_info_1;
9871         if (flags & NDR_IN) {
9872                 ZERO_STRUCT(r->out);
9873
9874                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9875                         NDR_PULL_ALLOC(ndr, r->in.handle);
9876                 }
9877                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9878                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9879                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9880                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9881                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9882                         NDR_PULL_ALLOC(ndr, r->in.trusted_domain);
9883                 }
9884                 _mem_save_trusted_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
9885                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trusted_domain, LIBNDR_FLAG_REF_ALLOC);
9886                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain));
9887                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trusted_domain_0, LIBNDR_FLAG_REF_ALLOC);
9888                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
9889                 NDR_PULL_ALLOC(ndr, r->out.info);
9890                 ZERO_STRUCTP(r->out.info);
9891         }
9892         if (flags & NDR_OUT) {
9893                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9894                         NDR_PULL_ALLOC(ndr, r->out.info);
9895                 }
9896                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9897                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9899                 if (_ptr_info) {
9900                         NDR_PULL_ALLOC(ndr, *r->out.info);
9901                 } else {
9902                         *r->out.info = NULL;
9903                 }
9904                 if (*r->out.info) {
9905                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
9906                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
9907                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
9908                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
9909                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
9910                 }
9911                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9912                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9913         }
9914         return NDR_ERR_SUCCESS;
9915 }
9916
9917 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfoByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfoByName *r)
9918 {
9919         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfoByName");
9920         ndr->depth++;
9921         if (flags & NDR_SET_VALUES) {
9922                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9923         }
9924         if (flags & NDR_IN) {
9925                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfoByName");
9926                 ndr->depth++;
9927                 ndr_print_ptr(ndr, "handle", r->in.handle);
9928                 ndr->depth++;
9929                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9930                 ndr->depth--;
9931                 ndr_print_ptr(ndr, "trusted_domain", r->in.trusted_domain);
9932                 ndr->depth++;
9933                 ndr_print_lsa_String(ndr, "trusted_domain", r->in.trusted_domain);
9934                 ndr->depth--;
9935                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
9936                 ndr->depth--;
9937         }
9938         if (flags & NDR_OUT) {
9939                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfoByName");
9940                 ndr->depth++;
9941                 ndr_print_ptr(ndr, "info", r->out.info);
9942                 ndr->depth++;
9943                 ndr_print_ptr(ndr, "info", *r->out.info);
9944                 ndr->depth++;
9945                 if (*r->out.info) {
9946                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
9947                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", *r->out.info);
9948                 }
9949                 ndr->depth--;
9950                 ndr->depth--;
9951                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9952                 ndr->depth--;
9953         }
9954         ndr->depth--;
9955 }
9956
9957 static enum ndr_err_code ndr_push_lsa_SetTrustedDomainInfoByName(struct ndr_push *ndr, int flags, const struct lsa_SetTrustedDomainInfoByName *r)
9958 {
9959         if (flags & NDR_IN) {
9960                 if (r->in.handle == NULL) {
9961                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9962                 }
9963                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9964                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
9965                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
9966                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
9967                 if (r->in.info) {
9968                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
9969                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9970                 }
9971         }
9972         if (flags & NDR_OUT) {
9973                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9974         }
9975         return NDR_ERR_SUCCESS;
9976 }
9977
9978 static enum ndr_err_code ndr_pull_lsa_SetTrustedDomainInfoByName(struct ndr_pull *ndr, int flags, struct lsa_SetTrustedDomainInfoByName *r)
9979 {
9980         uint32_t _ptr_info;
9981         TALLOC_CTX *_mem_save_handle_0;
9982         TALLOC_CTX *_mem_save_info_0;
9983         if (flags & NDR_IN) {
9984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9985                         NDR_PULL_ALLOC(ndr, r->in.handle);
9986                 }
9987                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9988                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9989                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9991                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
9992                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
9993                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9994                 if (_ptr_info) {
9995                         NDR_PULL_ALLOC(ndr, r->in.info);
9996                 } else {
9997                         r->in.info = NULL;
9998                 }
9999                 if (r->in.info) {
10000                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10001                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
10002                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
10003                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
10004                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10005                 }
10006         }
10007         if (flags & NDR_OUT) {
10008                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10009         }
10010         return NDR_ERR_SUCCESS;
10011 }
10012
10013 _PUBLIC_ void ndr_print_lsa_SetTrustedDomainInfoByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetTrustedDomainInfoByName *r)
10014 {
10015         ndr_print_struct(ndr, name, "lsa_SetTrustedDomainInfoByName");
10016         ndr->depth++;
10017         if (flags & NDR_SET_VALUES) {
10018                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10019         }
10020         if (flags & NDR_IN) {
10021                 ndr_print_struct(ndr, "in", "lsa_SetTrustedDomainInfoByName");
10022                 ndr->depth++;
10023                 ndr_print_ptr(ndr, "handle", r->in.handle);
10024                 ndr->depth++;
10025                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10026                 ndr->depth--;
10027                 ndr_print_lsa_String(ndr, "trusted_domain", &r->in.trusted_domain);
10028                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
10029                 ndr_print_ptr(ndr, "info", r->in.info);
10030                 ndr->depth++;
10031                 if (r->in.info) {
10032                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
10033                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->in.info);
10034                 }
10035                 ndr->depth--;
10036                 ndr->depth--;
10037         }
10038         if (flags & NDR_OUT) {
10039                 ndr_print_struct(ndr, "out", "lsa_SetTrustedDomainInfoByName");
10040                 ndr->depth++;
10041                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10042                 ndr->depth--;
10043         }
10044         ndr->depth--;
10045 }
10046
10047 static enum ndr_err_code ndr_push_lsa_EnumTrustedDomainsEx(struct ndr_push *ndr, int flags, const struct lsa_EnumTrustedDomainsEx *r)
10048 {
10049         if (flags & NDR_IN) {
10050                 if (r->in.handle == NULL) {
10051                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10052                 }
10053                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10054                 if (r->in.resume_handle == NULL) {
10055                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10056                 }
10057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
10058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
10059         }
10060         if (flags & NDR_OUT) {
10061                 if (r->out.resume_handle == NULL) {
10062                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10063                 }
10064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
10065                 if (r->out.domains == NULL) {
10066                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10067                 }
10068                 NDR_CHECK(ndr_push_lsa_DomainListEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
10069                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10070         }
10071         return NDR_ERR_SUCCESS;
10072 }
10073
10074 static enum ndr_err_code ndr_pull_lsa_EnumTrustedDomainsEx(struct ndr_pull *ndr, int flags, struct lsa_EnumTrustedDomainsEx *r)
10075 {
10076         TALLOC_CTX *_mem_save_handle_0;
10077         TALLOC_CTX *_mem_save_resume_handle_0;
10078         TALLOC_CTX *_mem_save_domains_0;
10079         if (flags & NDR_IN) {
10080                 ZERO_STRUCT(r->out);
10081
10082                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10083                         NDR_PULL_ALLOC(ndr, r->in.handle);
10084                 }
10085                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10086                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10087                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10088                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10089                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10090                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
10091                 }
10092                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10093                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
10094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
10095                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
10096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
10097                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
10098                 *r->out.resume_handle = *r->in.resume_handle;
10099                 NDR_PULL_ALLOC(ndr, r->out.domains);
10100                 ZERO_STRUCTP(r->out.domains);
10101         }
10102         if (flags & NDR_OUT) {
10103                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10104                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
10105                 }
10106                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10107                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
10108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
10109                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
10110                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10111                         NDR_PULL_ALLOC(ndr, r->out.domains);
10112                 }
10113                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
10114                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
10115                 NDR_CHECK(ndr_pull_lsa_DomainListEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
10116                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
10117                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10118         }
10119         return NDR_ERR_SUCCESS;
10120 }
10121
10122 _PUBLIC_ void ndr_print_lsa_EnumTrustedDomainsEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumTrustedDomainsEx *r)
10123 {
10124         ndr_print_struct(ndr, name, "lsa_EnumTrustedDomainsEx");
10125         ndr->depth++;
10126         if (flags & NDR_SET_VALUES) {
10127                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10128         }
10129         if (flags & NDR_IN) {
10130                 ndr_print_struct(ndr, "in", "lsa_EnumTrustedDomainsEx");
10131                 ndr->depth++;
10132                 ndr_print_ptr(ndr, "handle", r->in.handle);
10133                 ndr->depth++;
10134                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10135                 ndr->depth--;
10136                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
10137                 ndr->depth++;
10138                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
10139                 ndr->depth--;
10140                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
10141                 ndr->depth--;
10142         }
10143         if (flags & NDR_OUT) {
10144                 ndr_print_struct(ndr, "out", "lsa_EnumTrustedDomainsEx");
10145                 ndr->depth++;
10146                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
10147                 ndr->depth++;
10148                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
10149                 ndr->depth--;
10150                 ndr_print_ptr(ndr, "domains", r->out.domains);
10151                 ndr->depth++;
10152                 ndr_print_lsa_DomainListEx(ndr, "domains", r->out.domains);
10153                 ndr->depth--;
10154                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10155                 ndr->depth--;
10156         }
10157         ndr->depth--;
10158 }
10159
10160 static enum ndr_err_code ndr_push_lsa_CreateTrustedDomainEx(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomainEx *r)
10161 {
10162         if (flags & NDR_IN) {
10163                 if (r->in.policy_handle == NULL) {
10164                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10165                 }
10166                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.policy_handle));
10167                 if (r->in.info == NULL) {
10168                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10169                 }
10170                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
10171                 if (r->in.auth_info == NULL) {
10172                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10173                 }
10174                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.auth_info));
10175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
10176         }
10177         if (flags & NDR_OUT) {
10178                 if (r->out.trustdom_handle == NULL) {
10179                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10180                 }
10181                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
10182                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10183         }
10184         return NDR_ERR_SUCCESS;
10185 }
10186
10187 static enum ndr_err_code ndr_pull_lsa_CreateTrustedDomainEx(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomainEx *r)
10188 {
10189         TALLOC_CTX *_mem_save_policy_handle_0;
10190         TALLOC_CTX *_mem_save_info_0;
10191         TALLOC_CTX *_mem_save_auth_info_0;
10192         TALLOC_CTX *_mem_save_trustdom_handle_0;
10193         if (flags & NDR_IN) {
10194                 ZERO_STRUCT(r->out);
10195
10196                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10197                         NDR_PULL_ALLOC(ndr, r->in.policy_handle);
10198                 }
10199                 _mem_save_policy_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10200                 NDR_PULL_SET_MEM_CTX(ndr, r->in.policy_handle, LIBNDR_FLAG_REF_ALLOC);
10201                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.policy_handle));
10202                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_policy_handle_0, LIBNDR_FLAG_REF_ALLOC);
10203                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10204                         NDR_PULL_ALLOC(ndr, r->in.info);
10205                 }
10206                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10207                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
10208                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
10209                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10210                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10211                         NDR_PULL_ALLOC(ndr, r->in.auth_info);
10212                 }
10213                 _mem_save_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10214                 NDR_PULL_SET_MEM_CTX(ndr, r->in.auth_info, LIBNDR_FLAG_REF_ALLOC);
10215                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.auth_info));
10216                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_auth_info_0, LIBNDR_FLAG_REF_ALLOC);
10217                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
10218                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
10219                 ZERO_STRUCTP(r->out.trustdom_handle);
10220         }
10221         if (flags & NDR_OUT) {
10222                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10223                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
10224                 }
10225                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10226                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
10227                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
10228                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
10229                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10230         }
10231         return NDR_ERR_SUCCESS;
10232 }
10233
10234 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomainEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomainEx *r)
10235 {
10236         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomainEx");
10237         ndr->depth++;
10238         if (flags & NDR_SET_VALUES) {
10239                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10240         }
10241         if (flags & NDR_IN) {
10242                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomainEx");
10243                 ndr->depth++;
10244                 ndr_print_ptr(ndr, "policy_handle", r->in.policy_handle);
10245                 ndr->depth++;
10246                 ndr_print_policy_handle(ndr, "policy_handle", r->in.policy_handle);
10247                 ndr->depth--;
10248                 ndr_print_ptr(ndr, "info", r->in.info);
10249                 ndr->depth++;
10250                 ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info", r->in.info);
10251                 ndr->depth--;
10252                 ndr_print_ptr(ndr, "auth_info", r->in.auth_info);
10253                 ndr->depth++;
10254                 ndr_print_lsa_TrustDomainInfoAuthInfoInternal(ndr, "auth_info", r->in.auth_info);
10255                 ndr->depth--;
10256                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
10257                 ndr->depth--;
10258         }
10259         if (flags & NDR_OUT) {
10260                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomainEx");
10261                 ndr->depth++;
10262                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
10263                 ndr->depth++;
10264                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
10265                 ndr->depth--;
10266                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10267                 ndr->depth--;
10268         }
10269         ndr->depth--;
10270 }
10271
10272 static enum ndr_err_code ndr_push_lsa_CloseTrustedDomainEx(struct ndr_push *ndr, int flags, const struct lsa_CloseTrustedDomainEx *r)
10273 {
10274         if (flags & NDR_IN) {
10275                 if (r->in.handle == NULL) {
10276                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10277                 }
10278                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10279         }
10280         if (flags & NDR_OUT) {
10281                 if (r->out.handle == NULL) {
10282                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10283                 }
10284                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
10285                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10286         }
10287         return NDR_ERR_SUCCESS;
10288 }
10289
10290 static enum ndr_err_code ndr_pull_lsa_CloseTrustedDomainEx(struct ndr_pull *ndr, int flags, struct lsa_CloseTrustedDomainEx *r)
10291 {
10292         TALLOC_CTX *_mem_save_handle_0;
10293         if (flags & NDR_IN) {
10294                 ZERO_STRUCT(r->out);
10295
10296                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10297                         NDR_PULL_ALLOC(ndr, r->in.handle);
10298                 }
10299                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10300                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10301                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10302                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10303                 NDR_PULL_ALLOC(ndr, r->out.handle);
10304                 *r->out.handle = *r->in.handle;
10305         }
10306         if (flags & NDR_OUT) {
10307                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10308                         NDR_PULL_ALLOC(ndr, r->out.handle);
10309                 }
10310                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10311                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
10312                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
10313                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10314                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10315         }
10316         return NDR_ERR_SUCCESS;
10317 }
10318
10319 _PUBLIC_ void ndr_print_lsa_CloseTrustedDomainEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CloseTrustedDomainEx *r)
10320 {
10321         ndr_print_struct(ndr, name, "lsa_CloseTrustedDomainEx");
10322         ndr->depth++;
10323         if (flags & NDR_SET_VALUES) {
10324                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10325         }
10326         if (flags & NDR_IN) {
10327                 ndr_print_struct(ndr, "in", "lsa_CloseTrustedDomainEx");
10328                 ndr->depth++;
10329                 ndr_print_ptr(ndr, "handle", r->in.handle);
10330                 ndr->depth++;
10331                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10332                 ndr->depth--;
10333                 ndr->depth--;
10334         }
10335         if (flags & NDR_OUT) {
10336                 ndr_print_struct(ndr, "out", "lsa_CloseTrustedDomainEx");
10337                 ndr->depth++;
10338                 ndr_print_ptr(ndr, "handle", r->out.handle);
10339                 ndr->depth++;
10340                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
10341                 ndr->depth--;
10342                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10343                 ndr->depth--;
10344         }
10345         ndr->depth--;
10346 }
10347
10348 static enum ndr_err_code ndr_push_lsa_QueryDomainInformationPolicy(struct ndr_push *ndr, int flags, const struct lsa_QueryDomainInformationPolicy *r)
10349 {
10350         if (flags & NDR_IN) {
10351                 if (r->in.handle == NULL) {
10352                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10353                 }
10354                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10355                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10356         }
10357         if (flags & NDR_OUT) {
10358                 if (r->out.info == NULL) {
10359                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10360                 }
10361                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
10362                 if (*r->out.info) {
10363                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
10364                         NDR_CHECK(ndr_push_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10365                 }
10366                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10367         }
10368         return NDR_ERR_SUCCESS;
10369 }
10370
10371 static enum ndr_err_code ndr_pull_lsa_QueryDomainInformationPolicy(struct ndr_pull *ndr, int flags, struct lsa_QueryDomainInformationPolicy *r)
10372 {
10373         uint32_t _ptr_info;
10374         TALLOC_CTX *_mem_save_handle_0;
10375         TALLOC_CTX *_mem_save_info_0;
10376         TALLOC_CTX *_mem_save_info_1;
10377         if (flags & NDR_IN) {
10378                 ZERO_STRUCT(r->out);
10379
10380                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10381                         NDR_PULL_ALLOC(ndr, r->in.handle);
10382                 }
10383                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10384                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10385                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10386                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10387                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10388                 NDR_PULL_ALLOC(ndr, r->out.info);
10389                 ZERO_STRUCTP(r->out.info);
10390         }
10391         if (flags & NDR_OUT) {
10392                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10393                         NDR_PULL_ALLOC(ndr, r->out.info);
10394                 }
10395                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10396                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
10397                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10398                 if (_ptr_info) {
10399                         NDR_PULL_ALLOC(ndr, *r->out.info);
10400                 } else {
10401                         *r->out.info = NULL;
10402                 }
10403                 if (*r->out.info) {
10404                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
10405                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
10406                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
10407                         NDR_CHECK(ndr_pull_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
10408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
10409                 }
10410                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
10411                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10412         }
10413         return NDR_ERR_SUCCESS;
10414 }
10415
10416 _PUBLIC_ void ndr_print_lsa_QueryDomainInformationPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryDomainInformationPolicy *r)
10417 {
10418         ndr_print_struct(ndr, name, "lsa_QueryDomainInformationPolicy");
10419         ndr->depth++;
10420         if (flags & NDR_SET_VALUES) {
10421                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10422         }
10423         if (flags & NDR_IN) {
10424                 ndr_print_struct(ndr, "in", "lsa_QueryDomainInformationPolicy");
10425                 ndr->depth++;
10426                 ndr_print_ptr(ndr, "handle", r->in.handle);
10427                 ndr->depth++;
10428                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10429                 ndr->depth--;
10430                 ndr_print_uint16(ndr, "level", r->in.level);
10431                 ndr->depth--;
10432         }
10433         if (flags & NDR_OUT) {
10434                 ndr_print_struct(ndr, "out", "lsa_QueryDomainInformationPolicy");
10435                 ndr->depth++;
10436                 ndr_print_ptr(ndr, "info", r->out.info);
10437                 ndr->depth++;
10438                 ndr_print_ptr(ndr, "info", *r->out.info);
10439                 ndr->depth++;
10440                 if (*r->out.info) {
10441                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
10442                         ndr_print_lsa_DomainInformationPolicy(ndr, "info", *r->out.info);
10443                 }
10444                 ndr->depth--;
10445                 ndr->depth--;
10446                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10447                 ndr->depth--;
10448         }
10449         ndr->depth--;
10450 }
10451
10452 static enum ndr_err_code ndr_push_lsa_SetDomainInformationPolicy(struct ndr_push *ndr, int flags, const struct lsa_SetDomainInformationPolicy *r)
10453 {
10454         if (flags & NDR_IN) {
10455                 if (r->in.handle == NULL) {
10456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10457                 }
10458                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10459                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10460                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
10461                 if (r->in.info) {
10462                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
10463                         NDR_CHECK(ndr_push_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
10464                 }
10465         }
10466         if (flags & NDR_OUT) {
10467                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10468         }
10469         return NDR_ERR_SUCCESS;
10470 }
10471
10472 static enum ndr_err_code ndr_pull_lsa_SetDomainInformationPolicy(struct ndr_pull *ndr, int flags, struct lsa_SetDomainInformationPolicy *r)
10473 {
10474         uint32_t _ptr_info;
10475         TALLOC_CTX *_mem_save_handle_0;
10476         TALLOC_CTX *_mem_save_info_0;
10477         if (flags & NDR_IN) {
10478                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10479                         NDR_PULL_ALLOC(ndr, r->in.handle);
10480                 }
10481                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10482                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10483                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10484                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10485                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10487                 if (_ptr_info) {
10488                         NDR_PULL_ALLOC(ndr, r->in.info);
10489                 } else {
10490                         r->in.info = NULL;
10491                 }
10492                 if (r->in.info) {
10493                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10494                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
10495                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
10496                         NDR_CHECK(ndr_pull_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
10497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10498                 }
10499         }
10500         if (flags & NDR_OUT) {
10501                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10502         }
10503         return NDR_ERR_SUCCESS;
10504 }
10505
10506 _PUBLIC_ void ndr_print_lsa_SetDomainInformationPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetDomainInformationPolicy *r)
10507 {
10508         ndr_print_struct(ndr, name, "lsa_SetDomainInformationPolicy");
10509         ndr->depth++;
10510         if (flags & NDR_SET_VALUES) {
10511                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10512         }
10513         if (flags & NDR_IN) {
10514                 ndr_print_struct(ndr, "in", "lsa_SetDomainInformationPolicy");
10515                 ndr->depth++;
10516                 ndr_print_ptr(ndr, "handle", r->in.handle);
10517                 ndr->depth++;
10518                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10519                 ndr->depth--;
10520                 ndr_print_uint16(ndr, "level", r->in.level);
10521                 ndr_print_ptr(ndr, "info", r->in.info);
10522                 ndr->depth++;
10523                 if (r->in.info) {
10524                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
10525                         ndr_print_lsa_DomainInformationPolicy(ndr, "info", r->in.info);
10526                 }
10527                 ndr->depth--;
10528                 ndr->depth--;
10529         }
10530         if (flags & NDR_OUT) {
10531                 ndr_print_struct(ndr, "out", "lsa_SetDomainInformationPolicy");
10532                 ndr->depth++;
10533                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10534                 ndr->depth--;
10535         }
10536         ndr->depth--;
10537 }
10538
10539 static enum ndr_err_code ndr_push_lsa_OpenTrustedDomainByName(struct ndr_push *ndr, int flags, const struct lsa_OpenTrustedDomainByName *r)
10540 {
10541         if (flags & NDR_IN) {
10542                 if (r->in.handle == NULL) {
10543                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10544                 }
10545                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10546                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
10547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
10548         }
10549         if (flags & NDR_OUT) {
10550                 if (r->out.trustdom_handle == NULL) {
10551                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10552                 }
10553                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
10554                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10555         }
10556         return NDR_ERR_SUCCESS;
10557 }
10558
10559 static enum ndr_err_code ndr_pull_lsa_OpenTrustedDomainByName(struct ndr_pull *ndr, int flags, struct lsa_OpenTrustedDomainByName *r)
10560 {
10561         TALLOC_CTX *_mem_save_handle_0;
10562         TALLOC_CTX *_mem_save_trustdom_handle_0;
10563         if (flags & NDR_IN) {
10564                 ZERO_STRUCT(r->out);
10565
10566                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10567                         NDR_PULL_ALLOC(ndr, r->in.handle);
10568                 }
10569                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10570                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10571                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10572                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10573                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
10574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
10575                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
10576                 ZERO_STRUCTP(r->out.trustdom_handle);
10577         }
10578         if (flags & NDR_OUT) {
10579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10580                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
10581                 }
10582                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10583                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
10584                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
10585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
10586                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10587         }
10588         return NDR_ERR_SUCCESS;
10589 }
10590
10591 _PUBLIC_ void ndr_print_lsa_OpenTrustedDomainByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenTrustedDomainByName *r)
10592 {
10593         ndr_print_struct(ndr, name, "lsa_OpenTrustedDomainByName");
10594         ndr->depth++;
10595         if (flags & NDR_SET_VALUES) {
10596                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10597         }
10598         if (flags & NDR_IN) {
10599                 ndr_print_struct(ndr, "in", "lsa_OpenTrustedDomainByName");
10600                 ndr->depth++;
10601                 ndr_print_ptr(ndr, "handle", r->in.handle);
10602                 ndr->depth++;
10603                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10604                 ndr->depth--;
10605                 ndr_print_lsa_String(ndr, "name", &r->in.name);
10606                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
10607                 ndr->depth--;
10608         }
10609         if (flags & NDR_OUT) {
10610                 ndr_print_struct(ndr, "out", "lsa_OpenTrustedDomainByName");
10611                 ndr->depth++;
10612                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
10613                 ndr->depth++;
10614                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
10615                 ndr->depth--;
10616                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10617                 ndr->depth--;
10618         }
10619         ndr->depth--;
10620 }
10621
10622 static enum ndr_err_code ndr_push_lsa_TestCall(struct ndr_push *ndr, int flags, const struct lsa_TestCall *r)
10623 {
10624         if (flags & NDR_IN) {
10625         }
10626         if (flags & NDR_OUT) {
10627                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10628         }
10629         return NDR_ERR_SUCCESS;
10630 }
10631
10632 static enum ndr_err_code ndr_pull_lsa_TestCall(struct ndr_pull *ndr, int flags, struct lsa_TestCall *r)
10633 {
10634         if (flags & NDR_IN) {
10635         }
10636         if (flags & NDR_OUT) {
10637                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10638         }
10639         return NDR_ERR_SUCCESS;
10640 }
10641
10642 _PUBLIC_ void ndr_print_lsa_TestCall(struct ndr_print *ndr, const char *name, int flags, const struct lsa_TestCall *r)
10643 {
10644         ndr_print_struct(ndr, name, "lsa_TestCall");
10645         ndr->depth++;
10646         if (flags & NDR_SET_VALUES) {
10647                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10648         }
10649         if (flags & NDR_IN) {
10650                 ndr_print_struct(ndr, "in", "lsa_TestCall");
10651                 ndr->depth++;
10652                 ndr->depth--;
10653         }
10654         if (flags & NDR_OUT) {
10655                 ndr_print_struct(ndr, "out", "lsa_TestCall");
10656                 ndr->depth++;
10657                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10658                 ndr->depth--;
10659         }
10660         ndr->depth--;
10661 }
10662
10663 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupSids2(struct ndr_push *ndr, int flags, const struct lsa_LookupSids2 *r)
10664 {
10665         if (flags & NDR_IN) {
10666                 if (r->in.handle == NULL) {
10667                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10668                 }
10669                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10670                 if (r->in.sids == NULL) {
10671                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10672                 }
10673                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10674                 if (r->in.names == NULL) {
10675                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10676                 }
10677                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
10678                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10679                 if (r->in.count == NULL) {
10680                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10681                 }
10682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
10683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
10684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
10685         }
10686         if (flags & NDR_OUT) {
10687                 if (r->out.domains == NULL) {
10688                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10689                 }
10690                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
10691                 if (*r->out.domains) {
10692                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10693                 }
10694                 if (r->out.names == NULL) {
10695                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10696                 }
10697                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
10698                 if (r->out.count == NULL) {
10699                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10700                 }
10701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
10702                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10703         }
10704         return NDR_ERR_SUCCESS;
10705 }
10706
10707 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupSids2(struct ndr_pull *ndr, int flags, struct lsa_LookupSids2 *r)
10708 {
10709         uint32_t _ptr_domains;
10710         TALLOC_CTX *_mem_save_handle_0;
10711         TALLOC_CTX *_mem_save_sids_0;
10712         TALLOC_CTX *_mem_save_domains_0;
10713         TALLOC_CTX *_mem_save_domains_1;
10714         TALLOC_CTX *_mem_save_names_0;
10715         TALLOC_CTX *_mem_save_count_0;
10716         if (flags & NDR_IN) {
10717                 ZERO_STRUCT(r->out);
10718
10719                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10720                         NDR_PULL_ALLOC(ndr, r->in.handle);
10721                 }
10722                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10723                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10724                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10725                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10726                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10727                         NDR_PULL_ALLOC(ndr, r->in.sids);
10728                 }
10729                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10730                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10731                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10732                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10733                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10734                         NDR_PULL_ALLOC(ndr, r->in.names);
10735                 }
10736                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10737                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
10738                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
10739                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
10740                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10741                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10742                         NDR_PULL_ALLOC(ndr, r->in.count);
10743                 }
10744                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10745                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
10746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
10747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
10749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
10750                 NDR_PULL_ALLOC(ndr, r->out.domains);
10751                 ZERO_STRUCTP(r->out.domains);
10752                 NDR_PULL_ALLOC(ndr, r->out.names);
10753                 *r->out.names = *r->in.names;
10754                 NDR_PULL_ALLOC(ndr, r->out.count);
10755                 *r->out.count = *r->in.count;
10756         }
10757         if (flags & NDR_OUT) {
10758                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10759                         NDR_PULL_ALLOC(ndr, r->out.domains);
10760                 }
10761                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
10762                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
10763                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
10764                 if (_ptr_domains) {
10765                         NDR_PULL_ALLOC(ndr, *r->out.domains);
10766                 } else {
10767                         *r->out.domains = NULL;
10768                 }
10769                 if (*r->out.domains) {
10770                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
10771                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
10772                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
10774                 }
10775                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
10776                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10777                         NDR_PULL_ALLOC(ndr, r->out.names);
10778                 }
10779                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10780                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
10781                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
10782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
10783                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10784                         NDR_PULL_ALLOC(ndr, r->out.count);
10785                 }
10786                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10787                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
10788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
10789                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10790                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10791         }
10792         return NDR_ERR_SUCCESS;
10793 }
10794
10795 _PUBLIC_ void ndr_print_lsa_LookupSids2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids2 *r)
10796 {
10797         ndr_print_struct(ndr, name, "lsa_LookupSids2");
10798         ndr->depth++;
10799         if (flags & NDR_SET_VALUES) {
10800                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10801         }
10802         if (flags & NDR_IN) {
10803                 ndr_print_struct(ndr, "in", "lsa_LookupSids2");
10804                 ndr->depth++;
10805                 ndr_print_ptr(ndr, "handle", r->in.handle);
10806                 ndr->depth++;
10807                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10808                 ndr->depth--;
10809                 ndr_print_ptr(ndr, "sids", r->in.sids);
10810                 ndr->depth++;
10811                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10812                 ndr->depth--;
10813                 ndr_print_ptr(ndr, "names", r->in.names);
10814                 ndr->depth++;
10815                 ndr_print_lsa_TransNameArray2(ndr, "names", r->in.names);
10816                 ndr->depth--;
10817                 ndr_print_uint16(ndr, "level", r->in.level);
10818                 ndr_print_ptr(ndr, "count", r->in.count);
10819                 ndr->depth++;
10820                 ndr_print_uint32(ndr, "count", *r->in.count);
10821                 ndr->depth--;
10822                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
10823                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
10824                 ndr->depth--;
10825         }
10826         if (flags & NDR_OUT) {
10827                 ndr_print_struct(ndr, "out", "lsa_LookupSids2");
10828                 ndr->depth++;
10829                 ndr_print_ptr(ndr, "domains", r->out.domains);
10830                 ndr->depth++;
10831                 ndr_print_ptr(ndr, "domains", *r->out.domains);
10832                 ndr->depth++;
10833                 if (*r->out.domains) {
10834                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
10835                 }
10836                 ndr->depth--;
10837                 ndr->depth--;
10838                 ndr_print_ptr(ndr, "names", r->out.names);
10839                 ndr->depth++;
10840                 ndr_print_lsa_TransNameArray2(ndr, "names", r->out.names);
10841                 ndr->depth--;
10842                 ndr_print_ptr(ndr, "count", r->out.count);
10843                 ndr->depth++;
10844                 ndr_print_uint32(ndr, "count", *r->out.count);
10845                 ndr->depth--;
10846                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10847                 ndr->depth--;
10848         }
10849         ndr->depth--;
10850 }
10851
10852 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupNames2(struct ndr_push *ndr, int flags, const struct lsa_LookupNames2 *r)
10853 {
10854         uint32_t cntr_names_0;
10855         if (flags & NDR_IN) {
10856                 if (r->in.handle == NULL) {
10857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10858                 }
10859                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10862                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10863                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
10864                 }
10865                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10866                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
10867                 }
10868                 if (r->in.sids == NULL) {
10869                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10870                 }
10871                 NDR_CHECK(ndr_push_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10872                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
10873                 if (r->in.count == NULL) {
10874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10875                 }
10876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
10877                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.lookup_options));
10878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_revision));
10879         }
10880         if (flags & NDR_OUT) {
10881                 if (r->out.domains == NULL) {
10882                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10883                 }
10884                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
10885                 if (*r->out.domains) {
10886                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10887                 }
10888                 if (r->out.sids == NULL) {
10889                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10890                 }
10891                 NDR_CHECK(ndr_push_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
10892                 if (r->out.count == NULL) {
10893                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10894                 }
10895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
10896                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10897         }
10898         return NDR_ERR_SUCCESS;
10899 }
10900
10901 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupNames2(struct ndr_pull *ndr, int flags, struct lsa_LookupNames2 *r)
10902 {
10903         uint32_t cntr_names_0;
10904         uint32_t _ptr_domains;
10905         TALLOC_CTX *_mem_save_handle_0;
10906         TALLOC_CTX *_mem_save_names_0;
10907         TALLOC_CTX *_mem_save_domains_0;
10908         TALLOC_CTX *_mem_save_domains_1;
10909         TALLOC_CTX *_mem_save_sids_0;
10910         TALLOC_CTX *_mem_save_count_0;
10911         if (flags & NDR_IN) {
10912                 ZERO_STRUCT(r->out);
10913
10914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10915                         NDR_PULL_ALLOC(ndr, r->in.handle);
10916                 }
10917                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10918                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10919                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
10922                 if (r->in.num_names > 1000) {
10923                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
10924                 }
10925                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
10926                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
10927                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10928                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
10929                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10930                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
10931                 }
10932                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10933                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
10934                 }
10935                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
10936                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10937                         NDR_PULL_ALLOC(ndr, r->in.sids);
10938                 }
10939                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10940                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10941                 NDR_CHECK(ndr_pull_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10942                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10943                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
10944                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10945                         NDR_PULL_ALLOC(ndr, r->in.count);
10946                 }
10947                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10948                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
10949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
10950                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.lookup_options));
10952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_revision));
10953                 NDR_PULL_ALLOC(ndr, r->out.domains);
10954                 ZERO_STRUCTP(r->out.domains);
10955                 NDR_PULL_ALLOC(ndr, r->out.sids);
10956                 *r->out.sids = *r->in.sids;
10957                 NDR_PULL_ALLOC(ndr, r->out.count);
10958                 *r->out.count = *r->in.count;
10959                 if (r->in.names) {
10960                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
10961                 }
10962         }
10963         if (flags & NDR_OUT) {
10964                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10965                         NDR_PULL_ALLOC(ndr, r->out.domains);
10966                 }
10967                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
10968                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
10969                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
10970                 if (_ptr_domains) {
10971                         NDR_PULL_ALLOC(ndr, *r->out.domains);
10972                 } else {
10973                         *r->out.domains = NULL;
10974                 }
10975                 if (*r->out.domains) {
10976                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
10977                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
10978                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10979                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
10980                 }
10981                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
10982                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10983                         NDR_PULL_ALLOC(ndr, r->out.sids);
10984                 }
10985                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10986                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
10987                 NDR_CHECK(ndr_pull_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
10988                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10989                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10990                         NDR_PULL_ALLOC(ndr, r->out.count);
10991                 }
10992                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10993                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
10994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
10995                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10996                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10997         }
10998         return NDR_ERR_SUCCESS;
10999 }
11000
11001 _PUBLIC_ void ndr_print_lsa_LookupNames2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames2 *r)
11002 {
11003         uint32_t cntr_names_0;
11004         ndr_print_struct(ndr, name, "lsa_LookupNames2");
11005         ndr->depth++;
11006         if (flags & NDR_SET_VALUES) {
11007                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11008         }
11009         if (flags & NDR_IN) {
11010                 ndr_print_struct(ndr, "in", "lsa_LookupNames2");
11011                 ndr->depth++;
11012                 ndr_print_ptr(ndr, "handle", r->in.handle);
11013                 ndr->depth++;
11014                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11015                 ndr->depth--;
11016                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
11017                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
11018                 ndr->depth++;
11019                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
11020                         char *idx_0=NULL;
11021                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
11022                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
11023                                 free(idx_0);
11024                         }
11025                 }
11026                 ndr->depth--;
11027                 ndr_print_ptr(ndr, "sids", r->in.sids);
11028                 ndr->depth++;
11029                 ndr_print_lsa_TransSidArray2(ndr, "sids", r->in.sids);
11030                 ndr->depth--;
11031                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
11032                 ndr_print_ptr(ndr, "count", r->in.count);
11033                 ndr->depth++;
11034                 ndr_print_uint32(ndr, "count", *r->in.count);
11035                 ndr->depth--;
11036                 ndr_print_uint32(ndr, "lookup_options", r->in.lookup_options);
11037                 ndr_print_uint32(ndr, "client_revision", r->in.client_revision);
11038                 ndr->depth--;
11039         }
11040         if (flags & NDR_OUT) {
11041                 ndr_print_struct(ndr, "out", "lsa_LookupNames2");
11042                 ndr->depth++;
11043                 ndr_print_ptr(ndr, "domains", r->out.domains);
11044                 ndr->depth++;
11045                 ndr_print_ptr(ndr, "domains", *r->out.domains);
11046                 ndr->depth++;
11047                 if (*r->out.domains) {
11048                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
11049                 }
11050                 ndr->depth--;
11051                 ndr->depth--;
11052                 ndr_print_ptr(ndr, "sids", r->out.sids);
11053                 ndr->depth++;
11054                 ndr_print_lsa_TransSidArray2(ndr, "sids", r->out.sids);
11055                 ndr->depth--;
11056                 ndr_print_ptr(ndr, "count", r->out.count);
11057                 ndr->depth++;
11058                 ndr_print_uint32(ndr, "count", *r->out.count);
11059                 ndr->depth--;
11060                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11061                 ndr->depth--;
11062         }
11063         ndr->depth--;
11064 }
11065
11066 static enum ndr_err_code ndr_push_lsa_CreateTrustedDomainEx2(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomainEx2 *r)
11067 {
11068         if (flags & NDR_IN) {
11069                 if (r->in.policy_handle == NULL) {
11070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11071                 }
11072                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.policy_handle));
11073                 if (r->in.info == NULL) {
11074                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11075                 }
11076                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11077                 if (r->in.auth_info == NULL) {
11078                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11079                 }
11080                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.auth_info));
11081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
11082         }
11083         if (flags & NDR_OUT) {
11084                 if (r->out.trustdom_handle == NULL) {
11085                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11086                 }
11087                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
11088                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11089         }
11090         return NDR_ERR_SUCCESS;
11091 }
11092
11093 static enum ndr_err_code ndr_pull_lsa_CreateTrustedDomainEx2(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomainEx2 *r)
11094 {
11095         TALLOC_CTX *_mem_save_policy_handle_0;
11096         TALLOC_CTX *_mem_save_info_0;
11097         TALLOC_CTX *_mem_save_auth_info_0;
11098         TALLOC_CTX *_mem_save_trustdom_handle_0;
11099         if (flags & NDR_IN) {
11100                 ZERO_STRUCT(r->out);
11101
11102                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11103                         NDR_PULL_ALLOC(ndr, r->in.policy_handle);
11104                 }
11105                 _mem_save_policy_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11106                 NDR_PULL_SET_MEM_CTX(ndr, r->in.policy_handle, LIBNDR_FLAG_REF_ALLOC);
11107                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.policy_handle));
11108                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_policy_handle_0, LIBNDR_FLAG_REF_ALLOC);
11109                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11110                         NDR_PULL_ALLOC(ndr, r->in.info);
11111                 }
11112                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11113                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
11114                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
11115                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
11116                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11117                         NDR_PULL_ALLOC(ndr, r->in.auth_info);
11118                 }
11119                 _mem_save_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11120                 NDR_PULL_SET_MEM_CTX(ndr, r->in.auth_info, LIBNDR_FLAG_REF_ALLOC);
11121                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfoInternal(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.auth_info));
11122                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_auth_info_0, LIBNDR_FLAG_REF_ALLOC);
11123                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
11124                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
11125                 ZERO_STRUCTP(r->out.trustdom_handle);
11126         }
11127         if (flags & NDR_OUT) {
11128                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11129                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
11130                 }
11131                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11132                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
11133                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
11134                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
11135                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11136         }
11137         return NDR_ERR_SUCCESS;
11138 }
11139
11140 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomainEx2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomainEx2 *r)
11141 {
11142         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomainEx2");
11143         ndr->depth++;
11144         if (flags & NDR_SET_VALUES) {
11145                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11146         }
11147         if (flags & NDR_IN) {
11148                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomainEx2");
11149                 ndr->depth++;
11150                 ndr_print_ptr(ndr, "policy_handle", r->in.policy_handle);
11151                 ndr->depth++;
11152                 ndr_print_policy_handle(ndr, "policy_handle", r->in.policy_handle);
11153                 ndr->depth--;
11154                 ndr_print_ptr(ndr, "info", r->in.info);
11155                 ndr->depth++;
11156                 ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info", r->in.info);
11157                 ndr->depth--;
11158                 ndr_print_ptr(ndr, "auth_info", r->in.auth_info);
11159                 ndr->depth++;
11160                 ndr_print_lsa_TrustDomainInfoAuthInfoInternal(ndr, "auth_info", r->in.auth_info);
11161                 ndr->depth--;
11162                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
11163                 ndr->depth--;
11164         }
11165         if (flags & NDR_OUT) {
11166                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomainEx2");
11167                 ndr->depth++;
11168                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
11169                 ndr->depth++;
11170                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
11171                 ndr->depth--;
11172                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11173                 ndr->depth--;
11174         }
11175         ndr->depth--;
11176 }
11177
11178 static enum ndr_err_code ndr_push_lsa_CREDRWRITE(struct ndr_push *ndr, int flags, const struct lsa_CREDRWRITE *r)
11179 {
11180         if (flags & NDR_IN) {
11181         }
11182         if (flags & NDR_OUT) {
11183                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11184         }
11185         return NDR_ERR_SUCCESS;
11186 }
11187
11188 static enum ndr_err_code ndr_pull_lsa_CREDRWRITE(struct ndr_pull *ndr, int flags, struct lsa_CREDRWRITE *r)
11189 {
11190         if (flags & NDR_IN) {
11191         }
11192         if (flags & NDR_OUT) {
11193                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11194         }
11195         return NDR_ERR_SUCCESS;
11196 }
11197
11198 _PUBLIC_ void ndr_print_lsa_CREDRWRITE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRWRITE *r)
11199 {
11200         ndr_print_struct(ndr, name, "lsa_CREDRWRITE");
11201         ndr->depth++;
11202         if (flags & NDR_SET_VALUES) {
11203                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11204         }
11205         if (flags & NDR_IN) {
11206                 ndr_print_struct(ndr, "in", "lsa_CREDRWRITE");
11207                 ndr->depth++;
11208                 ndr->depth--;
11209         }
11210         if (flags & NDR_OUT) {
11211                 ndr_print_struct(ndr, "out", "lsa_CREDRWRITE");
11212                 ndr->depth++;
11213                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11214                 ndr->depth--;
11215         }
11216         ndr->depth--;
11217 }
11218
11219 static enum ndr_err_code ndr_push_lsa_CREDRREAD(struct ndr_push *ndr, int flags, const struct lsa_CREDRREAD *r)
11220 {
11221         if (flags & NDR_IN) {
11222         }
11223         if (flags & NDR_OUT) {
11224                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11225         }
11226         return NDR_ERR_SUCCESS;
11227 }
11228
11229 static enum ndr_err_code ndr_pull_lsa_CREDRREAD(struct ndr_pull *ndr, int flags, struct lsa_CREDRREAD *r)
11230 {
11231         if (flags & NDR_IN) {
11232         }
11233         if (flags & NDR_OUT) {
11234                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11235         }
11236         return NDR_ERR_SUCCESS;
11237 }
11238
11239 _PUBLIC_ void ndr_print_lsa_CREDRREAD(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRREAD *r)
11240 {
11241         ndr_print_struct(ndr, name, "lsa_CREDRREAD");
11242         ndr->depth++;
11243         if (flags & NDR_SET_VALUES) {
11244                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11245         }
11246         if (flags & NDR_IN) {
11247                 ndr_print_struct(ndr, "in", "lsa_CREDRREAD");
11248                 ndr->depth++;
11249                 ndr->depth--;
11250         }
11251         if (flags & NDR_OUT) {
11252                 ndr_print_struct(ndr, "out", "lsa_CREDRREAD");
11253                 ndr->depth++;
11254                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11255                 ndr->depth--;
11256         }
11257         ndr->depth--;
11258 }
11259
11260 static enum ndr_err_code ndr_push_lsa_CREDRENUMERATE(struct ndr_push *ndr, int flags, const struct lsa_CREDRENUMERATE *r)
11261 {
11262         if (flags & NDR_IN) {
11263         }
11264         if (flags & NDR_OUT) {
11265                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11266         }
11267         return NDR_ERR_SUCCESS;
11268 }
11269
11270 static enum ndr_err_code ndr_pull_lsa_CREDRENUMERATE(struct ndr_pull *ndr, int flags, struct lsa_CREDRENUMERATE *r)
11271 {
11272         if (flags & NDR_IN) {
11273         }
11274         if (flags & NDR_OUT) {
11275                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11276         }
11277         return NDR_ERR_SUCCESS;
11278 }
11279
11280 _PUBLIC_ void ndr_print_lsa_CREDRENUMERATE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRENUMERATE *r)
11281 {
11282         ndr_print_struct(ndr, name, "lsa_CREDRENUMERATE");
11283         ndr->depth++;
11284         if (flags & NDR_SET_VALUES) {
11285                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11286         }
11287         if (flags & NDR_IN) {
11288                 ndr_print_struct(ndr, "in", "lsa_CREDRENUMERATE");
11289                 ndr->depth++;
11290                 ndr->depth--;
11291         }
11292         if (flags & NDR_OUT) {
11293                 ndr_print_struct(ndr, "out", "lsa_CREDRENUMERATE");
11294                 ndr->depth++;
11295                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11296                 ndr->depth--;
11297         }
11298         ndr->depth--;
11299 }
11300
11301 static enum ndr_err_code ndr_push_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_push *ndr, int flags, const struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
11302 {
11303         if (flags & NDR_IN) {
11304         }
11305         if (flags & NDR_OUT) {
11306                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11307         }
11308         return NDR_ERR_SUCCESS;
11309 }
11310
11311 static enum ndr_err_code ndr_pull_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_pull *ndr, int flags, struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
11312 {
11313         if (flags & NDR_IN) {
11314         }
11315         if (flags & NDR_OUT) {
11316                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11317         }
11318         return NDR_ERR_SUCCESS;
11319 }
11320
11321 _PUBLIC_ void ndr_print_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
11322 {
11323         ndr_print_struct(ndr, name, "lsa_CREDRWRITEDOMAINCREDENTIALS");
11324         ndr->depth++;
11325         if (flags & NDR_SET_VALUES) {
11326                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11327         }
11328         if (flags & NDR_IN) {
11329                 ndr_print_struct(ndr, "in", "lsa_CREDRWRITEDOMAINCREDENTIALS");
11330                 ndr->depth++;
11331                 ndr->depth--;
11332         }
11333         if (flags & NDR_OUT) {
11334                 ndr_print_struct(ndr, "out", "lsa_CREDRWRITEDOMAINCREDENTIALS");
11335                 ndr->depth++;
11336                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11337                 ndr->depth--;
11338         }
11339         ndr->depth--;
11340 }
11341
11342 static enum ndr_err_code ndr_push_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_push *ndr, int flags, const struct lsa_CREDRREADDOMAINCREDENTIALS *r)
11343 {
11344         if (flags & NDR_IN) {
11345         }
11346         if (flags & NDR_OUT) {
11347                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11348         }
11349         return NDR_ERR_SUCCESS;
11350 }
11351
11352 static enum ndr_err_code ndr_pull_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_pull *ndr, int flags, struct lsa_CREDRREADDOMAINCREDENTIALS *r)
11353 {
11354         if (flags & NDR_IN) {
11355         }
11356         if (flags & NDR_OUT) {
11357                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11358         }
11359         return NDR_ERR_SUCCESS;
11360 }
11361
11362 _PUBLIC_ void ndr_print_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRREADDOMAINCREDENTIALS *r)
11363 {
11364         ndr_print_struct(ndr, name, "lsa_CREDRREADDOMAINCREDENTIALS");
11365         ndr->depth++;
11366         if (flags & NDR_SET_VALUES) {
11367                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11368         }
11369         if (flags & NDR_IN) {
11370                 ndr_print_struct(ndr, "in", "lsa_CREDRREADDOMAINCREDENTIALS");
11371                 ndr->depth++;
11372                 ndr->depth--;
11373         }
11374         if (flags & NDR_OUT) {
11375                 ndr_print_struct(ndr, "out", "lsa_CREDRREADDOMAINCREDENTIALS");
11376                 ndr->depth++;
11377                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11378                 ndr->depth--;
11379         }
11380         ndr->depth--;
11381 }
11382
11383 static enum ndr_err_code ndr_push_lsa_CREDRDELETE(struct ndr_push *ndr, int flags, const struct lsa_CREDRDELETE *r)
11384 {
11385         if (flags & NDR_IN) {
11386         }
11387         if (flags & NDR_OUT) {
11388                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11389         }
11390         return NDR_ERR_SUCCESS;
11391 }
11392
11393 static enum ndr_err_code ndr_pull_lsa_CREDRDELETE(struct ndr_pull *ndr, int flags, struct lsa_CREDRDELETE *r)
11394 {
11395         if (flags & NDR_IN) {
11396         }
11397         if (flags & NDR_OUT) {
11398                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11399         }
11400         return NDR_ERR_SUCCESS;
11401 }
11402
11403 _PUBLIC_ void ndr_print_lsa_CREDRDELETE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRDELETE *r)
11404 {
11405         ndr_print_struct(ndr, name, "lsa_CREDRDELETE");
11406         ndr->depth++;
11407         if (flags & NDR_SET_VALUES) {
11408                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11409         }
11410         if (flags & NDR_IN) {
11411                 ndr_print_struct(ndr, "in", "lsa_CREDRDELETE");
11412                 ndr->depth++;
11413                 ndr->depth--;
11414         }
11415         if (flags & NDR_OUT) {
11416                 ndr_print_struct(ndr, "out", "lsa_CREDRDELETE");
11417                 ndr->depth++;
11418                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11419                 ndr->depth--;
11420         }
11421         ndr->depth--;
11422 }
11423
11424 static enum ndr_err_code ndr_push_lsa_CREDRGETTARGETINFO(struct ndr_push *ndr, int flags, const struct lsa_CREDRGETTARGETINFO *r)
11425 {
11426         if (flags & NDR_IN) {
11427         }
11428         if (flags & NDR_OUT) {
11429                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11430         }
11431         return NDR_ERR_SUCCESS;
11432 }
11433
11434 static enum ndr_err_code ndr_pull_lsa_CREDRGETTARGETINFO(struct ndr_pull *ndr, int flags, struct lsa_CREDRGETTARGETINFO *r)
11435 {
11436         if (flags & NDR_IN) {
11437         }
11438         if (flags & NDR_OUT) {
11439                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11440         }
11441         return NDR_ERR_SUCCESS;
11442 }
11443
11444 _PUBLIC_ void ndr_print_lsa_CREDRGETTARGETINFO(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRGETTARGETINFO *r)
11445 {
11446         ndr_print_struct(ndr, name, "lsa_CREDRGETTARGETINFO");
11447         ndr->depth++;
11448         if (flags & NDR_SET_VALUES) {
11449                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11450         }
11451         if (flags & NDR_IN) {
11452                 ndr_print_struct(ndr, "in", "lsa_CREDRGETTARGETINFO");
11453                 ndr->depth++;
11454                 ndr->depth--;
11455         }
11456         if (flags & NDR_OUT) {
11457                 ndr_print_struct(ndr, "out", "lsa_CREDRGETTARGETINFO");
11458                 ndr->depth++;
11459                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11460                 ndr->depth--;
11461         }
11462         ndr->depth--;
11463 }
11464
11465 static enum ndr_err_code ndr_push_lsa_CREDRPROFILELOADED(struct ndr_push *ndr, int flags, const struct lsa_CREDRPROFILELOADED *r)
11466 {
11467         if (flags & NDR_IN) {
11468         }
11469         if (flags & NDR_OUT) {
11470                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11471         }
11472         return NDR_ERR_SUCCESS;
11473 }
11474
11475 static enum ndr_err_code ndr_pull_lsa_CREDRPROFILELOADED(struct ndr_pull *ndr, int flags, struct lsa_CREDRPROFILELOADED *r)
11476 {
11477         if (flags & NDR_IN) {
11478         }
11479         if (flags & NDR_OUT) {
11480                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11481         }
11482         return NDR_ERR_SUCCESS;
11483 }
11484
11485 _PUBLIC_ void ndr_print_lsa_CREDRPROFILELOADED(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRPROFILELOADED *r)
11486 {
11487         ndr_print_struct(ndr, name, "lsa_CREDRPROFILELOADED");
11488         ndr->depth++;
11489         if (flags & NDR_SET_VALUES) {
11490                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11491         }
11492         if (flags & NDR_IN) {
11493                 ndr_print_struct(ndr, "in", "lsa_CREDRPROFILELOADED");
11494                 ndr->depth++;
11495                 ndr->depth--;
11496         }
11497         if (flags & NDR_OUT) {
11498                 ndr_print_struct(ndr, "out", "lsa_CREDRPROFILELOADED");
11499                 ndr->depth++;
11500                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11501                 ndr->depth--;
11502         }
11503         ndr->depth--;
11504 }
11505
11506 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupNames3(struct ndr_push *ndr, int flags, const struct lsa_LookupNames3 *r)
11507 {
11508         uint32_t cntr_names_0;
11509         if (flags & NDR_IN) {
11510                 if (r->in.handle == NULL) {
11511                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11512                 }
11513                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
11515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
11516                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11517                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
11518                 }
11519                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11520                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
11521                 }
11522                 if (r->in.sids == NULL) {
11523                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11524                 }
11525                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11526                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
11527                 if (r->in.count == NULL) {
11528                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11529                 }
11530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
11531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.lookup_options));
11532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_revision));
11533         }
11534         if (flags & NDR_OUT) {
11535                 if (r->out.domains == NULL) {
11536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11537                 }
11538                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
11539                 if (*r->out.domains) {
11540                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11541                 }
11542                 if (r->out.sids == NULL) {
11543                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11544                 }
11545                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
11546                 if (r->out.count == NULL) {
11547                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11548                 }
11549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
11550                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11551         }
11552         return NDR_ERR_SUCCESS;
11553 }
11554
11555 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupNames3(struct ndr_pull *ndr, int flags, struct lsa_LookupNames3 *r)
11556 {
11557         uint32_t cntr_names_0;
11558         uint32_t _ptr_domains;
11559         TALLOC_CTX *_mem_save_handle_0;
11560         TALLOC_CTX *_mem_save_names_0;
11561         TALLOC_CTX *_mem_save_domains_0;
11562         TALLOC_CTX *_mem_save_domains_1;
11563         TALLOC_CTX *_mem_save_sids_0;
11564         TALLOC_CTX *_mem_save_count_0;
11565         if (flags & NDR_IN) {
11566                 ZERO_STRUCT(r->out);
11567
11568                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11569                         NDR_PULL_ALLOC(ndr, r->in.handle);
11570                 }
11571                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11572                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11573                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11574                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
11576                 if (r->in.num_names > 1000) {
11577                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11578                 }
11579                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
11580                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
11581                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11582                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
11583                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11584                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
11585                 }
11586                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11587                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
11588                 }
11589                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
11590                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11591                         NDR_PULL_ALLOC(ndr, r->in.sids);
11592                 }
11593                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11594                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
11595                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11596                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11597                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
11598                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11599                         NDR_PULL_ALLOC(ndr, r->in.count);
11600                 }
11601                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11602                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
11603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
11604                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.lookup_options));
11606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_revision));
11607                 NDR_PULL_ALLOC(ndr, r->out.domains);
11608                 ZERO_STRUCTP(r->out.domains);
11609                 NDR_PULL_ALLOC(ndr, r->out.sids);
11610                 *r->out.sids = *r->in.sids;
11611                 NDR_PULL_ALLOC(ndr, r->out.count);
11612                 *r->out.count = *r->in.count;
11613                 if (r->in.names) {
11614                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
11615                 }
11616         }
11617         if (flags & NDR_OUT) {
11618                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11619                         NDR_PULL_ALLOC(ndr, r->out.domains);
11620                 }
11621                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
11622                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
11623                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
11624                 if (_ptr_domains) {
11625                         NDR_PULL_ALLOC(ndr, *r->out.domains);
11626                 } else {
11627                         *r->out.domains = NULL;
11628                 }
11629                 if (*r->out.domains) {
11630                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
11631                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
11632                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11633                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
11634                 }
11635                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
11636                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11637                         NDR_PULL_ALLOC(ndr, r->out.sids);
11638                 }
11639                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11640                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
11641                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
11642                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11643                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11644                         NDR_PULL_ALLOC(ndr, r->out.count);
11645                 }
11646                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11647                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
11648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
11649                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11650                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11651         }
11652         return NDR_ERR_SUCCESS;
11653 }
11654
11655 _PUBLIC_ void ndr_print_lsa_LookupNames3(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames3 *r)
11656 {
11657         uint32_t cntr_names_0;
11658         ndr_print_struct(ndr, name, "lsa_LookupNames3");
11659         ndr->depth++;
11660         if (flags & NDR_SET_VALUES) {
11661                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11662         }
11663         if (flags & NDR_IN) {
11664                 ndr_print_struct(ndr, "in", "lsa_LookupNames3");
11665                 ndr->depth++;
11666                 ndr_print_ptr(ndr, "handle", r->in.handle);
11667                 ndr->depth++;
11668                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11669                 ndr->depth--;
11670                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
11671                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
11672                 ndr->depth++;
11673                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
11674                         char *idx_0=NULL;
11675                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
11676                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
11677                                 free(idx_0);
11678                         }
11679                 }
11680                 ndr->depth--;
11681                 ndr_print_ptr(ndr, "sids", r->in.sids);
11682                 ndr->depth++;
11683                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->in.sids);
11684                 ndr->depth--;
11685                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
11686                 ndr_print_ptr(ndr, "count", r->in.count);
11687                 ndr->depth++;
11688                 ndr_print_uint32(ndr, "count", *r->in.count);
11689                 ndr->depth--;
11690                 ndr_print_uint32(ndr, "lookup_options", r->in.lookup_options);
11691                 ndr_print_uint32(ndr, "client_revision", r->in.client_revision);
11692                 ndr->depth--;
11693         }
11694         if (flags & NDR_OUT) {
11695                 ndr_print_struct(ndr, "out", "lsa_LookupNames3");
11696                 ndr->depth++;
11697                 ndr_print_ptr(ndr, "domains", r->out.domains);
11698                 ndr->depth++;
11699                 ndr_print_ptr(ndr, "domains", *r->out.domains);
11700                 ndr->depth++;
11701                 if (*r->out.domains) {
11702                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
11703                 }
11704                 ndr->depth--;
11705                 ndr->depth--;
11706                 ndr_print_ptr(ndr, "sids", r->out.sids);
11707                 ndr->depth++;
11708                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->out.sids);
11709                 ndr->depth--;
11710                 ndr_print_ptr(ndr, "count", r->out.count);
11711                 ndr->depth++;
11712                 ndr_print_uint32(ndr, "count", *r->out.count);
11713                 ndr->depth--;
11714                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11715                 ndr->depth--;
11716         }
11717         ndr->depth--;
11718 }
11719
11720 static enum ndr_err_code ndr_push_lsa_CREDRGETSESSIONTYPES(struct ndr_push *ndr, int flags, const struct lsa_CREDRGETSESSIONTYPES *r)
11721 {
11722         if (flags & NDR_IN) {
11723         }
11724         if (flags & NDR_OUT) {
11725                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11726         }
11727         return NDR_ERR_SUCCESS;
11728 }
11729
11730 static enum ndr_err_code ndr_pull_lsa_CREDRGETSESSIONTYPES(struct ndr_pull *ndr, int flags, struct lsa_CREDRGETSESSIONTYPES *r)
11731 {
11732         if (flags & NDR_IN) {
11733         }
11734         if (flags & NDR_OUT) {
11735                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11736         }
11737         return NDR_ERR_SUCCESS;
11738 }
11739
11740 _PUBLIC_ void ndr_print_lsa_CREDRGETSESSIONTYPES(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRGETSESSIONTYPES *r)
11741 {
11742         ndr_print_struct(ndr, name, "lsa_CREDRGETSESSIONTYPES");
11743         ndr->depth++;
11744         if (flags & NDR_SET_VALUES) {
11745                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11746         }
11747         if (flags & NDR_IN) {
11748                 ndr_print_struct(ndr, "in", "lsa_CREDRGETSESSIONTYPES");
11749                 ndr->depth++;
11750                 ndr->depth--;
11751         }
11752         if (flags & NDR_OUT) {
11753                 ndr_print_struct(ndr, "out", "lsa_CREDRGETSESSIONTYPES");
11754                 ndr->depth++;
11755                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11756                 ndr->depth--;
11757         }
11758         ndr->depth--;
11759 }
11760
11761 static enum ndr_err_code ndr_push_lsa_LSARREGISTERAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARREGISTERAUDITEVENT *r)
11762 {
11763         if (flags & NDR_IN) {
11764         }
11765         if (flags & NDR_OUT) {
11766                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11767         }
11768         return NDR_ERR_SUCCESS;
11769 }
11770
11771 static enum ndr_err_code ndr_pull_lsa_LSARREGISTERAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARREGISTERAUDITEVENT *r)
11772 {
11773         if (flags & NDR_IN) {
11774         }
11775         if (flags & NDR_OUT) {
11776                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11777         }
11778         return NDR_ERR_SUCCESS;
11779 }
11780
11781 _PUBLIC_ void ndr_print_lsa_LSARREGISTERAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARREGISTERAUDITEVENT *r)
11782 {
11783         ndr_print_struct(ndr, name, "lsa_LSARREGISTERAUDITEVENT");
11784         ndr->depth++;
11785         if (flags & NDR_SET_VALUES) {
11786                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11787         }
11788         if (flags & NDR_IN) {
11789                 ndr_print_struct(ndr, "in", "lsa_LSARREGISTERAUDITEVENT");
11790                 ndr->depth++;
11791                 ndr->depth--;
11792         }
11793         if (flags & NDR_OUT) {
11794                 ndr_print_struct(ndr, "out", "lsa_LSARREGISTERAUDITEVENT");
11795                 ndr->depth++;
11796                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11797                 ndr->depth--;
11798         }
11799         ndr->depth--;
11800 }
11801
11802 static enum ndr_err_code ndr_push_lsa_LSARGENAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARGENAUDITEVENT *r)
11803 {
11804         if (flags & NDR_IN) {
11805         }
11806         if (flags & NDR_OUT) {
11807                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11808         }
11809         return NDR_ERR_SUCCESS;
11810 }
11811
11812 static enum ndr_err_code ndr_pull_lsa_LSARGENAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARGENAUDITEVENT *r)
11813 {
11814         if (flags & NDR_IN) {
11815         }
11816         if (flags & NDR_OUT) {
11817                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11818         }
11819         return NDR_ERR_SUCCESS;
11820 }
11821
11822 _PUBLIC_ void ndr_print_lsa_LSARGENAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARGENAUDITEVENT *r)
11823 {
11824         ndr_print_struct(ndr, name, "lsa_LSARGENAUDITEVENT");
11825         ndr->depth++;
11826         if (flags & NDR_SET_VALUES) {
11827                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11828         }
11829         if (flags & NDR_IN) {
11830                 ndr_print_struct(ndr, "in", "lsa_LSARGENAUDITEVENT");
11831                 ndr->depth++;
11832                 ndr->depth--;
11833         }
11834         if (flags & NDR_OUT) {
11835                 ndr_print_struct(ndr, "out", "lsa_LSARGENAUDITEVENT");
11836                 ndr->depth++;
11837                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11838                 ndr->depth--;
11839         }
11840         ndr->depth--;
11841 }
11842
11843 static enum ndr_err_code ndr_push_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARUNREGISTERAUDITEVENT *r)
11844 {
11845         if (flags & NDR_IN) {
11846         }
11847         if (flags & NDR_OUT) {
11848                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11849         }
11850         return NDR_ERR_SUCCESS;
11851 }
11852
11853 static enum ndr_err_code ndr_pull_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARUNREGISTERAUDITEVENT *r)
11854 {
11855         if (flags & NDR_IN) {
11856         }
11857         if (flags & NDR_OUT) {
11858                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11859         }
11860         return NDR_ERR_SUCCESS;
11861 }
11862
11863 _PUBLIC_ void ndr_print_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARUNREGISTERAUDITEVENT *r)
11864 {
11865         ndr_print_struct(ndr, name, "lsa_LSARUNREGISTERAUDITEVENT");
11866         ndr->depth++;
11867         if (flags & NDR_SET_VALUES) {
11868                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11869         }
11870         if (flags & NDR_IN) {
11871                 ndr_print_struct(ndr, "in", "lsa_LSARUNREGISTERAUDITEVENT");
11872                 ndr->depth++;
11873                 ndr->depth--;
11874         }
11875         if (flags & NDR_OUT) {
11876                 ndr_print_struct(ndr, "out", "lsa_LSARUNREGISTERAUDITEVENT");
11877                 ndr->depth++;
11878                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11879                 ndr->depth--;
11880         }
11881         ndr->depth--;
11882 }
11883
11884 static enum ndr_err_code ndr_push_lsa_lsaRQueryForestTrustInformation(struct ndr_push *ndr, int flags, const struct lsa_lsaRQueryForestTrustInformation *r)
11885 {
11886         if (flags & NDR_IN) {
11887                 if (r->in.handle == NULL) {
11888                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11889                 }
11890                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11891                 if (r->in.trusted_domain_name == NULL) {
11892                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11893                 }
11894                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain_name));
11895                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.unknown));
11896         }
11897         if (flags & NDR_OUT) {
11898                 if (r->out.forest_trust_info == NULL) {
11899                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11900                 }
11901                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.forest_trust_info));
11902                 if (*r->out.forest_trust_info) {
11903                         NDR_CHECK(ndr_push_lsa_ForestTrustInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.forest_trust_info));
11904                 }
11905                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11906         }
11907         return NDR_ERR_SUCCESS;
11908 }
11909
11910 static enum ndr_err_code ndr_pull_lsa_lsaRQueryForestTrustInformation(struct ndr_pull *ndr, int flags, struct lsa_lsaRQueryForestTrustInformation *r)
11911 {
11912         uint32_t _ptr_forest_trust_info;
11913         TALLOC_CTX *_mem_save_handle_0;
11914         TALLOC_CTX *_mem_save_trusted_domain_name_0;
11915         TALLOC_CTX *_mem_save_forest_trust_info_0;
11916         TALLOC_CTX *_mem_save_forest_trust_info_1;
11917         if (flags & NDR_IN) {
11918                 ZERO_STRUCT(r->out);
11919
11920                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11921                         NDR_PULL_ALLOC(ndr, r->in.handle);
11922                 }
11923                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11924                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11925                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11926                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11927                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11928                         NDR_PULL_ALLOC(ndr, r->in.trusted_domain_name);
11929                 }
11930                 _mem_save_trusted_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11931                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trusted_domain_name, LIBNDR_FLAG_REF_ALLOC);
11932                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain_name));
11933                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trusted_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
11934                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.unknown));
11935                 NDR_PULL_ALLOC(ndr, r->out.forest_trust_info);
11936                 ZERO_STRUCTP(r->out.forest_trust_info);
11937         }
11938         if (flags & NDR_OUT) {
11939                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11940                         NDR_PULL_ALLOC(ndr, r->out.forest_trust_info);
11941                 }
11942                 _mem_save_forest_trust_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11943                 NDR_PULL_SET_MEM_CTX(ndr, r->out.forest_trust_info, LIBNDR_FLAG_REF_ALLOC);
11944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_forest_trust_info));
11945                 if (_ptr_forest_trust_info) {
11946                         NDR_PULL_ALLOC(ndr, *r->out.forest_trust_info);
11947                 } else {
11948                         *r->out.forest_trust_info = NULL;
11949                 }
11950                 if (*r->out.forest_trust_info) {
11951                         _mem_save_forest_trust_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
11952                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.forest_trust_info, 0);
11953                         NDR_CHECK(ndr_pull_lsa_ForestTrustInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.forest_trust_info));
11954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_forest_trust_info_1, 0);
11955                 }
11956                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_forest_trust_info_0, LIBNDR_FLAG_REF_ALLOC);
11957                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11958         }
11959         return NDR_ERR_SUCCESS;
11960 }
11961
11962 _PUBLIC_ void ndr_print_lsa_lsaRQueryForestTrustInformation(struct ndr_print *ndr, const char *name, int flags, const struct lsa_lsaRQueryForestTrustInformation *r)
11963 {
11964         ndr_print_struct(ndr, name, "lsa_lsaRQueryForestTrustInformation");
11965         ndr->depth++;
11966         if (flags & NDR_SET_VALUES) {
11967                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11968         }
11969         if (flags & NDR_IN) {
11970                 ndr_print_struct(ndr, "in", "lsa_lsaRQueryForestTrustInformation");
11971                 ndr->depth++;
11972                 ndr_print_ptr(ndr, "handle", r->in.handle);
11973                 ndr->depth++;
11974                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11975                 ndr->depth--;
11976                 ndr_print_ptr(ndr, "trusted_domain_name", r->in.trusted_domain_name);
11977                 ndr->depth++;
11978                 ndr_print_lsa_String(ndr, "trusted_domain_name", r->in.trusted_domain_name);
11979                 ndr->depth--;
11980                 ndr_print_uint16(ndr, "unknown", r->in.unknown);
11981                 ndr->depth--;
11982         }
11983         if (flags & NDR_OUT) {
11984                 ndr_print_struct(ndr, "out", "lsa_lsaRQueryForestTrustInformation");
11985                 ndr->depth++;
11986                 ndr_print_ptr(ndr, "forest_trust_info", r->out.forest_trust_info);
11987                 ndr->depth++;
11988                 ndr_print_ptr(ndr, "forest_trust_info", *r->out.forest_trust_info);
11989                 ndr->depth++;
11990                 if (*r->out.forest_trust_info) {
11991                         ndr_print_lsa_ForestTrustInformation(ndr, "forest_trust_info", *r->out.forest_trust_info);
11992                 }
11993                 ndr->depth--;
11994                 ndr->depth--;
11995                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11996                 ndr->depth--;
11997         }
11998         ndr->depth--;
11999 }
12000
12001 static enum ndr_err_code ndr_push_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_push *ndr, int flags, const struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
12002 {
12003         if (flags & NDR_IN) {
12004         }
12005         if (flags & NDR_OUT) {
12006                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12007         }
12008         return NDR_ERR_SUCCESS;
12009 }
12010
12011 static enum ndr_err_code ndr_pull_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_pull *ndr, int flags, struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
12012 {
12013         if (flags & NDR_IN) {
12014         }
12015         if (flags & NDR_OUT) {
12016                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12017         }
12018         return NDR_ERR_SUCCESS;
12019 }
12020
12021 _PUBLIC_ void ndr_print_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
12022 {
12023         ndr_print_struct(ndr, name, "lsa_LSARSETFORESTTRUSTINFORMATION");
12024         ndr->depth++;
12025         if (flags & NDR_SET_VALUES) {
12026                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12027         }
12028         if (flags & NDR_IN) {
12029                 ndr_print_struct(ndr, "in", "lsa_LSARSETFORESTTRUSTINFORMATION");
12030                 ndr->depth++;
12031                 ndr->depth--;
12032         }
12033         if (flags & NDR_OUT) {
12034                 ndr_print_struct(ndr, "out", "lsa_LSARSETFORESTTRUSTINFORMATION");
12035                 ndr->depth++;
12036                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12037                 ndr->depth--;
12038         }
12039         ndr->depth--;
12040 }
12041
12042 static enum ndr_err_code ndr_push_lsa_CREDRRENAME(struct ndr_push *ndr, int flags, const struct lsa_CREDRRENAME *r)
12043 {
12044         if (flags & NDR_IN) {
12045         }
12046         if (flags & NDR_OUT) {
12047                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12048         }
12049         return NDR_ERR_SUCCESS;
12050 }
12051
12052 static enum ndr_err_code ndr_pull_lsa_CREDRRENAME(struct ndr_pull *ndr, int flags, struct lsa_CREDRRENAME *r)
12053 {
12054         if (flags & NDR_IN) {
12055         }
12056         if (flags & NDR_OUT) {
12057                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12058         }
12059         return NDR_ERR_SUCCESS;
12060 }
12061
12062 _PUBLIC_ void ndr_print_lsa_CREDRRENAME(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRRENAME *r)
12063 {
12064         ndr_print_struct(ndr, name, "lsa_CREDRRENAME");
12065         ndr->depth++;
12066         if (flags & NDR_SET_VALUES) {
12067                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12068         }
12069         if (flags & NDR_IN) {
12070                 ndr_print_struct(ndr, "in", "lsa_CREDRRENAME");
12071                 ndr->depth++;
12072                 ndr->depth--;
12073         }
12074         if (flags & NDR_OUT) {
12075                 ndr_print_struct(ndr, "out", "lsa_CREDRRENAME");
12076                 ndr->depth++;
12077                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12078                 ndr->depth--;
12079         }
12080         ndr->depth--;
12081 }
12082
12083 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupSids3(struct ndr_push *ndr, int flags, const struct lsa_LookupSids3 *r)
12084 {
12085         if (flags & NDR_IN) {
12086                 if (r->in.sids == NULL) {
12087                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12088                 }
12089                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
12090                 if (r->in.names == NULL) {
12091                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12092                 }
12093                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
12094                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
12095                 if (r->in.count == NULL) {
12096                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12097                 }
12098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
12099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
12100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
12101         }
12102         if (flags & NDR_OUT) {
12103                 if (r->out.domains == NULL) {
12104                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12105                 }
12106                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
12107                 if (*r->out.domains) {
12108                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
12109                 }
12110                 if (r->out.names == NULL) {
12111                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12112                 }
12113                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
12114                 if (r->out.count == NULL) {
12115                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12116                 }
12117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
12118                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12119         }
12120         return NDR_ERR_SUCCESS;
12121 }
12122
12123 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupSids3(struct ndr_pull *ndr, int flags, struct lsa_LookupSids3 *r)
12124 {
12125         uint32_t _ptr_domains;
12126         TALLOC_CTX *_mem_save_sids_0;
12127         TALLOC_CTX *_mem_save_domains_0;
12128         TALLOC_CTX *_mem_save_domains_1;
12129         TALLOC_CTX *_mem_save_names_0;
12130         TALLOC_CTX *_mem_save_count_0;
12131         if (flags & NDR_IN) {
12132                 ZERO_STRUCT(r->out);
12133
12134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12135                         NDR_PULL_ALLOC(ndr, r->in.sids);
12136                 }
12137                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
12138                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
12139                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
12140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
12141                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12142                         NDR_PULL_ALLOC(ndr, r->in.names);
12143                 }
12144                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12145                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
12146                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
12147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
12148                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
12149                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12150                         NDR_PULL_ALLOC(ndr, r->in.count);
12151                 }
12152                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
12153                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
12154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
12155                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
12156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
12157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
12158                 NDR_PULL_ALLOC(ndr, r->out.domains);
12159                 ZERO_STRUCTP(r->out.domains);
12160                 NDR_PULL_ALLOC(ndr, r->out.names);
12161                 *r->out.names = *r->in.names;
12162                 NDR_PULL_ALLOC(ndr, r->out.count);
12163                 *r->out.count = *r->in.count;
12164         }
12165         if (flags & NDR_OUT) {
12166                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12167                         NDR_PULL_ALLOC(ndr, r->out.domains);
12168                 }
12169                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
12170                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
12171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
12172                 if (_ptr_domains) {
12173                         NDR_PULL_ALLOC(ndr, *r->out.domains);
12174                 } else {
12175                         *r->out.domains = NULL;
12176                 }
12177                 if (*r->out.domains) {
12178                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
12179                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
12180                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
12181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
12182                 }
12183                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
12184                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12185                         NDR_PULL_ALLOC(ndr, r->out.names);
12186                 }
12187                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12188                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
12189                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
12190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
12191                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12192                         NDR_PULL_ALLOC(ndr, r->out.count);
12193                 }
12194                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
12195                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
12196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
12197                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
12198                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12199         }
12200         return NDR_ERR_SUCCESS;
12201 }
12202
12203 _PUBLIC_ void ndr_print_lsa_LookupSids3(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids3 *r)
12204 {
12205         ndr_print_struct(ndr, name, "lsa_LookupSids3");
12206         ndr->depth++;
12207         if (flags & NDR_SET_VALUES) {
12208                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12209         }
12210         if (flags & NDR_IN) {
12211                 ndr_print_struct(ndr, "in", "lsa_LookupSids3");
12212                 ndr->depth++;
12213                 ndr_print_ptr(ndr, "sids", r->in.sids);
12214                 ndr->depth++;
12215                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
12216                 ndr->depth--;
12217                 ndr_print_ptr(ndr, "names", r->in.names);
12218                 ndr->depth++;
12219                 ndr_print_lsa_TransNameArray2(ndr, "names", r->in.names);
12220                 ndr->depth--;
12221                 ndr_print_uint16(ndr, "level", r->in.level);
12222                 ndr_print_ptr(ndr, "count", r->in.count);
12223                 ndr->depth++;
12224                 ndr_print_uint32(ndr, "count", *r->in.count);
12225                 ndr->depth--;
12226                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
12227                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
12228                 ndr->depth--;
12229         }
12230         if (flags & NDR_OUT) {
12231                 ndr_print_struct(ndr, "out", "lsa_LookupSids3");
12232                 ndr->depth++;
12233                 ndr_print_ptr(ndr, "domains", r->out.domains);
12234                 ndr->depth++;
12235                 ndr_print_ptr(ndr, "domains", *r->out.domains);
12236                 ndr->depth++;
12237                 if (*r->out.domains) {
12238                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
12239                 }
12240                 ndr->depth--;
12241                 ndr->depth--;
12242                 ndr_print_ptr(ndr, "names", r->out.names);
12243                 ndr->depth++;
12244                 ndr_print_lsa_TransNameArray2(ndr, "names", r->out.names);
12245                 ndr->depth--;
12246                 ndr_print_ptr(ndr, "count", r->out.count);
12247                 ndr->depth++;
12248                 ndr_print_uint32(ndr, "count", *r->out.count);
12249                 ndr->depth--;
12250                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12251                 ndr->depth--;
12252         }
12253         ndr->depth--;
12254 }
12255
12256 static enum ndr_err_code ndr_push_lsa_LookupNames4(struct ndr_push *ndr, int flags, const struct lsa_LookupNames4 *r)
12257 {
12258         uint32_t cntr_names_0;
12259         if (flags & NDR_IN) {
12260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
12261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
12262                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
12263                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
12264                 }
12265                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
12266                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
12267                 }
12268                 if (r->in.sids == NULL) {
12269                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12270                 }
12271                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
12272                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
12273                 if (r->in.count == NULL) {
12274                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12275                 }
12276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
12277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.lookup_options));
12278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_revision));
12279         }
12280         if (flags & NDR_OUT) {
12281                 if (r->out.domains == NULL) {
12282                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12283                 }
12284                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
12285                 if (*r->out.domains) {
12286                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
12287                 }
12288                 if (r->out.sids == NULL) {
12289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12290                 }
12291                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
12292                 if (r->out.count == NULL) {
12293                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12294                 }
12295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
12296                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12297         }
12298         return NDR_ERR_SUCCESS;
12299 }
12300
12301 static enum ndr_err_code ndr_pull_lsa_LookupNames4(struct ndr_pull *ndr, int flags, struct lsa_LookupNames4 *r)
12302 {
12303         uint32_t cntr_names_0;
12304         uint32_t _ptr_domains;
12305         TALLOC_CTX *_mem_save_names_0;
12306         TALLOC_CTX *_mem_save_domains_0;
12307         TALLOC_CTX *_mem_save_domains_1;
12308         TALLOC_CTX *_mem_save_sids_0;
12309         TALLOC_CTX *_mem_save_count_0;
12310         if (flags & NDR_IN) {
12311                 ZERO_STRUCT(r->out);
12312
12313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
12314                 if (r->in.num_names > 1000) {
12315                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12316                 }
12317                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
12318                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
12319                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12320                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
12321                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
12322                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
12323                 }
12324                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
12325                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
12326                 }
12327                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
12328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12329                         NDR_PULL_ALLOC(ndr, r->in.sids);
12330                 }
12331                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
12332                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
12333                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
12334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
12335                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
12336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12337                         NDR_PULL_ALLOC(ndr, r->in.count);
12338                 }
12339                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
12340                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
12341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
12342                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
12343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.lookup_options));
12344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_revision));
12345                 NDR_PULL_ALLOC(ndr, r->out.domains);
12346                 ZERO_STRUCTP(r->out.domains);
12347                 NDR_PULL_ALLOC(ndr, r->out.sids);
12348                 *r->out.sids = *r->in.sids;
12349                 NDR_PULL_ALLOC(ndr, r->out.count);
12350                 *r->out.count = *r->in.count;
12351                 if (r->in.names) {
12352                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
12353                 }
12354         }
12355         if (flags & NDR_OUT) {
12356                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12357                         NDR_PULL_ALLOC(ndr, r->out.domains);
12358                 }
12359                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
12360                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
12361                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
12362                 if (_ptr_domains) {
12363                         NDR_PULL_ALLOC(ndr, *r->out.domains);
12364                 } else {
12365                         *r->out.domains = NULL;
12366                 }
12367                 if (*r->out.domains) {
12368                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
12369                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
12370                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
12371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
12372                 }
12373                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
12374                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12375                         NDR_PULL_ALLOC(ndr, r->out.sids);
12376                 }
12377                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
12378                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
12379                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
12380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
12381                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12382                         NDR_PULL_ALLOC(ndr, r->out.count);
12383                 }
12384                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
12385                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
12386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
12387                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
12388                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12389         }
12390         return NDR_ERR_SUCCESS;
12391 }
12392
12393 _PUBLIC_ void ndr_print_lsa_LookupNames4(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames4 *r)
12394 {
12395         uint32_t cntr_names_0;
12396         ndr_print_struct(ndr, name, "lsa_LookupNames4");
12397         ndr->depth++;
12398         if (flags & NDR_SET_VALUES) {
12399                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12400         }
12401         if (flags & NDR_IN) {
12402                 ndr_print_struct(ndr, "in", "lsa_LookupNames4");
12403                 ndr->depth++;
12404                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
12405                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->in.num_names);
12406                 ndr->depth++;
12407                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
12408                         char *idx_0=NULL;
12409                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
12410                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
12411                                 free(idx_0);
12412                         }
12413                 }
12414                 ndr->depth--;
12415                 ndr_print_ptr(ndr, "sids", r->in.sids);
12416                 ndr->depth++;
12417                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->in.sids);
12418                 ndr->depth--;
12419                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
12420                 ndr_print_ptr(ndr, "count", r->in.count);
12421                 ndr->depth++;
12422                 ndr_print_uint32(ndr, "count", *r->in.count);
12423                 ndr->depth--;
12424                 ndr_print_uint32(ndr, "lookup_options", r->in.lookup_options);
12425                 ndr_print_uint32(ndr, "client_revision", r->in.client_revision);
12426                 ndr->depth--;
12427         }
12428         if (flags & NDR_OUT) {
12429                 ndr_print_struct(ndr, "out", "lsa_LookupNames4");
12430                 ndr->depth++;
12431                 ndr_print_ptr(ndr, "domains", r->out.domains);
12432                 ndr->depth++;
12433                 ndr_print_ptr(ndr, "domains", *r->out.domains);
12434                 ndr->depth++;
12435                 if (*r->out.domains) {
12436                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
12437                 }
12438                 ndr->depth--;
12439                 ndr->depth--;
12440                 ndr_print_ptr(ndr, "sids", r->out.sids);
12441                 ndr->depth++;
12442                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->out.sids);
12443                 ndr->depth--;
12444                 ndr_print_ptr(ndr, "count", r->out.count);
12445                 ndr->depth++;
12446                 ndr_print_uint32(ndr, "count", *r->out.count);
12447                 ndr->depth--;
12448                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12449                 ndr->depth--;
12450         }
12451         ndr->depth--;
12452 }
12453
12454 static enum ndr_err_code ndr_push_lsa_LSAROPENPOLICYSCE(struct ndr_push *ndr, int flags, const struct lsa_LSAROPENPOLICYSCE *r)
12455 {
12456         if (flags & NDR_IN) {
12457         }
12458         if (flags & NDR_OUT) {
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_LSAROPENPOLICYSCE(struct ndr_pull *ndr, int flags, struct lsa_LSAROPENPOLICYSCE *r)
12465 {
12466         if (flags & NDR_IN) {
12467         }
12468         if (flags & NDR_OUT) {
12469                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12470         }
12471         return NDR_ERR_SUCCESS;
12472 }
12473
12474 _PUBLIC_ void ndr_print_lsa_LSAROPENPOLICYSCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSAROPENPOLICYSCE *r)
12475 {
12476         ndr_print_struct(ndr, name, "lsa_LSAROPENPOLICYSCE");
12477         ndr->depth++;
12478         if (flags & NDR_SET_VALUES) {
12479                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12480         }
12481         if (flags & NDR_IN) {
12482                 ndr_print_struct(ndr, "in", "lsa_LSAROPENPOLICYSCE");
12483                 ndr->depth++;
12484                 ndr->depth--;
12485         }
12486         if (flags & NDR_OUT) {
12487                 ndr_print_struct(ndr, "out", "lsa_LSAROPENPOLICYSCE");
12488                 ndr->depth++;
12489                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12490                 ndr->depth--;
12491         }
12492         ndr->depth--;
12493 }
12494
12495 static enum ndr_err_code ndr_push_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_push *ndr, int flags, const struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
12496 {
12497         if (flags & NDR_IN) {
12498         }
12499         if (flags & NDR_OUT) {
12500                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12501         }
12502         return NDR_ERR_SUCCESS;
12503 }
12504
12505 static enum ndr_err_code ndr_pull_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_pull *ndr, int flags, struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
12506 {
12507         if (flags & NDR_IN) {
12508         }
12509         if (flags & NDR_OUT) {
12510                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12511         }
12512         return NDR_ERR_SUCCESS;
12513 }
12514
12515 _PUBLIC_ void ndr_print_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
12516 {
12517         ndr_print_struct(ndr, name, "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
12518         ndr->depth++;
12519         if (flags & NDR_SET_VALUES) {
12520                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12521         }
12522         if (flags & NDR_IN) {
12523                 ndr_print_struct(ndr, "in", "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
12524                 ndr->depth++;
12525                 ndr->depth--;
12526         }
12527         if (flags & NDR_OUT) {
12528                 ndr_print_struct(ndr, "out", "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
12529                 ndr->depth++;
12530                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12531                 ndr->depth--;
12532         }
12533         ndr->depth--;
12534 }
12535
12536 static enum ndr_err_code ndr_push_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_push *ndr, int flags, const struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
12537 {
12538         if (flags & NDR_IN) {
12539         }
12540         if (flags & NDR_OUT) {
12541                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12542         }
12543         return NDR_ERR_SUCCESS;
12544 }
12545
12546 static enum ndr_err_code ndr_pull_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_pull *ndr, int flags, struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
12547 {
12548         if (flags & NDR_IN) {
12549         }
12550         if (flags & NDR_OUT) {
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_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
12557 {
12558         ndr_print_struct(ndr, name, "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
12559         ndr->depth++;
12560         if (flags & NDR_SET_VALUES) {
12561                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12562         }
12563         if (flags & NDR_IN) {
12564                 ndr_print_struct(ndr, "in", "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
12565                 ndr->depth++;
12566                 ndr->depth--;
12567         }
12568         if (flags & NDR_OUT) {
12569                 ndr_print_struct(ndr, "out", "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
12570                 ndr->depth++;
12571                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12572                 ndr->depth--;
12573         }
12574         ndr->depth--;
12575 }
12576
12577 static enum ndr_err_code ndr_push_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARADTREPORTSECURITYEVENT *r)
12578 {
12579         if (flags & NDR_IN) {
12580         }
12581         if (flags & NDR_OUT) {
12582                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
12583         }
12584         return NDR_ERR_SUCCESS;
12585 }
12586
12587 static enum ndr_err_code ndr_pull_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARADTREPORTSECURITYEVENT *r)
12588 {
12589         if (flags & NDR_IN) {
12590         }
12591         if (flags & NDR_OUT) {
12592                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
12593         }
12594         return NDR_ERR_SUCCESS;
12595 }
12596
12597 _PUBLIC_ void ndr_print_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTREPORTSECURITYEVENT *r)
12598 {
12599         ndr_print_struct(ndr, name, "lsa_LSARADTREPORTSECURITYEVENT");
12600         ndr->depth++;
12601         if (flags & NDR_SET_VALUES) {
12602                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12603         }
12604         if (flags & NDR_IN) {
12605                 ndr_print_struct(ndr, "in", "lsa_LSARADTREPORTSECURITYEVENT");
12606                 ndr->depth++;
12607                 ndr->depth--;
12608         }
12609         if (flags & NDR_OUT) {
12610                 ndr_print_struct(ndr, "out", "lsa_LSARADTREPORTSECURITYEVENT");
12611                 ndr->depth++;
12612                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
12613                 ndr->depth--;
12614         }
12615         ndr->depth--;
12616 }
12617
12618 static const struct ndr_interface_call lsarpc_calls[] = {
12619         {
12620                 "lsa_Close",
12621                 sizeof(struct lsa_Close),
12622                 (ndr_push_flags_fn_t) ndr_push_lsa_Close,
12623                 (ndr_pull_flags_fn_t) ndr_pull_lsa_Close,
12624                 (ndr_print_function_t) ndr_print_lsa_Close,
12625                 false,
12626         },
12627         {
12628                 "lsa_Delete",
12629                 sizeof(struct lsa_Delete),
12630                 (ndr_push_flags_fn_t) ndr_push_lsa_Delete,
12631                 (ndr_pull_flags_fn_t) ndr_pull_lsa_Delete,
12632                 (ndr_print_function_t) ndr_print_lsa_Delete,
12633                 false,
12634         },
12635         {
12636                 "lsa_EnumPrivs",
12637                 sizeof(struct lsa_EnumPrivs),
12638                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumPrivs,
12639                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumPrivs,
12640                 (ndr_print_function_t) ndr_print_lsa_EnumPrivs,
12641                 false,
12642         },
12643         {
12644                 "lsa_QuerySecurity",
12645                 sizeof(struct lsa_QuerySecurity),
12646                 (ndr_push_flags_fn_t) ndr_push_lsa_QuerySecurity,
12647                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QuerySecurity,
12648                 (ndr_print_function_t) ndr_print_lsa_QuerySecurity,
12649                 false,
12650         },
12651         {
12652                 "lsa_SetSecObj",
12653                 sizeof(struct lsa_SetSecObj),
12654                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSecObj,
12655                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSecObj,
12656                 (ndr_print_function_t) ndr_print_lsa_SetSecObj,
12657                 false,
12658         },
12659         {
12660                 "lsa_ChangePassword",
12661                 sizeof(struct lsa_ChangePassword),
12662                 (ndr_push_flags_fn_t) ndr_push_lsa_ChangePassword,
12663                 (ndr_pull_flags_fn_t) ndr_pull_lsa_ChangePassword,
12664                 (ndr_print_function_t) ndr_print_lsa_ChangePassword,
12665                 false,
12666         },
12667         {
12668                 "lsa_OpenPolicy",
12669                 sizeof(struct lsa_OpenPolicy),
12670                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenPolicy,
12671                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenPolicy,
12672                 (ndr_print_function_t) ndr_print_lsa_OpenPolicy,
12673                 false,
12674         },
12675         {
12676                 "lsa_QueryInfoPolicy",
12677                 sizeof(struct lsa_QueryInfoPolicy),
12678                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryInfoPolicy,
12679                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryInfoPolicy,
12680                 (ndr_print_function_t) ndr_print_lsa_QueryInfoPolicy,
12681                 false,
12682         },
12683         {
12684                 "lsa_SetInfoPolicy",
12685                 sizeof(struct lsa_SetInfoPolicy),
12686                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInfoPolicy,
12687                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInfoPolicy,
12688                 (ndr_print_function_t) ndr_print_lsa_SetInfoPolicy,
12689                 false,
12690         },
12691         {
12692                 "lsa_ClearAuditLog",
12693                 sizeof(struct lsa_ClearAuditLog),
12694                 (ndr_push_flags_fn_t) ndr_push_lsa_ClearAuditLog,
12695                 (ndr_pull_flags_fn_t) ndr_pull_lsa_ClearAuditLog,
12696                 (ndr_print_function_t) ndr_print_lsa_ClearAuditLog,
12697                 false,
12698         },
12699         {
12700                 "lsa_CreateAccount",
12701                 sizeof(struct lsa_CreateAccount),
12702                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateAccount,
12703                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateAccount,
12704                 (ndr_print_function_t) ndr_print_lsa_CreateAccount,
12705                 false,
12706         },
12707         {
12708                 "lsa_EnumAccounts",
12709                 sizeof(struct lsa_EnumAccounts),
12710                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccounts,
12711                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccounts,
12712                 (ndr_print_function_t) ndr_print_lsa_EnumAccounts,
12713                 false,
12714         },
12715         {
12716                 "lsa_CreateTrustedDomain",
12717                 sizeof(struct lsa_CreateTrustedDomain),
12718                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomain,
12719                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomain,
12720                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomain,
12721                 false,
12722         },
12723         {
12724                 "lsa_EnumTrustDom",
12725                 sizeof(struct lsa_EnumTrustDom),
12726                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumTrustDom,
12727                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumTrustDom,
12728                 (ndr_print_function_t) ndr_print_lsa_EnumTrustDom,
12729                 false,
12730         },
12731         {
12732                 "lsa_LookupNames",
12733                 sizeof(struct lsa_LookupNames),
12734                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames,
12735                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames,
12736                 (ndr_print_function_t) ndr_print_lsa_LookupNames,
12737                 false,
12738         },
12739         {
12740                 "lsa_LookupSids",
12741                 sizeof(struct lsa_LookupSids),
12742                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids,
12743                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids,
12744                 (ndr_print_function_t) ndr_print_lsa_LookupSids,
12745                 false,
12746         },
12747         {
12748                 "lsa_CreateSecret",
12749                 sizeof(struct lsa_CreateSecret),
12750                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateSecret,
12751                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateSecret,
12752                 (ndr_print_function_t) ndr_print_lsa_CreateSecret,
12753                 false,
12754         },
12755         {
12756                 "lsa_OpenAccount",
12757                 sizeof(struct lsa_OpenAccount),
12758                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenAccount,
12759                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenAccount,
12760                 (ndr_print_function_t) ndr_print_lsa_OpenAccount,
12761                 false,
12762         },
12763         {
12764                 "lsa_EnumPrivsAccount",
12765                 sizeof(struct lsa_EnumPrivsAccount),
12766                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumPrivsAccount,
12767                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumPrivsAccount,
12768                 (ndr_print_function_t) ndr_print_lsa_EnumPrivsAccount,
12769                 false,
12770         },
12771         {
12772                 "lsa_AddPrivilegesToAccount",
12773                 sizeof(struct lsa_AddPrivilegesToAccount),
12774                 (ndr_push_flags_fn_t) ndr_push_lsa_AddPrivilegesToAccount,
12775                 (ndr_pull_flags_fn_t) ndr_pull_lsa_AddPrivilegesToAccount,
12776                 (ndr_print_function_t) ndr_print_lsa_AddPrivilegesToAccount,
12777                 false,
12778         },
12779         {
12780                 "lsa_RemovePrivilegesFromAccount",
12781                 sizeof(struct lsa_RemovePrivilegesFromAccount),
12782                 (ndr_push_flags_fn_t) ndr_push_lsa_RemovePrivilegesFromAccount,
12783                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RemovePrivilegesFromAccount,
12784                 (ndr_print_function_t) ndr_print_lsa_RemovePrivilegesFromAccount,
12785                 false,
12786         },
12787         {
12788                 "lsa_GetQuotasForAccount",
12789                 sizeof(struct lsa_GetQuotasForAccount),
12790                 (ndr_push_flags_fn_t) ndr_push_lsa_GetQuotasForAccount,
12791                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetQuotasForAccount,
12792                 (ndr_print_function_t) ndr_print_lsa_GetQuotasForAccount,
12793                 false,
12794         },
12795         {
12796                 "lsa_SetQuotasForAccount",
12797                 sizeof(struct lsa_SetQuotasForAccount),
12798                 (ndr_push_flags_fn_t) ndr_push_lsa_SetQuotasForAccount,
12799                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetQuotasForAccount,
12800                 (ndr_print_function_t) ndr_print_lsa_SetQuotasForAccount,
12801                 false,
12802         },
12803         {
12804                 "lsa_GetSystemAccessAccount",
12805                 sizeof(struct lsa_GetSystemAccessAccount),
12806                 (ndr_push_flags_fn_t) ndr_push_lsa_GetSystemAccessAccount,
12807                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetSystemAccessAccount,
12808                 (ndr_print_function_t) ndr_print_lsa_GetSystemAccessAccount,
12809                 false,
12810         },
12811         {
12812                 "lsa_SetSystemAccessAccount",
12813                 sizeof(struct lsa_SetSystemAccessAccount),
12814                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSystemAccessAccount,
12815                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSystemAccessAccount,
12816                 (ndr_print_function_t) ndr_print_lsa_SetSystemAccessAccount,
12817                 false,
12818         },
12819         {
12820                 "lsa_OpenTrustedDomain",
12821                 sizeof(struct lsa_OpenTrustedDomain),
12822                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenTrustedDomain,
12823                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenTrustedDomain,
12824                 (ndr_print_function_t) ndr_print_lsa_OpenTrustedDomain,
12825                 false,
12826         },
12827         {
12828                 "lsa_QueryTrustedDomainInfo",
12829                 sizeof(struct lsa_QueryTrustedDomainInfo),
12830                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfo,
12831                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfo,
12832                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfo,
12833                 false,
12834         },
12835         {
12836                 "lsa_SetInformationTrustedDomain",
12837                 sizeof(struct lsa_SetInformationTrustedDomain),
12838                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInformationTrustedDomain,
12839                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInformationTrustedDomain,
12840                 (ndr_print_function_t) ndr_print_lsa_SetInformationTrustedDomain,
12841                 false,
12842         },
12843         {
12844                 "lsa_OpenSecret",
12845                 sizeof(struct lsa_OpenSecret),
12846                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenSecret,
12847                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenSecret,
12848                 (ndr_print_function_t) ndr_print_lsa_OpenSecret,
12849                 false,
12850         },
12851         {
12852                 "lsa_SetSecret",
12853                 sizeof(struct lsa_SetSecret),
12854                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSecret,
12855                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSecret,
12856                 (ndr_print_function_t) ndr_print_lsa_SetSecret,
12857                 false,
12858         },
12859         {
12860                 "lsa_QuerySecret",
12861                 sizeof(struct lsa_QuerySecret),
12862                 (ndr_push_flags_fn_t) ndr_push_lsa_QuerySecret,
12863                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QuerySecret,
12864                 (ndr_print_function_t) ndr_print_lsa_QuerySecret,
12865                 false,
12866         },
12867         {
12868                 "lsa_LookupPrivValue",
12869                 sizeof(struct lsa_LookupPrivValue),
12870                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivValue,
12871                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivValue,
12872                 (ndr_print_function_t) ndr_print_lsa_LookupPrivValue,
12873                 false,
12874         },
12875         {
12876                 "lsa_LookupPrivName",
12877                 sizeof(struct lsa_LookupPrivName),
12878                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivName,
12879                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivName,
12880                 (ndr_print_function_t) ndr_print_lsa_LookupPrivName,
12881                 false,
12882         },
12883         {
12884                 "lsa_LookupPrivDisplayName",
12885                 sizeof(struct lsa_LookupPrivDisplayName),
12886                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivDisplayName,
12887                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivDisplayName,
12888                 (ndr_print_function_t) ndr_print_lsa_LookupPrivDisplayName,
12889                 false,
12890         },
12891         {
12892                 "lsa_DeleteObject",
12893                 sizeof(struct lsa_DeleteObject),
12894                 (ndr_push_flags_fn_t) ndr_push_lsa_DeleteObject,
12895                 (ndr_pull_flags_fn_t) ndr_pull_lsa_DeleteObject,
12896                 (ndr_print_function_t) ndr_print_lsa_DeleteObject,
12897                 false,
12898         },
12899         {
12900                 "lsa_EnumAccountsWithUserRight",
12901                 sizeof(struct lsa_EnumAccountsWithUserRight),
12902                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccountsWithUserRight,
12903                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccountsWithUserRight,
12904                 (ndr_print_function_t) ndr_print_lsa_EnumAccountsWithUserRight,
12905                 false,
12906         },
12907         {
12908                 "lsa_EnumAccountRights",
12909                 sizeof(struct lsa_EnumAccountRights),
12910                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccountRights,
12911                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccountRights,
12912                 (ndr_print_function_t) ndr_print_lsa_EnumAccountRights,
12913                 false,
12914         },
12915         {
12916                 "lsa_AddAccountRights",
12917                 sizeof(struct lsa_AddAccountRights),
12918                 (ndr_push_flags_fn_t) ndr_push_lsa_AddAccountRights,
12919                 (ndr_pull_flags_fn_t) ndr_pull_lsa_AddAccountRights,
12920                 (ndr_print_function_t) ndr_print_lsa_AddAccountRights,
12921                 false,
12922         },
12923         {
12924                 "lsa_RemoveAccountRights",
12925                 sizeof(struct lsa_RemoveAccountRights),
12926                 (ndr_push_flags_fn_t) ndr_push_lsa_RemoveAccountRights,
12927                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RemoveAccountRights,
12928                 (ndr_print_function_t) ndr_print_lsa_RemoveAccountRights,
12929                 false,
12930         },
12931         {
12932                 "lsa_QueryTrustedDomainInfoBySid",
12933                 sizeof(struct lsa_QueryTrustedDomainInfoBySid),
12934                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfoBySid,
12935                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfoBySid,
12936                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfoBySid,
12937                 false,
12938         },
12939         {
12940                 "lsa_SetTrustedDomainInfo",
12941                 sizeof(struct lsa_SetTrustedDomainInfo),
12942                 (ndr_push_flags_fn_t) ndr_push_lsa_SetTrustedDomainInfo,
12943                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetTrustedDomainInfo,
12944                 (ndr_print_function_t) ndr_print_lsa_SetTrustedDomainInfo,
12945                 false,
12946         },
12947         {
12948                 "lsa_DeleteTrustedDomain",
12949                 sizeof(struct lsa_DeleteTrustedDomain),
12950                 (ndr_push_flags_fn_t) ndr_push_lsa_DeleteTrustedDomain,
12951                 (ndr_pull_flags_fn_t) ndr_pull_lsa_DeleteTrustedDomain,
12952                 (ndr_print_function_t) ndr_print_lsa_DeleteTrustedDomain,
12953                 false,
12954         },
12955         {
12956                 "lsa_StorePrivateData",
12957                 sizeof(struct lsa_StorePrivateData),
12958                 (ndr_push_flags_fn_t) ndr_push_lsa_StorePrivateData,
12959                 (ndr_pull_flags_fn_t) ndr_pull_lsa_StorePrivateData,
12960                 (ndr_print_function_t) ndr_print_lsa_StorePrivateData,
12961                 false,
12962         },
12963         {
12964                 "lsa_RetrievePrivateData",
12965                 sizeof(struct lsa_RetrievePrivateData),
12966                 (ndr_push_flags_fn_t) ndr_push_lsa_RetrievePrivateData,
12967                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RetrievePrivateData,
12968                 (ndr_print_function_t) ndr_print_lsa_RetrievePrivateData,
12969                 false,
12970         },
12971         {
12972                 "lsa_OpenPolicy2",
12973                 sizeof(struct lsa_OpenPolicy2),
12974                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenPolicy2,
12975                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenPolicy2,
12976                 (ndr_print_function_t) ndr_print_lsa_OpenPolicy2,
12977                 false,
12978         },
12979         {
12980                 "lsa_GetUserName",
12981                 sizeof(struct lsa_GetUserName),
12982                 (ndr_push_flags_fn_t) ndr_push_lsa_GetUserName,
12983                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetUserName,
12984                 (ndr_print_function_t) ndr_print_lsa_GetUserName,
12985                 false,
12986         },
12987         {
12988                 "lsa_QueryInfoPolicy2",
12989                 sizeof(struct lsa_QueryInfoPolicy2),
12990                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryInfoPolicy2,
12991                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryInfoPolicy2,
12992                 (ndr_print_function_t) ndr_print_lsa_QueryInfoPolicy2,
12993                 false,
12994         },
12995         {
12996                 "lsa_SetInfoPolicy2",
12997                 sizeof(struct lsa_SetInfoPolicy2),
12998                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInfoPolicy2,
12999                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInfoPolicy2,
13000                 (ndr_print_function_t) ndr_print_lsa_SetInfoPolicy2,
13001                 false,
13002         },
13003         {
13004                 "lsa_QueryTrustedDomainInfoByName",
13005                 sizeof(struct lsa_QueryTrustedDomainInfoByName),
13006                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfoByName,
13007                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfoByName,
13008                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfoByName,
13009                 false,
13010         },
13011         {
13012                 "lsa_SetTrustedDomainInfoByName",
13013                 sizeof(struct lsa_SetTrustedDomainInfoByName),
13014                 (ndr_push_flags_fn_t) ndr_push_lsa_SetTrustedDomainInfoByName,
13015                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetTrustedDomainInfoByName,
13016                 (ndr_print_function_t) ndr_print_lsa_SetTrustedDomainInfoByName,
13017                 false,
13018         },
13019         {
13020                 "lsa_EnumTrustedDomainsEx",
13021                 sizeof(struct lsa_EnumTrustedDomainsEx),
13022                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumTrustedDomainsEx,
13023                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumTrustedDomainsEx,
13024                 (ndr_print_function_t) ndr_print_lsa_EnumTrustedDomainsEx,
13025                 false,
13026         },
13027         {
13028                 "lsa_CreateTrustedDomainEx",
13029                 sizeof(struct lsa_CreateTrustedDomainEx),
13030                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomainEx,
13031                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomainEx,
13032                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomainEx,
13033                 false,
13034         },
13035         {
13036                 "lsa_CloseTrustedDomainEx",
13037                 sizeof(struct lsa_CloseTrustedDomainEx),
13038                 (ndr_push_flags_fn_t) ndr_push_lsa_CloseTrustedDomainEx,
13039                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CloseTrustedDomainEx,
13040                 (ndr_print_function_t) ndr_print_lsa_CloseTrustedDomainEx,
13041                 false,
13042         },
13043         {
13044                 "lsa_QueryDomainInformationPolicy",
13045                 sizeof(struct lsa_QueryDomainInformationPolicy),
13046                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryDomainInformationPolicy,
13047                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryDomainInformationPolicy,
13048                 (ndr_print_function_t) ndr_print_lsa_QueryDomainInformationPolicy,
13049                 false,
13050         },
13051         {
13052                 "lsa_SetDomainInformationPolicy",
13053                 sizeof(struct lsa_SetDomainInformationPolicy),
13054                 (ndr_push_flags_fn_t) ndr_push_lsa_SetDomainInformationPolicy,
13055                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetDomainInformationPolicy,
13056                 (ndr_print_function_t) ndr_print_lsa_SetDomainInformationPolicy,
13057                 false,
13058         },
13059         {
13060                 "lsa_OpenTrustedDomainByName",
13061                 sizeof(struct lsa_OpenTrustedDomainByName),
13062                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenTrustedDomainByName,
13063                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenTrustedDomainByName,
13064                 (ndr_print_function_t) ndr_print_lsa_OpenTrustedDomainByName,
13065                 false,
13066         },
13067         {
13068                 "lsa_TestCall",
13069                 sizeof(struct lsa_TestCall),
13070                 (ndr_push_flags_fn_t) ndr_push_lsa_TestCall,
13071                 (ndr_pull_flags_fn_t) ndr_pull_lsa_TestCall,
13072                 (ndr_print_function_t) ndr_print_lsa_TestCall,
13073                 false,
13074         },
13075         {
13076                 "lsa_LookupSids2",
13077                 sizeof(struct lsa_LookupSids2),
13078                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids2,
13079                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids2,
13080                 (ndr_print_function_t) ndr_print_lsa_LookupSids2,
13081                 false,
13082         },
13083         {
13084                 "lsa_LookupNames2",
13085                 sizeof(struct lsa_LookupNames2),
13086                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames2,
13087                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames2,
13088                 (ndr_print_function_t) ndr_print_lsa_LookupNames2,
13089                 false,
13090         },
13091         {
13092                 "lsa_CreateTrustedDomainEx2",
13093                 sizeof(struct lsa_CreateTrustedDomainEx2),
13094                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomainEx2,
13095                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomainEx2,
13096                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomainEx2,
13097                 false,
13098         },
13099         {
13100                 "lsa_CREDRWRITE",
13101                 sizeof(struct lsa_CREDRWRITE),
13102                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRWRITE,
13103                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRWRITE,
13104                 (ndr_print_function_t) ndr_print_lsa_CREDRWRITE,
13105                 false,
13106         },
13107         {
13108                 "lsa_CREDRREAD",
13109                 sizeof(struct lsa_CREDRREAD),
13110                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRREAD,
13111                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRREAD,
13112                 (ndr_print_function_t) ndr_print_lsa_CREDRREAD,
13113                 false,
13114         },
13115         {
13116                 "lsa_CREDRENUMERATE",
13117                 sizeof(struct lsa_CREDRENUMERATE),
13118                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRENUMERATE,
13119                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRENUMERATE,
13120                 (ndr_print_function_t) ndr_print_lsa_CREDRENUMERATE,
13121                 false,
13122         },
13123         {
13124                 "lsa_CREDRWRITEDOMAINCREDENTIALS",
13125                 sizeof(struct lsa_CREDRWRITEDOMAINCREDENTIALS),
13126                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRWRITEDOMAINCREDENTIALS,
13127                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRWRITEDOMAINCREDENTIALS,
13128                 (ndr_print_function_t) ndr_print_lsa_CREDRWRITEDOMAINCREDENTIALS,
13129                 false,
13130         },
13131         {
13132                 "lsa_CREDRREADDOMAINCREDENTIALS",
13133                 sizeof(struct lsa_CREDRREADDOMAINCREDENTIALS),
13134                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRREADDOMAINCREDENTIALS,
13135                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRREADDOMAINCREDENTIALS,
13136                 (ndr_print_function_t) ndr_print_lsa_CREDRREADDOMAINCREDENTIALS,
13137                 false,
13138         },
13139         {
13140                 "lsa_CREDRDELETE",
13141                 sizeof(struct lsa_CREDRDELETE),
13142                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRDELETE,
13143                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRDELETE,
13144                 (ndr_print_function_t) ndr_print_lsa_CREDRDELETE,
13145                 false,
13146         },
13147         {
13148                 "lsa_CREDRGETTARGETINFO",
13149                 sizeof(struct lsa_CREDRGETTARGETINFO),
13150                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRGETTARGETINFO,
13151                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRGETTARGETINFO,
13152                 (ndr_print_function_t) ndr_print_lsa_CREDRGETTARGETINFO,
13153                 false,
13154         },
13155         {
13156                 "lsa_CREDRPROFILELOADED",
13157                 sizeof(struct lsa_CREDRPROFILELOADED),
13158                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRPROFILELOADED,
13159                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRPROFILELOADED,
13160                 (ndr_print_function_t) ndr_print_lsa_CREDRPROFILELOADED,
13161                 false,
13162         },
13163         {
13164                 "lsa_LookupNames3",
13165                 sizeof(struct lsa_LookupNames3),
13166                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames3,
13167                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames3,
13168                 (ndr_print_function_t) ndr_print_lsa_LookupNames3,
13169                 false,
13170         },
13171         {
13172                 "lsa_CREDRGETSESSIONTYPES",
13173                 sizeof(struct lsa_CREDRGETSESSIONTYPES),
13174                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRGETSESSIONTYPES,
13175                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRGETSESSIONTYPES,
13176                 (ndr_print_function_t) ndr_print_lsa_CREDRGETSESSIONTYPES,
13177                 false,
13178         },
13179         {
13180                 "lsa_LSARREGISTERAUDITEVENT",
13181                 sizeof(struct lsa_LSARREGISTERAUDITEVENT),
13182                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARREGISTERAUDITEVENT,
13183                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARREGISTERAUDITEVENT,
13184                 (ndr_print_function_t) ndr_print_lsa_LSARREGISTERAUDITEVENT,
13185                 false,
13186         },
13187         {
13188                 "lsa_LSARGENAUDITEVENT",
13189                 sizeof(struct lsa_LSARGENAUDITEVENT),
13190                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARGENAUDITEVENT,
13191                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARGENAUDITEVENT,
13192                 (ndr_print_function_t) ndr_print_lsa_LSARGENAUDITEVENT,
13193                 false,
13194         },
13195         {
13196                 "lsa_LSARUNREGISTERAUDITEVENT",
13197                 sizeof(struct lsa_LSARUNREGISTERAUDITEVENT),
13198                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARUNREGISTERAUDITEVENT,
13199                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARUNREGISTERAUDITEVENT,
13200                 (ndr_print_function_t) ndr_print_lsa_LSARUNREGISTERAUDITEVENT,
13201                 false,
13202         },
13203         {
13204                 "lsa_lsaRQueryForestTrustInformation",
13205                 sizeof(struct lsa_lsaRQueryForestTrustInformation),
13206                 (ndr_push_flags_fn_t) ndr_push_lsa_lsaRQueryForestTrustInformation,
13207                 (ndr_pull_flags_fn_t) ndr_pull_lsa_lsaRQueryForestTrustInformation,
13208                 (ndr_print_function_t) ndr_print_lsa_lsaRQueryForestTrustInformation,
13209                 false,
13210         },
13211         {
13212                 "lsa_LSARSETFORESTTRUSTINFORMATION",
13213                 sizeof(struct lsa_LSARSETFORESTTRUSTINFORMATION),
13214                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARSETFORESTTRUSTINFORMATION,
13215                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARSETFORESTTRUSTINFORMATION,
13216                 (ndr_print_function_t) ndr_print_lsa_LSARSETFORESTTRUSTINFORMATION,
13217                 false,
13218         },
13219         {
13220                 "lsa_CREDRRENAME",
13221                 sizeof(struct lsa_CREDRRENAME),
13222                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRRENAME,
13223                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRRENAME,
13224                 (ndr_print_function_t) ndr_print_lsa_CREDRRENAME,
13225                 false,
13226         },
13227         {
13228                 "lsa_LookupSids3",
13229                 sizeof(struct lsa_LookupSids3),
13230                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids3,
13231                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids3,
13232                 (ndr_print_function_t) ndr_print_lsa_LookupSids3,
13233                 false,
13234         },
13235         {
13236                 "lsa_LookupNames4",
13237                 sizeof(struct lsa_LookupNames4),
13238                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames4,
13239                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames4,
13240                 (ndr_print_function_t) ndr_print_lsa_LookupNames4,
13241                 false,
13242         },
13243         {
13244                 "lsa_LSAROPENPOLICYSCE",
13245                 sizeof(struct lsa_LSAROPENPOLICYSCE),
13246                 (ndr_push_flags_fn_t) ndr_push_lsa_LSAROPENPOLICYSCE,
13247                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSAROPENPOLICYSCE,
13248                 (ndr_print_function_t) ndr_print_lsa_LSAROPENPOLICYSCE,
13249                 false,
13250         },
13251         {
13252                 "lsa_LSARADTREGISTERSECURITYEVENTSOURCE",
13253                 sizeof(struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE),
13254                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
13255                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
13256                 (ndr_print_function_t) ndr_print_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
13257                 false,
13258         },
13259         {
13260                 "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE",
13261                 sizeof(struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE),
13262                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
13263                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
13264                 (ndr_print_function_t) ndr_print_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
13265                 false,
13266         },
13267         {
13268                 "lsa_LSARADTREPORTSECURITYEVENT",
13269                 sizeof(struct lsa_LSARADTREPORTSECURITYEVENT),
13270                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTREPORTSECURITYEVENT,
13271                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTREPORTSECURITYEVENT,
13272                 (ndr_print_function_t) ndr_print_lsa_LSARADTREPORTSECURITYEVENT,
13273                 false,
13274         },
13275         { NULL, 0, NULL, NULL, NULL, false }
13276 };
13277
13278 static const char * const lsarpc_endpoint_strings[] = {
13279         "ncacn_np:[\\pipe\\lsarpc]",
13280         "ncacn_np:[\\pipe\\netlogon]",
13281         "ncacn_np:[\\pipe\\lsass]",
13282         "ncacn_ip_tcp:",
13283         "ncalrpc:",
13284 };
13285
13286 static const struct ndr_interface_string_array lsarpc_endpoints = {
13287         .count  = 5,
13288         .names  = lsarpc_endpoint_strings
13289 };
13290
13291 static const char * const lsarpc_authservice_strings[] = {
13292         "host",
13293 };
13294
13295 static const struct ndr_interface_string_array lsarpc_authservices = {
13296         .count  = 1,
13297         .names  = lsarpc_authservice_strings
13298 };
13299
13300
13301 const struct ndr_interface_table ndr_table_lsarpc = {
13302         .name           = "lsarpc",
13303         .syntax_id      = {
13304                 {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
13305                 NDR_LSARPC_VERSION
13306         },
13307         .helpstring     = NDR_LSARPC_HELPSTRING,
13308         .num_calls      = 82,
13309         .calls          = lsarpc_calls,
13310         .endpoints      = &lsarpc_endpoints,
13311         .authservices   = &lsarpc_authservices
13312 };
13313