source3/librpc/gen_ndr/ndr_lsa.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_lsa.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 _PUBLIC_ NTSTATUS ndr_push_lsa_String(struct ndr_push *ndr, int ndr_flags, const struct lsa_String *r)
   8 {
   9         if (ndr_flags & NDR_SCALARS) {
  10                 NDR_CHECK(ndr_push_align(ndr, 4));
  11                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  12                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  13                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
  14         }
  15         if (ndr_flags & NDR_BUFFERS) {
  16                 if (r->string) {
  17                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m(r->string) / 2));
  18                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  19                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m(r->string) / 2));
  20                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, 2 * strlen_m(r->string) / 2, sizeof(uint16_t), CH_UTF16));
  21                 }
  22         }
  23         return NT_STATUS_OK;
  24 }
  25
  26 _PUBLIC_ NTSTATUS ndr_pull_lsa_String(struct ndr_pull *ndr, int ndr_flags, struct lsa_String *r)
  27 {
  28         uint32_t _ptr_string;
  29         TALLOC_CTX *_mem_save_string_0;
  30         if (ndr_flags & NDR_SCALARS) {
  31                 NDR_CHECK(ndr_pull_align(ndr, 4));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
  34                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
  35                 if (_ptr_string) {
  36                         NDR_PULL_ALLOC(ndr, r->string);
  37                 } else {
  38                         r->string = NULL;
  39                 }
  40         }
  41         if (ndr_flags & NDR_BUFFERS) {
  42                 if (r->string) {
  43                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
  44                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
  45                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
  46                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
  47                         if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
  48                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string), ndr_get_array_length(ndr, &r->string));
  49                         }
  50                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
  51                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
  52                 }
  53                 if (r->string) {
  54                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
  55                 }
  56                 if (r->string) {
  57                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->string, r->length / 2));
  58                 }
  59         }
  60         return NT_STATUS_OK;
  61 }
  62
  63 _PUBLIC_ void ndr_print_lsa_String(struct ndr_print *ndr, const char *name, const struct lsa_String *r)
  64 {
  65         ndr_print_struct(ndr, name, "lsa_String");
  66         ndr->depth++;
  67         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->length);
  68         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->size);
  69         ndr_print_ptr(ndr, "string", r->string);
  70         ndr->depth++;
  71         if (r->string) {
  72                 ndr_print_string(ndr, "string", r->string);
  73         }
  74         ndr->depth--;
  75         ndr->depth--;
  76 }
  77
  78 _PUBLIC_ NTSTATUS ndr_push_lsa_StringLarge(struct ndr_push *ndr, int ndr_flags, const struct lsa_StringLarge *r)
  79 {
  80         if (ndr_flags & NDR_SCALARS) {
  81                 NDR_CHECK(ndr_push_align(ndr, 4));
  82                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  83                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * (strlen_m(r->string) + 1)));
  84                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
  85         }
  86         if (ndr_flags & NDR_BUFFERS) {
  87                 if (r->string) {
  88                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * (strlen_m(r->string) + 1) / 2));
  89                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  90                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m(r->string) / 2));
  91                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, 2 * strlen_m(r->string) / 2, sizeof(uint16_t), CH_UTF16));
  92                 }
  93         }
  94         return NT_STATUS_OK;
  95 }
  96
  97 _PUBLIC_ NTSTATUS ndr_pull_lsa_StringLarge(struct ndr_pull *ndr, int ndr_flags, struct lsa_StringLarge *r)
  98 {
  99         uint32_t _ptr_string;
 100         TALLOC_CTX *_mem_save_string_0;
 101         if (ndr_flags & NDR_SCALARS) {
 102                 NDR_CHECK(ndr_pull_align(ndr, 4));
 103                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 104                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
 106                 if (_ptr_string) {
 107                         NDR_PULL_ALLOC(ndr, r->string);
 108                 } else {
 109                         r->string = NULL;
 110                 }
 111         }
 112         if (ndr_flags & NDR_BUFFERS) {
 113                 if (r->string) {
 114                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
 115                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
 116                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
 117                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
 118                         if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
 119                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string), ndr_get_array_length(ndr, &r->string));
 120                         }
 121                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
 122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
 123                 }
 124                 if (r->string) {
 125                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
 126                 }
 127                 if (r->string) {
 128                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->string, r->length / 2));
 129                 }
 130         }
 131         return NT_STATUS_OK;
 132 }
 133
 134 _PUBLIC_ void ndr_print_lsa_StringLarge(struct ndr_print *ndr, const char *name, const struct lsa_StringLarge *r)
 135 {
 136         ndr_print_struct(ndr, name, "lsa_StringLarge");
 137         ndr->depth++;
 138         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->length);
 139         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * (strlen_m(r->string) + 1):r->size);
 140         ndr_print_ptr(ndr, "string", r->string);
 141         ndr->depth++;
 142         if (r->string) {
 143                 ndr_print_string(ndr, "string", r->string);
 144         }
 145         ndr->depth--;
 146         ndr->depth--;
 147 }
 148
 149 _PUBLIC_ NTSTATUS ndr_push_lsa_Strings(struct ndr_push *ndr, int ndr_flags, const struct lsa_Strings *r)
 150 {
 151         uint32_t cntr_names_1;
 152         if (ndr_flags & NDR_SCALARS) {
 153                 NDR_CHECK(ndr_push_align(ndr, 4));
 154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
 156         }
 157         if (ndr_flags & NDR_BUFFERS) {
 158                 if (r->names) {
 159                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 160                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 161                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
 162                         }
 163                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 164                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
 165                         }
 166                 }
 167         }
 168         return NT_STATUS_OK;
 169 }
 170
 171 _PUBLIC_ NTSTATUS ndr_pull_lsa_Strings(struct ndr_pull *ndr, int ndr_flags, struct lsa_Strings *r)
 172 {
 173         uint32_t _ptr_names;
 174         uint32_t cntr_names_1;
 175         TALLOC_CTX *_mem_save_names_0;
 176         TALLOC_CTX *_mem_save_names_1;
 177         if (ndr_flags & NDR_SCALARS) {
 178                 NDR_CHECK(ndr_pull_align(ndr, 4));
 179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
 181                 if (_ptr_names) {
 182                         NDR_PULL_ALLOC(ndr, r->names);
 183                 } else {
 184                         r->names = NULL;
 185                 }
 186         }
 187         if (ndr_flags & NDR_BUFFERS) {
 188                 if (r->names) {
 189                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
 190                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
 191                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
 192                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
 193                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
 194                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
 195                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 196                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
 197                         }
 198                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
 199                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
 200                         }
 201                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
 202                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
 203                 }
 204                 if (r->names) {
 205                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
 206                 }
 207         }
 208         return NT_STATUS_OK;
 209 }
 210
 211 _PUBLIC_ void ndr_print_lsa_Strings(struct ndr_print *ndr, const char *name, const struct lsa_Strings *r)
 212 {
 213         uint32_t cntr_names_1;
 214         ndr_print_struct(ndr, name, "lsa_Strings");
 215         ndr->depth++;
 216         ndr_print_uint32(ndr, "count", r->count);
 217         ndr_print_ptr(ndr, "names", r->names);
 218         ndr->depth++;
 219         if (r->names) {
 220                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->count);
 221                 ndr->depth++;
 222                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
 223                         char *idx_1=NULL;
 224                         asprintf(&idx_1, "[%d]", cntr_names_1);
 225                         if (idx_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_ NTSTATUS 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                 {
 243                         uint32_t _flags_save_string = ndr->flags;
 244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_LEN4);
 245                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
 246                         ndr->flags = _flags_save_string;
 247                 }
 248         }
 249         if (ndr_flags & NDR_BUFFERS) {
 250                 {
 251                         uint32_t _flags_save_string = ndr->flags;
 252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_LEN4);
 253                         if (r->string) {
 254                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
 255                         }
 256                         ndr->flags = _flags_save_string;
 257                 }
 258         }
 259         return NT_STATUS_OK;
 260 }
 261
 262 _PUBLIC_ NTSTATUS ndr_pull_lsa_AsciiString(struct ndr_pull *ndr, int ndr_flags, struct lsa_AsciiString *r)
 263 {
 264         uint32_t _ptr_string;
 265         TALLOC_CTX *_mem_save_string_0;
 266         if (ndr_flags & NDR_SCALARS) {
 267                 NDR_CHECK(ndr_pull_align(ndr, 4));
 268                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 269                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 270                 {
 271                         uint32_t _flags_save_string = ndr->flags;
 272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_LEN4);
 273                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
 274                         if (_ptr_string) {
 275                                 NDR_PULL_ALLOC(ndr, r->string);
 276                         } else {
 277                                 r->string = NULL;
 278                         }
 279                         ndr->flags = _flags_save_string;
 280                 }
 281         }
 282         if (ndr_flags & NDR_BUFFERS) {
 283                 {
 284                         uint32_t _flags_save_string = ndr->flags;
 285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_LEN4);
 286                         if (r->string) {
 287                                 _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
 288                                 NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
 289                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
 290                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
 291                         }
 292                         ndr->flags = _flags_save_string;
 293                 }
 294         }
 295         return NT_STATUS_OK;
 296 }
 297
 298 _PUBLIC_ void ndr_print_lsa_AsciiString(struct ndr_print *ndr, const char *name, const struct lsa_AsciiString *r)
 299 {
 300         ndr_print_struct(ndr, name, "lsa_AsciiString");
 301         ndr->depth++;
 302         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->length);
 303         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->size);
 304         ndr_print_ptr(ndr, "string", r->string);
 305         ndr->depth++;
 306         if (r->string) {
 307                 ndr_print_string(ndr, "string", r->string);
 308         }
 309         ndr->depth--;
 310         ndr->depth--;
 311 }
 312
 313 NTSTATUS ndr_push_lsa_LUID(struct ndr_push *ndr, int ndr_flags, const struct lsa_LUID *r)
 314 {
 315         if (ndr_flags & NDR_SCALARS) {
 316                 NDR_CHECK(ndr_push_align(ndr, 4));
 317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->low));
 318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high));
 319         }
 320         if (ndr_flags & NDR_BUFFERS) {
 321         }
 322         return NT_STATUS_OK;
 323 }
 324
 325 NTSTATUS ndr_pull_lsa_LUID(struct ndr_pull *ndr, int ndr_flags, struct lsa_LUID *r)
 326 {
 327         if (ndr_flags & NDR_SCALARS) {
 328                 NDR_CHECK(ndr_pull_align(ndr, 4));
 329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->low));
 330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high));
 331         }
 332         if (ndr_flags & NDR_BUFFERS) {
 333         }
 334         return NT_STATUS_OK;
 335 }
 336
 337 _PUBLIC_ void ndr_print_lsa_LUID(struct ndr_print *ndr, const char *name, const struct lsa_LUID *r)
 338 {
 339         ndr_print_struct(ndr, name, "lsa_LUID");
 340         ndr->depth++;
 341         ndr_print_uint32(ndr, "low", r->low);
 342         ndr_print_uint32(ndr, "high", r->high);
 343         ndr->depth--;
 344 }
 345
 346 NTSTATUS ndr_push_lsa_PrivEntry(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivEntry *r)
 347 {
 348         if (ndr_flags & NDR_SCALARS) {
 349                 NDR_CHECK(ndr_push_align(ndr, 4));
 350                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 351                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
 352         }
 353         if (ndr_flags & NDR_BUFFERS) {
 354                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 355         }
 356         return NT_STATUS_OK;
 357 }
 358
 359 NTSTATUS ndr_pull_lsa_PrivEntry(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivEntry *r)
 360 {
 361         if (ndr_flags & NDR_SCALARS) {
 362                 NDR_CHECK(ndr_pull_align(ndr, 4));
 363                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 364                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
 365         }
 366         if (ndr_flags & NDR_BUFFERS) {
 367                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 368         }
 369         return NT_STATUS_OK;
 370 }
 371
 372 _PUBLIC_ void ndr_print_lsa_PrivEntry(struct ndr_print *ndr, const char *name, const struct lsa_PrivEntry *r)
 373 {
 374         ndr_print_struct(ndr, name, "lsa_PrivEntry");
 375         ndr->depth++;
 376         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
 377         ndr_print_lsa_LUID(ndr, "luid", &r->luid);
 378         ndr->depth--;
 379 }
 380
 381 NTSTATUS ndr_push_lsa_PrivArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivArray *r)
 382 {
 383         uint32_t cntr_privs_1;
 384         if (ndr_flags & NDR_SCALARS) {
 385                 NDR_CHECK(ndr_push_align(ndr, 4));
 386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->privs));
 388         }
 389         if (ndr_flags & NDR_BUFFERS) {
 390                 if (r->privs) {
 391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 392                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 393                                 NDR_CHECK(ndr_push_lsa_PrivEntry(ndr, NDR_SCALARS, &r->privs[cntr_privs_1]));
 394                         }
 395                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 396                                 NDR_CHECK(ndr_push_lsa_PrivEntry(ndr, NDR_BUFFERS, &r->privs[cntr_privs_1]));
 397                         }
 398                 }
 399         }
 400         return NT_STATUS_OK;
 401 }
 402
 403 NTSTATUS ndr_pull_lsa_PrivArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivArray *r)
 404 {
 405         uint32_t _ptr_privs;
 406         uint32_t cntr_privs_1;
 407         TALLOC_CTX *_mem_save_privs_0;
 408         TALLOC_CTX *_mem_save_privs_1;
 409         if (ndr_flags & NDR_SCALARS) {
 410                 NDR_CHECK(ndr_pull_align(ndr, 4));
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 412                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
 413                 if (_ptr_privs) {
 414                         NDR_PULL_ALLOC(ndr, r->privs);
 415                 } else {
 416                         r->privs = NULL;
 417                 }
 418         }
 419         if (ndr_flags & NDR_BUFFERS) {
 420                 if (r->privs) {
 421                         _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
 422                         NDR_PULL_SET_MEM_CTX(ndr, r->privs, 0);
 423                         NDR_CHECK(ndr_pull_array_size(ndr, &r->privs));
 424                         NDR_PULL_ALLOC_N(ndr, r->privs, ndr_get_array_size(ndr, &r->privs));
 425                         _mem_save_privs_1 = NDR_PULL_GET_MEM_CTX(ndr);
 426                         NDR_PULL_SET_MEM_CTX(ndr, r->privs, 0);
 427                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 428                                 NDR_CHECK(ndr_pull_lsa_PrivEntry(ndr, NDR_SCALARS, &r->privs[cntr_privs_1]));
 429                         }
 430                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 431                                 NDR_CHECK(ndr_pull_lsa_PrivEntry(ndr, NDR_BUFFERS, &r->privs[cntr_privs_1]));
 432                         }
 433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_1, 0);
 434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, 0);
 435                 }
 436                 if (r->privs) {
 437                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->privs, r->count));
 438                 }
 439         }
 440         return NT_STATUS_OK;
 441 }
 442
 443 _PUBLIC_ void ndr_print_lsa_PrivArray(struct ndr_print *ndr, const char *name, const struct lsa_PrivArray *r)
 444 {
 445         uint32_t cntr_privs_1;
 446         ndr_print_struct(ndr, name, "lsa_PrivArray");
 447         ndr->depth++;
 448         ndr_print_uint32(ndr, "count", r->count);
 449         ndr_print_ptr(ndr, "privs", r->privs);
 450         ndr->depth++;
 451         if (r->privs) {
 452                 ndr->print(ndr, "%s: ARRAY(%d)", "privs", r->count);
 453                 ndr->depth++;
 454                 for (cntr_privs_1=0;cntr_privs_1<r->count;cntr_privs_1++) {
 455                         char *idx_1=NULL;
 456                         asprintf(&idx_1, "[%d]", cntr_privs_1);
 457                         if (idx_1) {
 458                                 ndr_print_lsa_PrivEntry(ndr, "privs", &r->privs[cntr_privs_1]);
 459                                 free(idx_1);
 460                         }
 461                 }
 462                 ndr->depth--;
 463         }
 464         ndr->depth--;
 465         ndr->depth--;
 466 }
 467
 468 NTSTATUS ndr_push_lsa_QosInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_QosInfo *r)
 469 {
 470         if (ndr_flags & NDR_SCALARS) {
 471                 NDR_CHECK(ndr_push_align(ndr, 4));
 472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
 473                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->impersonation_level));
 474                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->context_mode));
 475                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->effective_only));
 476         }
 477         if (ndr_flags & NDR_BUFFERS) {
 478         }
 479         return NT_STATUS_OK;
 480 }
 481
 482 NTSTATUS ndr_pull_lsa_QosInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_QosInfo *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->len));
 487                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->impersonation_level));
 488                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->context_mode));
 489                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->effective_only));
 490         }
 491         if (ndr_flags & NDR_BUFFERS) {
 492         }
 493         return NT_STATUS_OK;
 494 }
 495
 496 _PUBLIC_ void ndr_print_lsa_QosInfo(struct ndr_print *ndr, const char *name, const struct lsa_QosInfo *r)
 497 {
 498         ndr_print_struct(ndr, name, "lsa_QosInfo");
 499         ndr->depth++;
 500         ndr_print_uint32(ndr, "len", r->len);
 501         ndr_print_uint16(ndr, "impersonation_level", r->impersonation_level);
 502         ndr_print_uint8(ndr, "context_mode", r->context_mode);
 503         ndr_print_uint8(ndr, "effective_only", r->effective_only);
 504         ndr->depth--;
 505 }
 506
 507 NTSTATUS ndr_push_lsa_ObjectAttribute(struct ndr_push *ndr, int ndr_flags, const struct lsa_ObjectAttribute *r)
 508 {
 509         if (ndr_flags & NDR_SCALARS) {
 510                 NDR_CHECK(ndr_push_align(ndr, 4));
 511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
 512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->root_dir));
 513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_name));
 514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attributes));
 515                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sec_desc));
 516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sec_qos));
 517         }
 518         if (ndr_flags & NDR_BUFFERS) {
 519                 if (r->root_dir) {
 520                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->root_dir));
 521                 }
 522                 if (r->object_name) {
 523                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_name, CH_UTF16)));
 524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_name, CH_UTF16)));
 526                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_name, ndr_charset_length(r->object_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 527                 }
 528                 if (r->sec_desc) {
 529                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sec_desc));
 530                 }
 531                 if (r->sec_qos) {
 532                         NDR_CHECK(ndr_push_lsa_QosInfo(ndr, NDR_SCALARS, r->sec_qos));
 533                 }
 534         }
 535         return NT_STATUS_OK;
 536 }
 537
 538 NTSTATUS ndr_pull_lsa_ObjectAttribute(struct ndr_pull *ndr, int ndr_flags, struct lsa_ObjectAttribute *r)
 539 {
 540         uint32_t _ptr_root_dir;
 541         TALLOC_CTX *_mem_save_root_dir_0;
 542         uint32_t _ptr_object_name;
 543         TALLOC_CTX *_mem_save_object_name_0;
 544         uint32_t _ptr_sec_desc;
 545         TALLOC_CTX *_mem_save_sec_desc_0;
 546         uint32_t _ptr_sec_qos;
 547         TALLOC_CTX *_mem_save_sec_qos_0;
 548         if (ndr_flags & NDR_SCALARS) {
 549                 NDR_CHECK(ndr_pull_align(ndr, 4));
 550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
 551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_root_dir));
 552                 if (_ptr_root_dir) {
 553                         NDR_PULL_ALLOC(ndr, r->root_dir);
 554                 } else {
 555                         r->root_dir = NULL;
 556                 }
 557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_name));
 558                 if (_ptr_object_name) {
 559                         NDR_PULL_ALLOC(ndr, r->object_name);
 560                 } else {
 561                         r->object_name = NULL;
 562                 }
 563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attributes));
 564                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_desc));
 565                 if (_ptr_sec_desc) {
 566                         NDR_PULL_ALLOC(ndr, r->sec_desc);
 567                 } else {
 568                         r->sec_desc = NULL;
 569                 }
 570                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_qos));
 571                 if (_ptr_sec_qos) {
 572                         NDR_PULL_ALLOC(ndr, r->sec_qos);
 573                 } else {
 574                         r->sec_qos = NULL;
 575                 }
 576         }
 577         if (ndr_flags & NDR_BUFFERS) {
 578                 if (r->root_dir) {
 579                         _mem_save_root_dir_0 = NDR_PULL_GET_MEM_CTX(ndr);
 580                         NDR_PULL_SET_MEM_CTX(ndr, r->root_dir, 0);
 581                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->root_dir));
 582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_root_dir_0, 0);
 583                 }
 584                 if (r->object_name) {
 585                         _mem_save_object_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 586                         NDR_PULL_SET_MEM_CTX(ndr, r->object_name, 0);
 587                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_name));
 588                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_name));
 589                         if (ndr_get_array_length(ndr, &r->object_name) > ndr_get_array_size(ndr, &r->object_name)) {
 590                                 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));
 591                         }
 592                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_name), sizeof(uint16_t)));
 593                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_name, ndr_get_array_length(ndr, &r->object_name), sizeof(uint16_t), CH_UTF16));
 594                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_name_0, 0);
 595                 }
 596                 if (r->sec_desc) {
 597                         _mem_save_sec_desc_0 = NDR_PULL_GET_MEM_CTX(ndr);
 598                         NDR_PULL_SET_MEM_CTX(ndr, r->sec_desc, 0);
 599                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sec_desc));
 600                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_desc_0, 0);
 601                 }
 602                 if (r->sec_qos) {
 603                         _mem_save_sec_qos_0 = NDR_PULL_GET_MEM_CTX(ndr);
 604                         NDR_PULL_SET_MEM_CTX(ndr, r->sec_qos, 0);
 605                         NDR_CHECK(ndr_pull_lsa_QosInfo(ndr, NDR_SCALARS, r->sec_qos));
 606                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_qos_0, 0);
 607                 }
 608         }
 609         return NT_STATUS_OK;
 610 }
 611
 612 _PUBLIC_ void ndr_print_lsa_ObjectAttribute(struct ndr_print *ndr, const char *name, const struct lsa_ObjectAttribute *r)
 613 {
 614         ndr_print_struct(ndr, name, "lsa_ObjectAttribute");
 615         ndr->depth++;
 616         ndr_print_uint32(ndr, "len", r->len);
 617         ndr_print_ptr(ndr, "root_dir", r->root_dir);
 618         ndr->depth++;
 619         if (r->root_dir) {
 620                 ndr_print_uint8(ndr, "root_dir", *r->root_dir);
 621         }
 622         ndr->depth--;
 623         ndr_print_ptr(ndr, "object_name", r->object_name);
 624         ndr->depth++;
 625         if (r->object_name) {
 626                 ndr_print_string(ndr, "object_name", r->object_name);
 627         }
 628         ndr->depth--;
 629         ndr_print_uint32(ndr, "attributes", r->attributes);
 630         ndr_print_ptr(ndr, "sec_desc", r->sec_desc);
 631         ndr->depth++;
 632         if (r->sec_desc) {
 633                 ndr_print_security_descriptor(ndr, "sec_desc", r->sec_desc);
 634         }
 635         ndr->depth--;
 636         ndr_print_ptr(ndr, "sec_qos", r->sec_qos);
 637         ndr->depth++;
 638         if (r->sec_qos) {
 639                 ndr_print_lsa_QosInfo(ndr, "sec_qos", r->sec_qos);
 640         }
 641         ndr->depth--;
 642         ndr->depth--;
 643 }
 644
 645 NTSTATUS ndr_push_lsa_AuditLogInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditLogInfo *r)
 646 {
 647         if (ndr_flags & NDR_SCALARS) {
 648                 NDR_CHECK(ndr_push_align(ndr, 4));
 649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->percent_full));
 650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->log_size));
 651                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->retention_time));
 652                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_in_progress));
 653                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time_to_shutdown));
 654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_audit_record));
 655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
 656         }
 657         if (ndr_flags & NDR_BUFFERS) {
 658         }
 659         return NT_STATUS_OK;
 660 }
 661
 662 NTSTATUS ndr_pull_lsa_AuditLogInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditLogInfo *r)
 663 {
 664         if (ndr_flags & NDR_SCALARS) {
 665                 NDR_CHECK(ndr_pull_align(ndr, 4));
 666                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->percent_full));
 667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->log_size));
 668                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->retention_time));
 669                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_in_progress));
 670                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time_to_shutdown));
 671                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_audit_record));
 672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
 673         }
 674         if (ndr_flags & NDR_BUFFERS) {
 675         }
 676         return NT_STATUS_OK;
 677 }
 678
 679 _PUBLIC_ void ndr_print_lsa_AuditLogInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditLogInfo *r)
 680 {
 681         ndr_print_struct(ndr, name, "lsa_AuditLogInfo");
 682         ndr->depth++;
 683         ndr_print_uint32(ndr, "percent_full", r->percent_full);
 684         ndr_print_uint32(ndr, "log_size", r->log_size);
 685         ndr_print_NTTIME(ndr, "retention_time", r->retention_time);
 686         ndr_print_uint8(ndr, "shutdown_in_progress", r->shutdown_in_progress);
 687         ndr_print_NTTIME(ndr, "time_to_shutdown", r->time_to_shutdown);
 688         ndr_print_uint32(ndr, "next_audit_record", r->next_audit_record);
 689         ndr_print_uint32(ndr, "unknown", r->unknown);
 690         ndr->depth--;
 691 }
 692
 693 NTSTATUS ndr_push_lsa_AuditEventsInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditEventsInfo *r)
 694 {
 695         uint32_t cntr_settings_1;
 696         if (ndr_flags & NDR_SCALARS) {
 697                 NDR_CHECK(ndr_push_align(ndr, 4));
 698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditing_mode));
 699                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->settings));
 700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 701         }
 702         if (ndr_flags & NDR_BUFFERS) {
 703                 if (r->settings) {
 704                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 705                         for (cntr_settings_1 = 0; cntr_settings_1 < r->count; cntr_settings_1++) {
 706                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->settings[cntr_settings_1]));
 707                         }
 708                 }
 709         }
 710         return NT_STATUS_OK;
 711 }
 712
 713 NTSTATUS ndr_pull_lsa_AuditEventsInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditEventsInfo *r)
 714 {
 715         uint32_t _ptr_settings;
 716         uint32_t cntr_settings_1;
 717         TALLOC_CTX *_mem_save_settings_0;
 718         TALLOC_CTX *_mem_save_settings_1;
 719         if (ndr_flags & NDR_SCALARS) {
 720                 NDR_CHECK(ndr_pull_align(ndr, 4));
 721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditing_mode));
 722                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_settings));
 723                 if (_ptr_settings) {
 724                         NDR_PULL_ALLOC(ndr, r->settings);
 725                 } else {
 726                         r->settings = NULL;
 727                 }
 728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 729         }
 730         if (ndr_flags & NDR_BUFFERS) {
 731                 if (r->settings) {
 732                         _mem_save_settings_0 = NDR_PULL_GET_MEM_CTX(ndr);
 733                         NDR_PULL_SET_MEM_CTX(ndr, r->settings, 0);
 734                         NDR_CHECK(ndr_pull_array_size(ndr, &r->settings));
 735                         NDR_PULL_ALLOC_N(ndr, r->settings, ndr_get_array_size(ndr, &r->settings));
 736                         _mem_save_settings_1 = NDR_PULL_GET_MEM_CTX(ndr);
 737                         NDR_PULL_SET_MEM_CTX(ndr, r->settings, 0);
 738                         for (cntr_settings_1 = 0; cntr_settings_1 < r->count; cntr_settings_1++) {
 739                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->settings[cntr_settings_1]));
 740                         }
 741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_settings_1, 0);
 742                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_settings_0, 0);
 743                 }
 744                 if (r->settings) {
 745                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->settings, r->count));
 746                 }
 747         }
 748         return NT_STATUS_OK;
 749 }
 750
 751 _PUBLIC_ void ndr_print_lsa_AuditEventsInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditEventsInfo *r)
 752 {
 753         uint32_t cntr_settings_1;
 754         ndr_print_struct(ndr, name, "lsa_AuditEventsInfo");
 755         ndr->depth++;
 756         ndr_print_uint32(ndr, "auditing_mode", r->auditing_mode);
 757         ndr_print_ptr(ndr, "settings", r->settings);
 758         ndr->depth++;
 759         if (r->settings) {
 760                 ndr->print(ndr, "%s: ARRAY(%d)", "settings", r->count);
 761                 ndr->depth++;
 762                 for (cntr_settings_1=0;cntr_settings_1<r->count;cntr_settings_1++) {
 763                         char *idx_1=NULL;
 764                         asprintf(&idx_1, "[%d]", cntr_settings_1);
 765                         if (idx_1) {
 766                                 ndr_print_uint32(ndr, "settings", r->settings[cntr_settings_1]);
 767                                 free(idx_1);
 768                         }
 769                 }
 770                 ndr->depth--;
 771         }
 772         ndr->depth--;
 773         ndr_print_uint32(ndr, "count", r->count);
 774         ndr->depth--;
 775 }
 776
 777 NTSTATUS ndr_push_lsa_DomainInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfo *r)
 778 {
 779         if (ndr_flags & NDR_SCALARS) {
 780                 NDR_CHECK(ndr_push_align(ndr, 4));
 781                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 782                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
 783         }
 784         if (ndr_flags & NDR_BUFFERS) {
 785                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 786                 if (r->sid) {
 787                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 788                 }
 789         }
 790         return NT_STATUS_OK;
 791 }
 792
 793 NTSTATUS ndr_pull_lsa_DomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfo *r)
 794 {
 795         uint32_t _ptr_sid;
 796         TALLOC_CTX *_mem_save_sid_0;
 797         if (ndr_flags & NDR_SCALARS) {
 798                 NDR_CHECK(ndr_pull_align(ndr, 4));
 799                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 801                 if (_ptr_sid) {
 802                         NDR_PULL_ALLOC(ndr, r->sid);
 803                 } else {
 804                         r->sid = NULL;
 805                 }
 806         }
 807         if (ndr_flags & NDR_BUFFERS) {
 808                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 809                 if (r->sid) {
 810                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 811                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
 812                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 813                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
 814                 }
 815         }
 816         return NT_STATUS_OK;
 817 }
 818
 819 _PUBLIC_ void ndr_print_lsa_DomainInfo(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfo *r)
 820 {
 821         ndr_print_struct(ndr, name, "lsa_DomainInfo");
 822         ndr->depth++;
 823         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
 824         ndr_print_ptr(ndr, "sid", r->sid);
 825         ndr->depth++;
 826         if (r->sid) {
 827                 ndr_print_dom_sid2(ndr, "sid", r->sid);
 828         }
 829         ndr->depth--;
 830         ndr->depth--;
 831 }
 832
 833 NTSTATUS ndr_push_lsa_PDAccountInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_PDAccountInfo *r)
 834 {
 835         if (ndr_flags & NDR_SCALARS) {
 836                 NDR_CHECK(ndr_push_align(ndr, 4));
 837                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 838         }
 839         if (ndr_flags & NDR_BUFFERS) {
 840                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 841         }
 842         return NT_STATUS_OK;
 843 }
 844
 845 NTSTATUS ndr_pull_lsa_PDAccountInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_PDAccountInfo *r)
 846 {
 847         if (ndr_flags & NDR_SCALARS) {
 848                 NDR_CHECK(ndr_pull_align(ndr, 4));
 849                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 850         }
 851         if (ndr_flags & NDR_BUFFERS) {
 852                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 853         }
 854         return NT_STATUS_OK;
 855 }
 856
 857 _PUBLIC_ void ndr_print_lsa_PDAccountInfo(struct ndr_print *ndr, const char *name, const struct lsa_PDAccountInfo *r)
 858 {
 859         ndr_print_struct(ndr, name, "lsa_PDAccountInfo");
 860         ndr->depth++;
 861         ndr_print_lsa_String(ndr, "name", &r->name);
 862         ndr->depth--;
 863 }
 864
 865 NTSTATUS ndr_push_lsa_ServerRole(struct ndr_push *ndr, int ndr_flags, const struct lsa_ServerRole *r)
 866 {
 867         if (ndr_flags & NDR_SCALARS) {
 868                 NDR_CHECK(ndr_push_align(ndr, 2));
 869                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown));
 870                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->role));
 871         }
 872         if (ndr_flags & NDR_BUFFERS) {
 873         }
 874         return NT_STATUS_OK;
 875 }
 876
 877 NTSTATUS ndr_pull_lsa_ServerRole(struct ndr_pull *ndr, int ndr_flags, struct lsa_ServerRole *r)
 878 {
 879         if (ndr_flags & NDR_SCALARS) {
 880                 NDR_CHECK(ndr_pull_align(ndr, 2));
 881                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown));
 882                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->role));
 883         }
 884         if (ndr_flags & NDR_BUFFERS) {
 885         }
 886         return NT_STATUS_OK;
 887 }
 888
 889 _PUBLIC_ void ndr_print_lsa_ServerRole(struct ndr_print *ndr, const char *name, const struct lsa_ServerRole *r)
 890 {
 891         ndr_print_struct(ndr, name, "lsa_ServerRole");
 892         ndr->depth++;
 893         ndr_print_uint16(ndr, "unknown", r->unknown);
 894         ndr_print_uint16(ndr, "role", r->role);
 895         ndr->depth--;
 896 }
 897
 898 NTSTATUS ndr_push_lsa_ReplicaSourceInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_ReplicaSourceInfo *r)
 899 {
 900         if (ndr_flags & NDR_SCALARS) {
 901                 NDR_CHECK(ndr_push_align(ndr, 4));
 902                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->source));
 903                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account));
 904         }
 905         if (ndr_flags & NDR_BUFFERS) {
 906                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->source));
 907                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account));
 908         }
 909         return NT_STATUS_OK;
 910 }
 911
 912 NTSTATUS ndr_pull_lsa_ReplicaSourceInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ReplicaSourceInfo *r)
 913 {
 914         if (ndr_flags & NDR_SCALARS) {
 915                 NDR_CHECK(ndr_pull_align(ndr, 4));
 916                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->source));
 917                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account));
 918         }
 919         if (ndr_flags & NDR_BUFFERS) {
 920                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->source));
 921                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account));
 922         }
 923         return NT_STATUS_OK;
 924 }
 925
 926 _PUBLIC_ void ndr_print_lsa_ReplicaSourceInfo(struct ndr_print *ndr, const char *name, const struct lsa_ReplicaSourceInfo *r)
 927 {
 928         ndr_print_struct(ndr, name, "lsa_ReplicaSourceInfo");
 929         ndr->depth++;
 930         ndr_print_lsa_String(ndr, "source", &r->source);
 931         ndr_print_lsa_String(ndr, "account", &r->account);
 932         ndr->depth--;
 933 }
 934
 935 NTSTATUS ndr_push_lsa_DefaultQuotaInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DefaultQuotaInfo *r)
 936 {
 937         if (ndr_flags & NDR_SCALARS) {
 938                 NDR_CHECK(ndr_push_align(ndr, 8));
 939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->paged_pool));
 940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->non_paged_pool));
 941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->min_wss));
 942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_wss));
 943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pagefile));
 944                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown));
 945         }
 946         if (ndr_flags & NDR_BUFFERS) {
 947         }
 948         return NT_STATUS_OK;
 949 }
 950
 951 NTSTATUS ndr_pull_lsa_DefaultQuotaInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DefaultQuotaInfo *r)
 952 {
 953         if (ndr_flags & NDR_SCALARS) {
 954                 NDR_CHECK(ndr_pull_align(ndr, 8));
 955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->paged_pool));
 956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->non_paged_pool));
 957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->min_wss));
 958                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_wss));
 959                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pagefile));
 960                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown));
 961         }
 962         if (ndr_flags & NDR_BUFFERS) {
 963         }
 964         return NT_STATUS_OK;
 965 }
 966
 967 _PUBLIC_ void ndr_print_lsa_DefaultQuotaInfo(struct ndr_print *ndr, const char *name, const struct lsa_DefaultQuotaInfo *r)
 968 {
 969         ndr_print_struct(ndr, name, "lsa_DefaultQuotaInfo");
 970         ndr->depth++;
 971         ndr_print_uint32(ndr, "paged_pool", r->paged_pool);
 972         ndr_print_uint32(ndr, "non_paged_pool", r->non_paged_pool);
 973         ndr_print_uint32(ndr, "min_wss", r->min_wss);
 974         ndr_print_uint32(ndr, "max_wss", r->max_wss);
 975         ndr_print_uint32(ndr, "pagefile", r->pagefile);
 976         ndr_print_hyper(ndr, "unknown", r->unknown);
 977         ndr->depth--;
 978 }
 979
 980 NTSTATUS ndr_push_lsa_ModificationInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_ModificationInfo *r)
 981 {
 982         if (ndr_flags & NDR_SCALARS) {
 983                 NDR_CHECK(ndr_push_align(ndr, 8));
 984                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_id));
 985                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->db_create_time));
 986         }
 987         if (ndr_flags & NDR_BUFFERS) {
 988         }
 989         return NT_STATUS_OK;
 990 }
 991
 992 NTSTATUS ndr_pull_lsa_ModificationInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ModificationInfo *r)
 993 {
 994         if (ndr_flags & NDR_SCALARS) {
 995                 NDR_CHECK(ndr_pull_align(ndr, 8));
 996                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_id));
 997                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->db_create_time));
 998         }
 999         if (ndr_flags & NDR_BUFFERS) {
1000         }
1001         return NT_STATUS_OK;
1002 }
1003
1004 _PUBLIC_ void ndr_print_lsa_ModificationInfo(struct ndr_print *ndr, const char *name, const struct lsa_ModificationInfo *r)
1005 {
1006         ndr_print_struct(ndr, name, "lsa_ModificationInfo");
1007         ndr->depth++;
1008         ndr_print_hyper(ndr, "modified_id", r->modified_id);
1009         ndr_print_NTTIME(ndr, "db_create_time", r->db_create_time);
1010         ndr->depth--;
1011 }
1012
1013 NTSTATUS ndr_push_lsa_AuditFullSetInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditFullSetInfo *r)
1014 {
1015         if (ndr_flags & NDR_SCALARS) {
1016                 NDR_CHECK(ndr_push_align(ndr, 1));
1017                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_on_full));
1018         }
1019         if (ndr_flags & NDR_BUFFERS) {
1020         }
1021         return NT_STATUS_OK;
1022 }
1023
1024 NTSTATUS ndr_pull_lsa_AuditFullSetInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditFullSetInfo *r)
1025 {
1026         if (ndr_flags & NDR_SCALARS) {
1027                 NDR_CHECK(ndr_pull_align(ndr, 1));
1028                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_on_full));
1029         }
1030         if (ndr_flags & NDR_BUFFERS) {
1031         }
1032         return NT_STATUS_OK;
1033 }
1034
1035 _PUBLIC_ void ndr_print_lsa_AuditFullSetInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditFullSetInfo *r)
1036 {
1037         ndr_print_struct(ndr, name, "lsa_AuditFullSetInfo");
1038         ndr->depth++;
1039         ndr_print_uint8(ndr, "shutdown_on_full", r->shutdown_on_full);
1040         ndr->depth--;
1041 }
1042
1043 NTSTATUS ndr_push_lsa_AuditFullQueryInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditFullQueryInfo *r)
1044 {
1045         if (ndr_flags & NDR_SCALARS) {
1046                 NDR_CHECK(ndr_push_align(ndr, 2));
1047                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown));
1048                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_on_full));
1049                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->log_is_full));
1050         }
1051         if (ndr_flags & NDR_BUFFERS) {
1052         }
1053         return NT_STATUS_OK;
1054 }
1055
1056 NTSTATUS ndr_pull_lsa_AuditFullQueryInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditFullQueryInfo *r)
1057 {
1058         if (ndr_flags & NDR_SCALARS) {
1059                 NDR_CHECK(ndr_pull_align(ndr, 2));
1060                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown));
1061                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_on_full));
1062                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->log_is_full));
1063         }
1064         if (ndr_flags & NDR_BUFFERS) {
1065         }
1066         return NT_STATUS_OK;
1067 }
1068
1069 _PUBLIC_ void ndr_print_lsa_AuditFullQueryInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditFullQueryInfo *r)
1070 {
1071         ndr_print_struct(ndr, name, "lsa_AuditFullQueryInfo");
1072         ndr->depth++;
1073         ndr_print_uint16(ndr, "unknown", r->unknown);
1074         ndr_print_uint8(ndr, "shutdown_on_full", r->shutdown_on_full);
1075         ndr_print_uint8(ndr, "log_is_full", r->log_is_full);
1076         ndr->depth--;
1077 }
1078
1079 NTSTATUS ndr_push_lsa_DnsDomainInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DnsDomainInfo *r)
1080 {
1081         if (ndr_flags & NDR_SCALARS) {
1082                 NDR_CHECK(ndr_push_align(ndr, 4));
1083                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
1084                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain));
1085                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_forest));
1086                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_guid));
1087                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
1088         }
1089         if (ndr_flags & NDR_BUFFERS) {
1090                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1091                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain));
1092                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_forest));
1093                 NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->domain_guid));
1094                 if (r->sid) {
1095                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1096                 }
1097         }
1098         return NT_STATUS_OK;
1099 }
1100
1101 NTSTATUS ndr_pull_lsa_DnsDomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DnsDomainInfo *r)
1102 {
1103         uint32_t _ptr_sid;
1104         TALLOC_CTX *_mem_save_sid_0;
1105         if (ndr_flags & NDR_SCALARS) {
1106                 NDR_CHECK(ndr_pull_align(ndr, 4));
1107                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
1108                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain));
1109                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_forest));
1110                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_guid));
1111                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
1112                 if (_ptr_sid) {
1113                         NDR_PULL_ALLOC(ndr, r->sid);
1114                 } else {
1115                         r->sid = NULL;
1116                 }
1117         }
1118         if (ndr_flags & NDR_BUFFERS) {
1119                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1120                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain));
1121                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_forest));
1122                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->domain_guid));
1123                 if (r->sid) {
1124                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1125                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1126                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1127                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1128                 }
1129         }
1130         return NT_STATUS_OK;
1131 }
1132
1133 _PUBLIC_ void ndr_print_lsa_DnsDomainInfo(struct ndr_print *ndr, const char *name, const struct lsa_DnsDomainInfo *r)
1134 {
1135         ndr_print_struct(ndr, name, "lsa_DnsDomainInfo");
1136         ndr->depth++;
1137         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
1138         ndr_print_lsa_StringLarge(ndr, "dns_domain", &r->dns_domain);
1139         ndr_print_lsa_StringLarge(ndr, "dns_forest", &r->dns_forest);
1140         ndr_print_GUID(ndr, "domain_guid", &r->domain_guid);
1141         ndr_print_ptr(ndr, "sid", r->sid);
1142         ndr->depth++;
1143         if (r->sid) {
1144                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1145         }
1146         ndr->depth--;
1147         ndr->depth--;
1148 }
1149
1150 NTSTATUS ndr_push_lsa_PolicyInformation(struct ndr_push *ndr, int ndr_flags, const union lsa_PolicyInformation *r)
1151 {
1152         if (ndr_flags & NDR_SCALARS) {
1153                 int level = ndr_push_get_switch_value(ndr, r);
1154                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
1155                 switch (level) {
1156                         case LSA_POLICY_INFO_AUDIT_LOG:
1157                                 NDR_CHECK(ndr_push_lsa_AuditLogInfo(ndr, NDR_SCALARS, &r->audit_log));
1158                         break;
1159
1160                         case LSA_POLICY_INFO_AUDIT_EVENTS:
1161                                 NDR_CHECK(ndr_push_lsa_AuditEventsInfo(ndr, NDR_SCALARS, &r->audit_events));
1162                         break;
1163
1164                         case LSA_POLICY_INFO_DOMAIN:
1165                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domain));
1166                         break;
1167
1168                         case LSA_POLICY_INFO_PD:
1169                                 NDR_CHECK(ndr_push_lsa_PDAccountInfo(ndr, NDR_SCALARS, &r->pd));
1170                         break;
1171
1172                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1173                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->account_domain));
1174                         break;
1175
1176                         case LSA_POLICY_INFO_ROLE:
1177                                 NDR_CHECK(ndr_push_lsa_ServerRole(ndr, NDR_SCALARS, &r->role));
1178                         break;
1179
1180                         case LSA_POLICY_INFO_REPLICA:
1181                                 NDR_CHECK(ndr_push_lsa_ReplicaSourceInfo(ndr, NDR_SCALARS, &r->replica));
1182                         break;
1183
1184                         case LSA_POLICY_INFO_QUOTA:
1185                                 NDR_CHECK(ndr_push_lsa_DefaultQuotaInfo(ndr, NDR_SCALARS, &r->quota));
1186                         break;
1187
1188                         case LSA_POLICY_INFO_DB:
1189                                 NDR_CHECK(ndr_push_lsa_ModificationInfo(ndr, NDR_SCALARS, &r->db));
1190                         break;
1191
1192                         case LSA_POLICY_INFO_AUDIT_FULL_SET:
1193                                 NDR_CHECK(ndr_push_lsa_AuditFullSetInfo(ndr, NDR_SCALARS, &r->auditfullset));
1194                         break;
1195
1196                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1197                                 NDR_CHECK(ndr_push_lsa_AuditFullQueryInfo(ndr, NDR_SCALARS, &r->auditfullquery));
1198                         break;
1199
1200                         case LSA_POLICY_INFO_DNS:
1201                                 NDR_CHECK(ndr_push_lsa_DnsDomainInfo(ndr, NDR_SCALARS, &r->dns));
1202                         break;
1203
1204                         default:
1205                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1206                 }
1207         }
1208         if (ndr_flags & NDR_BUFFERS) {
1209                 int level = ndr_push_get_switch_value(ndr, r);
1210                 switch (level) {
1211                         case LSA_POLICY_INFO_AUDIT_LOG:
1212                         break;
1213
1214                         case LSA_POLICY_INFO_AUDIT_EVENTS:
1215                                 NDR_CHECK(ndr_push_lsa_AuditEventsInfo(ndr, NDR_BUFFERS, &r->audit_events));
1216                         break;
1217
1218                         case LSA_POLICY_INFO_DOMAIN:
1219                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domain));
1220                         break;
1221
1222                         case LSA_POLICY_INFO_PD:
1223                                 NDR_CHECK(ndr_push_lsa_PDAccountInfo(ndr, NDR_BUFFERS, &r->pd));
1224                         break;
1225
1226                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1227                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->account_domain));
1228                         break;
1229
1230                         case LSA_POLICY_INFO_ROLE:
1231                         break;
1232
1233                         case LSA_POLICY_INFO_REPLICA:
1234                                 NDR_CHECK(ndr_push_lsa_ReplicaSourceInfo(ndr, NDR_BUFFERS, &r->replica));
1235                         break;
1236
1237                         case LSA_POLICY_INFO_QUOTA:
1238                         break;
1239
1240                         case LSA_POLICY_INFO_DB:
1241                         break;
1242
1243                         case LSA_POLICY_INFO_AUDIT_FULL_SET:
1244                         break;
1245
1246                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1247                         break;
1248
1249                         case LSA_POLICY_INFO_DNS:
1250                                 NDR_CHECK(ndr_push_lsa_DnsDomainInfo(ndr, NDR_BUFFERS, &r->dns));
1251                         break;
1252
1253                         default:
1254                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1255                 }
1256         }
1257         return NT_STATUS_OK;
1258 }
1259
1260 NTSTATUS ndr_pull_lsa_PolicyInformation(struct ndr_pull *ndr, int ndr_flags, union lsa_PolicyInformation *r)
1261 {
1262         int level;
1263         uint16_t _level;
1264         level = ndr_pull_get_switch_value(ndr, r);
1265         if (ndr_flags & NDR_SCALARS) {
1266                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1267                 if (_level != level) {
1268                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1269                 }
1270                 switch (level) {
1271                         case LSA_POLICY_INFO_AUDIT_LOG: {
1272                                 NDR_CHECK(ndr_pull_lsa_AuditLogInfo(ndr, NDR_SCALARS, &r->audit_log));
1273                         break; }
1274
1275                         case LSA_POLICY_INFO_AUDIT_EVENTS: {
1276                                 NDR_CHECK(ndr_pull_lsa_AuditEventsInfo(ndr, NDR_SCALARS, &r->audit_events));
1277                         break; }
1278
1279                         case LSA_POLICY_INFO_DOMAIN: {
1280                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domain));
1281                         break; }
1282
1283                         case LSA_POLICY_INFO_PD: {
1284                                 NDR_CHECK(ndr_pull_lsa_PDAccountInfo(ndr, NDR_SCALARS, &r->pd));
1285                         break; }
1286
1287                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN: {
1288                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->account_domain));
1289                         break; }
1290
1291                         case LSA_POLICY_INFO_ROLE: {
1292                                 NDR_CHECK(ndr_pull_lsa_ServerRole(ndr, NDR_SCALARS, &r->role));
1293                         break; }
1294
1295                         case LSA_POLICY_INFO_REPLICA: {
1296                                 NDR_CHECK(ndr_pull_lsa_ReplicaSourceInfo(ndr, NDR_SCALARS, &r->replica));
1297                         break; }
1298
1299                         case LSA_POLICY_INFO_QUOTA: {
1300                                 NDR_CHECK(ndr_pull_lsa_DefaultQuotaInfo(ndr, NDR_SCALARS, &r->quota));
1301                         break; }
1302
1303                         case LSA_POLICY_INFO_DB: {
1304                                 NDR_CHECK(ndr_pull_lsa_ModificationInfo(ndr, NDR_SCALARS, &r->db));
1305                         break; }
1306
1307                         case LSA_POLICY_INFO_AUDIT_FULL_SET: {
1308                                 NDR_CHECK(ndr_pull_lsa_AuditFullSetInfo(ndr, NDR_SCALARS, &r->auditfullset));
1309                         break; }
1310
1311                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY: {
1312                                 NDR_CHECK(ndr_pull_lsa_AuditFullQueryInfo(ndr, NDR_SCALARS, &r->auditfullquery));
1313                         break; }
1314
1315                         case LSA_POLICY_INFO_DNS: {
1316                                 NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_SCALARS, &r->dns));
1317                         break; }
1318
1319                         default:
1320                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1321                 }
1322         }
1323         if (ndr_flags & NDR_BUFFERS) {
1324                 switch (level) {
1325                         case LSA_POLICY_INFO_AUDIT_LOG:
1326                         break;
1327
1328                         case LSA_POLICY_INFO_AUDIT_EVENTS:
1329                                 NDR_CHECK(ndr_pull_lsa_AuditEventsInfo(ndr, NDR_BUFFERS, &r->audit_events));
1330                         break;
1331
1332                         case LSA_POLICY_INFO_DOMAIN:
1333                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domain));
1334                         break;
1335
1336                         case LSA_POLICY_INFO_PD:
1337                                 NDR_CHECK(ndr_pull_lsa_PDAccountInfo(ndr, NDR_BUFFERS, &r->pd));
1338                         break;
1339
1340                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1341                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->account_domain));
1342                         break;
1343
1344                         case LSA_POLICY_INFO_ROLE:
1345                         break;
1346
1347                         case LSA_POLICY_INFO_REPLICA:
1348                                 NDR_CHECK(ndr_pull_lsa_ReplicaSourceInfo(ndr, NDR_BUFFERS, &r->replica));
1349                         break;
1350
1351                         case LSA_POLICY_INFO_QUOTA:
1352                         break;
1353
1354                         case LSA_POLICY_INFO_DB:
1355                         break;
1356
1357                         case LSA_POLICY_INFO_AUDIT_FULL_SET:
1358                         break;
1359
1360                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1361                         break;
1362
1363                         case LSA_POLICY_INFO_DNS:
1364                                 NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_BUFFERS, &r->dns));
1365                         break;
1366
1367                         default:
1368                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1369                 }
1370         }
1371         return NT_STATUS_OK;
1372 }
1373
1374 _PUBLIC_ void ndr_print_lsa_PolicyInformation(struct ndr_print *ndr, const char *name, const union lsa_PolicyInformation *r)
1375 {
1376         int level;
1377         level = ndr_print_get_switch_value(ndr, r);
1378         ndr_print_union(ndr, name, level, "lsa_PolicyInformation");
1379         switch (level) {
1380                 case LSA_POLICY_INFO_AUDIT_LOG:
1381                         ndr_print_lsa_AuditLogInfo(ndr, "audit_log", &r->audit_log);
1382                 break;
1383
1384                 case LSA_POLICY_INFO_AUDIT_EVENTS:
1385                         ndr_print_lsa_AuditEventsInfo(ndr, "audit_events", &r->audit_events);
1386                 break;
1387
1388                 case LSA_POLICY_INFO_DOMAIN:
1389                         ndr_print_lsa_DomainInfo(ndr, "domain", &r->domain);
1390                 break;
1391
1392                 case LSA_POLICY_INFO_PD:
1393                         ndr_print_lsa_PDAccountInfo(ndr, "pd", &r->pd);
1394                 break;
1395
1396                 case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1397                         ndr_print_lsa_DomainInfo(ndr, "account_domain", &r->account_domain);
1398                 break;
1399
1400                 case LSA_POLICY_INFO_ROLE:
1401                         ndr_print_lsa_ServerRole(ndr, "role", &r->role);
1402                 break;
1403
1404                 case LSA_POLICY_INFO_REPLICA:
1405                         ndr_print_lsa_ReplicaSourceInfo(ndr, "replica", &r->replica);
1406                 break;
1407
1408                 case LSA_POLICY_INFO_QUOTA:
1409                         ndr_print_lsa_DefaultQuotaInfo(ndr, "quota", &r->quota);
1410                 break;
1411
1412                 case LSA_POLICY_INFO_DB:
1413                         ndr_print_lsa_ModificationInfo(ndr, "db", &r->db);
1414                 break;
1415
1416                 case LSA_POLICY_INFO_AUDIT_FULL_SET:
1417                         ndr_print_lsa_AuditFullSetInfo(ndr, "auditfullset", &r->auditfullset);
1418                 break;
1419
1420                 case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1421                         ndr_print_lsa_AuditFullQueryInfo(ndr, "auditfullquery", &r->auditfullquery);
1422                 break;
1423
1424                 case LSA_POLICY_INFO_DNS:
1425                         ndr_print_lsa_DnsDomainInfo(ndr, "dns", &r->dns);
1426                 break;
1427
1428                 default:
1429                         ndr_print_bad_level(ndr, name, level);
1430         }
1431 }
1432
1433 NTSTATUS ndr_push_lsa_SidPtr(struct ndr_push *ndr, int ndr_flags, const struct lsa_SidPtr *r)
1434 {
1435         if (ndr_flags & NDR_SCALARS) {
1436                 NDR_CHECK(ndr_push_align(ndr, 4));
1437                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
1438         }
1439         if (ndr_flags & NDR_BUFFERS) {
1440                 if (r->sid) {
1441                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1442                 }
1443         }
1444         return NT_STATUS_OK;
1445 }
1446
1447 NTSTATUS ndr_pull_lsa_SidPtr(struct ndr_pull *ndr, int ndr_flags, struct lsa_SidPtr *r)
1448 {
1449         uint32_t _ptr_sid;
1450         TALLOC_CTX *_mem_save_sid_0;
1451         if (ndr_flags & NDR_SCALARS) {
1452                 NDR_CHECK(ndr_pull_align(ndr, 4));
1453                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
1454                 if (_ptr_sid) {
1455                         NDR_PULL_ALLOC(ndr, r->sid);
1456                 } else {
1457                         r->sid = NULL;
1458                 }
1459         }
1460         if (ndr_flags & NDR_BUFFERS) {
1461                 if (r->sid) {
1462                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1463                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1464                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1465                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1466                 }
1467         }
1468         return NT_STATUS_OK;
1469 }
1470
1471 _PUBLIC_ void ndr_print_lsa_SidPtr(struct ndr_print *ndr, const char *name, const struct lsa_SidPtr *r)
1472 {
1473         ndr_print_struct(ndr, name, "lsa_SidPtr");
1474         ndr->depth++;
1475         ndr_print_ptr(ndr, "sid", r->sid);
1476         ndr->depth++;
1477         if (r->sid) {
1478                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1479         }
1480         ndr->depth--;
1481         ndr->depth--;
1482 }
1483
1484 _PUBLIC_ NTSTATUS ndr_push_lsa_SidArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_SidArray *r)
1485 {
1486         uint32_t cntr_sids_1;
1487         if (ndr_flags & NDR_SCALARS) {
1488                 NDR_CHECK(ndr_push_align(ndr, 4));
1489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
1490                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
1491         }
1492         if (ndr_flags & NDR_BUFFERS) {
1493                 if (r->sids) {
1494                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
1495                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1496                                 NDR_CHECK(ndr_push_lsa_SidPtr(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1497                         }
1498                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1499                                 NDR_CHECK(ndr_push_lsa_SidPtr(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
1500                         }
1501                 }
1502         }
1503         return NT_STATUS_OK;
1504 }
1505
1506 _PUBLIC_ NTSTATUS ndr_pull_lsa_SidArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_SidArray *r)
1507 {
1508         uint32_t _ptr_sids;
1509         uint32_t cntr_sids_1;
1510         TALLOC_CTX *_mem_save_sids_0;
1511         TALLOC_CTX *_mem_save_sids_1;
1512         if (ndr_flags & NDR_SCALARS) {
1513                 NDR_CHECK(ndr_pull_align(ndr, 4));
1514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
1515                 if (r->num_sids < 0 || r->num_sids > 1000) {
1516                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1517                 }
1518                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
1519                 if (_ptr_sids) {
1520                         NDR_PULL_ALLOC(ndr, r->sids);
1521                 } else {
1522                         r->sids = NULL;
1523                 }
1524         }
1525         if (ndr_flags & NDR_BUFFERS) {
1526                 if (r->sids) {
1527                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1528                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1529                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
1530                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
1531                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1532                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1533                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1534                                 NDR_CHECK(ndr_pull_lsa_SidPtr(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1535                         }
1536                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1537                                 NDR_CHECK(ndr_pull_lsa_SidPtr(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
1538                         }
1539                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
1540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
1541                 }
1542                 if (r->sids) {
1543                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
1544                 }
1545         }
1546         return NT_STATUS_OK;
1547 }
1548
1549 _PUBLIC_ void ndr_print_lsa_SidArray(struct ndr_print *ndr, const char *name, const struct lsa_SidArray *r)
1550 {
1551         uint32_t cntr_sids_1;
1552         ndr_print_struct(ndr, name, "lsa_SidArray");
1553         ndr->depth++;
1554         ndr_print_uint32(ndr, "num_sids", r->num_sids);
1555         ndr_print_ptr(ndr, "sids", r->sids);
1556         ndr->depth++;
1557         if (r->sids) {
1558                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->num_sids);
1559                 ndr->depth++;
1560                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
1561                         char *idx_1=NULL;
1562                         asprintf(&idx_1, "[%d]", cntr_sids_1);
1563                         if (idx_1) {
1564                                 ndr_print_lsa_SidPtr(ndr, "sids", &r->sids[cntr_sids_1]);
1565                                 free(idx_1);
1566                         }
1567                 }
1568                 ndr->depth--;
1569         }
1570         ndr->depth--;
1571         ndr->depth--;
1572 }
1573
1574 NTSTATUS ndr_push_lsa_DomainList(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainList *r)
1575 {
1576         uint32_t cntr_domains_1;
1577         if (ndr_flags & NDR_SCALARS) {
1578                 NDR_CHECK(ndr_push_align(ndr, 4));
1579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1580                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
1581         }
1582         if (ndr_flags & NDR_BUFFERS) {
1583                 if (r->domains) {
1584                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1585                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1586                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
1587                         }
1588                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1589                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
1590                         }
1591                 }
1592         }
1593         return NT_STATUS_OK;
1594 }
1595
1596 NTSTATUS ndr_pull_lsa_DomainList(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainList *r)
1597 {
1598         uint32_t _ptr_domains;
1599         uint32_t cntr_domains_1;
1600         TALLOC_CTX *_mem_save_domains_0;
1601         TALLOC_CTX *_mem_save_domains_1;
1602         if (ndr_flags & NDR_SCALARS) {
1603                 NDR_CHECK(ndr_pull_align(ndr, 4));
1604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1605                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
1606                 if (_ptr_domains) {
1607                         NDR_PULL_ALLOC(ndr, r->domains);
1608                 } else {
1609                         r->domains = NULL;
1610                 }
1611         }
1612         if (ndr_flags & NDR_BUFFERS) {
1613                 if (r->domains) {
1614                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
1615                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1616                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
1617                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
1618                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
1619                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1620                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1621                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
1622                         }
1623                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1624                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
1625                         }
1626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
1627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
1628                 }
1629                 if (r->domains) {
1630                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
1631                 }
1632         }
1633         return NT_STATUS_OK;
1634 }
1635
1636 _PUBLIC_ void ndr_print_lsa_DomainList(struct ndr_print *ndr, const char *name, const struct lsa_DomainList *r)
1637 {
1638         uint32_t cntr_domains_1;
1639         ndr_print_struct(ndr, name, "lsa_DomainList");
1640         ndr->depth++;
1641         ndr_print_uint32(ndr, "count", r->count);
1642         ndr_print_ptr(ndr, "domains", r->domains);
1643         ndr->depth++;
1644         if (r->domains) {
1645                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", r->count);
1646                 ndr->depth++;
1647                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
1648                         char *idx_1=NULL;
1649                         asprintf(&idx_1, "[%d]", cntr_domains_1);
1650                         if (idx_1) {
1651                                 ndr_print_lsa_DomainInfo(ndr, "domains", &r->domains[cntr_domains_1]);
1652                                 free(idx_1);
1653                         }
1654                 }
1655                 ndr->depth--;
1656         }
1657         ndr->depth--;
1658         ndr->depth--;
1659 }
1660
1661 NTSTATUS ndr_push_lsa_SidType(struct ndr_push *ndr, int ndr_flags, enum lsa_SidType r)
1662 {
1663         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1664         return NT_STATUS_OK;
1665 }
1666
1667 NTSTATUS ndr_pull_lsa_SidType(struct ndr_pull *ndr, int ndr_flags, enum lsa_SidType *r)
1668 {
1669         uint16_t v;
1670         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1671         *r = v;
1672         return NT_STATUS_OK;
1673 }
1674
1675 _PUBLIC_ void ndr_print_lsa_SidType(struct ndr_print *ndr, const char *name, enum lsa_SidType r)
1676 {
1677         const char *val = NULL;
1678
1679         switch (r) {
1680                 case SID_NAME_USE_NONE: val = "SID_NAME_USE_NONE"; break;
1681                 case SID_NAME_USER: val = "SID_NAME_USER"; break;
1682                 case SID_NAME_DOM_GRP: val = "SID_NAME_DOM_GRP"; break;
1683                 case SID_NAME_DOMAIN: val = "SID_NAME_DOMAIN"; break;
1684                 case SID_NAME_ALIAS: val = "SID_NAME_ALIAS"; break;
1685                 case SID_NAME_WKN_GRP: val = "SID_NAME_WKN_GRP"; break;
1686                 case SID_NAME_DELETED: val = "SID_NAME_DELETED"; break;
1687                 case SID_NAME_INVALID: val = "SID_NAME_INVALID"; break;
1688                 case SID_NAME_UNKNOWN: val = "SID_NAME_UNKNOWN"; break;
1689                 case SID_NAME_COMPUTER: val = "SID_NAME_COMPUTER"; break;
1690         }
1691         ndr_print_enum(ndr, name, "ENUM", val, r);
1692 }
1693
1694 NTSTATUS ndr_push_lsa_TranslatedSid(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid *r)
1695 {
1696         if (ndr_flags & NDR_SCALARS) {
1697                 NDR_CHECK(ndr_push_align(ndr, 4));
1698                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
1699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
1700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
1701         }
1702         if (ndr_flags & NDR_BUFFERS) {
1703         }
1704         return NT_STATUS_OK;
1705 }
1706
1707 NTSTATUS ndr_pull_lsa_TranslatedSid(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid *r)
1708 {
1709         if (ndr_flags & NDR_SCALARS) {
1710                 NDR_CHECK(ndr_pull_align(ndr, 4));
1711                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
1712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
1713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
1714         }
1715         if (ndr_flags & NDR_BUFFERS) {
1716         }
1717         return NT_STATUS_OK;
1718 }
1719
1720 _PUBLIC_ void ndr_print_lsa_TranslatedSid(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid *r)
1721 {
1722         ndr_print_struct(ndr, name, "lsa_TranslatedSid");
1723         ndr->depth++;
1724         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
1725         ndr_print_uint32(ndr, "rid", r->rid);
1726         ndr_print_uint32(ndr, "sid_index", r->sid_index);
1727         ndr->depth--;
1728 }
1729
1730 NTSTATUS ndr_push_lsa_TransSidArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray *r)
1731 {
1732         uint32_t cntr_sids_1;
1733         if (ndr_flags & NDR_SCALARS) {
1734                 NDR_CHECK(ndr_push_align(ndr, 4));
1735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1736                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
1737         }
1738         if (ndr_flags & NDR_BUFFERS) {
1739                 if (r->sids) {
1740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1741                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
1742                                 NDR_CHECK(ndr_push_lsa_TranslatedSid(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1743                         }
1744                 }
1745         }
1746         return NT_STATUS_OK;
1747 }
1748
1749 NTSTATUS ndr_pull_lsa_TransSidArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray *r)
1750 {
1751         uint32_t _ptr_sids;
1752         uint32_t cntr_sids_1;
1753         TALLOC_CTX *_mem_save_sids_0;
1754         TALLOC_CTX *_mem_save_sids_1;
1755         if (ndr_flags & NDR_SCALARS) {
1756                 NDR_CHECK(ndr_pull_align(ndr, 4));
1757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1758                 if (r->count < 0 || r->count > 1000) {
1759                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1760                 }
1761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
1762                 if (_ptr_sids) {
1763                         NDR_PULL_ALLOC(ndr, r->sids);
1764                 } else {
1765                         r->sids = NULL;
1766                 }
1767         }
1768         if (ndr_flags & NDR_BUFFERS) {
1769                 if (r->sids) {
1770                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1771                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1772                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
1773                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
1774                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1775                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1776                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
1777                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1778                         }
1779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
1780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
1781                 }
1782                 if (r->sids) {
1783                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
1784                 }
1785         }
1786         return NT_STATUS_OK;
1787 }
1788
1789 _PUBLIC_ void ndr_print_lsa_TransSidArray(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray *r)
1790 {
1791         uint32_t cntr_sids_1;
1792         ndr_print_struct(ndr, name, "lsa_TransSidArray");
1793         ndr->depth++;
1794         ndr_print_uint32(ndr, "count", r->count);
1795         ndr_print_ptr(ndr, "sids", r->sids);
1796         ndr->depth++;
1797         if (r->sids) {
1798                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->count);
1799                 ndr->depth++;
1800                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
1801                         char *idx_1=NULL;
1802                         asprintf(&idx_1, "[%d]", cntr_sids_1);
1803                         if (idx_1) {
1804                                 ndr_print_lsa_TranslatedSid(ndr, "sids", &r->sids[cntr_sids_1]);
1805                                 free(idx_1);
1806                         }
1807                 }
1808                 ndr->depth--;
1809         }
1810         ndr->depth--;
1811         ndr->depth--;
1812 }
1813
1814 NTSTATUS ndr_push_lsa_RefDomainList(struct ndr_push *ndr, int ndr_flags, const struct lsa_RefDomainList *r)
1815 {
1816         uint32_t cntr_domains_1;
1817         if (ndr_flags & NDR_SCALARS) {
1818                 NDR_CHECK(ndr_push_align(ndr, 4));
1819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1820                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
1821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_size));
1822         }
1823         if (ndr_flags & NDR_BUFFERS) {
1824                 if (r->domains) {
1825                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1826                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1827                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
1828                         }
1829                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1830                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
1831                         }
1832                 }
1833         }
1834         return NT_STATUS_OK;
1835 }
1836
1837 NTSTATUS ndr_pull_lsa_RefDomainList(struct ndr_pull *ndr, int ndr_flags, struct lsa_RefDomainList *r)
1838 {
1839         uint32_t _ptr_domains;
1840         uint32_t cntr_domains_1;
1841         TALLOC_CTX *_mem_save_domains_0;
1842         TALLOC_CTX *_mem_save_domains_1;
1843         if (ndr_flags & NDR_SCALARS) {
1844                 NDR_CHECK(ndr_pull_align(ndr, 4));
1845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1846                 if (r->count < 0 || r->count > 1000) {
1847                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1848                 }
1849                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
1850                 if (_ptr_domains) {
1851                         NDR_PULL_ALLOC(ndr, r->domains);
1852                 } else {
1853                         r->domains = NULL;
1854                 }
1855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_size));
1856         }
1857         if (ndr_flags & NDR_BUFFERS) {
1858                 if (r->domains) {
1859                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
1860                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1861                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
1862                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
1863                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
1864                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1865                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1866                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
1867                         }
1868                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1869                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
1870                         }
1871                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
1872                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
1873                 }
1874                 if (r->domains) {
1875                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
1876                 }
1877         }
1878         return NT_STATUS_OK;
1879 }
1880
1881 _PUBLIC_ void ndr_print_lsa_RefDomainList(struct ndr_print *ndr, const char *name, const struct lsa_RefDomainList *r)
1882 {
1883         uint32_t cntr_domains_1;
1884         ndr_print_struct(ndr, name, "lsa_RefDomainList");
1885         ndr->depth++;
1886         ndr_print_uint32(ndr, "count", r->count);
1887         ndr_print_ptr(ndr, "domains", r->domains);
1888         ndr->depth++;
1889         if (r->domains) {
1890                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", r->count);
1891                 ndr->depth++;
1892                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
1893                         char *idx_1=NULL;
1894                         asprintf(&idx_1, "[%d]", cntr_domains_1);
1895                         if (idx_1) {
1896                                 ndr_print_lsa_DomainInfo(ndr, "domains", &r->domains[cntr_domains_1]);
1897                                 free(idx_1);
1898                         }
1899                 }
1900                 ndr->depth--;
1901         }
1902         ndr->depth--;
1903         ndr_print_uint32(ndr, "max_size", r->max_size);
1904         ndr->depth--;
1905 }
1906
1907 NTSTATUS ndr_push_lsa_TranslatedName(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedName *r)
1908 {
1909         if (ndr_flags & NDR_SCALARS) {
1910                 NDR_CHECK(ndr_push_align(ndr, 4));
1911                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
1912                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
1914         }
1915         if (ndr_flags & NDR_BUFFERS) {
1916                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
1917         }
1918         return NT_STATUS_OK;
1919 }
1920
1921 NTSTATUS ndr_pull_lsa_TranslatedName(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedName *r)
1922 {
1923         if (ndr_flags & NDR_SCALARS) {
1924                 NDR_CHECK(ndr_pull_align(ndr, 4));
1925                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
1926                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
1927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
1928         }
1929         if (ndr_flags & NDR_BUFFERS) {
1930                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
1931         }
1932         return NT_STATUS_OK;
1933 }
1934
1935 _PUBLIC_ void ndr_print_lsa_TranslatedName(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedName *r)
1936 {
1937         ndr_print_struct(ndr, name, "lsa_TranslatedName");
1938         ndr->depth++;
1939         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
1940         ndr_print_lsa_String(ndr, "name", &r->name);
1941         ndr_print_uint32(ndr, "sid_index", r->sid_index);
1942         ndr->depth--;
1943 }
1944
1945 NTSTATUS ndr_push_lsa_TransNameArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransNameArray *r)
1946 {
1947         uint32_t cntr_names_1;
1948         if (ndr_flags & NDR_SCALARS) {
1949                 NDR_CHECK(ndr_push_align(ndr, 4));
1950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
1952         }
1953         if (ndr_flags & NDR_BUFFERS) {
1954                 if (r->names) {
1955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1956                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
1957                                 NDR_CHECK(ndr_push_lsa_TranslatedName(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
1958                         }
1959                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
1960                                 NDR_CHECK(ndr_push_lsa_TranslatedName(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
1961                         }
1962                 }
1963         }
1964         return NT_STATUS_OK;
1965 }
1966
1967 NTSTATUS ndr_pull_lsa_TransNameArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransNameArray *r)
1968 {
1969         uint32_t _ptr_names;
1970         uint32_t cntr_names_1;
1971         TALLOC_CTX *_mem_save_names_0;
1972         TALLOC_CTX *_mem_save_names_1;
1973         if (ndr_flags & NDR_SCALARS) {
1974                 NDR_CHECK(ndr_pull_align(ndr, 4));
1975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1976                 if (r->count < 0 || r->count > 1000) {
1977                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1978                 }
1979                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
1980                 if (_ptr_names) {
1981                         NDR_PULL_ALLOC(ndr, r->names);
1982                 } else {
1983                         r->names = NULL;
1984                 }
1985         }
1986         if (ndr_flags & NDR_BUFFERS) {
1987                 if (r->names) {
1988                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
1989                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
1990                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
1991                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
1992                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
1993                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
1994                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
1995                                 NDR_CHECK(ndr_pull_lsa_TranslatedName(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
1996                         }
1997                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
1998                                 NDR_CHECK(ndr_pull_lsa_TranslatedName(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
1999                         }
2000                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
2001                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
2002                 }
2003                 if (r->names) {
2004                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
2005                 }
2006         }
2007         return NT_STATUS_OK;
2008 }
2009
2010 _PUBLIC_ void ndr_print_lsa_TransNameArray(struct ndr_print *ndr, const char *name, const struct lsa_TransNameArray *r)
2011 {
2012         uint32_t cntr_names_1;
2013         ndr_print_struct(ndr, name, "lsa_TransNameArray");
2014         ndr->depth++;
2015         ndr_print_uint32(ndr, "count", r->count);
2016         ndr_print_ptr(ndr, "names", r->names);
2017         ndr->depth++;
2018         if (r->names) {
2019                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->count);
2020                 ndr->depth++;
2021                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
2022                         char *idx_1=NULL;
2023                         asprintf(&idx_1, "[%d]", cntr_names_1);
2024                         if (idx_1) {
2025                                 ndr_print_lsa_TranslatedName(ndr, "names", &r->names[cntr_names_1]);
2026                                 free(idx_1);
2027                         }
2028                 }
2029                 ndr->depth--;
2030         }
2031         ndr->depth--;
2032         ndr->depth--;
2033 }
2034
2035 NTSTATUS ndr_push_lsa_LUIDAttribute(struct ndr_push *ndr, int ndr_flags, const struct lsa_LUIDAttribute *r)
2036 {
2037         if (ndr_flags & NDR_SCALARS) {
2038                 NDR_CHECK(ndr_push_align(ndr, 4));
2039                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
2040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attribute));
2041         }
2042         if (ndr_flags & NDR_BUFFERS) {
2043         }
2044         return NT_STATUS_OK;
2045 }
2046
2047 NTSTATUS ndr_pull_lsa_LUIDAttribute(struct ndr_pull *ndr, int ndr_flags, struct lsa_LUIDAttribute *r)
2048 {
2049         if (ndr_flags & NDR_SCALARS) {
2050                 NDR_CHECK(ndr_pull_align(ndr, 4));
2051                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
2052                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attribute));
2053         }
2054         if (ndr_flags & NDR_BUFFERS) {
2055         }
2056         return NT_STATUS_OK;
2057 }
2058
2059 _PUBLIC_ void ndr_print_lsa_LUIDAttribute(struct ndr_print *ndr, const char *name, const struct lsa_LUIDAttribute *r)
2060 {
2061         ndr_print_struct(ndr, name, "lsa_LUIDAttribute");
2062         ndr->depth++;
2063         ndr_print_lsa_LUID(ndr, "luid", &r->luid);
2064         ndr_print_uint32(ndr, "attribute", r->attribute);
2065         ndr->depth--;
2066 }
2067
2068 NTSTATUS ndr_push_lsa_PrivilegeSet(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivilegeSet *r)
2069 {
2070         uint32_t cntr_set_0;
2071         if (ndr_flags & NDR_SCALARS) {
2072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2073                 NDR_CHECK(ndr_push_align(ndr, 4));
2074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
2076                 for (cntr_set_0 = 0; cntr_set_0 < r->count; cntr_set_0++) {
2077                         NDR_CHECK(ndr_push_lsa_LUIDAttribute(ndr, NDR_SCALARS, &r->set[cntr_set_0]));
2078                 }
2079         }
2080         if (ndr_flags & NDR_BUFFERS) {
2081         }
2082         return NT_STATUS_OK;
2083 }
2084
2085 NTSTATUS ndr_pull_lsa_PrivilegeSet(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivilegeSet *r)
2086 {
2087         uint32_t cntr_set_0;
2088         TALLOC_CTX *_mem_save_set_0;
2089         if (ndr_flags & NDR_SCALARS) {
2090                 NDR_CHECK(ndr_pull_array_size(ndr, &r->set));
2091                 NDR_CHECK(ndr_pull_align(ndr, 4));
2092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2093                 if (r->count < 0 || r->count > 1000) {
2094                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2095                 }
2096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
2097                 NDR_PULL_ALLOC_N(ndr, r->set, ndr_get_array_size(ndr, &r->set));
2098                 _mem_save_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
2099                 NDR_PULL_SET_MEM_CTX(ndr, r->set, 0);
2100                 for (cntr_set_0 = 0; cntr_set_0 < r->count; cntr_set_0++) {
2101                         NDR_CHECK(ndr_pull_lsa_LUIDAttribute(ndr, NDR_SCALARS, &r->set[cntr_set_0]));
2102                 }
2103                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_set_0, 0);
2104                 if (r->set) {
2105                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->set, r->count));
2106                 }
2107         }
2108         if (ndr_flags & NDR_BUFFERS) {
2109         }
2110         return NT_STATUS_OK;
2111 }
2112
2113 _PUBLIC_ void ndr_print_lsa_PrivilegeSet(struct ndr_print *ndr, const char *name, const struct lsa_PrivilegeSet *r)
2114 {
2115         uint32_t cntr_set_0;
2116         ndr_print_struct(ndr, name, "lsa_PrivilegeSet");
2117         ndr->depth++;
2118         ndr_print_uint32(ndr, "count", r->count);
2119         ndr_print_uint32(ndr, "unknown", r->unknown);
2120         ndr->print(ndr, "%s: ARRAY(%d)", "set", r->count);
2121         ndr->depth++;
2122         for (cntr_set_0=0;cntr_set_0<r->count;cntr_set_0++) {
2123                 char *idx_0=NULL;
2124                 asprintf(&idx_0, "[%d]", cntr_set_0);
2125                 if (idx_0) {
2126                         ndr_print_lsa_LUIDAttribute(ndr, "set", &r->set[cntr_set_0]);
2127                         free(idx_0);
2128                 }
2129         }
2130         ndr->depth--;
2131         ndr->depth--;
2132 }
2133
2134 NTSTATUS ndr_push_lsa_DATA_BUF(struct ndr_push *ndr, int ndr_flags, const struct lsa_DATA_BUF *r)
2135 {
2136         {
2137                 uint32_t _flags_save_STRUCT = ndr->flags;
2138                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2139                 if (ndr_flags & NDR_SCALARS) {
2140                         NDR_CHECK(ndr_push_align(ndr, 4));
2141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
2142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2143                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
2144                 }
2145                 if (ndr_flags & NDR_BUFFERS) {
2146                         if (r->data) {
2147                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2148                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2149                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
2150                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
2151                         }
2152                 }
2153                 ndr->flags = _flags_save_STRUCT;
2154         }
2155         return NT_STATUS_OK;
2156 }
2157
2158 NTSTATUS ndr_pull_lsa_DATA_BUF(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF *r)
2159 {
2160         uint32_t _ptr_data;
2161         TALLOC_CTX *_mem_save_data_0;
2162         {
2163                 uint32_t _flags_save_STRUCT = ndr->flags;
2164                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2165                 if (ndr_flags & NDR_SCALARS) {
2166                         NDR_CHECK(ndr_pull_align(ndr, 4));
2167                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
2168                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2169                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2170                         if (_ptr_data) {
2171                                 NDR_PULL_ALLOC(ndr, r->data);
2172                         } else {
2173                                 r->data = NULL;
2174                         }
2175                 }
2176                 if (ndr_flags & NDR_BUFFERS) {
2177                         if (r->data) {
2178                                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2179                                 NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
2180                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
2181                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->data));
2182                                 if (ndr_get_array_length(ndr, &r->data) > ndr_get_array_size(ndr, &r->data)) {
2183                                         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));
2184                                 }
2185                                 NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
2186                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_length(ndr, &r->data)));
2187                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2188                         }
2189                         if (r->data) {
2190                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
2191                         }
2192                         if (r->data) {
2193                                 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->data, r->length));
2194                         }
2195                 }
2196                 ndr->flags = _flags_save_STRUCT;
2197         }
2198         return NT_STATUS_OK;
2199 }
2200
2201 _PUBLIC_ void ndr_print_lsa_DATA_BUF(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF *r)
2202 {
2203         ndr_print_struct(ndr, name, "lsa_DATA_BUF");
2204         {
2205                 uint32_t _flags_save_STRUCT = ndr->flags;
2206                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2207                 ndr->depth++;
2208                 ndr_print_uint32(ndr, "length", r->length);
2209                 ndr_print_uint32(ndr, "size", r->size);
2210                 ndr_print_ptr(ndr, "data", r->data);
2211                 ndr->depth++;
2212                 if (r->data) {
2213                         ndr_print_array_uint8(ndr, "data", r->data, r->length);
2214                 }
2215                 ndr->depth--;
2216                 ndr->depth--;
2217                 ndr->flags = _flags_save_STRUCT;
2218         }
2219 }
2220
2221 NTSTATUS ndr_push_lsa_DATA_BUF2(struct ndr_push *ndr, int ndr_flags, const struct lsa_DATA_BUF2 *r)
2222 {
2223         {
2224                 uint32_t _flags_save_STRUCT = ndr->flags;
2225                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2226                 if (ndr_flags & NDR_SCALARS) {
2227                         NDR_CHECK(ndr_push_align(ndr, 4));
2228                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2229                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
2230                 }
2231                 if (ndr_flags & NDR_BUFFERS) {
2232                         if (r->data) {
2233                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2234                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
2235                         }
2236                 }
2237                 ndr->flags = _flags_save_STRUCT;
2238         }
2239         return NT_STATUS_OK;
2240 }
2241
2242 NTSTATUS ndr_pull_lsa_DATA_BUF2(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF2 *r)
2243 {
2244         uint32_t _ptr_data;
2245         TALLOC_CTX *_mem_save_data_0;
2246         {
2247                 uint32_t _flags_save_STRUCT = ndr->flags;
2248                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2249                 if (ndr_flags & NDR_SCALARS) {
2250                         NDR_CHECK(ndr_pull_align(ndr, 4));
2251                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2252                         if (r->size < 0 || r->size > 65536) {
2253                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2254                         }
2255                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2256                         if (_ptr_data) {
2257                                 NDR_PULL_ALLOC(ndr, r->data);
2258                         } else {
2259                                 r->data = NULL;
2260                         }
2261                 }
2262                 if (ndr_flags & NDR_BUFFERS) {
2263                         if (r->data) {
2264                                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2265                                 NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
2266                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
2267                                 NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
2268                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
2269                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2270                         }
2271                         if (r->data) {
2272                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
2273                         }
2274                 }
2275                 ndr->flags = _flags_save_STRUCT;
2276         }
2277         return NT_STATUS_OK;
2278 }
2279
2280 _PUBLIC_ void ndr_print_lsa_DATA_BUF2(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF2 *r)
2281 {
2282         ndr_print_struct(ndr, name, "lsa_DATA_BUF2");
2283         {
2284                 uint32_t _flags_save_STRUCT = ndr->flags;
2285                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2286                 ndr->depth++;
2287                 ndr_print_uint32(ndr, "size", r->size);
2288                 ndr_print_ptr(ndr, "data", r->data);
2289                 ndr->depth++;
2290                 if (r->data) {
2291                         ndr_print_array_uint8(ndr, "data", r->data, r->size);
2292                 }
2293                 ndr->depth--;
2294                 ndr->depth--;
2295                 ndr->flags = _flags_save_STRUCT;
2296         }
2297 }
2298
2299 NTSTATUS ndr_push_lsa_TrustDomInfoEnum(struct ndr_push *ndr, int ndr_flags, enum lsa_TrustDomInfoEnum r)
2300 {
2301         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
2302         return NT_STATUS_OK;
2303 }
2304
2305 NTSTATUS ndr_pull_lsa_TrustDomInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum lsa_TrustDomInfoEnum *r)
2306 {
2307         uint16_t v;
2308         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
2309         *r = v;
2310         return NT_STATUS_OK;
2311 }
2312
2313 _PUBLIC_ void ndr_print_lsa_TrustDomInfoEnum(struct ndr_print *ndr, const char *name, enum lsa_TrustDomInfoEnum r)
2314 {
2315         const char *val = NULL;
2316
2317         switch (r) {
2318                 case LSA_TRUSTED_DOMAIN_INFO_NAME: val = "LSA_TRUSTED_DOMAIN_INFO_NAME"; break;
2319                 case LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS_INFO: val = "LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS_INFO"; break;
2320                 case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET: val = "LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET"; break;
2321                 case LSA_TRUSTED_DOMAIN_INFO_PASSWORD: val = "LSA_TRUSTED_DOMAIN_INFO_PASSWORD"; break;
2322                 case LSA_TRUSTED_DOMAIN_INFO_BASIC: val = "LSA_TRUSTED_DOMAIN_INFO_BASIC"; break;
2323                 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX: val = "LSA_TRUSTED_DOMAIN_INFO_INFO_EX"; break;
2324                 case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO: val = "LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO"; break;
2325                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO: val = "LSA_TRUSTED_DOMAIN_INFO_FULL_INFO"; break;
2326                 case LSA_TRUSTED_DOMAIN_INFO_11: val = "LSA_TRUSTED_DOMAIN_INFO_11"; break;
2327                 case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL: val = "LSA_TRUSTED_DOMAIN_INFO_INFO_ALL"; break;
2328         }
2329         ndr_print_enum(ndr, name, "ENUM", val, r);
2330 }
2331
2332 NTSTATUS ndr_push_lsa_TrustDomainInfoName(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoName *r)
2333 {
2334         if (ndr_flags & NDR_SCALARS) {
2335                 NDR_CHECK(ndr_push_align(ndr, 4));
2336                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2337         }
2338         if (ndr_flags & NDR_BUFFERS) {
2339                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2340         }
2341         return NT_STATUS_OK;
2342 }
2343
2344 NTSTATUS ndr_pull_lsa_TrustDomainInfoName(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoName *r)
2345 {
2346         if (ndr_flags & NDR_SCALARS) {
2347                 NDR_CHECK(ndr_pull_align(ndr, 4));
2348                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2349         }
2350         if (ndr_flags & NDR_BUFFERS) {
2351                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2352         }
2353         return NT_STATUS_OK;
2354 }
2355
2356 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoName(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoName *r)
2357 {
2358         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoName");
2359         ndr->depth++;
2360         ndr_print_lsa_StringLarge(ndr, "netbios_name", &r->netbios_name);
2361         ndr->depth--;
2362 }
2363
2364 NTSTATUS ndr_push_lsa_TrustDomainInfoPosixOffset(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoPosixOffset *r)
2365 {
2366         if (ndr_flags & NDR_SCALARS) {
2367                 NDR_CHECK(ndr_push_align(ndr, 4));
2368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->posix_offset));
2369         }
2370         if (ndr_flags & NDR_BUFFERS) {
2371         }
2372         return NT_STATUS_OK;
2373 }
2374
2375 NTSTATUS ndr_pull_lsa_TrustDomainInfoPosixOffset(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoPosixOffset *r)
2376 {
2377         if (ndr_flags & NDR_SCALARS) {
2378                 NDR_CHECK(ndr_pull_align(ndr, 4));
2379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->posix_offset));
2380         }
2381         if (ndr_flags & NDR_BUFFERS) {
2382         }
2383         return NT_STATUS_OK;
2384 }
2385
2386 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoPosixOffset(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoPosixOffset *r)
2387 {
2388         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoPosixOffset");
2389         ndr->depth++;
2390         ndr_print_uint32(ndr, "posix_offset", r->posix_offset);
2391         ndr->depth--;
2392 }
2393
2394 NTSTATUS ndr_push_lsa_TrustDomainInfoPassword(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoPassword *r)
2395 {
2396         if (ndr_flags & NDR_SCALARS) {
2397                 NDR_CHECK(ndr_push_align(ndr, 4));
2398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
2399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->old_password));
2400         }
2401         if (ndr_flags & NDR_BUFFERS) {
2402                 if (r->password) {
2403                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->password));
2404                 }
2405                 if (r->old_password) {
2406                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->old_password));
2407                 }
2408         }
2409         return NT_STATUS_OK;
2410 }
2411
2412 NTSTATUS ndr_pull_lsa_TrustDomainInfoPassword(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoPassword *r)
2413 {
2414         uint32_t _ptr_password;
2415         TALLOC_CTX *_mem_save_password_0;
2416         uint32_t _ptr_old_password;
2417         TALLOC_CTX *_mem_save_old_password_0;
2418         if (ndr_flags & NDR_SCALARS) {
2419                 NDR_CHECK(ndr_pull_align(ndr, 4));
2420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
2421                 if (_ptr_password) {
2422                         NDR_PULL_ALLOC(ndr, r->password);
2423                 } else {
2424                         r->password = NULL;
2425                 }
2426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_password));
2427                 if (_ptr_old_password) {
2428                         NDR_PULL_ALLOC(ndr, r->old_password);
2429                 } else {
2430                         r->old_password = NULL;
2431                 }
2432         }
2433         if (ndr_flags & NDR_BUFFERS) {
2434                 if (r->password) {
2435                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
2436                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
2437                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->password));
2438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
2439                 }
2440                 if (r->old_password) {
2441                         _mem_save_old_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
2442                         NDR_PULL_SET_MEM_CTX(ndr, r->old_password, 0);
2443                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->old_password));
2444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_password_0, 0);
2445                 }
2446         }
2447         return NT_STATUS_OK;
2448 }
2449
2450 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoPassword(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoPassword *r)
2451 {
2452         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoPassword");
2453         ndr->depth++;
2454         ndr_print_ptr(ndr, "password", r->password);
2455         ndr->depth++;
2456         if (r->password) {
2457                 ndr_print_lsa_DATA_BUF(ndr, "password", r->password);
2458         }
2459         ndr->depth--;
2460         ndr_print_ptr(ndr, "old_password", r->old_password);
2461         ndr->depth++;
2462         if (r->old_password) {
2463                 ndr_print_lsa_DATA_BUF(ndr, "old_password", r->old_password);
2464         }
2465         ndr->depth--;
2466         ndr->depth--;
2467 }
2468
2469 NTSTATUS ndr_push_lsa_TrustDomainInfoBasic(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoBasic *r)
2470 {
2471         if (ndr_flags & NDR_SCALARS) {
2472                 NDR_CHECK(ndr_push_align(ndr, 4));
2473                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->netbios_name));
2474                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2475         }
2476         if (ndr_flags & NDR_BUFFERS) {
2477                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->netbios_name));
2478                 if (r->sid) {
2479                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2480                 }
2481         }
2482         return NT_STATUS_OK;
2483 }
2484
2485 NTSTATUS ndr_pull_lsa_TrustDomainInfoBasic(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoBasic *r)
2486 {
2487         uint32_t _ptr_sid;
2488         TALLOC_CTX *_mem_save_sid_0;
2489         if (ndr_flags & NDR_SCALARS) {
2490                 NDR_CHECK(ndr_pull_align(ndr, 4));
2491                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->netbios_name));
2492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2493                 if (_ptr_sid) {
2494                         NDR_PULL_ALLOC(ndr, r->sid);
2495                 } else {
2496                         r->sid = NULL;
2497                 }
2498         }
2499         if (ndr_flags & NDR_BUFFERS) {
2500                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->netbios_name));
2501                 if (r->sid) {
2502                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2503                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2504                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2505                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2506                 }
2507         }
2508         return NT_STATUS_OK;
2509 }
2510
2511 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoBasic(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoBasic *r)
2512 {
2513         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoBasic");
2514         ndr->depth++;
2515         ndr_print_lsa_String(ndr, "netbios_name", &r->netbios_name);
2516         ndr_print_ptr(ndr, "sid", r->sid);
2517         ndr->depth++;
2518         if (r->sid) {
2519                 ndr_print_dom_sid2(ndr, "sid", r->sid);
2520         }
2521         ndr->depth--;
2522         ndr->depth--;
2523 }
2524
2525 NTSTATUS ndr_push_lsa_TrustDomainInfoInfoEx(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoInfoEx *r)
2526 {
2527         if (ndr_flags & NDR_SCALARS) {
2528                 NDR_CHECK(ndr_push_align(ndr, 4));
2529                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->domain_name));
2530                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2531                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->trust_direction));
2533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->trust_type));
2534                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->trust_attributes));
2535         }
2536         if (ndr_flags & NDR_BUFFERS) {
2537                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domain_name));
2538                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2539                 if (r->sid) {
2540                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2541                 }
2542         }
2543         return NT_STATUS_OK;
2544 }
2545
2546 NTSTATUS ndr_pull_lsa_TrustDomainInfoInfoEx(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoInfoEx *r)
2547 {
2548         uint32_t _ptr_sid;
2549         TALLOC_CTX *_mem_save_sid_0;
2550         if (ndr_flags & NDR_SCALARS) {
2551                 NDR_CHECK(ndr_pull_align(ndr, 4));
2552                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->domain_name));
2553                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2555                 if (_ptr_sid) {
2556                         NDR_PULL_ALLOC(ndr, r->sid);
2557                 } else {
2558                         r->sid = NULL;
2559                 }
2560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->trust_direction));
2561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->trust_type));
2562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->trust_attributes));
2563         }
2564         if (ndr_flags & NDR_BUFFERS) {
2565                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domain_name));
2566                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2567                 if (r->sid) {
2568                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2569                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2570                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2572                 }
2573         }
2574         return NT_STATUS_OK;
2575 }
2576
2577 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoInfoEx(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoInfoEx *r)
2578 {
2579         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoInfoEx");
2580         ndr->depth++;
2581         ndr_print_lsa_StringLarge(ndr, "domain_name", &r->domain_name);
2582         ndr_print_lsa_StringLarge(ndr, "netbios_name", &r->netbios_name);
2583         ndr_print_ptr(ndr, "sid", r->sid);
2584         ndr->depth++;
2585         if (r->sid) {
2586                 ndr_print_dom_sid2(ndr, "sid", r->sid);
2587         }
2588         ndr->depth--;
2589         ndr_print_uint32(ndr, "trust_direction", r->trust_direction);
2590         ndr_print_uint32(ndr, "trust_type", r->trust_type);
2591         ndr_print_uint32(ndr, "trust_attributes", r->trust_attributes);
2592         ndr->depth--;
2593 }
2594
2595 NTSTATUS ndr_push_lsa_TrustDomainInfoBuffer(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoBuffer *r)
2596 {
2597         if (ndr_flags & NDR_SCALARS) {
2598                 NDR_CHECK(ndr_push_align(ndr, 8));
2599                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_update_time));
2600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secret_type));
2601                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data));
2602         }
2603         if (ndr_flags & NDR_BUFFERS) {
2604                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data));
2605         }
2606         return NT_STATUS_OK;
2607 }
2608
2609 NTSTATUS ndr_pull_lsa_TrustDomainInfoBuffer(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoBuffer *r)
2610 {
2611         if (ndr_flags & NDR_SCALARS) {
2612                 NDR_CHECK(ndr_pull_align(ndr, 8));
2613                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_update_time));
2614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secret_type));
2615                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data));
2616         }
2617         if (ndr_flags & NDR_BUFFERS) {
2618                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data));
2619         }
2620         return NT_STATUS_OK;
2621 }
2622
2623 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoBuffer(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoBuffer *r)
2624 {
2625         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoBuffer");
2626         ndr->depth++;
2627         ndr_print_NTTIME_hyper(ndr, "last_update_time", r->last_update_time);
2628         ndr_print_uint32(ndr, "secret_type", r->secret_type);
2629         ndr_print_lsa_DATA_BUF2(ndr, "data", &r->data);
2630         ndr->depth--;
2631 }
2632
2633 NTSTATUS ndr_push_lsa_TrustDomainInfoAuthInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoAuthInfo *r)
2634 {
2635         if (ndr_flags & NDR_SCALARS) {
2636                 NDR_CHECK(ndr_push_align(ndr, 4));
2637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->incoming_count));
2638                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->incoming_current_auth_info));
2639                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->incoming_previous_auth_info));
2640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->outgoing_count));
2641                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->outgoing_current_auth_info));
2642                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->outgoing_previous_auth_info));
2643         }
2644         if (ndr_flags & NDR_BUFFERS) {
2645                 if (r->incoming_current_auth_info) {
2646                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_current_auth_info));
2647                 }
2648                 if (r->incoming_previous_auth_info) {
2649                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_previous_auth_info));
2650                 }
2651                 if (r->outgoing_current_auth_info) {
2652                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_current_auth_info));
2653                 }
2654                 if (r->outgoing_previous_auth_info) {
2655                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_previous_auth_info));
2656                 }
2657         }
2658         return NT_STATUS_OK;
2659 }
2660
2661 NTSTATUS ndr_pull_lsa_TrustDomainInfoAuthInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoAuthInfo *r)
2662 {
2663         uint32_t _ptr_incoming_current_auth_info;
2664         TALLOC_CTX *_mem_save_incoming_current_auth_info_0;
2665         uint32_t _ptr_incoming_previous_auth_info;
2666         TALLOC_CTX *_mem_save_incoming_previous_auth_info_0;
2667         uint32_t _ptr_outgoing_current_auth_info;
2668         TALLOC_CTX *_mem_save_outgoing_current_auth_info_0;
2669         uint32_t _ptr_outgoing_previous_auth_info;
2670         TALLOC_CTX *_mem_save_outgoing_previous_auth_info_0;
2671         if (ndr_flags & NDR_SCALARS) {
2672                 NDR_CHECK(ndr_pull_align(ndr, 4));
2673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->incoming_count));
2674                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_incoming_current_auth_info));
2675                 if (_ptr_incoming_current_auth_info) {
2676                         NDR_PULL_ALLOC(ndr, r->incoming_current_auth_info);
2677                 } else {
2678                         r->incoming_current_auth_info = NULL;
2679                 }
2680                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_incoming_previous_auth_info));
2681                 if (_ptr_incoming_previous_auth_info) {
2682                         NDR_PULL_ALLOC(ndr, r->incoming_previous_auth_info);
2683                 } else {
2684                         r->incoming_previous_auth_info = NULL;
2685                 }
2686                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->outgoing_count));
2687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_outgoing_current_auth_info));
2688                 if (_ptr_outgoing_current_auth_info) {
2689                         NDR_PULL_ALLOC(ndr, r->outgoing_current_auth_info);
2690                 } else {
2691                         r->outgoing_current_auth_info = NULL;
2692                 }
2693                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_outgoing_previous_auth_info));
2694                 if (_ptr_outgoing_previous_auth_info) {
2695                         NDR_PULL_ALLOC(ndr, r->outgoing_previous_auth_info);
2696                 } else {
2697                         r->outgoing_previous_auth_info = NULL;
2698                 }
2699         }
2700         if (ndr_flags & NDR_BUFFERS) {
2701                 if (r->incoming_current_auth_info) {
2702                         _mem_save_incoming_current_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2703                         NDR_PULL_SET_MEM_CTX(ndr, r->incoming_current_auth_info, 0);
2704                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_current_auth_info));
2705                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_incoming_current_auth_info_0, 0);
2706                 }
2707                 if (r->incoming_previous_auth_info) {
2708                         _mem_save_incoming_previous_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2709                         NDR_PULL_SET_MEM_CTX(ndr, r->incoming_previous_auth_info, 0);
2710                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_previous_auth_info));
2711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_incoming_previous_auth_info_0, 0);
2712                 }
2713                 if (r->outgoing_current_auth_info) {
2714                         _mem_save_outgoing_current_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2715                         NDR_PULL_SET_MEM_CTX(ndr, r->outgoing_current_auth_info, 0);
2716                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_current_auth_info));
2717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_outgoing_current_auth_info_0, 0);
2718                 }
2719                 if (r->outgoing_previous_auth_info) {
2720                         _mem_save_outgoing_previous_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2721                         NDR_PULL_SET_MEM_CTX(ndr, r->outgoing_previous_auth_info, 0);
2722                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_previous_auth_info));
2723                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_outgoing_previous_auth_info_0, 0);
2724                 }
2725         }
2726         return NT_STATUS_OK;
2727 }
2728
2729 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoAuthInfo(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoAuthInfo *r)
2730 {
2731         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoAuthInfo");
2732         ndr->depth++;
2733         ndr_print_uint32(ndr, "incoming_count", r->incoming_count);
2734         ndr_print_ptr(ndr, "incoming_current_auth_info", r->incoming_current_auth_info);
2735         ndr->depth++;
2736         if (r->incoming_current_auth_info) {
2737                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "incoming_current_auth_info", r->incoming_current_auth_info);
2738         }
2739         ndr->depth--;
2740         ndr_print_ptr(ndr, "incoming_previous_auth_info", r->incoming_previous_auth_info);
2741         ndr->depth++;
2742         if (r->incoming_previous_auth_info) {
2743                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "incoming_previous_auth_info", r->incoming_previous_auth_info);
2744         }
2745         ndr->depth--;
2746         ndr_print_uint32(ndr, "outgoing_count", r->outgoing_count);
2747         ndr_print_ptr(ndr, "outgoing_current_auth_info", r->outgoing_current_auth_info);
2748         ndr->depth++;
2749         if (r->outgoing_current_auth_info) {
2750                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "outgoing_current_auth_info", r->outgoing_current_auth_info);
2751         }
2752         ndr->depth--;
2753         ndr_print_ptr(ndr, "outgoing_previous_auth_info", r->outgoing_previous_auth_info);
2754         ndr->depth++;
2755         if (r->outgoing_previous_auth_info) {
2756                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "outgoing_previous_auth_info", r->outgoing_previous_auth_info);
2757         }
2758         ndr->depth--;
2759         ndr->depth--;
2760 }
2761
2762 NTSTATUS ndr_push_lsa_TrustDomainInfoFullInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoFullInfo *r)
2763 {
2764         if (ndr_flags & NDR_SCALARS) {
2765                 NDR_CHECK(ndr_push_align(ndr, 4));
2766                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2767                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
2768                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
2769         }
2770         if (ndr_flags & NDR_BUFFERS) {
2771                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2772                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
2773         }
2774         return NT_STATUS_OK;
2775 }
2776
2777 NTSTATUS ndr_pull_lsa_TrustDomainInfoFullInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoFullInfo *r)
2778 {
2779         if (ndr_flags & NDR_SCALARS) {
2780                 NDR_CHECK(ndr_pull_align(ndr, 4));
2781                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2782                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
2783                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
2784         }
2785         if (ndr_flags & NDR_BUFFERS) {
2786                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2787                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
2788         }
2789         return NT_STATUS_OK;
2790 }
2791
2792 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoFullInfo(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoFullInfo *r)
2793 {
2794         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoFullInfo");
2795         ndr->depth++;
2796         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
2797         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
2798         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
2799         ndr->depth--;
2800 }
2801
2802 NTSTATUS ndr_push_lsa_TrustDomainInfo11(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfo11 *r)
2803 {
2804         if (ndr_flags & NDR_SCALARS) {
2805                 NDR_CHECK(ndr_push_align(ndr, 4));
2806                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2807                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
2808         }
2809         if (ndr_flags & NDR_BUFFERS) {
2810                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2811                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
2812         }
2813         return NT_STATUS_OK;
2814 }
2815
2816 NTSTATUS ndr_pull_lsa_TrustDomainInfo11(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfo11 *r)
2817 {
2818         if (ndr_flags & NDR_SCALARS) {
2819                 NDR_CHECK(ndr_pull_align(ndr, 4));
2820                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2821                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
2822         }
2823         if (ndr_flags & NDR_BUFFERS) {
2824                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2825                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
2826         }
2827         return NT_STATUS_OK;
2828 }
2829
2830 _PUBLIC_ void ndr_print_lsa_TrustDomainInfo11(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfo11 *r)
2831 {
2832         ndr_print_struct(ndr, name, "lsa_TrustDomainInfo11");
2833         ndr->depth++;
2834         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
2835         ndr_print_lsa_DATA_BUF2(ndr, "data1", &r->data1);
2836         ndr->depth--;
2837 }
2838
2839 NTSTATUS ndr_push_lsa_TrustDomainInfoInfoAll(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoInfoAll *r)
2840 {
2841         if (ndr_flags & NDR_SCALARS) {
2842                 NDR_CHECK(ndr_push_align(ndr, 4));
2843                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2844                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
2845                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
2846                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
2847         }
2848         if (ndr_flags & NDR_BUFFERS) {
2849                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2850                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
2851                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
2852         }
2853         return NT_STATUS_OK;
2854 }
2855
2856 NTSTATUS ndr_pull_lsa_TrustDomainInfoInfoAll(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoInfoAll *r)
2857 {
2858         if (ndr_flags & NDR_SCALARS) {
2859                 NDR_CHECK(ndr_pull_align(ndr, 4));
2860                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2861                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
2862                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
2863                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
2864         }
2865         if (ndr_flags & NDR_BUFFERS) {
2866                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2867                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
2868                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
2869         }
2870         return NT_STATUS_OK;
2871 }
2872
2873 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoInfoAll(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoInfoAll *r)
2874 {
2875         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoInfoAll");
2876         ndr->depth++;
2877         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
2878         ndr_print_lsa_DATA_BUF2(ndr, "data1", &r->data1);
2879         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
2880         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
2881         ndr->depth--;
2882 }
2883
2884 NTSTATUS ndr_push_lsa_TrustedDomainInfo(struct ndr_push *ndr, int ndr_flags, const union lsa_TrustedDomainInfo *r)
2885 {
2886         if (ndr_flags & NDR_SCALARS) {
2887                 int level = ndr_push_get_switch_value(ndr, r);
2888                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, level));
2889                 switch (level) {
2890                         case LSA_TRUSTED_DOMAIN_INFO_NAME:
2891                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoName(ndr, NDR_SCALARS, &r->name));
2892                         break;
2893
2894                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
2895                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
2896                         break;
2897
2898                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
2899                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPassword(ndr, NDR_SCALARS, &r->password));
2900                         break;
2901
2902                         case LSA_TRUSTED_DOMAIN_INFO_BASIC:
2903                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoBasic(ndr, NDR_SCALARS, &r->info_basic));
2904                         break;
2905
2906                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
2907                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2908                         break;
2909
2910                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
2911                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
2912                         break;
2913
2914                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
2915                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfo(ndr, NDR_SCALARS, &r->full_info));
2916                         break;
2917
2918                         case LSA_TRUSTED_DOMAIN_INFO_11:
2919                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfo11(ndr, NDR_SCALARS, &r->info11));
2920                         break;
2921
2922                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL:
2923                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoAll(ndr, NDR_SCALARS, &r->info_all));
2924                         break;
2925
2926                         default:
2927                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2928                 }
2929         }
2930         if (ndr_flags & NDR_BUFFERS) {
2931                 int level = ndr_push_get_switch_value(ndr, r);
2932                 switch (level) {
2933                         case LSA_TRUSTED_DOMAIN_INFO_NAME:
2934                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoName(ndr, NDR_BUFFERS, &r->name));
2935                         break;
2936
2937                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
2938                         break;
2939
2940                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
2941                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPassword(ndr, NDR_BUFFERS, &r->password));
2942                         break;
2943
2944                         case LSA_TRUSTED_DOMAIN_INFO_BASIC:
2945                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoBasic(ndr, NDR_BUFFERS, &r->info_basic));
2946                         break;
2947
2948                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
2949                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2950                         break;
2951
2952                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
2953                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
2954                         break;
2955
2956                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
2957                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfo(ndr, NDR_BUFFERS, &r->full_info));
2958                         break;
2959
2960                         case LSA_TRUSTED_DOMAIN_INFO_11:
2961                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfo11(ndr, NDR_BUFFERS, &r->info11));
2962                         break;
2963
2964                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL:
2965                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoAll(ndr, NDR_BUFFERS, &r->info_all));
2966                         break;
2967
2968                         default:
2969                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
2970                 }
2971         }
2972         return NT_STATUS_OK;
2973 }
2974
2975 NTSTATUS ndr_pull_lsa_TrustedDomainInfo(struct ndr_pull *ndr, int ndr_flags, union lsa_TrustedDomainInfo *r)
2976 {
2977         int level;
2978         uint16_t _level;
2979         level = ndr_pull_get_switch_value(ndr, r);
2980         if (ndr_flags & NDR_SCALARS) {
2981                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
2982                 if (_level != level) {
2983                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
2984                 }
2985                 switch (level) {
2986                         case LSA_TRUSTED_DOMAIN_INFO_NAME: {
2987                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoName(ndr, NDR_SCALARS, &r->name));
2988                         break; }
2989
2990                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET: {
2991                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
2992                         break; }
2993
2994                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD: {
2995                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPassword(ndr, NDR_SCALARS, &r->password));
2996                         break; }
2997
2998                         case LSA_TRUSTED_DOMAIN_INFO_BASIC: {
2999                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBasic(ndr, NDR_SCALARS, &r->info_basic));
3000                         break; }
3001
3002                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX: {
3003                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3004                         break; }
3005
3006                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO: {
3007                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3008                         break; }
3009
3010                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO: {
3011                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfo(ndr, NDR_SCALARS, &r->full_info));
3012                         break; }
3013
3014                         case LSA_TRUSTED_DOMAIN_INFO_11: {
3015                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfo11(ndr, NDR_SCALARS, &r->info11));
3016                         break; }
3017
3018                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL: {
3019                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoAll(ndr, NDR_SCALARS, &r->info_all));
3020                         break; }
3021
3022                         default:
3023                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3024                 }
3025         }
3026         if (ndr_flags & NDR_BUFFERS) {
3027                 switch (level) {
3028                         case LSA_TRUSTED_DOMAIN_INFO_NAME:
3029                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoName(ndr, NDR_BUFFERS, &r->name));
3030                         break;
3031
3032                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
3033                         break;
3034
3035                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
3036                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPassword(ndr, NDR_BUFFERS, &r->password));
3037                         break;
3038
3039                         case LSA_TRUSTED_DOMAIN_INFO_BASIC:
3040                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBasic(ndr, NDR_BUFFERS, &r->info_basic));
3041                         break;
3042
3043                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
3044                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3045                         break;
3046
3047                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
3048                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3049                         break;
3050
3051                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
3052                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfo(ndr, NDR_BUFFERS, &r->full_info));
3053                         break;
3054
3055                         case LSA_TRUSTED_DOMAIN_INFO_11:
3056                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfo11(ndr, NDR_BUFFERS, &r->info11));
3057                         break;
3058
3059                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL:
3060                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoAll(ndr, NDR_BUFFERS, &r->info_all));
3061                         break;
3062
3063                         default:
3064                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3065                 }
3066         }
3067         return NT_STATUS_OK;
3068 }
3069
3070 _PUBLIC_ void ndr_print_lsa_TrustedDomainInfo(struct ndr_print *ndr, const char *name, const union lsa_TrustedDomainInfo *r)
3071 {
3072         int level;
3073         level = ndr_print_get_switch_value(ndr, r);
3074         ndr_print_union(ndr, name, level, "lsa_TrustedDomainInfo");
3075         switch (level) {
3076                 case LSA_TRUSTED_DOMAIN_INFO_NAME:
3077                         ndr_print_lsa_TrustDomainInfoName(ndr, "name", &r->name);
3078                 break;
3079
3080                 case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
3081                         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
3082                 break;
3083
3084                 case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
3085                         ndr_print_lsa_TrustDomainInfoPassword(ndr, "password", &r->password);
3086                 break;
3087
3088                 case LSA_TRUSTED_DOMAIN_INFO_BASIC:
3089                         ndr_print_lsa_TrustDomainInfoBasic(ndr, "info_basic", &r->info_basic);
3090                 break;
3091
3092                 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
3093                         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
3094                 break;
3095
3096                 case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
3097                         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
3098                 break;
3099
3100                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
3101                         ndr_print_lsa_TrustDomainInfoFullInfo(ndr, "full_info", &r->full_info);
3102                 break;
3103
3104                 case LSA_TRUSTED_DOMAIN_INFO_11:
3105                         ndr_print_lsa_TrustDomainInfo11(ndr, "info11", &r->info11);
3106                 break;
3107
3108                 case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL:
3109                         ndr_print_lsa_TrustDomainInfoInfoAll(ndr, "info_all", &r->info_all);
3110                 break;
3111
3112                 default:
3113                         ndr_print_bad_level(ndr, name, level);
3114         }
3115 }
3116
3117 NTSTATUS ndr_push_lsa_DATA_BUF_PTR(struct ndr_push *ndr, int ndr_flags, const struct lsa_DATA_BUF_PTR *r)
3118 {
3119         if (ndr_flags & NDR_SCALARS) {
3120                 NDR_CHECK(ndr_push_align(ndr, 4));
3121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->buf));
3122         }
3123         if (ndr_flags & NDR_BUFFERS) {
3124                 if (r->buf) {
3125                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->buf));
3126                 }
3127         }
3128         return NT_STATUS_OK;
3129 }
3130
3131 NTSTATUS ndr_pull_lsa_DATA_BUF_PTR(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF_PTR *r)
3132 {
3133         uint32_t _ptr_buf;
3134         TALLOC_CTX *_mem_save_buf_0;
3135         if (ndr_flags & NDR_SCALARS) {
3136                 NDR_CHECK(ndr_pull_align(ndr, 4));
3137                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buf));
3138                 if (_ptr_buf) {
3139                         NDR_PULL_ALLOC(ndr, r->buf);
3140                 } else {
3141                         r->buf = NULL;
3142                 }
3143         }
3144         if (ndr_flags & NDR_BUFFERS) {
3145                 if (r->buf) {
3146                         _mem_save_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);
3147                         NDR_PULL_SET_MEM_CTX(ndr, r->buf, 0);
3148                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->buf));
3149                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buf_0, 0);
3150                 }
3151         }
3152         return NT_STATUS_OK;
3153 }
3154
3155 _PUBLIC_ void ndr_print_lsa_DATA_BUF_PTR(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF_PTR *r)
3156 {
3157         ndr_print_struct(ndr, name, "lsa_DATA_BUF_PTR");
3158         ndr->depth++;
3159         ndr_print_ptr(ndr, "buf", r->buf);
3160         ndr->depth++;
3161         if (r->buf) {
3162                 ndr_print_lsa_DATA_BUF(ndr, "buf", r->buf);
3163         }
3164         ndr->depth--;
3165         ndr->depth--;
3166 }
3167
3168 NTSTATUS ndr_push_lsa_RightSet(struct ndr_push *ndr, int ndr_flags, const struct lsa_RightSet *r)
3169 {
3170         uint32_t cntr_names_1;
3171         if (ndr_flags & NDR_SCALARS) {
3172                 NDR_CHECK(ndr_push_align(ndr, 4));
3173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3174                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
3175         }
3176         if (ndr_flags & NDR_BUFFERS) {
3177                 if (r->names) {
3178                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3179                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3180                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3181                         }
3182                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3183                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3184                         }
3185                 }
3186         }
3187         return NT_STATUS_OK;
3188 }
3189
3190 NTSTATUS ndr_pull_lsa_RightSet(struct ndr_pull *ndr, int ndr_flags, struct lsa_RightSet *r)
3191 {
3192         uint32_t _ptr_names;
3193         uint32_t cntr_names_1;
3194         TALLOC_CTX *_mem_save_names_0;
3195         TALLOC_CTX *_mem_save_names_1;
3196         if (ndr_flags & NDR_SCALARS) {
3197                 NDR_CHECK(ndr_pull_align(ndr, 4));
3198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
3200                 if (_ptr_names) {
3201                         NDR_PULL_ALLOC(ndr, r->names);
3202                 } else {
3203                         r->names = NULL;
3204                 }
3205         }
3206         if (ndr_flags & NDR_BUFFERS) {
3207                 if (r->names) {
3208                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
3209                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3210                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
3211                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
3212                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
3213                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3214                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3215                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3216                         }
3217                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3218                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3219                         }
3220                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
3221                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
3222                 }
3223                 if (r->names) {
3224                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
3225                 }
3226         }
3227         return NT_STATUS_OK;
3228 }
3229
3230 _PUBLIC_ void ndr_print_lsa_RightSet(struct ndr_print *ndr, const char *name, const struct lsa_RightSet *r)
3231 {
3232         uint32_t cntr_names_1;
3233         ndr_print_struct(ndr, name, "lsa_RightSet");
3234         ndr->depth++;
3235         ndr_print_uint32(ndr, "count", r->count);
3236         ndr_print_ptr(ndr, "names", r->names);
3237         ndr->depth++;
3238         if (r->names) {
3239                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->count);
3240                 ndr->depth++;
3241                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
3242                         char *idx_1=NULL;
3243                         asprintf(&idx_1, "[%d]", cntr_names_1);
3244                         if (idx_1) {
3245                                 ndr_print_lsa_StringLarge(ndr, "names", &r->names[cntr_names_1]);
3246                                 free(idx_1);
3247                         }
3248                 }
3249                 ndr->depth--;
3250         }
3251         ndr->depth--;
3252         ndr->depth--;
3253 }
3254
3255 NTSTATUS ndr_push_lsa_StringPointer(struct ndr_push *ndr, int ndr_flags, const struct lsa_StringPointer *r)
3256 {
3257         if (ndr_flags & NDR_SCALARS) {
3258                 NDR_CHECK(ndr_push_align(ndr, 4));
3259                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
3260         }
3261         if (ndr_flags & NDR_BUFFERS) {
3262                 if (r->string) {
3263                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->string));
3264                 }
3265         }
3266         return NT_STATUS_OK;
3267 }
3268
3269 NTSTATUS ndr_pull_lsa_StringPointer(struct ndr_pull *ndr, int ndr_flags, struct lsa_StringPointer *r)
3270 {
3271         uint32_t _ptr_string;
3272         TALLOC_CTX *_mem_save_string_0;
3273         if (ndr_flags & NDR_SCALARS) {
3274                 NDR_CHECK(ndr_pull_align(ndr, 4));
3275                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
3276                 if (_ptr_string) {
3277                         NDR_PULL_ALLOC(ndr, r->string);
3278                 } else {
3279                         r->string = NULL;
3280                 }
3281         }
3282         if (ndr_flags & NDR_BUFFERS) {
3283                 if (r->string) {
3284                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
3285                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
3286                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->string));
3287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
3288                 }
3289         }
3290         return NT_STATUS_OK;
3291 }
3292
3293 _PUBLIC_ void ndr_print_lsa_StringPointer(struct ndr_print *ndr, const char *name, const struct lsa_StringPointer *r)
3294 {
3295         ndr_print_struct(ndr, name, "lsa_StringPointer");
3296         ndr->depth++;
3297         ndr_print_ptr(ndr, "string", r->string);
3298         ndr->depth++;
3299         if (r->string) {
3300                 ndr_print_lsa_String(ndr, "string", r->string);
3301         }
3302         ndr->depth--;
3303         ndr->depth--;
3304 }
3305
3306 NTSTATUS ndr_push_lsa_DomainListEx(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainListEx *r)
3307 {
3308         uint32_t cntr_domains_1;
3309         if (ndr_flags & NDR_SCALARS) {
3310                 NDR_CHECK(ndr_push_align(ndr, 4));
3311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3312                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
3313         }
3314         if (ndr_flags & NDR_BUFFERS) {
3315                 if (r->domains) {
3316                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3317                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3318                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
3319                         }
3320                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3321                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
3322                         }
3323                 }
3324         }
3325         return NT_STATUS_OK;
3326 }
3327
3328 NTSTATUS ndr_pull_lsa_DomainListEx(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainListEx *r)
3329 {
3330         uint32_t _ptr_domains;
3331         uint32_t cntr_domains_1;
3332         TALLOC_CTX *_mem_save_domains_0;
3333         TALLOC_CTX *_mem_save_domains_1;
3334         if (ndr_flags & NDR_SCALARS) {
3335                 NDR_CHECK(ndr_pull_align(ndr, 4));
3336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3337                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
3338                 if (_ptr_domains) {
3339                         NDR_PULL_ALLOC(ndr, r->domains);
3340                 } else {
3341                         r->domains = NULL;
3342                 }
3343         }
3344         if (ndr_flags & NDR_BUFFERS) {
3345                 if (r->domains) {
3346                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3347                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
3348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
3349                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
3350                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
3351                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
3352                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3353                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
3354                         }
3355                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3356                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
3357                         }
3358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
3359                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
3360                 }
3361                 if (r->domains) {
3362                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
3363                 }
3364         }
3365         return NT_STATUS_OK;
3366 }
3367
3368 _PUBLIC_ void ndr_print_lsa_DomainListEx(struct ndr_print *ndr, const char *name, const struct lsa_DomainListEx *r)
3369 {
3370         uint32_t cntr_domains_1;
3371         ndr_print_struct(ndr, name, "lsa_DomainListEx");
3372         ndr->depth++;
3373         ndr_print_uint32(ndr, "count", r->count);
3374         ndr_print_ptr(ndr, "domains", r->domains);
3375         ndr->depth++;
3376         if (r->domains) {
3377                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", r->count);
3378                 ndr->depth++;
3379                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
3380                         char *idx_1=NULL;
3381                         asprintf(&idx_1, "[%d]", cntr_domains_1);
3382                         if (idx_1) {
3383                                 ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "domains", &r->domains[cntr_domains_1]);
3384                                 free(idx_1);
3385                         }
3386                 }
3387                 ndr->depth--;
3388         }
3389         ndr->depth--;
3390         ndr->depth--;
3391 }
3392
3393 NTSTATUS ndr_push_lsa_DomainInfoKerberos(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfoKerberos *r)
3394 {
3395         if (ndr_flags & NDR_SCALARS) {
3396                 NDR_CHECK(ndr_push_align(ndr, 8));
3397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enforce_restrictions));
3398                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->service_tkt_lifetime));
3399                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->user_tkt_lifetime));
3400                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->user_tkt_renewaltime));
3401                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->clock_skew));
3402                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown6));
3403         }
3404         if (ndr_flags & NDR_BUFFERS) {
3405         }
3406         return NT_STATUS_OK;
3407 }
3408
3409 NTSTATUS ndr_pull_lsa_DomainInfoKerberos(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfoKerberos *r)
3410 {
3411         if (ndr_flags & NDR_SCALARS) {
3412                 NDR_CHECK(ndr_pull_align(ndr, 8));
3413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enforce_restrictions));
3414                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->service_tkt_lifetime));
3415                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->user_tkt_lifetime));
3416                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->user_tkt_renewaltime));
3417                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->clock_skew));
3418                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown6));
3419         }
3420         if (ndr_flags & NDR_BUFFERS) {
3421         }
3422         return NT_STATUS_OK;
3423 }
3424
3425 _PUBLIC_ void ndr_print_lsa_DomainInfoKerberos(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfoKerberos *r)
3426 {
3427         ndr_print_struct(ndr, name, "lsa_DomainInfoKerberos");
3428         ndr->depth++;
3429         ndr_print_uint32(ndr, "enforce_restrictions", r->enforce_restrictions);
3430         ndr_print_hyper(ndr, "service_tkt_lifetime", r->service_tkt_lifetime);
3431         ndr_print_hyper(ndr, "user_tkt_lifetime", r->user_tkt_lifetime);
3432         ndr_print_hyper(ndr, "user_tkt_renewaltime", r->user_tkt_renewaltime);
3433         ndr_print_hyper(ndr, "clock_skew", r->clock_skew);
3434         ndr_print_hyper(ndr, "unknown6", r->unknown6);
3435         ndr->depth--;
3436 }
3437
3438 NTSTATUS ndr_push_lsa_DomainInfoEfs(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfoEfs *r)
3439 {
3440         if (ndr_flags & NDR_SCALARS) {
3441                 NDR_CHECK(ndr_push_align(ndr, 4));
3442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->blob_size));
3443                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->efs_blob));
3444         }
3445         if (ndr_flags & NDR_BUFFERS) {
3446                 if (r->efs_blob) {
3447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->blob_size));
3448                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->efs_blob, r->blob_size));
3449                 }
3450         }
3451         return NT_STATUS_OK;
3452 }
3453
3454 NTSTATUS ndr_pull_lsa_DomainInfoEfs(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfoEfs *r)
3455 {
3456         uint32_t _ptr_efs_blob;
3457         TALLOC_CTX *_mem_save_efs_blob_0;
3458         if (ndr_flags & NDR_SCALARS) {
3459                 NDR_CHECK(ndr_pull_align(ndr, 4));
3460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->blob_size));
3461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_efs_blob));
3462                 if (_ptr_efs_blob) {
3463                         NDR_PULL_ALLOC(ndr, r->efs_blob);
3464                 } else {
3465                         r->efs_blob = NULL;
3466                 }
3467         }
3468         if (ndr_flags & NDR_BUFFERS) {
3469                 if (r->efs_blob) {
3470                         _mem_save_efs_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
3471                         NDR_PULL_SET_MEM_CTX(ndr, r->efs_blob, 0);
3472                         NDR_CHECK(ndr_pull_array_size(ndr, &r->efs_blob));
3473                         NDR_PULL_ALLOC_N(ndr, r->efs_blob, ndr_get_array_size(ndr, &r->efs_blob));
3474                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->efs_blob, ndr_get_array_size(ndr, &r->efs_blob)));
3475                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_efs_blob_0, 0);
3476                 }
3477                 if (r->efs_blob) {
3478                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->efs_blob, r->blob_size));
3479                 }
3480         }
3481         return NT_STATUS_OK;
3482 }
3483
3484 _PUBLIC_ void ndr_print_lsa_DomainInfoEfs(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfoEfs *r)
3485 {
3486         ndr_print_struct(ndr, name, "lsa_DomainInfoEfs");
3487         ndr->depth++;
3488         ndr_print_uint32(ndr, "blob_size", r->blob_size);
3489         ndr_print_ptr(ndr, "efs_blob", r->efs_blob);
3490         ndr->depth++;
3491         if (r->efs_blob) {
3492                 ndr_print_array_uint8(ndr, "efs_blob", r->efs_blob, r->blob_size);
3493         }
3494         ndr->depth--;
3495         ndr->depth--;
3496 }
3497
3498 NTSTATUS ndr_push_lsa_DomainInformationPolicy(struct ndr_push *ndr, int ndr_flags, const union lsa_DomainInformationPolicy *r)
3499 {
3500         if (ndr_flags & NDR_SCALARS) {
3501                 int level = ndr_push_get_switch_value(ndr, r);
3502                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
3503                 switch (level) {
3504                         case LSA_DOMAIN_INFO_POLICY_EFS:
3505                                 NDR_CHECK(ndr_push_lsa_DomainInfoEfs(ndr, NDR_SCALARS, &r->efs_info));
3506                         break;
3507
3508                         case LSA_DOMAIN_INFO_POLICY_KERBEROS:
3509                                 NDR_CHECK(ndr_push_lsa_DomainInfoKerberos(ndr, NDR_SCALARS, &r->kerberos_info));
3510                         break;
3511
3512                         default:
3513                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3514                 }
3515         }
3516         if (ndr_flags & NDR_BUFFERS) {
3517                 int level = ndr_push_get_switch_value(ndr, r);
3518                 switch (level) {
3519                         case LSA_DOMAIN_INFO_POLICY_EFS:
3520                                 NDR_CHECK(ndr_push_lsa_DomainInfoEfs(ndr, NDR_BUFFERS, &r->efs_info));
3521                         break;
3522
3523                         case LSA_DOMAIN_INFO_POLICY_KERBEROS:
3524                         break;
3525
3526                         default:
3527                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3528                 }
3529         }
3530         return NT_STATUS_OK;
3531 }
3532
3533 NTSTATUS ndr_pull_lsa_DomainInformationPolicy(struct ndr_pull *ndr, int ndr_flags, union lsa_DomainInformationPolicy *r)
3534 {
3535         int level;
3536         uint16_t _level;
3537         level = ndr_pull_get_switch_value(ndr, r);
3538         if (ndr_flags & NDR_SCALARS) {
3539                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3540                 if (_level != level) {
3541                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3542                 }
3543                 switch (level) {
3544                         case LSA_DOMAIN_INFO_POLICY_EFS: {
3545                                 NDR_CHECK(ndr_pull_lsa_DomainInfoEfs(ndr, NDR_SCALARS, &r->efs_info));
3546                         break; }
3547
3548                         case LSA_DOMAIN_INFO_POLICY_KERBEROS: {
3549                                 NDR_CHECK(ndr_pull_lsa_DomainInfoKerberos(ndr, NDR_SCALARS, &r->kerberos_info));
3550                         break; }
3551
3552                         default:
3553                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3554                 }
3555         }
3556         if (ndr_flags & NDR_BUFFERS) {
3557                 switch (level) {
3558                         case LSA_DOMAIN_INFO_POLICY_EFS:
3559                                 NDR_CHECK(ndr_pull_lsa_DomainInfoEfs(ndr, NDR_BUFFERS, &r->efs_info));
3560                         break;
3561
3562                         case LSA_DOMAIN_INFO_POLICY_KERBEROS:
3563                         break;
3564
3565                         default:
3566                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3567                 }
3568         }
3569         return NT_STATUS_OK;
3570 }
3571
3572 _PUBLIC_ void ndr_print_lsa_DomainInformationPolicy(struct ndr_print *ndr, const char *name, const union lsa_DomainInformationPolicy *r)
3573 {
3574         int level;
3575         level = ndr_print_get_switch_value(ndr, r);
3576         ndr_print_union(ndr, name, level, "lsa_DomainInformationPolicy");
3577         switch (level) {
3578                 case LSA_DOMAIN_INFO_POLICY_EFS:
3579                         ndr_print_lsa_DomainInfoEfs(ndr, "efs_info", &r->efs_info);
3580                 break;
3581
3582                 case LSA_DOMAIN_INFO_POLICY_KERBEROS:
3583                         ndr_print_lsa_DomainInfoKerberos(ndr, "kerberos_info", &r->kerberos_info);
3584                 break;
3585
3586                 default:
3587                         ndr_print_bad_level(ndr, name, level);
3588         }
3589 }
3590
3591 NTSTATUS ndr_push_lsa_TranslatedName2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedName2 *r)
3592 {
3593         if (ndr_flags & NDR_SCALARS) {
3594                 NDR_CHECK(ndr_push_align(ndr, 4));
3595                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
3596                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
3597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
3598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
3599         }
3600         if (ndr_flags & NDR_BUFFERS) {
3601                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
3602         }
3603         return NT_STATUS_OK;
3604 }
3605
3606 NTSTATUS ndr_pull_lsa_TranslatedName2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedName2 *r)
3607 {
3608         if (ndr_flags & NDR_SCALARS) {
3609                 NDR_CHECK(ndr_pull_align(ndr, 4));
3610                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
3611                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
3612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
3613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
3614         }
3615         if (ndr_flags & NDR_BUFFERS) {
3616                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
3617         }
3618         return NT_STATUS_OK;
3619 }
3620
3621 _PUBLIC_ void ndr_print_lsa_TranslatedName2(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedName2 *r)
3622 {
3623         ndr_print_struct(ndr, name, "lsa_TranslatedName2");
3624         ndr->depth++;
3625         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
3626         ndr_print_lsa_String(ndr, "name", &r->name);
3627         ndr_print_uint32(ndr, "sid_index", r->sid_index);
3628         ndr_print_uint32(ndr, "unknown", r->unknown);
3629         ndr->depth--;
3630 }
3631
3632 NTSTATUS ndr_push_lsa_TransNameArray2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransNameArray2 *r)
3633 {
3634         uint32_t cntr_names_1;
3635         if (ndr_flags & NDR_SCALARS) {
3636                 NDR_CHECK(ndr_push_align(ndr, 4));
3637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3638                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
3639         }
3640         if (ndr_flags & NDR_BUFFERS) {
3641                 if (r->names) {
3642                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3643                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3644                                 NDR_CHECK(ndr_push_lsa_TranslatedName2(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3645                         }
3646                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3647                                 NDR_CHECK(ndr_push_lsa_TranslatedName2(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3648                         }
3649                 }
3650         }
3651         return NT_STATUS_OK;
3652 }
3653
3654 NTSTATUS ndr_pull_lsa_TransNameArray2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransNameArray2 *r)
3655 {
3656         uint32_t _ptr_names;
3657         uint32_t cntr_names_1;
3658         TALLOC_CTX *_mem_save_names_0;
3659         TALLOC_CTX *_mem_save_names_1;
3660         if (ndr_flags & NDR_SCALARS) {
3661                 NDR_CHECK(ndr_pull_align(ndr, 4));
3662                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3663                 if (r->count < 0 || r->count > 1000) {
3664                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3665                 }
3666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
3667                 if (_ptr_names) {
3668                         NDR_PULL_ALLOC(ndr, r->names);
3669                 } else {
3670                         r->names = NULL;
3671                 }
3672         }
3673         if (ndr_flags & NDR_BUFFERS) {
3674                 if (r->names) {
3675                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
3676                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3677                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
3678                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
3679                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
3680                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3681                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3682                                 NDR_CHECK(ndr_pull_lsa_TranslatedName2(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3683                         }
3684                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3685                                 NDR_CHECK(ndr_pull_lsa_TranslatedName2(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3686                         }
3687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
3688                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
3689                 }
3690                 if (r->names) {
3691                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
3692                 }
3693         }
3694         return NT_STATUS_OK;
3695 }
3696
3697 _PUBLIC_ void ndr_print_lsa_TransNameArray2(struct ndr_print *ndr, const char *name, const struct lsa_TransNameArray2 *r)
3698 {
3699         uint32_t cntr_names_1;
3700         ndr_print_struct(ndr, name, "lsa_TransNameArray2");
3701         ndr->depth++;
3702         ndr_print_uint32(ndr, "count", r->count);
3703         ndr_print_ptr(ndr, "names", r->names);
3704         ndr->depth++;
3705         if (r->names) {
3706                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->count);
3707                 ndr->depth++;
3708                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
3709                         char *idx_1=NULL;
3710                         asprintf(&idx_1, "[%d]", cntr_names_1);
3711                         if (idx_1) {
3712                                 ndr_print_lsa_TranslatedName2(ndr, "names", &r->names[cntr_names_1]);
3713                                 free(idx_1);
3714                         }
3715                 }
3716                 ndr->depth--;
3717         }
3718         ndr->depth--;
3719         ndr->depth--;
3720 }
3721
3722 NTSTATUS ndr_push_lsa_TranslatedSid2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid2 *r)
3723 {
3724         if (ndr_flags & NDR_SCALARS) {
3725                 NDR_CHECK(ndr_push_align(ndr, 4));
3726                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
3727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
3729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
3730         }
3731         if (ndr_flags & NDR_BUFFERS) {
3732         }
3733         return NT_STATUS_OK;
3734 }
3735
3736 NTSTATUS ndr_pull_lsa_TranslatedSid2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid2 *r)
3737 {
3738         if (ndr_flags & NDR_SCALARS) {
3739                 NDR_CHECK(ndr_pull_align(ndr, 4));
3740                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
3741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
3743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
3744         }
3745         if (ndr_flags & NDR_BUFFERS) {
3746         }
3747         return NT_STATUS_OK;
3748 }
3749
3750 _PUBLIC_ void ndr_print_lsa_TranslatedSid2(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid2 *r)
3751 {
3752         ndr_print_struct(ndr, name, "lsa_TranslatedSid2");
3753         ndr->depth++;
3754         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
3755         ndr_print_uint32(ndr, "rid", r->rid);
3756         ndr_print_uint32(ndr, "sid_index", r->sid_index);
3757         ndr_print_uint32(ndr, "unknown", r->unknown);
3758         ndr->depth--;
3759 }
3760
3761 NTSTATUS ndr_push_lsa_TransSidArray2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray2 *r)
3762 {
3763         uint32_t cntr_sids_1;
3764         if (ndr_flags & NDR_SCALARS) {
3765                 NDR_CHECK(ndr_push_align(ndr, 4));
3766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
3768         }
3769         if (ndr_flags & NDR_BUFFERS) {
3770                 if (r->sids) {
3771                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3772                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3773                                 NDR_CHECK(ndr_push_lsa_TranslatedSid2(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
3774                         }
3775                 }
3776         }
3777         return NT_STATUS_OK;
3778 }
3779
3780 NTSTATUS ndr_pull_lsa_TransSidArray2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray2 *r)
3781 {
3782         uint32_t _ptr_sids;
3783         uint32_t cntr_sids_1;
3784         TALLOC_CTX *_mem_save_sids_0;
3785         TALLOC_CTX *_mem_save_sids_1;
3786         if (ndr_flags & NDR_SCALARS) {
3787                 NDR_CHECK(ndr_pull_align(ndr, 4));
3788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3789                 if (r->count < 0 || r->count > 1000) {
3790                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3791                 }
3792                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
3793                 if (_ptr_sids) {
3794                         NDR_PULL_ALLOC(ndr, r->sids);
3795                 } else {
3796                         r->sids = NULL;
3797                 }
3798         }
3799         if (ndr_flags & NDR_BUFFERS) {
3800                 if (r->sids) {
3801                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
3802                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3803                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
3804                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
3805                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
3806                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3807                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3808                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid2(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
3809                         }
3810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
3811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
3812                 }
3813                 if (r->sids) {
3814                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
3815                 }
3816         }
3817         return NT_STATUS_OK;
3818 }
3819
3820 _PUBLIC_ void ndr_print_lsa_TransSidArray2(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray2 *r)
3821 {
3822         uint32_t cntr_sids_1;
3823         ndr_print_struct(ndr, name, "lsa_TransSidArray2");
3824         ndr->depth++;
3825         ndr_print_uint32(ndr, "count", r->count);
3826         ndr_print_ptr(ndr, "sids", r->sids);
3827         ndr->depth++;
3828         if (r->sids) {
3829                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->count);
3830                 ndr->depth++;
3831                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
3832                         char *idx_1=NULL;
3833                         asprintf(&idx_1, "[%d]", cntr_sids_1);
3834                         if (idx_1) {
3835                                 ndr_print_lsa_TranslatedSid2(ndr, "sids", &r->sids[cntr_sids_1]);
3836                                 free(idx_1);
3837                         }
3838                 }
3839                 ndr->depth--;
3840         }
3841         ndr->depth--;
3842         ndr->depth--;
3843 }
3844
3845 NTSTATUS ndr_push_lsa_TranslatedSid3(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid3 *r)
3846 {
3847         if (ndr_flags & NDR_SCALARS) {
3848                 NDR_CHECK(ndr_push_align(ndr, 4));
3849                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
3850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
3851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
3852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
3853         }
3854         if (ndr_flags & NDR_BUFFERS) {
3855                 if (r->sid) {
3856                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
3857                 }
3858         }
3859         return NT_STATUS_OK;
3860 }
3861
3862 NTSTATUS ndr_pull_lsa_TranslatedSid3(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid3 *r)
3863 {
3864         uint32_t _ptr_sid;
3865         TALLOC_CTX *_mem_save_sid_0;
3866         if (ndr_flags & NDR_SCALARS) {
3867                 NDR_CHECK(ndr_pull_align(ndr, 4));
3868                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
3869                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
3870                 if (_ptr_sid) {
3871                         NDR_PULL_ALLOC(ndr, r->sid);
3872                 } else {
3873                         r->sid = NULL;
3874                 }
3875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
3876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
3877         }
3878         if (ndr_flags & NDR_BUFFERS) {
3879                 if (r->sid) {
3880                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
3881                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
3882                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
3883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
3884                 }
3885         }
3886         return NT_STATUS_OK;
3887 }
3888
3889 _PUBLIC_ void ndr_print_lsa_TranslatedSid3(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid3 *r)
3890 {
3891         ndr_print_struct(ndr, name, "lsa_TranslatedSid3");
3892         ndr->depth++;
3893         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
3894         ndr_print_ptr(ndr, "sid", r->sid);
3895         ndr->depth++;
3896         if (r->sid) {
3897                 ndr_print_dom_sid2(ndr, "sid", r->sid);
3898         }
3899         ndr->depth--;
3900         ndr_print_uint32(ndr, "sid_index", r->sid_index);
3901         ndr_print_uint32(ndr, "unknown", r->unknown);
3902         ndr->depth--;
3903 }
3904
3905 NTSTATUS ndr_push_lsa_TransSidArray3(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray3 *r)
3906 {
3907         uint32_t cntr_sids_1;
3908         if (ndr_flags & NDR_SCALARS) {
3909                 NDR_CHECK(ndr_push_align(ndr, 4));
3910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3911                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
3912         }
3913         if (ndr_flags & NDR_BUFFERS) {
3914                 if (r->sids) {
3915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3916                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3917                                 NDR_CHECK(ndr_push_lsa_TranslatedSid3(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
3918                         }
3919                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3920                                 NDR_CHECK(ndr_push_lsa_TranslatedSid3(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
3921                         }
3922                 }
3923         }
3924         return NT_STATUS_OK;
3925 }
3926
3927 NTSTATUS ndr_pull_lsa_TransSidArray3(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray3 *r)
3928 {
3929         uint32_t _ptr_sids;
3930         uint32_t cntr_sids_1;
3931         TALLOC_CTX *_mem_save_sids_0;
3932         TALLOC_CTX *_mem_save_sids_1;
3933         if (ndr_flags & NDR_SCALARS) {
3934                 NDR_CHECK(ndr_pull_align(ndr, 4));
3935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3936                 if (r->count < 0 || r->count > 1000) {
3937                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3938                 }
3939                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
3940                 if (_ptr_sids) {
3941                         NDR_PULL_ALLOC(ndr, r->sids);
3942                 } else {
3943                         r->sids = NULL;
3944                 }
3945         }
3946         if (ndr_flags & NDR_BUFFERS) {
3947                 if (r->sids) {
3948                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
3949                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3950                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
3951                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
3952                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
3953                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3954                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3955                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid3(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
3956                         }
3957                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3958                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid3(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
3959                         }
3960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
3961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
3962                 }
3963                 if (r->sids) {
3964                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
3965                 }
3966         }
3967         return NT_STATUS_OK;
3968 }
3969
3970 _PUBLIC_ void ndr_print_lsa_TransSidArray3(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray3 *r)
3971 {
3972         uint32_t cntr_sids_1;
3973         ndr_print_struct(ndr, name, "lsa_TransSidArray3");
3974         ndr->depth++;
3975         ndr_print_uint32(ndr, "count", r->count);
3976         ndr_print_ptr(ndr, "sids", r->sids);
3977         ndr->depth++;
3978         if (r->sids) {
3979                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->count);
3980                 ndr->depth++;
3981                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
3982                         char *idx_1=NULL;
3983                         asprintf(&idx_1, "[%d]", cntr_sids_1);
3984                         if (idx_1) {
3985                                 ndr_print_lsa_TranslatedSid3(ndr, "sids", &r->sids[cntr_sids_1]);
3986                                 free(idx_1);
3987                         }
3988                 }
3989                 ndr->depth--;
3990         }
3991         ndr->depth--;
3992         ndr->depth--;
3993 }
3994
3995 NTSTATUS ndr_push_lsa_Close(struct ndr_push *ndr, int flags, const struct lsa_Close *r)
3996 {
3997         if (flags & NDR_IN) {
3998                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3999                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4000         }
4001         if (flags & NDR_OUT) {
4002                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4003                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
4004                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4005         }
4006         return NT_STATUS_OK;
4007 }
4008
4009 NTSTATUS ndr_pull_lsa_Close(struct ndr_pull *ndr, int flags, struct lsa_Close *r)
4010 {
4011         TALLOC_CTX *_mem_save_handle_0;
4012         if (flags & NDR_IN) {
4013                 ZERO_STRUCT(r->out);
4014
4015                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4016                         NDR_PULL_ALLOC(ndr, r->in.handle);
4017                 }
4018                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4019                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4020                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4021                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4022                 NDR_PULL_ALLOC(ndr, r->out.handle);
4023                 *r->out.handle = *r->in.handle;
4024         }
4025         if (flags & NDR_OUT) {
4026                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4027                         NDR_PULL_ALLOC(ndr, r->out.handle);
4028                 }
4029                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4030                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
4031                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
4032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4033                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4034         }
4035         return NT_STATUS_OK;
4036 }
4037
4038 _PUBLIC_ void ndr_print_lsa_Close(struct ndr_print *ndr, const char *name, int flags, const struct lsa_Close *r)
4039 {
4040         ndr_print_struct(ndr, name, "lsa_Close");
4041         ndr->depth++;
4042         if (flags & NDR_SET_VALUES) {
4043                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4044         }
4045         if (flags & NDR_IN) {
4046                 ndr_print_struct(ndr, "in", "lsa_Close");
4047                 ndr->depth++;
4048                 ndr_print_ptr(ndr, "handle", r->in.handle);
4049                 ndr->depth++;
4050                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4051                 ndr->depth--;
4052                 ndr->depth--;
4053         }
4054         if (flags & NDR_OUT) {
4055                 ndr_print_struct(ndr, "out", "lsa_Close");
4056                 ndr->depth++;
4057                 ndr_print_ptr(ndr, "handle", r->out.handle);
4058                 ndr->depth++;
4059                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
4060                 ndr->depth--;
4061                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4062                 ndr->depth--;
4063         }
4064         ndr->depth--;
4065 }
4066
4067 NTSTATUS ndr_push_lsa_Delete(struct ndr_push *ndr, int flags, const struct lsa_Delete *r)
4068 {
4069         if (flags & NDR_IN) {
4070                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4071                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4072         }
4073         if (flags & NDR_OUT) {
4074                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4075         }
4076         return NT_STATUS_OK;
4077 }
4078
4079 NTSTATUS ndr_pull_lsa_Delete(struct ndr_pull *ndr, int flags, struct lsa_Delete *r)
4080 {
4081         TALLOC_CTX *_mem_save_handle_0;
4082         if (flags & NDR_IN) {
4083                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4084                         NDR_PULL_ALLOC(ndr, r->in.handle);
4085                 }
4086                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4087                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4088                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4090         }
4091         if (flags & NDR_OUT) {
4092                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4093         }
4094         return NT_STATUS_OK;
4095 }
4096
4097 _PUBLIC_ void ndr_print_lsa_Delete(struct ndr_print *ndr, const char *name, int flags, const struct lsa_Delete *r)
4098 {
4099         ndr_print_struct(ndr, name, "lsa_Delete");
4100         ndr->depth++;
4101         if (flags & NDR_SET_VALUES) {
4102                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4103         }
4104         if (flags & NDR_IN) {
4105                 ndr_print_struct(ndr, "in", "lsa_Delete");
4106                 ndr->depth++;
4107                 ndr_print_ptr(ndr, "handle", r->in.handle);
4108                 ndr->depth++;
4109                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4110                 ndr->depth--;
4111                 ndr->depth--;
4112         }
4113         if (flags & NDR_OUT) {
4114                 ndr_print_struct(ndr, "out", "lsa_Delete");
4115                 ndr->depth++;
4116                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4117                 ndr->depth--;
4118         }
4119         ndr->depth--;
4120 }
4121
4122 NTSTATUS ndr_push_lsa_EnumPrivs(struct ndr_push *ndr, int flags, const struct lsa_EnumPrivs *r)
4123 {
4124         if (flags & NDR_IN) {
4125                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4126                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4127                 if (r->in.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
4129                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_count));
4130         }
4131         if (flags & NDR_OUT) {
4132                 if (r->out.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
4134                 if (r->out.privs == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4135                 NDR_CHECK(ndr_push_lsa_PrivArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.privs));
4136                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4137         }
4138         return NT_STATUS_OK;
4139 }
4140
4141 NTSTATUS ndr_pull_lsa_EnumPrivs(struct ndr_pull *ndr, int flags, struct lsa_EnumPrivs *r)
4142 {
4143         TALLOC_CTX *_mem_save_handle_0;
4144         TALLOC_CTX *_mem_save_resume_handle_0;
4145         TALLOC_CTX *_mem_save_privs_0;
4146         if (flags & NDR_IN) {
4147                 ZERO_STRUCT(r->out);
4148
4149                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4150                         NDR_PULL_ALLOC(ndr, r->in.handle);
4151                 }
4152                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4153                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4154                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4155                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4156                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4157                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
4158                 }
4159                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4160                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
4161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
4162                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
4163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_count));
4164                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
4165                 *r->out.resume_handle = *r->in.resume_handle;
4166                 NDR_PULL_ALLOC(ndr, r->out.privs);
4167                 ZERO_STRUCTP(r->out.privs);
4168         }
4169         if (flags & NDR_OUT) {
4170                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4171                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
4172                 }
4173                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4174                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
4175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
4176                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
4177                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4178                         NDR_PULL_ALLOC(ndr, r->out.privs);
4179                 }
4180                 _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4181                 NDR_PULL_SET_MEM_CTX(ndr, r->out.privs, LIBNDR_FLAG_REF_ALLOC);
4182                 NDR_CHECK(ndr_pull_lsa_PrivArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.privs));
4183                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, LIBNDR_FLAG_REF_ALLOC);
4184                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4185         }
4186         return NT_STATUS_OK;
4187 }
4188
4189 _PUBLIC_ void ndr_print_lsa_EnumPrivs(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumPrivs *r)
4190 {
4191         ndr_print_struct(ndr, name, "lsa_EnumPrivs");
4192         ndr->depth++;
4193         if (flags & NDR_SET_VALUES) {
4194                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4195         }
4196         if (flags & NDR_IN) {
4197                 ndr_print_struct(ndr, "in", "lsa_EnumPrivs");
4198                 ndr->depth++;
4199                 ndr_print_ptr(ndr, "handle", r->in.handle);
4200                 ndr->depth++;
4201                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4202                 ndr->depth--;
4203                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
4204                 ndr->depth++;
4205                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
4206                 ndr->depth--;
4207                 ndr_print_uint32(ndr, "max_count", r->in.max_count);
4208                 ndr->depth--;
4209         }
4210         if (flags & NDR_OUT) {
4211                 ndr_print_struct(ndr, "out", "lsa_EnumPrivs");
4212                 ndr->depth++;
4213                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
4214                 ndr->depth++;
4215                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
4216                 ndr->depth--;
4217                 ndr_print_ptr(ndr, "privs", r->out.privs);
4218                 ndr->depth++;
4219                 ndr_print_lsa_PrivArray(ndr, "privs", r->out.privs);
4220                 ndr->depth--;
4221                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4222                 ndr->depth--;
4223         }
4224         ndr->depth--;
4225 }
4226
4227 NTSTATUS ndr_push_lsa_QuerySecurity(struct ndr_push *ndr, int flags, const struct lsa_QuerySecurity *r)
4228 {
4229         if (flags & NDR_IN) {
4230                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4231                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4232                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
4233         }
4234         if (flags & NDR_OUT) {
4235                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.sdbuf));
4236                 if (r->out.sdbuf) {
4237                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sdbuf));
4238                 }
4239                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4240         }
4241         return NT_STATUS_OK;
4242 }
4243
4244 NTSTATUS ndr_pull_lsa_QuerySecurity(struct ndr_pull *ndr, int flags, struct lsa_QuerySecurity *r)
4245 {
4246         uint32_t _ptr_sdbuf;
4247         TALLOC_CTX *_mem_save_handle_0;
4248         TALLOC_CTX *_mem_save_sdbuf_0;
4249         if (flags & NDR_IN) {
4250                 ZERO_STRUCT(r->out);
4251
4252                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4253                         NDR_PULL_ALLOC(ndr, r->in.handle);
4254                 }
4255                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4256                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4257                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4258                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4259                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
4260         }
4261         if (flags & NDR_OUT) {
4262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
4263                 if (_ptr_sdbuf) {
4264                         NDR_PULL_ALLOC(ndr, r->out.sdbuf);
4265                 } else {
4266                         r->out.sdbuf = NULL;
4267                 }
4268                 if (r->out.sdbuf) {
4269                         _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
4270                         NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, 0);
4271                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sdbuf));
4272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, 0);
4273                 }
4274                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4275         }
4276         return NT_STATUS_OK;
4277 }
4278
4279 _PUBLIC_ void ndr_print_lsa_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QuerySecurity *r)
4280 {
4281         ndr_print_struct(ndr, name, "lsa_QuerySecurity");
4282         ndr->depth++;
4283         if (flags & NDR_SET_VALUES) {
4284                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4285         }
4286         if (flags & NDR_IN) {
4287                 ndr_print_struct(ndr, "in", "lsa_QuerySecurity");
4288                 ndr->depth++;
4289                 ndr_print_ptr(ndr, "handle", r->in.handle);
4290                 ndr->depth++;
4291                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4292                 ndr->depth--;
4293                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
4294                 ndr->depth--;
4295         }
4296         if (flags & NDR_OUT) {
4297                 ndr_print_struct(ndr, "out", "lsa_QuerySecurity");
4298                 ndr->depth++;
4299                 ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
4300                 ndr->depth++;
4301                 if (r->out.sdbuf) {
4302                         ndr_print_sec_desc_buf(ndr, "sdbuf", r->out.sdbuf);
4303                 }
4304                 ndr->depth--;
4305                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4306                 ndr->depth--;
4307         }
4308         ndr->depth--;
4309 }
4310
4311 NTSTATUS ndr_push_lsa_SetSecObj(struct ndr_push *ndr, int flags, const struct lsa_SetSecObj *r)
4312 {
4313         if (flags & NDR_IN) {
4314         }
4315         if (flags & NDR_OUT) {
4316                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4317         }
4318         return NT_STATUS_OK;
4319 }
4320
4321 NTSTATUS ndr_pull_lsa_SetSecObj(struct ndr_pull *ndr, int flags, struct lsa_SetSecObj *r)
4322 {
4323         if (flags & NDR_IN) {
4324         }
4325         if (flags & NDR_OUT) {
4326                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4327         }
4328         return NT_STATUS_OK;
4329 }
4330
4331 _PUBLIC_ void ndr_print_lsa_SetSecObj(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSecObj *r)
4332 {
4333         ndr_print_struct(ndr, name, "lsa_SetSecObj");
4334         ndr->depth++;
4335         if (flags & NDR_SET_VALUES) {
4336                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4337         }
4338         if (flags & NDR_IN) {
4339                 ndr_print_struct(ndr, "in", "lsa_SetSecObj");
4340                 ndr->depth++;
4341                 ndr->depth--;
4342         }
4343         if (flags & NDR_OUT) {
4344                 ndr_print_struct(ndr, "out", "lsa_SetSecObj");
4345                 ndr->depth++;
4346                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4347                 ndr->depth--;
4348         }
4349         ndr->depth--;
4350 }
4351
4352 NTSTATUS ndr_push_lsa_ChangePassword(struct ndr_push *ndr, int flags, const struct lsa_ChangePassword *r)
4353 {
4354         if (flags & NDR_IN) {
4355         }
4356         if (flags & NDR_OUT) {
4357                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4358         }
4359         return NT_STATUS_OK;
4360 }
4361
4362 NTSTATUS ndr_pull_lsa_ChangePassword(struct ndr_pull *ndr, int flags, struct lsa_ChangePassword *r)
4363 {
4364         if (flags & NDR_IN) {
4365         }
4366         if (flags & NDR_OUT) {
4367                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4368         }
4369         return NT_STATUS_OK;
4370 }
4371
4372 _PUBLIC_ void ndr_print_lsa_ChangePassword(struct ndr_print *ndr, const char *name, int flags, const struct lsa_ChangePassword *r)
4373 {
4374         ndr_print_struct(ndr, name, "lsa_ChangePassword");
4375         ndr->depth++;
4376         if (flags & NDR_SET_VALUES) {
4377                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4378         }
4379         if (flags & NDR_IN) {
4380                 ndr_print_struct(ndr, "in", "lsa_ChangePassword");
4381                 ndr->depth++;
4382                 ndr->depth--;
4383         }
4384         if (flags & NDR_OUT) {
4385                 ndr_print_struct(ndr, "out", "lsa_ChangePassword");
4386                 ndr->depth++;
4387                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4388                 ndr->depth--;
4389         }
4390         ndr->depth--;
4391 }
4392
4393 NTSTATUS ndr_push_lsa_OpenPolicy(struct ndr_push *ndr, int flags, const struct lsa_OpenPolicy *r)
4394 {
4395         if (flags & NDR_IN) {
4396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
4397                 if (r->in.system_name) {
4398                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
4399                 }
4400                 if (r->in.attr == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4401                 NDR_CHECK(ndr_push_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
4402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
4403         }
4404         if (flags & NDR_OUT) {
4405                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4406                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
4407                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4408         }
4409         return NT_STATUS_OK;
4410 }
4411
4412 NTSTATUS ndr_pull_lsa_OpenPolicy(struct ndr_pull *ndr, int flags, struct lsa_OpenPolicy *r)
4413 {
4414         uint32_t _ptr_system_name;
4415         TALLOC_CTX *_mem_save_system_name_0;
4416         TALLOC_CTX *_mem_save_attr_0;
4417         TALLOC_CTX *_mem_save_handle_0;
4418         if (flags & NDR_IN) {
4419                 ZERO_STRUCT(r->out);
4420
4421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
4422                 if (_ptr_system_name) {
4423                         NDR_PULL_ALLOC(ndr, r->in.system_name);
4424                 } else {
4425                         r->in.system_name = NULL;
4426                 }
4427                 if (r->in.system_name) {
4428                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4429                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
4430                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
4431                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
4432                 }
4433                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4434                         NDR_PULL_ALLOC(ndr, r->in.attr);
4435                 }
4436                 _mem_save_attr_0 = NDR_PULL_GET_MEM_CTX(ndr);
4437                 NDR_PULL_SET_MEM_CTX(ndr, r->in.attr, LIBNDR_FLAG_REF_ALLOC);
4438                 NDR_CHECK(ndr_pull_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
4439                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attr_0, LIBNDR_FLAG_REF_ALLOC);
4440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
4441                 NDR_PULL_ALLOC(ndr, r->out.handle);
4442                 ZERO_STRUCTP(r->out.handle);
4443         }
4444         if (flags & NDR_OUT) {
4445                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4446                         NDR_PULL_ALLOC(ndr, r->out.handle);
4447                 }
4448                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4449                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
4450                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
4451                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4452                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4453         }
4454         return NT_STATUS_OK;
4455 }
4456
4457 _PUBLIC_ void ndr_print_lsa_OpenPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenPolicy *r)
4458 {
4459         ndr_print_struct(ndr, name, "lsa_OpenPolicy");
4460         ndr->depth++;
4461         if (flags & NDR_SET_VALUES) {
4462                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4463         }
4464         if (flags & NDR_IN) {
4465                 ndr_print_struct(ndr, "in", "lsa_OpenPolicy");
4466                 ndr->depth++;
4467                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
4468                 ndr->depth++;
4469                 if (r->in.system_name) {
4470                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
4471                 }
4472                 ndr->depth--;
4473                 ndr_print_ptr(ndr, "attr", r->in.attr);
4474                 ndr->depth++;
4475                 ndr_print_lsa_ObjectAttribute(ndr, "attr", r->in.attr);
4476                 ndr->depth--;
4477                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
4478                 ndr->depth--;
4479         }
4480         if (flags & NDR_OUT) {
4481                 ndr_print_struct(ndr, "out", "lsa_OpenPolicy");
4482                 ndr->depth++;
4483                 ndr_print_ptr(ndr, "handle", r->out.handle);
4484                 ndr->depth++;
4485                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
4486                 ndr->depth--;
4487                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4488                 ndr->depth--;
4489         }
4490         ndr->depth--;
4491 }
4492
4493 NTSTATUS ndr_push_lsa_QueryInfoPolicy(struct ndr_push *ndr, int flags, const struct lsa_QueryInfoPolicy *r)
4494 {
4495         if (flags & NDR_IN) {
4496                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4497                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4498                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
4499         }
4500         if (flags & NDR_OUT) {
4501                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
4502                 if (r->out.info) {
4503                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
4504                         NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
4505                 }
4506                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4507         }
4508         return NT_STATUS_OK;
4509 }
4510
4511 NTSTATUS ndr_pull_lsa_QueryInfoPolicy(struct ndr_pull *ndr, int flags, struct lsa_QueryInfoPolicy *r)
4512 {
4513         uint32_t _ptr_info;
4514         TALLOC_CTX *_mem_save_handle_0;
4515         TALLOC_CTX *_mem_save_info_0;
4516         if (flags & NDR_IN) {
4517                 ZERO_STRUCT(r->out);
4518
4519                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4520                         NDR_PULL_ALLOC(ndr, r->in.handle);
4521                 }
4522                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4523                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4524                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4525                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4526                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
4527         }
4528         if (flags & NDR_OUT) {
4529                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
4530                 if (_ptr_info) {
4531                         NDR_PULL_ALLOC(ndr, r->out.info);
4532                 } else {
4533                         r->out.info = NULL;
4534                 }
4535                 if (r->out.info) {
4536                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
4537                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
4538                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
4539                         NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
4540                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
4541                 }
4542                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4543         }
4544         return NT_STATUS_OK;
4545 }
4546
4547 _PUBLIC_ void ndr_print_lsa_QueryInfoPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryInfoPolicy *r)
4548 {
4549         ndr_print_struct(ndr, name, "lsa_QueryInfoPolicy");
4550         ndr->depth++;
4551         if (flags & NDR_SET_VALUES) {
4552                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4553         }
4554         if (flags & NDR_IN) {
4555                 ndr_print_struct(ndr, "in", "lsa_QueryInfoPolicy");
4556                 ndr->depth++;
4557                 ndr_print_ptr(ndr, "handle", r->in.handle);
4558                 ndr->depth++;
4559                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4560                 ndr->depth--;
4561                 ndr_print_uint16(ndr, "level", r->in.level);
4562                 ndr->depth--;
4563         }
4564         if (flags & NDR_OUT) {
4565                 ndr_print_struct(ndr, "out", "lsa_QueryInfoPolicy");
4566                 ndr->depth++;
4567                 ndr_print_ptr(ndr, "info", r->out.info);
4568                 ndr->depth++;
4569                 if (r->out.info) {
4570                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
4571                         ndr_print_lsa_PolicyInformation(ndr, "info", r->out.info);
4572                 }
4573                 ndr->depth--;
4574                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4575                 ndr->depth--;
4576         }
4577         ndr->depth--;
4578 }
4579
4580 NTSTATUS ndr_push_lsa_SetInfoPolicy(struct ndr_push *ndr, int flags, const struct lsa_SetInfoPolicy *r)
4581 {
4582         if (flags & NDR_IN) {
4583         }
4584         if (flags & NDR_OUT) {
4585                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4586         }
4587         return NT_STATUS_OK;
4588 }
4589
4590 NTSTATUS ndr_pull_lsa_SetInfoPolicy(struct ndr_pull *ndr, int flags, struct lsa_SetInfoPolicy *r)
4591 {
4592         if (flags & NDR_IN) {
4593         }
4594         if (flags & NDR_OUT) {
4595                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4596         }
4597         return NT_STATUS_OK;
4598 }
4599
4600 _PUBLIC_ void ndr_print_lsa_SetInfoPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInfoPolicy *r)
4601 {
4602         ndr_print_struct(ndr, name, "lsa_SetInfoPolicy");
4603         ndr->depth++;
4604         if (flags & NDR_SET_VALUES) {
4605                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4606         }
4607         if (flags & NDR_IN) {
4608                 ndr_print_struct(ndr, "in", "lsa_SetInfoPolicy");
4609                 ndr->depth++;
4610                 ndr->depth--;
4611         }
4612         if (flags & NDR_OUT) {
4613                 ndr_print_struct(ndr, "out", "lsa_SetInfoPolicy");
4614                 ndr->depth++;
4615                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4616                 ndr->depth--;
4617         }
4618         ndr->depth--;
4619 }
4620
4621 NTSTATUS ndr_push_lsa_ClearAuditLog(struct ndr_push *ndr, int flags, const struct lsa_ClearAuditLog *r)
4622 {
4623         if (flags & NDR_IN) {
4624         }
4625         if (flags & NDR_OUT) {
4626                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4627         }
4628         return NT_STATUS_OK;
4629 }
4630
4631 NTSTATUS ndr_pull_lsa_ClearAuditLog(struct ndr_pull *ndr, int flags, struct lsa_ClearAuditLog *r)
4632 {
4633         if (flags & NDR_IN) {
4634         }
4635         if (flags & NDR_OUT) {
4636                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4637         }
4638         return NT_STATUS_OK;
4639 }
4640
4641 _PUBLIC_ void ndr_print_lsa_ClearAuditLog(struct ndr_print *ndr, const char *name, int flags, const struct lsa_ClearAuditLog *r)
4642 {
4643         ndr_print_struct(ndr, name, "lsa_ClearAuditLog");
4644         ndr->depth++;
4645         if (flags & NDR_SET_VALUES) {
4646                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4647         }
4648         if (flags & NDR_IN) {
4649                 ndr_print_struct(ndr, "in", "lsa_ClearAuditLog");
4650                 ndr->depth++;
4651                 ndr->depth--;
4652         }
4653         if (flags & NDR_OUT) {
4654                 ndr_print_struct(ndr, "out", "lsa_ClearAuditLog");
4655                 ndr->depth++;
4656                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4657                 ndr->depth--;
4658         }
4659         ndr->depth--;
4660 }
4661
4662 NTSTATUS ndr_push_lsa_CreateAccount(struct ndr_push *ndr, int flags, const struct lsa_CreateAccount *r)
4663 {
4664         if (flags & NDR_IN) {
4665                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4666                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4667                 if (r->in.sid == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4668                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
4669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
4670         }
4671         if (flags & NDR_OUT) {
4672                 if (r->out.acct_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4673                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
4674                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4675         }
4676         return NT_STATUS_OK;
4677 }
4678
4679 NTSTATUS ndr_pull_lsa_CreateAccount(struct ndr_pull *ndr, int flags, struct lsa_CreateAccount *r)
4680 {
4681         TALLOC_CTX *_mem_save_handle_0;
4682         TALLOC_CTX *_mem_save_sid_0;
4683         TALLOC_CTX *_mem_save_acct_handle_0;
4684         if (flags & NDR_IN) {
4685                 ZERO_STRUCT(r->out);
4686
4687                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4688                         NDR_PULL_ALLOC(ndr, r->in.handle);
4689                 }
4690                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4691                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4692                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4693                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4694                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4695                         NDR_PULL_ALLOC(ndr, r->in.sid);
4696                 }
4697                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4698                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
4699                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
4700                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
4701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
4702                 NDR_PULL_ALLOC(ndr, r->out.acct_handle);
4703                 ZERO_STRUCTP(r->out.acct_handle);
4704         }
4705         if (flags & NDR_OUT) {
4706                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4707                         NDR_PULL_ALLOC(ndr, r->out.acct_handle);
4708                 }
4709                 _mem_save_acct_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4710                 NDR_PULL_SET_MEM_CTX(ndr, r->out.acct_handle, LIBNDR_FLAG_REF_ALLOC);
4711                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
4712                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_handle_0, LIBNDR_FLAG_REF_ALLOC);
4713                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4714         }
4715         return NT_STATUS_OK;
4716 }
4717
4718 _PUBLIC_ void ndr_print_lsa_CreateAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateAccount *r)
4719 {
4720         ndr_print_struct(ndr, name, "lsa_CreateAccount");
4721         ndr->depth++;
4722         if (flags & NDR_SET_VALUES) {
4723                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4724         }
4725         if (flags & NDR_IN) {
4726                 ndr_print_struct(ndr, "in", "lsa_CreateAccount");
4727                 ndr->depth++;
4728                 ndr_print_ptr(ndr, "handle", r->in.handle);
4729                 ndr->depth++;
4730                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4731                 ndr->depth--;
4732                 ndr_print_ptr(ndr, "sid", r->in.sid);
4733                 ndr->depth++;
4734                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
4735                 ndr->depth--;
4736                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
4737                 ndr->depth--;
4738         }
4739         if (flags & NDR_OUT) {
4740                 ndr_print_struct(ndr, "out", "lsa_CreateAccount");
4741                 ndr->depth++;
4742                 ndr_print_ptr(ndr, "acct_handle", r->out.acct_handle);
4743                 ndr->depth++;
4744                 ndr_print_policy_handle(ndr, "acct_handle", r->out.acct_handle);
4745                 ndr->depth--;
4746                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4747                 ndr->depth--;
4748         }
4749         ndr->depth--;
4750 }
4751
4752 NTSTATUS ndr_push_lsa_EnumAccounts(struct ndr_push *ndr, int flags, const struct lsa_EnumAccounts *r)
4753 {
4754         if (flags & NDR_IN) {
4755                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4756                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4757                 if (r->in.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
4759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_entries));
4760         }
4761         if (flags & NDR_OUT) {
4762                 if (r->out.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
4764                 if (r->out.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4765                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
4766                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4767         }
4768         return NT_STATUS_OK;
4769 }
4770
4771 NTSTATUS ndr_pull_lsa_EnumAccounts(struct ndr_pull *ndr, int flags, struct lsa_EnumAccounts *r)
4772 {
4773         TALLOC_CTX *_mem_save_handle_0;
4774         TALLOC_CTX *_mem_save_resume_handle_0;
4775         TALLOC_CTX *_mem_save_sids_0;
4776         if (flags & NDR_IN) {
4777                 ZERO_STRUCT(r->out);
4778
4779                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4780                         NDR_PULL_ALLOC(ndr, r->in.handle);
4781                 }
4782                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4783                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4784                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4785                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4787                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
4788                 }
4789                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4790                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
4791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
4792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
4793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_entries));
4794                 if (r->in.num_entries < 0 || r->in.num_entries > 8192) {
4795                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4796                 }
4797                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
4798                 *r->out.resume_handle = *r->in.resume_handle;
4799                 NDR_PULL_ALLOC(ndr, r->out.sids);
4800                 ZERO_STRUCTP(r->out.sids);
4801         }
4802         if (flags & NDR_OUT) {
4803                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4804                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
4805                 }
4806                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4807                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
4808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
4809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
4810                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4811                         NDR_PULL_ALLOC(ndr, r->out.sids);
4812                 }
4813                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4814                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
4815                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
4816                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
4817                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4818         }
4819         return NT_STATUS_OK;
4820 }
4821
4822 _PUBLIC_ void ndr_print_lsa_EnumAccounts(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccounts *r)
4823 {
4824         ndr_print_struct(ndr, name, "lsa_EnumAccounts");
4825         ndr->depth++;
4826         if (flags & NDR_SET_VALUES) {
4827                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4828         }
4829         if (flags & NDR_IN) {
4830                 ndr_print_struct(ndr, "in", "lsa_EnumAccounts");
4831                 ndr->depth++;
4832                 ndr_print_ptr(ndr, "handle", r->in.handle);
4833                 ndr->depth++;
4834                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4835                 ndr->depth--;
4836                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
4837                 ndr->depth++;
4838                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
4839                 ndr->depth--;
4840                 ndr_print_uint32(ndr, "num_entries", r->in.num_entries);
4841                 ndr->depth--;
4842         }
4843         if (flags & NDR_OUT) {
4844                 ndr_print_struct(ndr, "out", "lsa_EnumAccounts");
4845                 ndr->depth++;
4846                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
4847                 ndr->depth++;
4848                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
4849                 ndr->depth--;
4850                 ndr_print_ptr(ndr, "sids", r->out.sids);
4851                 ndr->depth++;
4852                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
4853                 ndr->depth--;
4854                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4855                 ndr->depth--;
4856         }
4857         ndr->depth--;
4858 }
4859
4860 NTSTATUS ndr_push_lsa_CreateTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomain *r)
4861 {
4862         if (flags & NDR_IN) {
4863                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4864                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4865                 if (r->in.info == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4866                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
4867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
4868         }
4869         if (flags & NDR_OUT) {
4870                 if (r->out.trustdom_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4871                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
4872                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4873         }
4874         return NT_STATUS_OK;
4875 }
4876
4877 NTSTATUS ndr_pull_lsa_CreateTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomain *r)
4878 {
4879         TALLOC_CTX *_mem_save_handle_0;
4880         TALLOC_CTX *_mem_save_info_0;
4881         TALLOC_CTX *_mem_save_trustdom_handle_0;
4882         if (flags & NDR_IN) {
4883                 ZERO_STRUCT(r->out);
4884
4885                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4886                         NDR_PULL_ALLOC(ndr, r->in.handle);
4887                 }
4888                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4889                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4890                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4891                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4892                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4893                         NDR_PULL_ALLOC(ndr, r->in.info);
4894                 }
4895                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
4896                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
4897                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
4898                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
4899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
4900                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
4901                 ZERO_STRUCTP(r->out.trustdom_handle);
4902         }
4903         if (flags & NDR_OUT) {
4904                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4905                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
4906                 }
4907                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4908                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
4909                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
4910                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
4911                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4912         }
4913         return NT_STATUS_OK;
4914 }
4915
4916 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomain *r)
4917 {
4918         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomain");
4919         ndr->depth++;
4920         if (flags & NDR_SET_VALUES) {
4921                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4922         }
4923         if (flags & NDR_IN) {
4924                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomain");
4925                 ndr->depth++;
4926                 ndr_print_ptr(ndr, "handle", r->in.handle);
4927                 ndr->depth++;
4928                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4929                 ndr->depth--;
4930                 ndr_print_ptr(ndr, "info", r->in.info);
4931                 ndr->depth++;
4932                 ndr_print_lsa_DomainInfo(ndr, "info", r->in.info);
4933                 ndr->depth--;
4934                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
4935                 ndr->depth--;
4936         }
4937         if (flags & NDR_OUT) {
4938                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomain");
4939                 ndr->depth++;
4940                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
4941                 ndr->depth++;
4942                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
4943                 ndr->depth--;
4944                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4945                 ndr->depth--;
4946         }
4947         ndr->depth--;
4948 }
4949
4950 NTSTATUS ndr_push_lsa_EnumTrustDom(struct ndr_push *ndr, int flags, const struct lsa_EnumTrustDom *r)
4951 {
4952         if (flags & NDR_IN) {
4953                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4954                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4955                 if (r->in.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
4957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
4958         }
4959         if (flags & NDR_OUT) {
4960                 if (r->out.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
4962                 if (r->out.domains == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4963                 NDR_CHECK(ndr_push_lsa_DomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
4964                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4965         }
4966         return NT_STATUS_OK;
4967 }
4968
4969 NTSTATUS ndr_pull_lsa_EnumTrustDom(struct ndr_pull *ndr, int flags, struct lsa_EnumTrustDom *r)
4970 {
4971         TALLOC_CTX *_mem_save_handle_0;
4972         TALLOC_CTX *_mem_save_resume_handle_0;
4973         TALLOC_CTX *_mem_save_domains_0;
4974         if (flags & NDR_IN) {
4975                 ZERO_STRUCT(r->out);
4976
4977                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4978                         NDR_PULL_ALLOC(ndr, r->in.handle);
4979                 }
4980                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4981                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4982                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4983                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4985                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
4986                 }
4987                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4988                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
4989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
4990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
4991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
4992                 if (r->in.max_size < 0 || r->in.max_size > 1000) {
4993                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4994                 }
4995                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
4996                 *r->out.resume_handle = *r->in.resume_handle;
4997                 NDR_PULL_ALLOC(ndr, r->out.domains);
4998                 ZERO_STRUCTP(r->out.domains);
4999         }
5000         if (flags & NDR_OUT) {
5001                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5002                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5003                 }
5004                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5005                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5007                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5009                         NDR_PULL_ALLOC(ndr, r->out.domains);
5010                 }
5011                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
5012                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
5013                 NDR_CHECK(ndr_pull_lsa_DomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
5014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
5015                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5016         }
5017         return NT_STATUS_OK;
5018 }
5019
5020 _PUBLIC_ void ndr_print_lsa_EnumTrustDom(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumTrustDom *r)
5021 {
5022         ndr_print_struct(ndr, name, "lsa_EnumTrustDom");
5023         ndr->depth++;
5024         if (flags & NDR_SET_VALUES) {
5025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5026         }
5027         if (flags & NDR_IN) {
5028                 ndr_print_struct(ndr, "in", "lsa_EnumTrustDom");
5029                 ndr->depth++;
5030                 ndr_print_ptr(ndr, "handle", r->in.handle);
5031                 ndr->depth++;
5032                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5033                 ndr->depth--;
5034                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5035                 ndr->depth++;
5036                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5037                 ndr->depth--;
5038                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
5039                 ndr->depth--;
5040         }
5041         if (flags & NDR_OUT) {
5042                 ndr_print_struct(ndr, "out", "lsa_EnumTrustDom");
5043                 ndr->depth++;
5044                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5045                 ndr->depth++;
5046                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5047                 ndr->depth--;
5048                 ndr_print_ptr(ndr, "domains", r->out.domains);
5049                 ndr->depth++;
5050                 ndr_print_lsa_DomainList(ndr, "domains", r->out.domains);
5051                 ndr->depth--;
5052                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5053                 ndr->depth--;
5054         }
5055         ndr->depth--;
5056 }
5057
5058 NTSTATUS ndr_push_lsa_LookupNames(struct ndr_push *ndr, int flags, const struct lsa_LookupNames *r)
5059 {
5060         uint32_t cntr_names_0;
5061         if (flags & NDR_IN) {
5062                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5063                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
5065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
5066                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5067                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
5068                 }
5069                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5070                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
5071                 }
5072                 if (r->in.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5073                 NDR_CHECK(ndr_push_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
5074                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
5075                 if (r->in.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
5077         }
5078         if (flags & NDR_OUT) {
5079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.domains));
5080                 if (r->out.domains) {
5081                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
5082                 }
5083                 if (r->out.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5084                 NDR_CHECK(ndr_push_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
5085                 if (r->out.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
5087                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5088         }
5089         return NT_STATUS_OK;
5090 }
5091
5092 NTSTATUS ndr_pull_lsa_LookupNames(struct ndr_pull *ndr, int flags, struct lsa_LookupNames *r)
5093 {
5094         uint32_t cntr_names_0;
5095         uint32_t _ptr_domains;
5096         TALLOC_CTX *_mem_save_handle_0;
5097         TALLOC_CTX *_mem_save_names_0;
5098         TALLOC_CTX *_mem_save_domains_0;
5099         TALLOC_CTX *_mem_save_sids_0;
5100         TALLOC_CTX *_mem_save_count_0;
5101         if (flags & NDR_IN) {
5102                 ZERO_STRUCT(r->out);
5103
5104                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5105                         NDR_PULL_ALLOC(ndr, r->in.handle);
5106                 }
5107                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5108                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5109                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5110                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
5112                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
5113                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5114                 }
5115                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
5116                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
5117                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5118                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
5119                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5120                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
5121                 }
5122                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5123                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
5124                 }
5125                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5126                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5127                         NDR_PULL_ALLOC(ndr, r->in.sids);
5128                 }
5129                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
5130                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
5131                 NDR_CHECK(ndr_pull_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
5132                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
5133                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
5134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5135                         NDR_PULL_ALLOC(ndr, r->in.count);
5136                 }
5137                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
5138                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
5139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
5140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
5141                 NDR_PULL_ALLOC(ndr, r->out.sids);
5142                 *r->out.sids = *r->in.sids;
5143                 NDR_PULL_ALLOC(ndr, r->out.count);
5144                 *r->out.count = *r->in.count;
5145                 if (r->in.names) {
5146                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
5147                 }
5148         }
5149         if (flags & NDR_OUT) {
5150                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
5151                 if (_ptr_domains) {
5152                         NDR_PULL_ALLOC(ndr, r->out.domains);
5153                 } else {
5154                         r->out.domains = NULL;
5155                 }
5156                 if (r->out.domains) {
5157                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
5158                         NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, 0);
5159                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
5160                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
5161                 }
5162                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5163                         NDR_PULL_ALLOC(ndr, r->out.sids);
5164                 }
5165                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
5166                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
5167                 NDR_CHECK(ndr_pull_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
5168                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
5169                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5170                         NDR_PULL_ALLOC(ndr, r->out.count);
5171                 }
5172                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
5173                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
5174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
5175                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
5176                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5177         }
5178         return NT_STATUS_OK;
5179 }
5180
5181 _PUBLIC_ void ndr_print_lsa_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames *r)
5182 {
5183         uint32_t cntr_names_0;
5184         ndr_print_struct(ndr, name, "lsa_LookupNames");
5185         ndr->depth++;
5186         if (flags & NDR_SET_VALUES) {
5187                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5188         }
5189         if (flags & NDR_IN) {
5190                 ndr_print_struct(ndr, "in", "lsa_LookupNames");
5191                 ndr->depth++;
5192                 ndr_print_ptr(ndr, "handle", r->in.handle);
5193                 ndr->depth++;
5194                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5195                 ndr->depth--;
5196                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
5197                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
5198                 ndr->depth++;
5199                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
5200                         char *idx_0=NULL;
5201                         asprintf(&idx_0, "[%d]", cntr_names_0);
5202                         if (idx_0) {
5203                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
5204                                 free(idx_0);
5205                         }
5206                 }
5207                 ndr->depth--;
5208                 ndr_print_ptr(ndr, "sids", r->in.sids);
5209                 ndr->depth++;
5210                 ndr_print_lsa_TransSidArray(ndr, "sids", r->in.sids);
5211                 ndr->depth--;
5212                 ndr_print_uint16(ndr, "level", r->in.level);
5213                 ndr_print_ptr(ndr, "count", r->in.count);
5214                 ndr->depth++;
5215                 ndr_print_uint32(ndr, "count", *r->in.count);
5216                 ndr->depth--;
5217                 ndr->depth--;
5218         }
5219         if (flags & NDR_OUT) {
5220                 ndr_print_struct(ndr, "out", "lsa_LookupNames");
5221                 ndr->depth++;
5222                 ndr_print_ptr(ndr, "domains", r->out.domains);
5223                 ndr->depth++;
5224                 if (r->out.domains) {
5225                         ndr_print_lsa_RefDomainList(ndr, "domains", r->out.domains);
5226                 }
5227                 ndr->depth--;
5228                 ndr_print_ptr(ndr, "sids", r->out.sids);
5229                 ndr->depth++;
5230                 ndr_print_lsa_TransSidArray(ndr, "sids", r->out.sids);
5231                 ndr->depth--;
5232                 ndr_print_ptr(ndr, "count", r->out.count);
5233                 ndr->depth++;
5234                 ndr_print_uint32(ndr, "count", *r->out.count);
5235                 ndr->depth--;
5236                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5237                 ndr->depth--;
5238         }
5239         ndr->depth--;
5240 }
5241
5242 NTSTATUS ndr_push_lsa_LookupSids(struct ndr_push *ndr, int flags, const struct lsa_LookupSids *r)
5243 {
5244         if (flags & NDR_IN) {
5245                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5246                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5247                 if (r->in.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5248                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
5249                 if (r->in.names == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5250                 NDR_CHECK(ndr_push_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
5251                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
5252                 if (r->in.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
5254         }
5255         if (flags & NDR_OUT) {
5256                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.domains));
5257                 if (r->out.domains) {
5258                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
5259                 }
5260                 if (r->out.names == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5261                 NDR_CHECK(ndr_push_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
5262                 if (r->out.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
5264                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5265         }
5266         return NT_STATUS_OK;
5267 }
5268
5269 NTSTATUS ndr_pull_lsa_LookupSids(struct ndr_pull *ndr, int flags, struct lsa_LookupSids *r)
5270 {
5271         uint32_t _ptr_domains;
5272         TALLOC_CTX *_mem_save_handle_0;
5273         TALLOC_CTX *_mem_save_sids_0;
5274         TALLOC_CTX *_mem_save_domains_0;
5275         TALLOC_CTX *_mem_save_names_0;
5276         TALLOC_CTX *_mem_save_count_0;
5277         if (flags & NDR_IN) {
5278                 ZERO_STRUCT(r->out);
5279
5280                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5281                         NDR_PULL_ALLOC(ndr, r->in.handle);
5282                 }
5283                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5284                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5285                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5287                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5288                         NDR_PULL_ALLOC(ndr, r->in.sids);
5289                 }
5290                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
5291                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
5292                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
5293                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
5294                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5295                         NDR_PULL_ALLOC(ndr, r->in.names);
5296                 }
5297                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5298                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
5299                 NDR_CHECK(ndr_pull_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
5300                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
5301                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
5302                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5303                         NDR_PULL_ALLOC(ndr, r->in.count);
5304                 }
5305                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
5306                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
5307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
5308                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
5309                 NDR_PULL_ALLOC(ndr, r->out.names);
5310                 *r->out.names = *r->in.names;
5311                 NDR_PULL_ALLOC(ndr, r->out.count);
5312                 *r->out.count = *r->in.count;
5313         }
5314         if (flags & NDR_OUT) {
5315                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
5316                 if (_ptr_domains) {
5317                         NDR_PULL_ALLOC(ndr, r->out.domains);
5318                 } else {
5319                         r->out.domains = NULL;
5320                 }
5321                 if (r->out.domains) {
5322                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
5323                         NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, 0);
5324                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
5325                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
5326                 }
5327                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5328                         NDR_PULL_ALLOC(ndr, r->out.names);
5329                 }
5330                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5331                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
5332                 NDR_CHECK(ndr_pull_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
5333                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
5334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5335                         NDR_PULL_ALLOC(ndr, r->out.count);
5336                 }
5337                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
5338                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
5339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
5340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
5341                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5342         }
5343         return NT_STATUS_OK;
5344 }
5345
5346 _PUBLIC_ void ndr_print_lsa_LookupSids(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids *r)
5347 {
5348         ndr_print_struct(ndr, name, "lsa_LookupSids");
5349         ndr->depth++;
5350         if (flags & NDR_SET_VALUES) {
5351                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5352         }
5353         if (flags & NDR_IN) {
5354                 ndr_print_struct(ndr, "in", "lsa_LookupSids");
5355                 ndr->depth++;
5356                 ndr_print_ptr(ndr, "handle", r->in.handle);
5357                 ndr->depth++;
5358                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5359                 ndr->depth--;
5360                 ndr_print_ptr(ndr, "sids", r->in.sids);
5361                 ndr->depth++;
5362                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
5363                 ndr->depth--;
5364                 ndr_print_ptr(ndr, "names", r->in.names);
5365                 ndr->depth++;
5366                 ndr_print_lsa_TransNameArray(ndr, "names", r->in.names);
5367                 ndr->depth--;
5368                 ndr_print_uint16(ndr, "level", r->in.level);
5369                 ndr_print_ptr(ndr, "count", r->in.count);
5370                 ndr->depth++;
5371                 ndr_print_uint32(ndr, "count", *r->in.count);
5372                 ndr->depth--;
5373                 ndr->depth--;
5374         }
5375         if (flags & NDR_OUT) {
5376                 ndr_print_struct(ndr, "out", "lsa_LookupSids");
5377                 ndr->depth++;
5378                 ndr_print_ptr(ndr, "domains", r->out.domains);
5379                 ndr->depth++;
5380                 if (r->out.domains) {
5381                         ndr_print_lsa_RefDomainList(ndr, "domains", r->out.domains);
5382                 }
5383                 ndr->depth--;
5384                 ndr_print_ptr(ndr, "names", r->out.names);
5385                 ndr->depth++;
5386                 ndr_print_lsa_TransNameArray(ndr, "names", r->out.names);
5387                 ndr->depth--;
5388                 ndr_print_ptr(ndr, "count", r->out.count);
5389                 ndr->depth++;
5390                 ndr_print_uint32(ndr, "count", *r->out.count);
5391                 ndr->depth--;
5392                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5393                 ndr->depth--;
5394         }
5395         ndr->depth--;
5396 }
5397
5398 NTSTATUS ndr_push_lsa_CreateSecret(struct ndr_push *ndr, int flags, const struct lsa_CreateSecret *r)
5399 {
5400         if (flags & NDR_IN) {
5401                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5402                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5403                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
5404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
5405         }
5406         if (flags & NDR_OUT) {
5407                 if (r->out.sec_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5408                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
5409                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5410         }
5411         return NT_STATUS_OK;
5412 }
5413
5414 NTSTATUS ndr_pull_lsa_CreateSecret(struct ndr_pull *ndr, int flags, struct lsa_CreateSecret *r)
5415 {
5416         TALLOC_CTX *_mem_save_handle_0;
5417         TALLOC_CTX *_mem_save_sec_handle_0;
5418         if (flags & NDR_IN) {
5419                 ZERO_STRUCT(r->out);
5420
5421                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5422                         NDR_PULL_ALLOC(ndr, r->in.handle);
5423                 }
5424                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5425                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5426                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5427                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5428                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
5429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
5430                 NDR_PULL_ALLOC(ndr, r->out.sec_handle);
5431                 ZERO_STRUCTP(r->out.sec_handle);
5432         }
5433         if (flags & NDR_OUT) {
5434                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5435                         NDR_PULL_ALLOC(ndr, r->out.sec_handle);
5436                 }
5437                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5438                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sec_handle, LIBNDR_FLAG_REF_ALLOC);
5439                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
5440                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
5441                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5442         }
5443         return NT_STATUS_OK;
5444 }
5445
5446 _PUBLIC_ void ndr_print_lsa_CreateSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateSecret *r)
5447 {
5448         ndr_print_struct(ndr, name, "lsa_CreateSecret");
5449         ndr->depth++;
5450         if (flags & NDR_SET_VALUES) {
5451                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5452         }
5453         if (flags & NDR_IN) {
5454                 ndr_print_struct(ndr, "in", "lsa_CreateSecret");
5455                 ndr->depth++;
5456                 ndr_print_ptr(ndr, "handle", r->in.handle);
5457                 ndr->depth++;
5458                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5459                 ndr->depth--;
5460                 ndr_print_lsa_String(ndr, "name", &r->in.name);
5461                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
5462                 ndr->depth--;
5463         }
5464         if (flags & NDR_OUT) {
5465                 ndr_print_struct(ndr, "out", "lsa_CreateSecret");
5466                 ndr->depth++;
5467                 ndr_print_ptr(ndr, "sec_handle", r->out.sec_handle);
5468                 ndr->depth++;
5469                 ndr_print_policy_handle(ndr, "sec_handle", r->out.sec_handle);
5470                 ndr->depth--;
5471                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5472                 ndr->depth--;
5473         }
5474         ndr->depth--;
5475 }
5476
5477 NTSTATUS ndr_push_lsa_OpenAccount(struct ndr_push *ndr, int flags, const struct lsa_OpenAccount *r)
5478 {
5479         if (flags & NDR_IN) {
5480                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5481                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5482                 if (r->in.sid == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5483                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
5484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
5485         }
5486         if (flags & NDR_OUT) {
5487                 if (r->out.acct_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5488                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
5489                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5490         }
5491         return NT_STATUS_OK;
5492 }
5493
5494 NTSTATUS ndr_pull_lsa_OpenAccount(struct ndr_pull *ndr, int flags, struct lsa_OpenAccount *r)
5495 {
5496         TALLOC_CTX *_mem_save_handle_0;
5497         TALLOC_CTX *_mem_save_sid_0;
5498         TALLOC_CTX *_mem_save_acct_handle_0;
5499         if (flags & NDR_IN) {
5500                 ZERO_STRUCT(r->out);
5501
5502                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5503                         NDR_PULL_ALLOC(ndr, r->in.handle);
5504                 }
5505                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5506                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5507                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5508                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5509                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5510                         NDR_PULL_ALLOC(ndr, r->in.sid);
5511                 }
5512                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
5513                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
5514                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
5515                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
5516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
5517                 NDR_PULL_ALLOC(ndr, r->out.acct_handle);
5518                 ZERO_STRUCTP(r->out.acct_handle);
5519         }
5520         if (flags & NDR_OUT) {
5521                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5522                         NDR_PULL_ALLOC(ndr, r->out.acct_handle);
5523                 }
5524                 _mem_save_acct_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5525                 NDR_PULL_SET_MEM_CTX(ndr, r->out.acct_handle, LIBNDR_FLAG_REF_ALLOC);
5526                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
5527                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_handle_0, LIBNDR_FLAG_REF_ALLOC);
5528                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5529         }
5530         return NT_STATUS_OK;
5531 }
5532
5533 _PUBLIC_ void ndr_print_lsa_OpenAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenAccount *r)
5534 {
5535         ndr_print_struct(ndr, name, "lsa_OpenAccount");
5536         ndr->depth++;
5537         if (flags & NDR_SET_VALUES) {
5538                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5539         }
5540         if (flags & NDR_IN) {
5541                 ndr_print_struct(ndr, "in", "lsa_OpenAccount");
5542                 ndr->depth++;
5543                 ndr_print_ptr(ndr, "handle", r->in.handle);
5544                 ndr->depth++;
5545                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5546                 ndr->depth--;
5547                 ndr_print_ptr(ndr, "sid", r->in.sid);
5548                 ndr->depth++;
5549                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
5550                 ndr->depth--;
5551                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
5552                 ndr->depth--;
5553         }
5554         if (flags & NDR_OUT) {
5555                 ndr_print_struct(ndr, "out", "lsa_OpenAccount");
5556                 ndr->depth++;
5557                 ndr_print_ptr(ndr, "acct_handle", r->out.acct_handle);
5558                 ndr->depth++;
5559                 ndr_print_policy_handle(ndr, "acct_handle", r->out.acct_handle);
5560                 ndr->depth--;
5561                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5562                 ndr->depth--;
5563         }
5564         ndr->depth--;
5565 }
5566
5567 NTSTATUS ndr_push_lsa_EnumPrivsAccount(struct ndr_push *ndr, int flags, const struct lsa_EnumPrivsAccount *r)
5568 {
5569         if (flags & NDR_IN) {
5570                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5571                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5572         }
5573         if (flags & NDR_OUT) {
5574                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.privs));
5575                 if (r->out.privs) {
5576                         NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->out.privs));
5577                 }
5578                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5579         }
5580         return NT_STATUS_OK;
5581 }
5582
5583 NTSTATUS ndr_pull_lsa_EnumPrivsAccount(struct ndr_pull *ndr, int flags, struct lsa_EnumPrivsAccount *r)
5584 {
5585         uint32_t _ptr_privs;
5586         TALLOC_CTX *_mem_save_handle_0;
5587         TALLOC_CTX *_mem_save_privs_0;
5588         if (flags & NDR_IN) {
5589                 ZERO_STRUCT(r->out);
5590
5591                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5592                         NDR_PULL_ALLOC(ndr, r->in.handle);
5593                 }
5594                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5595                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5596                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5597                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5598         }
5599         if (flags & NDR_OUT) {
5600                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
5601                 if (_ptr_privs) {
5602                         NDR_PULL_ALLOC(ndr, r->out.privs);
5603                 } else {
5604                         r->out.privs = NULL;
5605                 }
5606                 if (r->out.privs) {
5607                         _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
5608                         NDR_PULL_SET_MEM_CTX(ndr, r->out.privs, 0);
5609                         NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->out.privs));
5610                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, 0);
5611                 }
5612                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5613         }
5614         return NT_STATUS_OK;
5615 }
5616
5617 _PUBLIC_ void ndr_print_lsa_EnumPrivsAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumPrivsAccount *r)
5618 {
5619         ndr_print_struct(ndr, name, "lsa_EnumPrivsAccount");
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_EnumPrivsAccount");
5626                 ndr->depth++;
5627                 ndr_print_ptr(ndr, "handle", r->in.handle);
5628                 ndr->depth++;
5629                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5630                 ndr->depth--;
5631                 ndr->depth--;
5632         }
5633         if (flags & NDR_OUT) {
5634                 ndr_print_struct(ndr, "out", "lsa_EnumPrivsAccount");
5635                 ndr->depth++;
5636                 ndr_print_ptr(ndr, "privs", r->out.privs);
5637                 ndr->depth++;
5638                 if (r->out.privs) {
5639                         ndr_print_lsa_PrivilegeSet(ndr, "privs", r->out.privs);
5640                 }
5641                 ndr->depth--;
5642                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5643                 ndr->depth--;
5644         }
5645         ndr->depth--;
5646 }
5647
5648 NTSTATUS ndr_push_lsa_AddPrivilegesToAccount(struct ndr_push *ndr, int flags, const struct lsa_AddPrivilegesToAccount *r)
5649 {
5650         if (flags & NDR_IN) {
5651                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5652                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5653                 if (r->in.privs == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5654                 NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
5655         }
5656         if (flags & NDR_OUT) {
5657                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5658         }
5659         return NT_STATUS_OK;
5660 }
5661
5662 NTSTATUS ndr_pull_lsa_AddPrivilegesToAccount(struct ndr_pull *ndr, int flags, struct lsa_AddPrivilegesToAccount *r)
5663 {
5664         TALLOC_CTX *_mem_save_handle_0;
5665         TALLOC_CTX *_mem_save_privs_0;
5666         if (flags & NDR_IN) {
5667                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5668                         NDR_PULL_ALLOC(ndr, r->in.handle);
5669                 }
5670                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5671                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5672                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5673                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5675                         NDR_PULL_ALLOC(ndr, r->in.privs);
5676                 }
5677                 _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
5678                 NDR_PULL_SET_MEM_CTX(ndr, r->in.privs, LIBNDR_FLAG_REF_ALLOC);
5679                 NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
5680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, LIBNDR_FLAG_REF_ALLOC);
5681         }
5682         if (flags & NDR_OUT) {
5683                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5684         }
5685         return NT_STATUS_OK;
5686 }
5687
5688 _PUBLIC_ void ndr_print_lsa_AddPrivilegesToAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_AddPrivilegesToAccount *r)
5689 {
5690         ndr_print_struct(ndr, name, "lsa_AddPrivilegesToAccount");
5691         ndr->depth++;
5692         if (flags & NDR_SET_VALUES) {
5693                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5694         }
5695         if (flags & NDR_IN) {
5696                 ndr_print_struct(ndr, "in", "lsa_AddPrivilegesToAccount");
5697                 ndr->depth++;
5698                 ndr_print_ptr(ndr, "handle", r->in.handle);
5699                 ndr->depth++;
5700                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5701                 ndr->depth--;
5702                 ndr_print_ptr(ndr, "privs", r->in.privs);
5703                 ndr->depth++;
5704                 ndr_print_lsa_PrivilegeSet(ndr, "privs", r->in.privs);
5705                 ndr->depth--;
5706                 ndr->depth--;
5707         }
5708         if (flags & NDR_OUT) {
5709                 ndr_print_struct(ndr, "out", "lsa_AddPrivilegesToAccount");
5710                 ndr->depth++;
5711                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5712                 ndr->depth--;
5713         }
5714         ndr->depth--;
5715 }
5716
5717 NTSTATUS ndr_push_lsa_RemovePrivilegesFromAccount(struct ndr_push *ndr, int flags, const struct lsa_RemovePrivilegesFromAccount *r)
5718 {
5719         if (flags & NDR_IN) {
5720                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5721                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5722                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.remove_all));
5723                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.privs));
5724                 if (r->in.privs) {
5725                         NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
5726                 }
5727         }
5728         if (flags & NDR_OUT) {
5729                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5730         }
5731         return NT_STATUS_OK;
5732 }
5733
5734 NTSTATUS ndr_pull_lsa_RemovePrivilegesFromAccount(struct ndr_pull *ndr, int flags, struct lsa_RemovePrivilegesFromAccount *r)
5735 {
5736         uint32_t _ptr_privs;
5737         TALLOC_CTX *_mem_save_handle_0;
5738         TALLOC_CTX *_mem_save_privs_0;
5739         if (flags & NDR_IN) {
5740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5741                         NDR_PULL_ALLOC(ndr, r->in.handle);
5742                 }
5743                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5744                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5745                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5747                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.remove_all));
5748                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
5749                 if (_ptr_privs) {
5750                         NDR_PULL_ALLOC(ndr, r->in.privs);
5751                 } else {
5752                         r->in.privs = NULL;
5753                 }
5754                 if (r->in.privs) {
5755                         _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
5756                         NDR_PULL_SET_MEM_CTX(ndr, r->in.privs, 0);
5757                         NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
5758                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, 0);
5759                 }
5760         }
5761         if (flags & NDR_OUT) {
5762                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5763         }
5764         return NT_STATUS_OK;
5765 }
5766
5767 _PUBLIC_ void ndr_print_lsa_RemovePrivilegesFromAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RemovePrivilegesFromAccount *r)
5768 {
5769         ndr_print_struct(ndr, name, "lsa_RemovePrivilegesFromAccount");
5770         ndr->depth++;
5771         if (flags & NDR_SET_VALUES) {
5772                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5773         }
5774         if (flags & NDR_IN) {
5775                 ndr_print_struct(ndr, "in", "lsa_RemovePrivilegesFromAccount");
5776                 ndr->depth++;
5777                 ndr_print_ptr(ndr, "handle", r->in.handle);
5778                 ndr->depth++;
5779                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5780                 ndr->depth--;
5781                 ndr_print_uint8(ndr, "remove_all", r->in.remove_all);
5782                 ndr_print_ptr(ndr, "privs", r->in.privs);
5783                 ndr->depth++;
5784                 if (r->in.privs) {
5785                         ndr_print_lsa_PrivilegeSet(ndr, "privs", r->in.privs);
5786                 }
5787                 ndr->depth--;
5788                 ndr->depth--;
5789         }
5790         if (flags & NDR_OUT) {
5791                 ndr_print_struct(ndr, "out", "lsa_RemovePrivilegesFromAccount");
5792                 ndr->depth++;
5793                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5794                 ndr->depth--;
5795         }
5796         ndr->depth--;
5797 }
5798
5799 NTSTATUS ndr_push_lsa_GetQuotasForAccount(struct ndr_push *ndr, int flags, const struct lsa_GetQuotasForAccount *r)
5800 {
5801         if (flags & NDR_IN) {
5802         }
5803         if (flags & NDR_OUT) {
5804                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5805         }
5806         return NT_STATUS_OK;
5807 }
5808
5809 NTSTATUS ndr_pull_lsa_GetQuotasForAccount(struct ndr_pull *ndr, int flags, struct lsa_GetQuotasForAccount *r)
5810 {
5811         if (flags & NDR_IN) {
5812         }
5813         if (flags & NDR_OUT) {
5814                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5815         }
5816         return NT_STATUS_OK;
5817 }
5818
5819 _PUBLIC_ void ndr_print_lsa_GetQuotasForAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetQuotasForAccount *r)
5820 {
5821         ndr_print_struct(ndr, name, "lsa_GetQuotasForAccount");
5822         ndr->depth++;
5823         if (flags & NDR_SET_VALUES) {
5824                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5825         }
5826         if (flags & NDR_IN) {
5827                 ndr_print_struct(ndr, "in", "lsa_GetQuotasForAccount");
5828                 ndr->depth++;
5829                 ndr->depth--;
5830         }
5831         if (flags & NDR_OUT) {
5832                 ndr_print_struct(ndr, "out", "lsa_GetQuotasForAccount");
5833                 ndr->depth++;
5834                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5835                 ndr->depth--;
5836         }
5837         ndr->depth--;
5838 }
5839
5840 NTSTATUS ndr_push_lsa_SetQuotasForAccount(struct ndr_push *ndr, int flags, const struct lsa_SetQuotasForAccount *r)
5841 {
5842         if (flags & NDR_IN) {
5843         }
5844         if (flags & NDR_OUT) {
5845                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5846         }
5847         return NT_STATUS_OK;
5848 }
5849
5850 NTSTATUS ndr_pull_lsa_SetQuotasForAccount(struct ndr_pull *ndr, int flags, struct lsa_SetQuotasForAccount *r)
5851 {
5852         if (flags & NDR_IN) {
5853         }
5854         if (flags & NDR_OUT) {
5855                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5856         }
5857         return NT_STATUS_OK;
5858 }
5859
5860 _PUBLIC_ void ndr_print_lsa_SetQuotasForAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetQuotasForAccount *r)
5861 {
5862         ndr_print_struct(ndr, name, "lsa_SetQuotasForAccount");
5863         ndr->depth++;
5864         if (flags & NDR_SET_VALUES) {
5865                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5866         }
5867         if (flags & NDR_IN) {
5868                 ndr_print_struct(ndr, "in", "lsa_SetQuotasForAccount");
5869                 ndr->depth++;
5870                 ndr->depth--;
5871         }
5872         if (flags & NDR_OUT) {
5873                 ndr_print_struct(ndr, "out", "lsa_SetQuotasForAccount");
5874                 ndr->depth++;
5875                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5876                 ndr->depth--;
5877         }
5878         ndr->depth--;
5879 }
5880
5881 NTSTATUS ndr_push_lsa_GetSystemAccessAccount(struct ndr_push *ndr, int flags, const struct lsa_GetSystemAccessAccount *r)
5882 {
5883         if (flags & NDR_IN) {
5884         }
5885         if (flags & NDR_OUT) {
5886                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5887         }
5888         return NT_STATUS_OK;
5889 }
5890
5891 NTSTATUS ndr_pull_lsa_GetSystemAccessAccount(struct ndr_pull *ndr, int flags, struct lsa_GetSystemAccessAccount *r)
5892 {
5893         if (flags & NDR_IN) {
5894         }
5895         if (flags & NDR_OUT) {
5896                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5897         }
5898         return NT_STATUS_OK;
5899 }
5900
5901 _PUBLIC_ void ndr_print_lsa_GetSystemAccessAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetSystemAccessAccount *r)
5902 {
5903         ndr_print_struct(ndr, name, "lsa_GetSystemAccessAccount");
5904         ndr->depth++;
5905         if (flags & NDR_SET_VALUES) {
5906                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5907         }
5908         if (flags & NDR_IN) {
5909                 ndr_print_struct(ndr, "in", "lsa_GetSystemAccessAccount");
5910                 ndr->depth++;
5911                 ndr->depth--;
5912         }
5913         if (flags & NDR_OUT) {
5914                 ndr_print_struct(ndr, "out", "lsa_GetSystemAccessAccount");
5915                 ndr->depth++;
5916                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5917                 ndr->depth--;
5918         }
5919         ndr->depth--;
5920 }
5921
5922 NTSTATUS ndr_push_lsa_SetSystemAccessAccount(struct ndr_push *ndr, int flags, const struct lsa_SetSystemAccessAccount *r)
5923 {
5924         if (flags & NDR_IN) {
5925         }
5926         if (flags & NDR_OUT) {
5927                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5928         }
5929         return NT_STATUS_OK;
5930 }
5931
5932 NTSTATUS ndr_pull_lsa_SetSystemAccessAccount(struct ndr_pull *ndr, int flags, struct lsa_SetSystemAccessAccount *r)
5933 {
5934         if (flags & NDR_IN) {
5935         }
5936         if (flags & NDR_OUT) {
5937                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5938         }
5939         return NT_STATUS_OK;
5940 }
5941
5942 _PUBLIC_ void ndr_print_lsa_SetSystemAccessAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSystemAccessAccount *r)
5943 {
5944         ndr_print_struct(ndr, name, "lsa_SetSystemAccessAccount");
5945         ndr->depth++;
5946         if (flags & NDR_SET_VALUES) {
5947                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5948         }
5949         if (flags & NDR_IN) {
5950                 ndr_print_struct(ndr, "in", "lsa_SetSystemAccessAccount");
5951                 ndr->depth++;
5952                 ndr->depth--;
5953         }
5954         if (flags & NDR_OUT) {
5955                 ndr_print_struct(ndr, "out", "lsa_SetSystemAccessAccount");
5956                 ndr->depth++;
5957                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5958                 ndr->depth--;
5959         }
5960         ndr->depth--;
5961 }
5962
5963 NTSTATUS ndr_push_lsa_OpenTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_OpenTrustedDomain *r)
5964 {
5965         if (flags & NDR_IN) {
5966                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5967                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5968                 if (r->in.sid == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5969                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
5970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
5971         }
5972         if (flags & NDR_OUT) {
5973                 if (r->out.trustdom_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5974                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
5975                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5976         }
5977         return NT_STATUS_OK;
5978 }
5979
5980 NTSTATUS ndr_pull_lsa_OpenTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_OpenTrustedDomain *r)
5981 {
5982         TALLOC_CTX *_mem_save_handle_0;
5983         TALLOC_CTX *_mem_save_sid_0;
5984         TALLOC_CTX *_mem_save_trustdom_handle_0;
5985         if (flags & NDR_IN) {
5986                 ZERO_STRUCT(r->out);
5987
5988                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5989                         NDR_PULL_ALLOC(ndr, r->in.handle);
5990                 }
5991                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5992                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5993                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5994                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5995                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5996                         NDR_PULL_ALLOC(ndr, r->in.sid);
5997                 }
5998                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
5999                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6000                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6001                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6003                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
6004                 ZERO_STRUCTP(r->out.trustdom_handle);
6005         }
6006         if (flags & NDR_OUT) {
6007                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6008                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
6009                 }
6010                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6011                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
6012                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
6013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
6014                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6015         }
6016         return NT_STATUS_OK;
6017 }
6018
6019 _PUBLIC_ void ndr_print_lsa_OpenTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenTrustedDomain *r)
6020 {
6021         ndr_print_struct(ndr, name, "lsa_OpenTrustedDomain");
6022         ndr->depth++;
6023         if (flags & NDR_SET_VALUES) {
6024                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6025         }
6026         if (flags & NDR_IN) {
6027                 ndr_print_struct(ndr, "in", "lsa_OpenTrustedDomain");
6028                 ndr->depth++;
6029                 ndr_print_ptr(ndr, "handle", r->in.handle);
6030                 ndr->depth++;
6031                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6032                 ndr->depth--;
6033                 ndr_print_ptr(ndr, "sid", r->in.sid);
6034                 ndr->depth++;
6035                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6036                 ndr->depth--;
6037                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
6038                 ndr->depth--;
6039         }
6040         if (flags & NDR_OUT) {
6041                 ndr_print_struct(ndr, "out", "lsa_OpenTrustedDomain");
6042                 ndr->depth++;
6043                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
6044                 ndr->depth++;
6045                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
6046                 ndr->depth--;
6047                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6048                 ndr->depth--;
6049         }
6050         ndr->depth--;
6051 }
6052
6053 NTSTATUS ndr_push_lsa_QueryTrustedDomainInfo(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfo *r)
6054 {
6055         if (flags & NDR_IN) {
6056                 if (r->in.trustdom_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6057                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trustdom_handle));
6058                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
6059         }
6060         if (flags & NDR_OUT) {
6061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
6062                 if (r->out.info) {
6063                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
6064                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6065                 }
6066                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6067         }
6068         return NT_STATUS_OK;
6069 }
6070
6071 NTSTATUS ndr_pull_lsa_QueryTrustedDomainInfo(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfo *r)
6072 {
6073         uint32_t _ptr_info;
6074         TALLOC_CTX *_mem_save_trustdom_handle_0;
6075         TALLOC_CTX *_mem_save_info_0;
6076         if (flags & NDR_IN) {
6077                 ZERO_STRUCT(r->out);
6078
6079                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6080                         NDR_PULL_ALLOC(ndr, r->in.trustdom_handle);
6081                 }
6082                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6083                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
6084                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trustdom_handle));
6085                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
6086                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
6087         }
6088         if (flags & NDR_OUT) {
6089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6090                 if (_ptr_info) {
6091                         NDR_PULL_ALLOC(ndr, r->out.info);
6092                 } else {
6093                         r->out.info = NULL;
6094                 }
6095                 if (r->out.info) {
6096                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6097                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
6098                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
6099                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6100                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
6101                 }
6102                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6103         }
6104         return NT_STATUS_OK;
6105 }
6106
6107 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfo *r)
6108 {
6109         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfo");
6110         ndr->depth++;
6111         if (flags & NDR_SET_VALUES) {
6112                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6113         }
6114         if (flags & NDR_IN) {
6115                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfo");
6116                 ndr->depth++;
6117                 ndr_print_ptr(ndr, "trustdom_handle", r->in.trustdom_handle);
6118                 ndr->depth++;
6119                 ndr_print_policy_handle(ndr, "trustdom_handle", r->in.trustdom_handle);
6120                 ndr->depth--;
6121                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
6122                 ndr->depth--;
6123         }
6124         if (flags & NDR_OUT) {
6125                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfo");
6126                 ndr->depth++;
6127                 ndr_print_ptr(ndr, "info", r->out.info);
6128                 ndr->depth++;
6129                 if (r->out.info) {
6130                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
6131                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->out.info);
6132                 }
6133                 ndr->depth--;
6134                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6135                 ndr->depth--;
6136         }
6137         ndr->depth--;
6138 }
6139
6140 NTSTATUS ndr_push_lsa_SetInformationTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_SetInformationTrustedDomain *r)
6141 {
6142         if (flags & NDR_IN) {
6143         }
6144         if (flags & NDR_OUT) {
6145                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6146         }
6147         return NT_STATUS_OK;
6148 }
6149
6150 NTSTATUS ndr_pull_lsa_SetInformationTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_SetInformationTrustedDomain *r)
6151 {
6152         if (flags & NDR_IN) {
6153         }
6154         if (flags & NDR_OUT) {
6155                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6156         }
6157         return NT_STATUS_OK;
6158 }
6159
6160 _PUBLIC_ void ndr_print_lsa_SetInformationTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInformationTrustedDomain *r)
6161 {
6162         ndr_print_struct(ndr, name, "lsa_SetInformationTrustedDomain");
6163         ndr->depth++;
6164         if (flags & NDR_SET_VALUES) {
6165                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6166         }
6167         if (flags & NDR_IN) {
6168                 ndr_print_struct(ndr, "in", "lsa_SetInformationTrustedDomain");
6169                 ndr->depth++;
6170                 ndr->depth--;
6171         }
6172         if (flags & NDR_OUT) {
6173                 ndr_print_struct(ndr, "out", "lsa_SetInformationTrustedDomain");
6174                 ndr->depth++;
6175                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6176                 ndr->depth--;
6177         }
6178         ndr->depth--;
6179 }
6180
6181 NTSTATUS ndr_push_lsa_OpenSecret(struct ndr_push *ndr, int flags, const struct lsa_OpenSecret *r)
6182 {
6183         if (flags & NDR_IN) {
6184                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6185                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6186                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6188         }
6189         if (flags & NDR_OUT) {
6190                 if (r->out.sec_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6191                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
6192                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6193         }
6194         return NT_STATUS_OK;
6195 }
6196
6197 NTSTATUS ndr_pull_lsa_OpenSecret(struct ndr_pull *ndr, int flags, struct lsa_OpenSecret *r)
6198 {
6199         TALLOC_CTX *_mem_save_handle_0;
6200         TALLOC_CTX *_mem_save_sec_handle_0;
6201         if (flags & NDR_IN) {
6202                 ZERO_STRUCT(r->out);
6203
6204                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6205                         NDR_PULL_ALLOC(ndr, r->in.handle);
6206                 }
6207                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6208                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6209                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6210                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6211                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6213                 NDR_PULL_ALLOC(ndr, r->out.sec_handle);
6214                 ZERO_STRUCTP(r->out.sec_handle);
6215         }
6216         if (flags & NDR_OUT) {
6217                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6218                         NDR_PULL_ALLOC(ndr, r->out.sec_handle);
6219                 }
6220                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6221                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sec_handle, LIBNDR_FLAG_REF_ALLOC);
6222                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
6223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
6224                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6225         }
6226         return NT_STATUS_OK;
6227 }
6228
6229 _PUBLIC_ void ndr_print_lsa_OpenSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenSecret *r)
6230 {
6231         ndr_print_struct(ndr, name, "lsa_OpenSecret");
6232         ndr->depth++;
6233         if (flags & NDR_SET_VALUES) {
6234                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6235         }
6236         if (flags & NDR_IN) {
6237                 ndr_print_struct(ndr, "in", "lsa_OpenSecret");
6238                 ndr->depth++;
6239                 ndr_print_ptr(ndr, "handle", r->in.handle);
6240                 ndr->depth++;
6241                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6242                 ndr->depth--;
6243                 ndr_print_lsa_String(ndr, "name", &r->in.name);
6244                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
6245                 ndr->depth--;
6246         }
6247         if (flags & NDR_OUT) {
6248                 ndr_print_struct(ndr, "out", "lsa_OpenSecret");
6249                 ndr->depth++;
6250                 ndr_print_ptr(ndr, "sec_handle", r->out.sec_handle);
6251                 ndr->depth++;
6252                 ndr_print_policy_handle(ndr, "sec_handle", r->out.sec_handle);
6253                 ndr->depth--;
6254                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6255                 ndr->depth--;
6256         }
6257         ndr->depth--;
6258 }
6259
6260 NTSTATUS ndr_push_lsa_SetSecret(struct ndr_push *ndr, int flags, const struct lsa_SetSecret *r)
6261 {
6262         if (flags & NDR_IN) {
6263                 if (r->in.sec_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6264                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
6265                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_val));
6266                 if (r->in.new_val) {
6267                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
6268                 }
6269                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_val));
6270                 if (r->in.old_val) {
6271                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
6272                 }
6273         }
6274         if (flags & NDR_OUT) {
6275                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6276         }
6277         return NT_STATUS_OK;
6278 }
6279
6280 NTSTATUS ndr_pull_lsa_SetSecret(struct ndr_pull *ndr, int flags, struct lsa_SetSecret *r)
6281 {
6282         uint32_t _ptr_new_val;
6283         uint32_t _ptr_old_val;
6284         TALLOC_CTX *_mem_save_sec_handle_0;
6285         TALLOC_CTX *_mem_save_new_val_0;
6286         TALLOC_CTX *_mem_save_old_val_0;
6287         if (flags & NDR_IN) {
6288                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6289                         NDR_PULL_ALLOC(ndr, r->in.sec_handle);
6290                 }
6291                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6292                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_handle, LIBNDR_FLAG_REF_ALLOC);
6293                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
6294                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
6295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
6296                 if (_ptr_new_val) {
6297                         NDR_PULL_ALLOC(ndr, r->in.new_val);
6298                 } else {
6299                         r->in.new_val = NULL;
6300                 }
6301                 if (r->in.new_val) {
6302                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
6303                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_val, 0);
6304                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
6305                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
6306                 }
6307                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
6308                 if (_ptr_old_val) {
6309                         NDR_PULL_ALLOC(ndr, r->in.old_val);
6310                 } else {
6311                         r->in.old_val = NULL;
6312                 }
6313                 if (r->in.old_val) {
6314                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
6315                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_val, 0);
6316                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
6317                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
6318                 }
6319         }
6320         if (flags & NDR_OUT) {
6321                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6322         }
6323         return NT_STATUS_OK;
6324 }
6325
6326 _PUBLIC_ void ndr_print_lsa_SetSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSecret *r)
6327 {
6328         ndr_print_struct(ndr, name, "lsa_SetSecret");
6329         ndr->depth++;
6330         if (flags & NDR_SET_VALUES) {
6331                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6332         }
6333         if (flags & NDR_IN) {
6334                 ndr_print_struct(ndr, "in", "lsa_SetSecret");
6335                 ndr->depth++;
6336                 ndr_print_ptr(ndr, "sec_handle", r->in.sec_handle);
6337                 ndr->depth++;
6338                 ndr_print_policy_handle(ndr, "sec_handle", r->in.sec_handle);
6339                 ndr->depth--;
6340                 ndr_print_ptr(ndr, "new_val", r->in.new_val);
6341                 ndr->depth++;
6342                 if (r->in.new_val) {
6343                         ndr_print_lsa_DATA_BUF(ndr, "new_val", r->in.new_val);
6344                 }
6345                 ndr->depth--;
6346                 ndr_print_ptr(ndr, "old_val", r->in.old_val);
6347                 ndr->depth++;
6348                 if (r->in.old_val) {
6349                         ndr_print_lsa_DATA_BUF(ndr, "old_val", r->in.old_val);
6350                 }
6351                 ndr->depth--;
6352                 ndr->depth--;
6353         }
6354         if (flags & NDR_OUT) {
6355                 ndr_print_struct(ndr, "out", "lsa_SetSecret");
6356                 ndr->depth++;
6357                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6358                 ndr->depth--;
6359         }
6360         ndr->depth--;
6361 }
6362
6363 NTSTATUS ndr_push_lsa_QuerySecret(struct ndr_push *ndr, int flags, const struct lsa_QuerySecret *r)
6364 {
6365         if (flags & NDR_IN) {
6366                 if (r->in.sec_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6367                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
6368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_val));
6369                 if (r->in.new_val) {
6370                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
6371                 }
6372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_mtime));
6373                 if (r->in.new_mtime) {
6374                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->in.new_mtime));
6375                 }
6376                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_val));
6377                 if (r->in.old_val) {
6378                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
6379                 }
6380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_mtime));
6381                 if (r->in.old_mtime) {
6382                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->in.old_mtime));
6383                 }
6384         }
6385         if (flags & NDR_OUT) {
6386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.new_val));
6387                 if (r->out.new_val) {
6388                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.new_val));
6389                 }
6390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.new_mtime));
6391                 if (r->out.new_mtime) {
6392                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->out.new_mtime));
6393                 }
6394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.old_val));
6395                 if (r->out.old_val) {
6396                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.old_val));
6397                 }
6398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.old_mtime));
6399                 if (r->out.old_mtime) {
6400                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->out.old_mtime));
6401                 }
6402                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6403         }
6404         return NT_STATUS_OK;
6405 }
6406
6407 NTSTATUS ndr_pull_lsa_QuerySecret(struct ndr_pull *ndr, int flags, struct lsa_QuerySecret *r)
6408 {
6409         uint32_t _ptr_new_val;
6410         uint32_t _ptr_new_mtime;
6411         uint32_t _ptr_old_val;
6412         uint32_t _ptr_old_mtime;
6413         TALLOC_CTX *_mem_save_sec_handle_0;
6414         TALLOC_CTX *_mem_save_new_val_0;
6415         TALLOC_CTX *_mem_save_new_mtime_0;
6416         TALLOC_CTX *_mem_save_old_val_0;
6417         TALLOC_CTX *_mem_save_old_mtime_0;
6418         if (flags & NDR_IN) {
6419                 ZERO_STRUCT(r->out);
6420
6421                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6422                         NDR_PULL_ALLOC(ndr, r->in.sec_handle);
6423                 }
6424                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6425                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_handle, LIBNDR_FLAG_REF_ALLOC);
6426                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
6427                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
6428                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
6429                 if (_ptr_new_val) {
6430                         NDR_PULL_ALLOC(ndr, r->in.new_val);
6431                 } else {
6432                         r->in.new_val = NULL;
6433                 }
6434                 if (r->in.new_val) {
6435                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
6436                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_val, 0);
6437                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
6438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
6439                 }
6440                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_mtime));
6441                 if (_ptr_new_mtime) {
6442                         NDR_PULL_ALLOC(ndr, r->in.new_mtime);
6443                 } else {
6444                         r->in.new_mtime = NULL;
6445                 }
6446                 if (r->in.new_mtime) {
6447                         _mem_save_new_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
6448                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_mtime, 0);
6449                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->in.new_mtime));
6450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_mtime_0, 0);
6451                 }
6452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
6453                 if (_ptr_old_val) {
6454                         NDR_PULL_ALLOC(ndr, r->in.old_val);
6455                 } else {
6456                         r->in.old_val = NULL;
6457                 }
6458                 if (r->in.old_val) {
6459                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
6460                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_val, 0);
6461                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
6462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
6463                 }
6464                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_mtime));
6465                 if (_ptr_old_mtime) {
6466                         NDR_PULL_ALLOC(ndr, r->in.old_mtime);
6467                 } else {
6468                         r->in.old_mtime = NULL;
6469                 }
6470                 if (r->in.old_mtime) {
6471                         _mem_save_old_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
6472                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_mtime, 0);
6473                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->in.old_mtime));
6474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_mtime_0, 0);
6475                 }
6476         }
6477         if (flags & NDR_OUT) {
6478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
6479                 if (_ptr_new_val) {
6480                         NDR_PULL_ALLOC(ndr, r->out.new_val);
6481                 } else {
6482                         r->out.new_val = NULL;
6483                 }
6484                 if (r->out.new_val) {
6485                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
6486                         NDR_PULL_SET_MEM_CTX(ndr, r->out.new_val, 0);
6487                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.new_val));
6488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
6489                 }
6490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_mtime));
6491                 if (_ptr_new_mtime) {
6492                         NDR_PULL_ALLOC(ndr, r->out.new_mtime);
6493                 } else {
6494                         r->out.new_mtime = NULL;
6495                 }
6496                 if (r->out.new_mtime) {
6497                         _mem_save_new_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
6498                         NDR_PULL_SET_MEM_CTX(ndr, r->out.new_mtime, 0);
6499                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->out.new_mtime));
6500                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_mtime_0, 0);
6501                 }
6502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
6503                 if (_ptr_old_val) {
6504                         NDR_PULL_ALLOC(ndr, r->out.old_val);
6505                 } else {
6506                         r->out.old_val = NULL;
6507                 }
6508                 if (r->out.old_val) {
6509                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
6510                         NDR_PULL_SET_MEM_CTX(ndr, r->out.old_val, 0);
6511                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.old_val));
6512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
6513                 }
6514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_mtime));
6515                 if (_ptr_old_mtime) {
6516                         NDR_PULL_ALLOC(ndr, r->out.old_mtime);
6517                 } else {
6518                         r->out.old_mtime = NULL;
6519                 }
6520                 if (r->out.old_mtime) {
6521                         _mem_save_old_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
6522                         NDR_PULL_SET_MEM_CTX(ndr, r->out.old_mtime, 0);
6523                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->out.old_mtime));
6524                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_mtime_0, 0);
6525                 }
6526                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6527         }
6528         return NT_STATUS_OK;
6529 }
6530
6531 _PUBLIC_ void ndr_print_lsa_QuerySecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QuerySecret *r)
6532 {
6533         ndr_print_struct(ndr, name, "lsa_QuerySecret");
6534         ndr->depth++;
6535         if (flags & NDR_SET_VALUES) {
6536                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6537         }
6538         if (flags & NDR_IN) {
6539                 ndr_print_struct(ndr, "in", "lsa_QuerySecret");
6540                 ndr->depth++;
6541                 ndr_print_ptr(ndr, "sec_handle", r->in.sec_handle);
6542                 ndr->depth++;
6543                 ndr_print_policy_handle(ndr, "sec_handle", r->in.sec_handle);
6544                 ndr->depth--;
6545                 ndr_print_ptr(ndr, "new_val", r->in.new_val);
6546                 ndr->depth++;
6547                 if (r->in.new_val) {
6548                         ndr_print_lsa_DATA_BUF_PTR(ndr, "new_val", r->in.new_val);
6549                 }
6550                 ndr->depth--;
6551                 ndr_print_ptr(ndr, "new_mtime", r->in.new_mtime);
6552                 ndr->depth++;
6553                 if (r->in.new_mtime) {
6554                         ndr_print_NTTIME_hyper(ndr, "new_mtime", *r->in.new_mtime);
6555                 }
6556                 ndr->depth--;
6557                 ndr_print_ptr(ndr, "old_val", r->in.old_val);
6558                 ndr->depth++;
6559                 if (r->in.old_val) {
6560                         ndr_print_lsa_DATA_BUF_PTR(ndr, "old_val", r->in.old_val);
6561                 }
6562                 ndr->depth--;
6563                 ndr_print_ptr(ndr, "old_mtime", r->in.old_mtime);
6564                 ndr->depth++;
6565                 if (r->in.old_mtime) {
6566                         ndr_print_NTTIME_hyper(ndr, "old_mtime", *r->in.old_mtime);
6567                 }
6568                 ndr->depth--;
6569                 ndr->depth--;
6570         }
6571         if (flags & NDR_OUT) {
6572                 ndr_print_struct(ndr, "out", "lsa_QuerySecret");
6573                 ndr->depth++;
6574                 ndr_print_ptr(ndr, "new_val", r->out.new_val);
6575                 ndr->depth++;
6576                 if (r->out.new_val) {
6577                         ndr_print_lsa_DATA_BUF_PTR(ndr, "new_val", r->out.new_val);
6578                 }
6579                 ndr->depth--;
6580                 ndr_print_ptr(ndr, "new_mtime", r->out.new_mtime);
6581                 ndr->depth++;
6582                 if (r->out.new_mtime) {
6583                         ndr_print_NTTIME_hyper(ndr, "new_mtime", *r->out.new_mtime);
6584                 }
6585                 ndr->depth--;
6586                 ndr_print_ptr(ndr, "old_val", r->out.old_val);
6587                 ndr->depth++;
6588                 if (r->out.old_val) {
6589                         ndr_print_lsa_DATA_BUF_PTR(ndr, "old_val", r->out.old_val);
6590                 }
6591                 ndr->depth--;
6592                 ndr_print_ptr(ndr, "old_mtime", r->out.old_mtime);
6593                 ndr->depth++;
6594                 if (r->out.old_mtime) {
6595                         ndr_print_NTTIME_hyper(ndr, "old_mtime", *r->out.old_mtime);
6596                 }
6597                 ndr->depth--;
6598                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6599                 ndr->depth--;
6600         }
6601         ndr->depth--;
6602 }
6603
6604 NTSTATUS ndr_push_lsa_LookupPrivValue(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivValue *r)
6605 {
6606         if (flags & NDR_IN) {
6607                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6608                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6609                 if (r->in.name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6610                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6611         }
6612         if (flags & NDR_OUT) {
6613                 if (r->out.luid == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6614                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, r->out.luid));
6615                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6616         }
6617         return NT_STATUS_OK;
6618 }
6619
6620 NTSTATUS ndr_pull_lsa_LookupPrivValue(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivValue *r)
6621 {
6622         TALLOC_CTX *_mem_save_handle_0;
6623         TALLOC_CTX *_mem_save_name_0;
6624         TALLOC_CTX *_mem_save_luid_0;
6625         if (flags & NDR_IN) {
6626                 ZERO_STRUCT(r->out);
6627
6628                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6629                         NDR_PULL_ALLOC(ndr, r->in.handle);
6630                 }
6631                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6632                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6633                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6635                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6636                         NDR_PULL_ALLOC(ndr, r->in.name);
6637                 }
6638                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6639                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
6640                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6641                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
6642                 NDR_PULL_ALLOC(ndr, r->out.luid);
6643                 ZERO_STRUCTP(r->out.luid);
6644         }
6645         if (flags & NDR_OUT) {
6646                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6647                         NDR_PULL_ALLOC(ndr, r->out.luid);
6648                 }
6649                 _mem_save_luid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6650                 NDR_PULL_SET_MEM_CTX(ndr, r->out.luid, LIBNDR_FLAG_REF_ALLOC);
6651                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, r->out.luid));
6652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_luid_0, LIBNDR_FLAG_REF_ALLOC);
6653                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6654         }
6655         return NT_STATUS_OK;
6656 }
6657
6658 _PUBLIC_ void ndr_print_lsa_LookupPrivValue(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivValue *r)
6659 {
6660         ndr_print_struct(ndr, name, "lsa_LookupPrivValue");
6661         ndr->depth++;
6662         if (flags & NDR_SET_VALUES) {
6663                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6664         }
6665         if (flags & NDR_IN) {
6666                 ndr_print_struct(ndr, "in", "lsa_LookupPrivValue");
6667                 ndr->depth++;
6668                 ndr_print_ptr(ndr, "handle", r->in.handle);
6669                 ndr->depth++;
6670                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6671                 ndr->depth--;
6672                 ndr_print_ptr(ndr, "name", r->in.name);
6673                 ndr->depth++;
6674                 ndr_print_lsa_String(ndr, "name", r->in.name);
6675                 ndr->depth--;
6676                 ndr->depth--;
6677         }
6678         if (flags & NDR_OUT) {
6679                 ndr_print_struct(ndr, "out", "lsa_LookupPrivValue");
6680                 ndr->depth++;
6681                 ndr_print_ptr(ndr, "luid", r->out.luid);
6682                 ndr->depth++;
6683                 ndr_print_lsa_LUID(ndr, "luid", r->out.luid);
6684                 ndr->depth--;
6685                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6686                 ndr->depth--;
6687         }
6688         ndr->depth--;
6689 }
6690
6691 NTSTATUS ndr_push_lsa_LookupPrivName(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivName *r)
6692 {
6693         if (flags & NDR_IN) {
6694                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6695                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6696                 if (r->in.luid == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6697                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, r->in.luid));
6698         }
6699         if (flags & NDR_OUT) {
6700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.name));
6701                 if (r->out.name) {
6702                         NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
6703                 }
6704                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6705         }
6706         return NT_STATUS_OK;
6707 }
6708
6709 NTSTATUS ndr_pull_lsa_LookupPrivName(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivName *r)
6710 {
6711         uint32_t _ptr_name;
6712         TALLOC_CTX *_mem_save_handle_0;
6713         TALLOC_CTX *_mem_save_luid_0;
6714         TALLOC_CTX *_mem_save_name_0;
6715         if (flags & NDR_IN) {
6716                 ZERO_STRUCT(r->out);
6717
6718                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6719                         NDR_PULL_ALLOC(ndr, r->in.handle);
6720                 }
6721                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6722                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6723                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6724                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6725                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6726                         NDR_PULL_ALLOC(ndr, r->in.luid);
6727                 }
6728                 _mem_save_luid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6729                 NDR_PULL_SET_MEM_CTX(ndr, r->in.luid, LIBNDR_FLAG_REF_ALLOC);
6730                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, r->in.luid));
6731                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_luid_0, LIBNDR_FLAG_REF_ALLOC);
6732         }
6733         if (flags & NDR_OUT) {
6734                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6735                 if (_ptr_name) {
6736                         NDR_PULL_ALLOC(ndr, r->out.name);
6737                 } else {
6738                         r->out.name = NULL;
6739                 }
6740                 if (r->out.name) {
6741                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6742                         NDR_PULL_SET_MEM_CTX(ndr, r->out.name, 0);
6743                         NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
6744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6745                 }
6746                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6747         }
6748         return NT_STATUS_OK;
6749 }
6750
6751 _PUBLIC_ void ndr_print_lsa_LookupPrivName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivName *r)
6752 {
6753         ndr_print_struct(ndr, name, "lsa_LookupPrivName");
6754         ndr->depth++;
6755         if (flags & NDR_SET_VALUES) {
6756                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6757         }
6758         if (flags & NDR_IN) {
6759                 ndr_print_struct(ndr, "in", "lsa_LookupPrivName");
6760                 ndr->depth++;
6761                 ndr_print_ptr(ndr, "handle", r->in.handle);
6762                 ndr->depth++;
6763                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6764                 ndr->depth--;
6765                 ndr_print_ptr(ndr, "luid", r->in.luid);
6766                 ndr->depth++;
6767                 ndr_print_lsa_LUID(ndr, "luid", r->in.luid);
6768                 ndr->depth--;
6769                 ndr->depth--;
6770         }
6771         if (flags & NDR_OUT) {
6772                 ndr_print_struct(ndr, "out", "lsa_LookupPrivName");
6773                 ndr->depth++;
6774                 ndr_print_ptr(ndr, "name", r->out.name);
6775                 ndr->depth++;
6776                 if (r->out.name) {
6777                         ndr_print_lsa_StringLarge(ndr, "name", r->out.name);
6778                 }
6779                 ndr->depth--;
6780                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6781                 ndr->depth--;
6782         }
6783         ndr->depth--;
6784 }
6785
6786 NTSTATUS ndr_push_lsa_LookupPrivDisplayName(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivDisplayName *r)
6787 {
6788         if (flags & NDR_IN) {
6789                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6790                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6791                 if (r->in.name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6792                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6793                 if (r->in.language_id == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6794                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.language_id));
6795                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.unknown));
6796         }
6797         if (flags & NDR_OUT) {
6798                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.disp_name));
6799                 if (r->out.disp_name) {
6800                         NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.disp_name));
6801                 }
6802                 if (r->out.language_id == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6803                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->out.language_id));
6804                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6805         }
6806         return NT_STATUS_OK;
6807 }
6808
6809 NTSTATUS ndr_pull_lsa_LookupPrivDisplayName(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivDisplayName *r)
6810 {
6811         uint32_t _ptr_disp_name;
6812         TALLOC_CTX *_mem_save_handle_0;
6813         TALLOC_CTX *_mem_save_name_0;
6814         TALLOC_CTX *_mem_save_disp_name_0;
6815         TALLOC_CTX *_mem_save_language_id_0;
6816         if (flags & NDR_IN) {
6817                 ZERO_STRUCT(r->out);
6818
6819                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6820                         NDR_PULL_ALLOC(ndr, r->in.handle);
6821                 }
6822                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6823                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6824                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6825                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6827                         NDR_PULL_ALLOC(ndr, r->in.name);
6828                 }
6829                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6830                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
6831                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
6833                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6834                         NDR_PULL_ALLOC(ndr, r->in.language_id);
6835                 }
6836                 _mem_save_language_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6837                 NDR_PULL_SET_MEM_CTX(ndr, r->in.language_id, LIBNDR_FLAG_REF_ALLOC);
6838                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.language_id));
6839                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_id_0, LIBNDR_FLAG_REF_ALLOC);
6840                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.unknown));
6841                 NDR_PULL_ALLOC(ndr, r->out.language_id);
6842                 *r->out.language_id = *r->in.language_id;
6843         }
6844         if (flags & NDR_OUT) {
6845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_disp_name));
6846                 if (_ptr_disp_name) {
6847                         NDR_PULL_ALLOC(ndr, r->out.disp_name);
6848                 } else {
6849                         r->out.disp_name = NULL;
6850                 }
6851                 if (r->out.disp_name) {
6852                         _mem_save_disp_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6853                         NDR_PULL_SET_MEM_CTX(ndr, r->out.disp_name, 0);
6854                         NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.disp_name));
6855                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disp_name_0, 0);
6856                 }
6857                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6858                         NDR_PULL_ALLOC(ndr, r->out.language_id);
6859                 }
6860                 _mem_save_language_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
6861                 NDR_PULL_SET_MEM_CTX(ndr, r->out.language_id, LIBNDR_FLAG_REF_ALLOC);
6862                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->out.language_id));
6863                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_id_0, LIBNDR_FLAG_REF_ALLOC);
6864                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6865         }
6866         return NT_STATUS_OK;
6867 }
6868
6869 _PUBLIC_ void ndr_print_lsa_LookupPrivDisplayName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivDisplayName *r)
6870 {
6871         ndr_print_struct(ndr, name, "lsa_LookupPrivDisplayName");
6872         ndr->depth++;
6873         if (flags & NDR_SET_VALUES) {
6874                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6875         }
6876         if (flags & NDR_IN) {
6877                 ndr_print_struct(ndr, "in", "lsa_LookupPrivDisplayName");
6878                 ndr->depth++;
6879                 ndr_print_ptr(ndr, "handle", r->in.handle);
6880                 ndr->depth++;
6881                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6882                 ndr->depth--;
6883                 ndr_print_ptr(ndr, "name", r->in.name);
6884                 ndr->depth++;
6885                 ndr_print_lsa_String(ndr, "name", r->in.name);
6886                 ndr->depth--;
6887                 ndr_print_ptr(ndr, "language_id", r->in.language_id);
6888                 ndr->depth++;
6889                 ndr_print_uint16(ndr, "language_id", *r->in.language_id);
6890                 ndr->depth--;
6891                 ndr_print_uint16(ndr, "unknown", r->in.unknown);
6892                 ndr->depth--;
6893         }
6894         if (flags & NDR_OUT) {
6895                 ndr_print_struct(ndr, "out", "lsa_LookupPrivDisplayName");
6896                 ndr->depth++;
6897                 ndr_print_ptr(ndr, "disp_name", r->out.disp_name);
6898                 ndr->depth++;
6899                 if (r->out.disp_name) {
6900                         ndr_print_lsa_StringLarge(ndr, "disp_name", r->out.disp_name);
6901                 }
6902                 ndr->depth--;
6903                 ndr_print_ptr(ndr, "language_id", r->out.language_id);
6904                 ndr->depth++;
6905                 ndr_print_uint16(ndr, "language_id", *r->out.language_id);
6906                 ndr->depth--;
6907                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6908                 ndr->depth--;
6909         }
6910         ndr->depth--;
6911 }
6912
6913 NTSTATUS ndr_push_lsa_DeleteObject(struct ndr_push *ndr, int flags, const struct lsa_DeleteObject *r)
6914 {
6915         if (flags & NDR_IN) {
6916         }
6917         if (flags & NDR_OUT) {
6918                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6919         }
6920         return NT_STATUS_OK;
6921 }
6922
6923 NTSTATUS ndr_pull_lsa_DeleteObject(struct ndr_pull *ndr, int flags, struct lsa_DeleteObject *r)
6924 {
6925         if (flags & NDR_IN) {
6926         }
6927         if (flags & NDR_OUT) {
6928                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6929         }
6930         return NT_STATUS_OK;
6931 }
6932
6933 _PUBLIC_ void ndr_print_lsa_DeleteObject(struct ndr_print *ndr, const char *name, int flags, const struct lsa_DeleteObject *r)
6934 {
6935         ndr_print_struct(ndr, name, "lsa_DeleteObject");
6936         ndr->depth++;
6937         if (flags & NDR_SET_VALUES) {
6938                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6939         }
6940         if (flags & NDR_IN) {
6941                 ndr_print_struct(ndr, "in", "lsa_DeleteObject");
6942                 ndr->depth++;
6943                 ndr->depth--;
6944         }
6945         if (flags & NDR_OUT) {
6946                 ndr_print_struct(ndr, "out", "lsa_DeleteObject");
6947                 ndr->depth++;
6948                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6949                 ndr->depth--;
6950         }
6951         ndr->depth--;
6952 }
6953
6954 NTSTATUS ndr_push_lsa_EnumAccountsWithUserRight(struct ndr_push *ndr, int flags, const struct lsa_EnumAccountsWithUserRight *r)
6955 {
6956         if (flags & NDR_IN) {
6957                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6958                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6959                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
6960                 if (r->in.name) {
6961                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6962                 }
6963         }
6964         if (flags & NDR_OUT) {
6965                 if (r->out.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
6966                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
6967                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6968         }
6969         return NT_STATUS_OK;
6970 }
6971
6972 NTSTATUS ndr_pull_lsa_EnumAccountsWithUserRight(struct ndr_pull *ndr, int flags, struct lsa_EnumAccountsWithUserRight *r)
6973 {
6974         uint32_t _ptr_name;
6975         TALLOC_CTX *_mem_save_handle_0;
6976         TALLOC_CTX *_mem_save_name_0;
6977         TALLOC_CTX *_mem_save_sids_0;
6978         if (flags & NDR_IN) {
6979                 ZERO_STRUCT(r->out);
6980
6981                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6982                         NDR_PULL_ALLOC(ndr, r->in.handle);
6983                 }
6984                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6985                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6986                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6987                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6989                 if (_ptr_name) {
6990                         NDR_PULL_ALLOC(ndr, r->in.name);
6991                 } else {
6992                         r->in.name = NULL;
6993                 }
6994                 if (r->in.name) {
6995                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6996                         NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
6997                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
6998                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6999                 }
7000                 NDR_PULL_ALLOC(ndr, r->out.sids);
7001                 ZERO_STRUCTP(r->out.sids);
7002         }
7003         if (flags & NDR_OUT) {
7004                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7005                         NDR_PULL_ALLOC(ndr, r->out.sids);
7006                 }
7007                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7008                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
7009                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
7010                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
7011                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7012         }
7013         return NT_STATUS_OK;
7014 }
7015
7016 _PUBLIC_ void ndr_print_lsa_EnumAccountsWithUserRight(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccountsWithUserRight *r)
7017 {
7018         ndr_print_struct(ndr, name, "lsa_EnumAccountsWithUserRight");
7019         ndr->depth++;
7020         if (flags & NDR_SET_VALUES) {
7021                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7022         }
7023         if (flags & NDR_IN) {
7024                 ndr_print_struct(ndr, "in", "lsa_EnumAccountsWithUserRight");
7025                 ndr->depth++;
7026                 ndr_print_ptr(ndr, "handle", r->in.handle);
7027                 ndr->depth++;
7028                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7029                 ndr->depth--;
7030                 ndr_print_ptr(ndr, "name", r->in.name);
7031                 ndr->depth++;
7032                 if (r->in.name) {
7033                         ndr_print_lsa_String(ndr, "name", r->in.name);
7034                 }
7035                 ndr->depth--;
7036                 ndr->depth--;
7037         }
7038         if (flags & NDR_OUT) {
7039                 ndr_print_struct(ndr, "out", "lsa_EnumAccountsWithUserRight");
7040                 ndr->depth++;
7041                 ndr_print_ptr(ndr, "sids", r->out.sids);
7042                 ndr->depth++;
7043                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
7044                 ndr->depth--;
7045                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7046                 ndr->depth--;
7047         }
7048         ndr->depth--;
7049 }
7050
7051 NTSTATUS ndr_push_lsa_EnumAccountRights(struct ndr_push *ndr, int flags, const struct lsa_EnumAccountRights *r)
7052 {
7053         if (flags & NDR_IN) {
7054                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7055                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7056                 if (r->in.sid == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7057                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
7058         }
7059         if (flags & NDR_OUT) {
7060                 if (r->out.rights == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7061                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rights));
7062                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7063         }
7064         return NT_STATUS_OK;
7065 }
7066
7067 NTSTATUS ndr_pull_lsa_EnumAccountRights(struct ndr_pull *ndr, int flags, struct lsa_EnumAccountRights *r)
7068 {
7069         TALLOC_CTX *_mem_save_handle_0;
7070         TALLOC_CTX *_mem_save_sid_0;
7071         TALLOC_CTX *_mem_save_rights_0;
7072         if (flags & NDR_IN) {
7073                 ZERO_STRUCT(r->out);
7074
7075                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7076                         NDR_PULL_ALLOC(ndr, r->in.handle);
7077                 }
7078                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7079                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7080                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7081                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7082                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7083                         NDR_PULL_ALLOC(ndr, r->in.sid);
7084                 }
7085                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7086                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
7087                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
7088                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
7089                 NDR_PULL_ALLOC(ndr, r->out.rights);
7090                 ZERO_STRUCTP(r->out.rights);
7091         }
7092         if (flags & NDR_OUT) {
7093                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7094                         NDR_PULL_ALLOC(ndr, r->out.rights);
7095                 }
7096                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
7097                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rights, LIBNDR_FLAG_REF_ALLOC);
7098                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rights));
7099                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
7100                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7101         }
7102         return NT_STATUS_OK;
7103 }
7104
7105 _PUBLIC_ void ndr_print_lsa_EnumAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccountRights *r)
7106 {
7107         ndr_print_struct(ndr, name, "lsa_EnumAccountRights");
7108         ndr->depth++;
7109         if (flags & NDR_SET_VALUES) {
7110                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7111         }
7112         if (flags & NDR_IN) {
7113                 ndr_print_struct(ndr, "in", "lsa_EnumAccountRights");
7114                 ndr->depth++;
7115                 ndr_print_ptr(ndr, "handle", r->in.handle);
7116                 ndr->depth++;
7117                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7118                 ndr->depth--;
7119                 ndr_print_ptr(ndr, "sid", r->in.sid);
7120                 ndr->depth++;
7121                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
7122                 ndr->depth--;
7123                 ndr->depth--;
7124         }
7125         if (flags & NDR_OUT) {
7126                 ndr_print_struct(ndr, "out", "lsa_EnumAccountRights");
7127                 ndr->depth++;
7128                 ndr_print_ptr(ndr, "rights", r->out.rights);
7129                 ndr->depth++;
7130                 ndr_print_lsa_RightSet(ndr, "rights", r->out.rights);
7131                 ndr->depth--;
7132                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7133                 ndr->depth--;
7134         }
7135         ndr->depth--;
7136 }
7137
7138 NTSTATUS ndr_push_lsa_AddAccountRights(struct ndr_push *ndr, int flags, const struct lsa_AddAccountRights *r)
7139 {
7140         if (flags & NDR_IN) {
7141                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7142                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7143                 if (r->in.sid == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7144                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
7145                 if (r->in.rights == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7146                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
7147         }
7148         if (flags & NDR_OUT) {
7149                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7150         }
7151         return NT_STATUS_OK;
7152 }
7153
7154 NTSTATUS ndr_pull_lsa_AddAccountRights(struct ndr_pull *ndr, int flags, struct lsa_AddAccountRights *r)
7155 {
7156         TALLOC_CTX *_mem_save_handle_0;
7157         TALLOC_CTX *_mem_save_sid_0;
7158         TALLOC_CTX *_mem_save_rights_0;
7159         if (flags & NDR_IN) {
7160                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7161                         NDR_PULL_ALLOC(ndr, r->in.handle);
7162                 }
7163                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7164                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7165                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7166                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7167                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7168                         NDR_PULL_ALLOC(ndr, r->in.sid);
7169                 }
7170                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7171                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
7172                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
7173                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
7174                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7175                         NDR_PULL_ALLOC(ndr, r->in.rights);
7176                 }
7177                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
7178                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rights, LIBNDR_FLAG_REF_ALLOC);
7179                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
7180                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
7181         }
7182         if (flags & NDR_OUT) {
7183                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7184         }
7185         return NT_STATUS_OK;
7186 }
7187
7188 _PUBLIC_ void ndr_print_lsa_AddAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_AddAccountRights *r)
7189 {
7190         ndr_print_struct(ndr, name, "lsa_AddAccountRights");
7191         ndr->depth++;
7192         if (flags & NDR_SET_VALUES) {
7193                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7194         }
7195         if (flags & NDR_IN) {
7196                 ndr_print_struct(ndr, "in", "lsa_AddAccountRights");
7197                 ndr->depth++;
7198                 ndr_print_ptr(ndr, "handle", r->in.handle);
7199                 ndr->depth++;
7200                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7201                 ndr->depth--;
7202                 ndr_print_ptr(ndr, "sid", r->in.sid);
7203                 ndr->depth++;
7204                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
7205                 ndr->depth--;
7206                 ndr_print_ptr(ndr, "rights", r->in.rights);
7207                 ndr->depth++;
7208                 ndr_print_lsa_RightSet(ndr, "rights", r->in.rights);
7209                 ndr->depth--;
7210                 ndr->depth--;
7211         }
7212         if (flags & NDR_OUT) {
7213                 ndr_print_struct(ndr, "out", "lsa_AddAccountRights");
7214                 ndr->depth++;
7215                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7216                 ndr->depth--;
7217         }
7218         ndr->depth--;
7219 }
7220
7221 NTSTATUS ndr_push_lsa_RemoveAccountRights(struct ndr_push *ndr, int flags, const struct lsa_RemoveAccountRights *r)
7222 {
7223         if (flags & NDR_IN) {
7224                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7225                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7226                 if (r->in.sid == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7227                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
7228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
7229                 if (r->in.rights == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7230                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
7231         }
7232         if (flags & NDR_OUT) {
7233                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7234         }
7235         return NT_STATUS_OK;
7236 }
7237
7238 NTSTATUS ndr_pull_lsa_RemoveAccountRights(struct ndr_pull *ndr, int flags, struct lsa_RemoveAccountRights *r)
7239 {
7240         TALLOC_CTX *_mem_save_handle_0;
7241         TALLOC_CTX *_mem_save_sid_0;
7242         TALLOC_CTX *_mem_save_rights_0;
7243         if (flags & NDR_IN) {
7244                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7245                         NDR_PULL_ALLOC(ndr, r->in.handle);
7246                 }
7247                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7248                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7249                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7250                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7251                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7252                         NDR_PULL_ALLOC(ndr, r->in.sid);
7253                 }
7254                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7255                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
7256                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
7257                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
7258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
7259                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7260                         NDR_PULL_ALLOC(ndr, r->in.rights);
7261                 }
7262                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
7263                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rights, LIBNDR_FLAG_REF_ALLOC);
7264                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
7265                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
7266         }
7267         if (flags & NDR_OUT) {
7268                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7269         }
7270         return NT_STATUS_OK;
7271 }
7272
7273 _PUBLIC_ void ndr_print_lsa_RemoveAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RemoveAccountRights *r)
7274 {
7275         ndr_print_struct(ndr, name, "lsa_RemoveAccountRights");
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_RemoveAccountRights");
7282                 ndr->depth++;
7283                 ndr_print_ptr(ndr, "handle", r->in.handle);
7284                 ndr->depth++;
7285                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7286                 ndr->depth--;
7287                 ndr_print_ptr(ndr, "sid", r->in.sid);
7288                 ndr->depth++;
7289                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
7290                 ndr->depth--;
7291                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
7292                 ndr_print_ptr(ndr, "rights", r->in.rights);
7293                 ndr->depth++;
7294                 ndr_print_lsa_RightSet(ndr, "rights", r->in.rights);
7295                 ndr->depth--;
7296                 ndr->depth--;
7297         }
7298         if (flags & NDR_OUT) {
7299                 ndr_print_struct(ndr, "out", "lsa_RemoveAccountRights");
7300                 ndr->depth++;
7301                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7302                 ndr->depth--;
7303         }
7304         ndr->depth--;
7305 }
7306
7307 NTSTATUS ndr_push_lsa_QueryTrustedDomainInfoBySid(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfoBySid *r)
7308 {
7309         if (flags & NDR_IN) {
7310                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7311                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7312                 if (r->in.dom_sid == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7313                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
7314                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
7315         }
7316         if (flags & NDR_OUT) {
7317                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
7318                 if (r->out.info) {
7319                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
7320                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7321                 }
7322                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7323         }
7324         return NT_STATUS_OK;
7325 }
7326
7327 NTSTATUS ndr_pull_lsa_QueryTrustedDomainInfoBySid(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfoBySid *r)
7328 {
7329         uint32_t _ptr_info;
7330         TALLOC_CTX *_mem_save_handle_0;
7331         TALLOC_CTX *_mem_save_dom_sid_0;
7332         TALLOC_CTX *_mem_save_info_0;
7333         if (flags & NDR_IN) {
7334                 ZERO_STRUCT(r->out);
7335
7336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7337                         NDR_PULL_ALLOC(ndr, r->in.handle);
7338                 }
7339                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7340                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7341                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7342                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7343                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7344                         NDR_PULL_ALLOC(ndr, r->in.dom_sid);
7345                 }
7346                 _mem_save_dom_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7347                 NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_sid, LIBNDR_FLAG_REF_ALLOC);
7348                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
7349                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_sid_0, LIBNDR_FLAG_REF_ALLOC);
7350                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7351         }
7352         if (flags & NDR_OUT) {
7353                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7354                 if (_ptr_info) {
7355                         NDR_PULL_ALLOC(ndr, r->out.info);
7356                 } else {
7357                         r->out.info = NULL;
7358                 }
7359                 if (r->out.info) {
7360                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7361                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
7362                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
7363                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7364                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
7365                 }
7366                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7367         }
7368         return NT_STATUS_OK;
7369 }
7370
7371 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfoBySid(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfoBySid *r)
7372 {
7373         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfoBySid");
7374         ndr->depth++;
7375         if (flags & NDR_SET_VALUES) {
7376                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7377         }
7378         if (flags & NDR_IN) {
7379                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfoBySid");
7380                 ndr->depth++;
7381                 ndr_print_ptr(ndr, "handle", r->in.handle);
7382                 ndr->depth++;
7383                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7384                 ndr->depth--;
7385                 ndr_print_ptr(ndr, "dom_sid", r->in.dom_sid);
7386                 ndr->depth++;
7387                 ndr_print_dom_sid2(ndr, "dom_sid", r->in.dom_sid);
7388                 ndr->depth--;
7389                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
7390                 ndr->depth--;
7391         }
7392         if (flags & NDR_OUT) {
7393                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfoBySid");
7394                 ndr->depth++;
7395                 ndr_print_ptr(ndr, "info", r->out.info);
7396                 ndr->depth++;
7397                 if (r->out.info) {
7398                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
7399                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->out.info);
7400                 }
7401                 ndr->depth--;
7402                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7403                 ndr->depth--;
7404         }
7405         ndr->depth--;
7406 }
7407
7408 NTSTATUS ndr_push_lsa_SetTrustedDomainInfo(struct ndr_push *ndr, int flags, const struct lsa_SetTrustedDomainInfo *r)
7409 {
7410         if (flags & NDR_IN) {
7411         }
7412         if (flags & NDR_OUT) {
7413                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7414         }
7415         return NT_STATUS_OK;
7416 }
7417
7418 NTSTATUS ndr_pull_lsa_SetTrustedDomainInfo(struct ndr_pull *ndr, int flags, struct lsa_SetTrustedDomainInfo *r)
7419 {
7420         if (flags & NDR_IN) {
7421         }
7422         if (flags & NDR_OUT) {
7423                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7424         }
7425         return NT_STATUS_OK;
7426 }
7427
7428 _PUBLIC_ void ndr_print_lsa_SetTrustedDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetTrustedDomainInfo *r)
7429 {
7430         ndr_print_struct(ndr, name, "lsa_SetTrustedDomainInfo");
7431         ndr->depth++;
7432         if (flags & NDR_SET_VALUES) {
7433                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7434         }
7435         if (flags & NDR_IN) {
7436                 ndr_print_struct(ndr, "in", "lsa_SetTrustedDomainInfo");
7437                 ndr->depth++;
7438                 ndr->depth--;
7439         }
7440         if (flags & NDR_OUT) {
7441                 ndr_print_struct(ndr, "out", "lsa_SetTrustedDomainInfo");
7442                 ndr->depth++;
7443                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7444                 ndr->depth--;
7445         }
7446         ndr->depth--;
7447 }
7448
7449 NTSTATUS ndr_push_lsa_DeleteTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_DeleteTrustedDomain *r)
7450 {
7451         if (flags & NDR_IN) {
7452                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7453                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7454                 if (r->in.dom_sid == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7455                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
7456         }
7457         if (flags & NDR_OUT) {
7458                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7459         }
7460         return NT_STATUS_OK;
7461 }
7462
7463 NTSTATUS ndr_pull_lsa_DeleteTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_DeleteTrustedDomain *r)
7464 {
7465         TALLOC_CTX *_mem_save_handle_0;
7466         TALLOC_CTX *_mem_save_dom_sid_0;
7467         if (flags & NDR_IN) {
7468                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7469                         NDR_PULL_ALLOC(ndr, r->in.handle);
7470                 }
7471                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7472                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7473                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7474                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7475                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7476                         NDR_PULL_ALLOC(ndr, r->in.dom_sid);
7477                 }
7478                 _mem_save_dom_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7479                 NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_sid, LIBNDR_FLAG_REF_ALLOC);
7480                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
7481                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_sid_0, LIBNDR_FLAG_REF_ALLOC);
7482         }
7483         if (flags & NDR_OUT) {
7484                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7485         }
7486         return NT_STATUS_OK;
7487 }
7488
7489 _PUBLIC_ void ndr_print_lsa_DeleteTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_DeleteTrustedDomain *r)
7490 {
7491         ndr_print_struct(ndr, name, "lsa_DeleteTrustedDomain");
7492         ndr->depth++;
7493         if (flags & NDR_SET_VALUES) {
7494                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7495         }
7496         if (flags & NDR_IN) {
7497                 ndr_print_struct(ndr, "in", "lsa_DeleteTrustedDomain");
7498                 ndr->depth++;
7499                 ndr_print_ptr(ndr, "handle", r->in.handle);
7500                 ndr->depth++;
7501                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7502                 ndr->depth--;
7503                 ndr_print_ptr(ndr, "dom_sid", r->in.dom_sid);
7504                 ndr->depth++;
7505                 ndr_print_dom_sid2(ndr, "dom_sid", r->in.dom_sid);
7506                 ndr->depth--;
7507                 ndr->depth--;
7508         }
7509         if (flags & NDR_OUT) {
7510                 ndr_print_struct(ndr, "out", "lsa_DeleteTrustedDomain");
7511                 ndr->depth++;
7512                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7513                 ndr->depth--;
7514         }
7515         ndr->depth--;
7516 }
7517
7518 NTSTATUS ndr_push_lsa_StorePrivateData(struct ndr_push *ndr, int flags, const struct lsa_StorePrivateData *r)
7519 {
7520         if (flags & NDR_IN) {
7521         }
7522         if (flags & NDR_OUT) {
7523                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7524         }
7525         return NT_STATUS_OK;
7526 }
7527
7528 NTSTATUS ndr_pull_lsa_StorePrivateData(struct ndr_pull *ndr, int flags, struct lsa_StorePrivateData *r)
7529 {
7530         if (flags & NDR_IN) {
7531         }
7532         if (flags & NDR_OUT) {
7533                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7534         }
7535         return NT_STATUS_OK;
7536 }
7537
7538 _PUBLIC_ void ndr_print_lsa_StorePrivateData(struct ndr_print *ndr, const char *name, int flags, const struct lsa_StorePrivateData *r)
7539 {
7540         ndr_print_struct(ndr, name, "lsa_StorePrivateData");
7541         ndr->depth++;
7542         if (flags & NDR_SET_VALUES) {
7543                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7544         }
7545         if (flags & NDR_IN) {
7546                 ndr_print_struct(ndr, "in", "lsa_StorePrivateData");
7547                 ndr->depth++;
7548                 ndr->depth--;
7549         }
7550         if (flags & NDR_OUT) {
7551                 ndr_print_struct(ndr, "out", "lsa_StorePrivateData");
7552                 ndr->depth++;
7553                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7554                 ndr->depth--;
7555         }
7556         ndr->depth--;
7557 }
7558
7559 NTSTATUS ndr_push_lsa_RetrievePrivateData(struct ndr_push *ndr, int flags, const struct lsa_RetrievePrivateData *r)
7560 {
7561         if (flags & NDR_IN) {
7562         }
7563         if (flags & NDR_OUT) {
7564                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7565         }
7566         return NT_STATUS_OK;
7567 }
7568
7569 NTSTATUS ndr_pull_lsa_RetrievePrivateData(struct ndr_pull *ndr, int flags, struct lsa_RetrievePrivateData *r)
7570 {
7571         if (flags & NDR_IN) {
7572         }
7573         if (flags & NDR_OUT) {
7574                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7575         }
7576         return NT_STATUS_OK;
7577 }
7578
7579 _PUBLIC_ void ndr_print_lsa_RetrievePrivateData(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RetrievePrivateData *r)
7580 {
7581         ndr_print_struct(ndr, name, "lsa_RetrievePrivateData");
7582         ndr->depth++;
7583         if (flags & NDR_SET_VALUES) {
7584                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7585         }
7586         if (flags & NDR_IN) {
7587                 ndr_print_struct(ndr, "in", "lsa_RetrievePrivateData");
7588                 ndr->depth++;
7589                 ndr->depth--;
7590         }
7591         if (flags & NDR_OUT) {
7592                 ndr_print_struct(ndr, "out", "lsa_RetrievePrivateData");
7593                 ndr->depth++;
7594                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7595                 ndr->depth--;
7596         }
7597         ndr->depth--;
7598 }
7599
7600 NTSTATUS ndr_push_lsa_OpenPolicy2(struct ndr_push *ndr, int flags, const struct lsa_OpenPolicy2 *r)
7601 {
7602         if (flags & NDR_IN) {
7603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
7604                 if (r->in.system_name) {
7605                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
7606                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7607                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
7608                         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));
7609                 }
7610                 if (r->in.attr == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7611                 NDR_CHECK(ndr_push_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
7612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
7613         }
7614         if (flags & NDR_OUT) {
7615                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7616                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
7617                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7618         }
7619         return NT_STATUS_OK;
7620 }
7621
7622 NTSTATUS ndr_pull_lsa_OpenPolicy2(struct ndr_pull *ndr, int flags, struct lsa_OpenPolicy2 *r)
7623 {
7624         uint32_t _ptr_system_name;
7625         TALLOC_CTX *_mem_save_system_name_0;
7626         TALLOC_CTX *_mem_save_attr_0;
7627         TALLOC_CTX *_mem_save_handle_0;
7628         if (flags & NDR_IN) {
7629                 ZERO_STRUCT(r->out);
7630
7631                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
7632                 if (_ptr_system_name) {
7633                         NDR_PULL_ALLOC(ndr, r->in.system_name);
7634                 } else {
7635                         r->in.system_name = NULL;
7636                 }
7637                 if (r->in.system_name) {
7638                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7639                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
7640                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
7641                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
7642                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
7643                                 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));
7644                         }
7645                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
7646                         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));
7647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
7648                 }
7649                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7650                         NDR_PULL_ALLOC(ndr, r->in.attr);
7651                 }
7652                 _mem_save_attr_0 = NDR_PULL_GET_MEM_CTX(ndr);
7653                 NDR_PULL_SET_MEM_CTX(ndr, r->in.attr, LIBNDR_FLAG_REF_ALLOC);
7654                 NDR_CHECK(ndr_pull_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
7655                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attr_0, LIBNDR_FLAG_REF_ALLOC);
7656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
7657                 NDR_PULL_ALLOC(ndr, r->out.handle);
7658                 ZERO_STRUCTP(r->out.handle);
7659         }
7660         if (flags & NDR_OUT) {
7661                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7662                         NDR_PULL_ALLOC(ndr, r->out.handle);
7663                 }
7664                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7665                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
7666                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
7667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7668                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7669         }
7670         return NT_STATUS_OK;
7671 }
7672
7673 _PUBLIC_ void ndr_print_lsa_OpenPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenPolicy2 *r)
7674 {
7675         ndr_print_struct(ndr, name, "lsa_OpenPolicy2");
7676         ndr->depth++;
7677         if (flags & NDR_SET_VALUES) {
7678                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7679         }
7680         if (flags & NDR_IN) {
7681                 ndr_print_struct(ndr, "in", "lsa_OpenPolicy2");
7682                 ndr->depth++;
7683                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
7684                 ndr->depth++;
7685                 if (r->in.system_name) {
7686                         ndr_print_string(ndr, "system_name", r->in.system_name);
7687                 }
7688                 ndr->depth--;
7689                 ndr_print_ptr(ndr, "attr", r->in.attr);
7690                 ndr->depth++;
7691                 ndr_print_lsa_ObjectAttribute(ndr, "attr", r->in.attr);
7692                 ndr->depth--;
7693                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
7694                 ndr->depth--;
7695         }
7696         if (flags & NDR_OUT) {
7697                 ndr_print_struct(ndr, "out", "lsa_OpenPolicy2");
7698                 ndr->depth++;
7699                 ndr_print_ptr(ndr, "handle", r->out.handle);
7700                 ndr->depth++;
7701                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
7702                 ndr->depth--;
7703                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7704                 ndr->depth--;
7705         }
7706         ndr->depth--;
7707 }
7708
7709 NTSTATUS ndr_push_lsa_GetUserName(struct ndr_push *ndr, int flags, const struct lsa_GetUserName *r)
7710 {
7711         if (flags & NDR_IN) {
7712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
7713                 if (r->in.system_name) {
7714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
7715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
7717                         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));
7718                 }
7719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.account_name));
7720                 if (r->in.account_name) {
7721                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
7722                 }
7723                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.authority_name));
7724                 if (r->in.authority_name) {
7725                         NDR_CHECK(ndr_push_lsa_StringPointer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.authority_name));
7726                 }
7727         }
7728         if (flags & NDR_OUT) {
7729                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.account_name));
7730                 if (r->out.account_name) {
7731                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.account_name));
7732                 }
7733                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.authority_name));
7734                 if (r->out.authority_name) {
7735                         NDR_CHECK(ndr_push_lsa_StringPointer(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.authority_name));
7736                 }
7737                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7738         }
7739         return NT_STATUS_OK;
7740 }
7741
7742 NTSTATUS ndr_pull_lsa_GetUserName(struct ndr_pull *ndr, int flags, struct lsa_GetUserName *r)
7743 {
7744         uint32_t _ptr_system_name;
7745         uint32_t _ptr_account_name;
7746         uint32_t _ptr_authority_name;
7747         TALLOC_CTX *_mem_save_system_name_0;
7748         TALLOC_CTX *_mem_save_account_name_0;
7749         TALLOC_CTX *_mem_save_authority_name_0;
7750         if (flags & NDR_IN) {
7751                 ZERO_STRUCT(r->out);
7752
7753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
7754                 if (_ptr_system_name) {
7755                         NDR_PULL_ALLOC(ndr, r->in.system_name);
7756                 } else {
7757                         r->in.system_name = NULL;
7758                 }
7759                 if (r->in.system_name) {
7760                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7761                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
7762                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
7763                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
7764                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
7765                                 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));
7766                         }
7767                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
7768                         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));
7769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
7770                 }
7771                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
7772                 if (_ptr_account_name) {
7773                         NDR_PULL_ALLOC(ndr, r->in.account_name);
7774                 } else {
7775                         r->in.account_name = NULL;
7776                 }
7777                 if (r->in.account_name) {
7778                         _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7779                         NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, 0);
7780                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.account_name));
7781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, 0);
7782                 }
7783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
7784                 if (_ptr_authority_name) {
7785                         NDR_PULL_ALLOC(ndr, r->in.authority_name);
7786                 } else {
7787                         r->in.authority_name = NULL;
7788                 }
7789                 if (r->in.authority_name) {
7790                         _mem_save_authority_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7791                         NDR_PULL_SET_MEM_CTX(ndr, r->in.authority_name, 0);
7792                         NDR_CHECK(ndr_pull_lsa_StringPointer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.authority_name));
7793                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_0, 0);
7794                 }
7795         }
7796         if (flags & NDR_OUT) {
7797                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
7798                 if (_ptr_account_name) {
7799                         NDR_PULL_ALLOC(ndr, r->out.account_name);
7800                 } else {
7801                         r->out.account_name = NULL;
7802                 }
7803                 if (r->out.account_name) {
7804                         _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7805                         NDR_PULL_SET_MEM_CTX(ndr, r->out.account_name, 0);
7806                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.account_name));
7807                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, 0);
7808                 }
7809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
7810                 if (_ptr_authority_name) {
7811                         NDR_PULL_ALLOC(ndr, r->out.authority_name);
7812                 } else {
7813                         r->out.authority_name = NULL;
7814                 }
7815                 if (r->out.authority_name) {
7816                         _mem_save_authority_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7817                         NDR_PULL_SET_MEM_CTX(ndr, r->out.authority_name, 0);
7818                         NDR_CHECK(ndr_pull_lsa_StringPointer(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.authority_name));
7819                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_0, 0);
7820                 }
7821                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7822         }
7823         return NT_STATUS_OK;
7824 }
7825
7826 _PUBLIC_ void ndr_print_lsa_GetUserName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetUserName *r)
7827 {
7828         ndr_print_struct(ndr, name, "lsa_GetUserName");
7829         ndr->depth++;
7830         if (flags & NDR_SET_VALUES) {
7831                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7832         }
7833         if (flags & NDR_IN) {
7834                 ndr_print_struct(ndr, "in", "lsa_GetUserName");
7835                 ndr->depth++;
7836                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
7837                 ndr->depth++;
7838                 if (r->in.system_name) {
7839                         ndr_print_string(ndr, "system_name", r->in.system_name);
7840                 }
7841                 ndr->depth--;
7842                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
7843                 ndr->depth++;
7844                 if (r->in.account_name) {
7845                         ndr_print_lsa_String(ndr, "account_name", r->in.account_name);
7846                 }
7847                 ndr->depth--;
7848                 ndr_print_ptr(ndr, "authority_name", r->in.authority_name);
7849                 ndr->depth++;
7850                 if (r->in.authority_name) {
7851                         ndr_print_lsa_StringPointer(ndr, "authority_name", r->in.authority_name);
7852                 }
7853                 ndr->depth--;
7854                 ndr->depth--;
7855         }
7856         if (flags & NDR_OUT) {
7857                 ndr_print_struct(ndr, "out", "lsa_GetUserName");
7858                 ndr->depth++;
7859                 ndr_print_ptr(ndr, "account_name", r->out.account_name);
7860                 ndr->depth++;
7861                 if (r->out.account_name) {
7862                         ndr_print_lsa_String(ndr, "account_name", r->out.account_name);
7863                 }
7864                 ndr->depth--;
7865                 ndr_print_ptr(ndr, "authority_name", r->out.authority_name);
7866                 ndr->depth++;
7867                 if (r->out.authority_name) {
7868                         ndr_print_lsa_StringPointer(ndr, "authority_name", r->out.authority_name);
7869                 }
7870                 ndr->depth--;
7871                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7872                 ndr->depth--;
7873         }
7874         ndr->depth--;
7875 }
7876
7877 NTSTATUS ndr_push_lsa_QueryInfoPolicy2(struct ndr_push *ndr, int flags, const struct lsa_QueryInfoPolicy2 *r)
7878 {
7879         if (flags & NDR_IN) {
7880                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
7881                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7882                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
7883         }
7884         if (flags & NDR_OUT) {
7885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
7886                 if (r->out.info) {
7887                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
7888                         NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7889                 }
7890                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7891         }
7892         return NT_STATUS_OK;
7893 }
7894
7895 NTSTATUS ndr_pull_lsa_QueryInfoPolicy2(struct ndr_pull *ndr, int flags, struct lsa_QueryInfoPolicy2 *r)
7896 {
7897         uint32_t _ptr_info;
7898         TALLOC_CTX *_mem_save_handle_0;
7899         TALLOC_CTX *_mem_save_info_0;
7900         if (flags & NDR_IN) {
7901                 ZERO_STRUCT(r->out);
7902
7903                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7904                         NDR_PULL_ALLOC(ndr, r->in.handle);
7905                 }
7906                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7907                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7908                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7909                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7910                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
7911         }
7912         if (flags & NDR_OUT) {
7913                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
7914                 if (_ptr_info) {
7915                         NDR_PULL_ALLOC(ndr, r->out.info);
7916                 } else {
7917                         r->out.info = NULL;
7918                 }
7919                 if (r->out.info) {
7920                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
7921                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
7922                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
7923                         NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
7924                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
7925                 }
7926                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7927         }
7928         return NT_STATUS_OK;
7929 }
7930
7931 _PUBLIC_ void ndr_print_lsa_QueryInfoPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryInfoPolicy2 *r)
7932 {
7933         ndr_print_struct(ndr, name, "lsa_QueryInfoPolicy2");
7934         ndr->depth++;
7935         if (flags & NDR_SET_VALUES) {
7936                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7937         }
7938         if (flags & NDR_IN) {
7939                 ndr_print_struct(ndr, "in", "lsa_QueryInfoPolicy2");
7940                 ndr->depth++;
7941                 ndr_print_ptr(ndr, "handle", r->in.handle);
7942                 ndr->depth++;
7943                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7944                 ndr->depth--;
7945                 ndr_print_uint16(ndr, "level", r->in.level);
7946                 ndr->depth--;
7947         }
7948         if (flags & NDR_OUT) {
7949                 ndr_print_struct(ndr, "out", "lsa_QueryInfoPolicy2");
7950                 ndr->depth++;
7951                 ndr_print_ptr(ndr, "info", r->out.info);
7952                 ndr->depth++;
7953                 if (r->out.info) {
7954                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
7955                         ndr_print_lsa_PolicyInformation(ndr, "info", r->out.info);
7956                 }
7957                 ndr->depth--;
7958                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7959                 ndr->depth--;
7960         }
7961         ndr->depth--;
7962 }
7963
7964 NTSTATUS ndr_push_lsa_SetInfoPolicy2(struct ndr_push *ndr, int flags, const struct lsa_SetInfoPolicy2 *r)
7965 {
7966         if (flags & NDR_IN) {
7967         }
7968         if (flags & NDR_OUT) {
7969                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7970         }
7971         return NT_STATUS_OK;
7972 }
7973
7974 NTSTATUS ndr_pull_lsa_SetInfoPolicy2(struct ndr_pull *ndr, int flags, struct lsa_SetInfoPolicy2 *r)
7975 {
7976         if (flags & NDR_IN) {
7977         }
7978         if (flags & NDR_OUT) {
7979                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7980         }
7981         return NT_STATUS_OK;
7982 }
7983
7984 _PUBLIC_ void ndr_print_lsa_SetInfoPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInfoPolicy2 *r)
7985 {
7986         ndr_print_struct(ndr, name, "lsa_SetInfoPolicy2");
7987         ndr->depth++;
7988         if (flags & NDR_SET_VALUES) {
7989                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7990         }
7991         if (flags & NDR_IN) {
7992                 ndr_print_struct(ndr, "in", "lsa_SetInfoPolicy2");
7993                 ndr->depth++;
7994                 ndr->depth--;
7995         }
7996         if (flags & NDR_OUT) {
7997                 ndr_print_struct(ndr, "out", "lsa_SetInfoPolicy2");
7998                 ndr->depth++;
7999                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8000                 ndr->depth--;
8001         }
8002         ndr->depth--;
8003 }
8004
8005 NTSTATUS ndr_push_lsa_QueryTrustedDomainInfoByName(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfoByName *r)
8006 {
8007         if (flags & NDR_IN) {
8008                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8009                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8010                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
8011                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
8012         }
8013         if (flags & NDR_OUT) {
8014                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
8015                 if (r->out.info) {
8016                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
8017                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
8018                 }
8019                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8020         }
8021         return NT_STATUS_OK;
8022 }
8023
8024 NTSTATUS ndr_pull_lsa_QueryTrustedDomainInfoByName(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfoByName *r)
8025 {
8026         uint32_t _ptr_info;
8027         TALLOC_CTX *_mem_save_handle_0;
8028         TALLOC_CTX *_mem_save_info_0;
8029         if (flags & NDR_IN) {
8030                 ZERO_STRUCT(r->out);
8031
8032                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8033                         NDR_PULL_ALLOC(ndr, r->in.handle);
8034                 }
8035                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8036                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8037                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8038                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8039                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
8040                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8041         }
8042         if (flags & NDR_OUT) {
8043                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8044                 if (_ptr_info) {
8045                         NDR_PULL_ALLOC(ndr, r->out.info);
8046                 } else {
8047                         r->out.info = NULL;
8048                 }
8049                 if (r->out.info) {
8050                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8051                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
8052                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
8053                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
8054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8055                 }
8056                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8057         }
8058         return NT_STATUS_OK;
8059 }
8060
8061 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfoByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfoByName *r)
8062 {
8063         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfoByName");
8064         ndr->depth++;
8065         if (flags & NDR_SET_VALUES) {
8066                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8067         }
8068         if (flags & NDR_IN) {
8069                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfoByName");
8070                 ndr->depth++;
8071                 ndr_print_ptr(ndr, "handle", r->in.handle);
8072                 ndr->depth++;
8073                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8074                 ndr->depth--;
8075                 ndr_print_lsa_String(ndr, "trusted_domain", &r->in.trusted_domain);
8076                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
8077                 ndr->depth--;
8078         }
8079         if (flags & NDR_OUT) {
8080                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfoByName");
8081                 ndr->depth++;
8082                 ndr_print_ptr(ndr, "info", r->out.info);
8083                 ndr->depth++;
8084                 if (r->out.info) {
8085                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
8086                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->out.info);
8087                 }
8088                 ndr->depth--;
8089                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8090                 ndr->depth--;
8091         }
8092         ndr->depth--;
8093 }
8094
8095 NTSTATUS ndr_push_lsa_SetTrustedDomainInfoByName(struct ndr_push *ndr, int flags, const struct lsa_SetTrustedDomainInfoByName *r)
8096 {
8097         if (flags & NDR_IN) {
8098                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8099                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8100                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
8101                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
8102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
8103                 if (r->in.info) {
8104                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8105                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8106                 }
8107         }
8108         if (flags & NDR_OUT) {
8109                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8110         }
8111         return NT_STATUS_OK;
8112 }
8113
8114 NTSTATUS ndr_pull_lsa_SetTrustedDomainInfoByName(struct ndr_pull *ndr, int flags, struct lsa_SetTrustedDomainInfoByName *r)
8115 {
8116         uint32_t _ptr_info;
8117         TALLOC_CTX *_mem_save_handle_0;
8118         TALLOC_CTX *_mem_save_info_0;
8119         if (flags & NDR_IN) {
8120                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8121                         NDR_PULL_ALLOC(ndr, r->in.handle);
8122                 }
8123                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8124                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8125                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8126                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8127                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
8128                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8130                 if (_ptr_info) {
8131                         NDR_PULL_ALLOC(ndr, r->in.info);
8132                 } else {
8133                         r->in.info = NULL;
8134                 }
8135                 if (r->in.info) {
8136                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8137                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
8138                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8139                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8141                 }
8142         }
8143         if (flags & NDR_OUT) {
8144                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8145         }
8146         return NT_STATUS_OK;
8147 }
8148
8149 _PUBLIC_ void ndr_print_lsa_SetTrustedDomainInfoByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetTrustedDomainInfoByName *r)
8150 {
8151         ndr_print_struct(ndr, name, "lsa_SetTrustedDomainInfoByName");
8152         ndr->depth++;
8153         if (flags & NDR_SET_VALUES) {
8154                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8155         }
8156         if (flags & NDR_IN) {
8157                 ndr_print_struct(ndr, "in", "lsa_SetTrustedDomainInfoByName");
8158                 ndr->depth++;
8159                 ndr_print_ptr(ndr, "handle", r->in.handle);
8160                 ndr->depth++;
8161                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8162                 ndr->depth--;
8163                 ndr_print_lsa_String(ndr, "trusted_domain", &r->in.trusted_domain);
8164                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
8165                 ndr_print_ptr(ndr, "info", r->in.info);
8166                 ndr->depth++;
8167                 if (r->in.info) {
8168                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8169                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->in.info);
8170                 }
8171                 ndr->depth--;
8172                 ndr->depth--;
8173         }
8174         if (flags & NDR_OUT) {
8175                 ndr_print_struct(ndr, "out", "lsa_SetTrustedDomainInfoByName");
8176                 ndr->depth++;
8177                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8178                 ndr->depth--;
8179         }
8180         ndr->depth--;
8181 }
8182
8183 NTSTATUS ndr_push_lsa_EnumTrustedDomainsEx(struct ndr_push *ndr, int flags, const struct lsa_EnumTrustedDomainsEx *r)
8184 {
8185         if (flags & NDR_IN) {
8186                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8187                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8188                 if (r->in.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
8190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
8191         }
8192         if (flags & NDR_OUT) {
8193                 if (r->out.resume_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
8195                 if (r->out.domains == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8196                 NDR_CHECK(ndr_push_lsa_DomainListEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
8197                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8198         }
8199         return NT_STATUS_OK;
8200 }
8201
8202 NTSTATUS ndr_pull_lsa_EnumTrustedDomainsEx(struct ndr_pull *ndr, int flags, struct lsa_EnumTrustedDomainsEx *r)
8203 {
8204         TALLOC_CTX *_mem_save_handle_0;
8205         TALLOC_CTX *_mem_save_resume_handle_0;
8206         TALLOC_CTX *_mem_save_domains_0;
8207         if (flags & NDR_IN) {
8208                 ZERO_STRUCT(r->out);
8209
8210                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8211                         NDR_PULL_ALLOC(ndr, r->in.handle);
8212                 }
8213                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8214                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8215                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8216                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8217                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8218                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
8219                 }
8220                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8221                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
8222                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
8223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
8224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
8225                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
8226                 *r->out.resume_handle = *r->in.resume_handle;
8227                 NDR_PULL_ALLOC(ndr, r->out.domains);
8228                 ZERO_STRUCTP(r->out.domains);
8229         }
8230         if (flags & NDR_OUT) {
8231                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8232                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
8233                 }
8234                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8235                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
8236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
8237                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
8238                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8239                         NDR_PULL_ALLOC(ndr, r->out.domains);
8240                 }
8241                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
8242                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
8243                 NDR_CHECK(ndr_pull_lsa_DomainListEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
8244                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
8245                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8246         }
8247         return NT_STATUS_OK;
8248 }
8249
8250 _PUBLIC_ void ndr_print_lsa_EnumTrustedDomainsEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumTrustedDomainsEx *r)
8251 {
8252         ndr_print_struct(ndr, name, "lsa_EnumTrustedDomainsEx");
8253         ndr->depth++;
8254         if (flags & NDR_SET_VALUES) {
8255                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8256         }
8257         if (flags & NDR_IN) {
8258                 ndr_print_struct(ndr, "in", "lsa_EnumTrustedDomainsEx");
8259                 ndr->depth++;
8260                 ndr_print_ptr(ndr, "handle", r->in.handle);
8261                 ndr->depth++;
8262                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8263                 ndr->depth--;
8264                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
8265                 ndr->depth++;
8266                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
8267                 ndr->depth--;
8268                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
8269                 ndr->depth--;
8270         }
8271         if (flags & NDR_OUT) {
8272                 ndr_print_struct(ndr, "out", "lsa_EnumTrustedDomainsEx");
8273                 ndr->depth++;
8274                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
8275                 ndr->depth++;
8276                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
8277                 ndr->depth--;
8278                 ndr_print_ptr(ndr, "domains", r->out.domains);
8279                 ndr->depth++;
8280                 ndr_print_lsa_DomainListEx(ndr, "domains", r->out.domains);
8281                 ndr->depth--;
8282                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8283                 ndr->depth--;
8284         }
8285         ndr->depth--;
8286 }
8287
8288 NTSTATUS ndr_push_lsa_CreateTrustedDomainEx(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomainEx *r)
8289 {
8290         if (flags & NDR_IN) {
8291         }
8292         if (flags & NDR_OUT) {
8293                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8294         }
8295         return NT_STATUS_OK;
8296 }
8297
8298 NTSTATUS ndr_pull_lsa_CreateTrustedDomainEx(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomainEx *r)
8299 {
8300         if (flags & NDR_IN) {
8301         }
8302         if (flags & NDR_OUT) {
8303                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8304         }
8305         return NT_STATUS_OK;
8306 }
8307
8308 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomainEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomainEx *r)
8309 {
8310         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomainEx");
8311         ndr->depth++;
8312         if (flags & NDR_SET_VALUES) {
8313                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8314         }
8315         if (flags & NDR_IN) {
8316                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomainEx");
8317                 ndr->depth++;
8318                 ndr->depth--;
8319         }
8320         if (flags & NDR_OUT) {
8321                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomainEx");
8322                 ndr->depth++;
8323                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8324                 ndr->depth--;
8325         }
8326         ndr->depth--;
8327 }
8328
8329 NTSTATUS ndr_push_lsa_CloseTrustedDomainEx(struct ndr_push *ndr, int flags, const struct lsa_CloseTrustedDomainEx *r)
8330 {
8331         if (flags & NDR_IN) {
8332                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8333                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8334         }
8335         if (flags & NDR_OUT) {
8336                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8337                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
8338                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8339         }
8340         return NT_STATUS_OK;
8341 }
8342
8343 NTSTATUS ndr_pull_lsa_CloseTrustedDomainEx(struct ndr_pull *ndr, int flags, struct lsa_CloseTrustedDomainEx *r)
8344 {
8345         TALLOC_CTX *_mem_save_handle_0;
8346         if (flags & NDR_IN) {
8347                 ZERO_STRUCT(r->out);
8348
8349                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8350                         NDR_PULL_ALLOC(ndr, r->in.handle);
8351                 }
8352                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8353                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8354                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8355                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8356                 NDR_PULL_ALLOC(ndr, r->out.handle);
8357                 *r->out.handle = *r->in.handle;
8358         }
8359         if (flags & NDR_OUT) {
8360                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8361                         NDR_PULL_ALLOC(ndr, r->out.handle);
8362                 }
8363                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8364                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
8365                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
8366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8367                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8368         }
8369         return NT_STATUS_OK;
8370 }
8371
8372 _PUBLIC_ void ndr_print_lsa_CloseTrustedDomainEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CloseTrustedDomainEx *r)
8373 {
8374         ndr_print_struct(ndr, name, "lsa_CloseTrustedDomainEx");
8375         ndr->depth++;
8376         if (flags & NDR_SET_VALUES) {
8377                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8378         }
8379         if (flags & NDR_IN) {
8380                 ndr_print_struct(ndr, "in", "lsa_CloseTrustedDomainEx");
8381                 ndr->depth++;
8382                 ndr_print_ptr(ndr, "handle", r->in.handle);
8383                 ndr->depth++;
8384                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8385                 ndr->depth--;
8386                 ndr->depth--;
8387         }
8388         if (flags & NDR_OUT) {
8389                 ndr_print_struct(ndr, "out", "lsa_CloseTrustedDomainEx");
8390                 ndr->depth++;
8391                 ndr_print_ptr(ndr, "handle", r->out.handle);
8392                 ndr->depth++;
8393                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
8394                 ndr->depth--;
8395                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8396                 ndr->depth--;
8397         }
8398         ndr->depth--;
8399 }
8400
8401 NTSTATUS ndr_push_lsa_QueryDomainInformationPolicy(struct ndr_push *ndr, int flags, const struct lsa_QueryDomainInformationPolicy *r)
8402 {
8403         if (flags & NDR_IN) {
8404                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8405                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8406                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
8407         }
8408         if (flags & NDR_OUT) {
8409                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
8410                 if (r->out.info) {
8411                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
8412                         NDR_CHECK(ndr_push_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
8413                 }
8414                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8415         }
8416         return NT_STATUS_OK;
8417 }
8418
8419 NTSTATUS ndr_pull_lsa_QueryDomainInformationPolicy(struct ndr_pull *ndr, int flags, struct lsa_QueryDomainInformationPolicy *r)
8420 {
8421         uint32_t _ptr_info;
8422         TALLOC_CTX *_mem_save_handle_0;
8423         TALLOC_CTX *_mem_save_info_0;
8424         if (flags & NDR_IN) {
8425                 ZERO_STRUCT(r->out);
8426
8427                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8428                         NDR_PULL_ALLOC(ndr, r->in.handle);
8429                 }
8430                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8431                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8432                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8433                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8434                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
8435         }
8436         if (flags & NDR_OUT) {
8437                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8438                 if (_ptr_info) {
8439                         NDR_PULL_ALLOC(ndr, r->out.info);
8440                 } else {
8441                         r->out.info = NULL;
8442                 }
8443                 if (r->out.info) {
8444                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8445                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
8446                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
8447                         NDR_CHECK(ndr_pull_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
8448                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8449                 }
8450                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8451         }
8452         return NT_STATUS_OK;
8453 }
8454
8455 _PUBLIC_ void ndr_print_lsa_QueryDomainInformationPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryDomainInformationPolicy *r)
8456 {
8457         ndr_print_struct(ndr, name, "lsa_QueryDomainInformationPolicy");
8458         ndr->depth++;
8459         if (flags & NDR_SET_VALUES) {
8460                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8461         }
8462         if (flags & NDR_IN) {
8463                 ndr_print_struct(ndr, "in", "lsa_QueryDomainInformationPolicy");
8464                 ndr->depth++;
8465                 ndr_print_ptr(ndr, "handle", r->in.handle);
8466                 ndr->depth++;
8467                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8468                 ndr->depth--;
8469                 ndr_print_uint16(ndr, "level", r->in.level);
8470                 ndr->depth--;
8471         }
8472         if (flags & NDR_OUT) {
8473                 ndr_print_struct(ndr, "out", "lsa_QueryDomainInformationPolicy");
8474                 ndr->depth++;
8475                 ndr_print_ptr(ndr, "info", r->out.info);
8476                 ndr->depth++;
8477                 if (r->out.info) {
8478                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
8479                         ndr_print_lsa_DomainInformationPolicy(ndr, "info", r->out.info);
8480                 }
8481                 ndr->depth--;
8482                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8483                 ndr->depth--;
8484         }
8485         ndr->depth--;
8486 }
8487
8488 NTSTATUS ndr_push_lsa_SetDomainInformationPolicy(struct ndr_push *ndr, int flags, const struct lsa_SetDomainInformationPolicy *r)
8489 {
8490         if (flags & NDR_IN) {
8491                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8492                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8493                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
8494                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
8495                 if (r->in.info) {
8496                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8497                         NDR_CHECK(ndr_push_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8498                 }
8499         }
8500         if (flags & NDR_OUT) {
8501                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8502         }
8503         return NT_STATUS_OK;
8504 }
8505
8506 NTSTATUS ndr_pull_lsa_SetDomainInformationPolicy(struct ndr_pull *ndr, int flags, struct lsa_SetDomainInformationPolicy *r)
8507 {
8508         uint32_t _ptr_info;
8509         TALLOC_CTX *_mem_save_handle_0;
8510         TALLOC_CTX *_mem_save_info_0;
8511         if (flags & NDR_IN) {
8512                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8513                         NDR_PULL_ALLOC(ndr, r->in.handle);
8514                 }
8515                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8516                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8517                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8518                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8519                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
8520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8521                 if (_ptr_info) {
8522                         NDR_PULL_ALLOC(ndr, r->in.info);
8523                 } else {
8524                         r->in.info = NULL;
8525                 }
8526                 if (r->in.info) {
8527                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8528                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
8529                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8530                         NDR_CHECK(ndr_pull_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8531                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8532                 }
8533         }
8534         if (flags & NDR_OUT) {
8535                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8536         }
8537         return NT_STATUS_OK;
8538 }
8539
8540 _PUBLIC_ void ndr_print_lsa_SetDomainInformationPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetDomainInformationPolicy *r)
8541 {
8542         ndr_print_struct(ndr, name, "lsa_SetDomainInformationPolicy");
8543         ndr->depth++;
8544         if (flags & NDR_SET_VALUES) {
8545                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8546         }
8547         if (flags & NDR_IN) {
8548                 ndr_print_struct(ndr, "in", "lsa_SetDomainInformationPolicy");
8549                 ndr->depth++;
8550                 ndr_print_ptr(ndr, "handle", r->in.handle);
8551                 ndr->depth++;
8552                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8553                 ndr->depth--;
8554                 ndr_print_uint16(ndr, "level", r->in.level);
8555                 ndr_print_ptr(ndr, "info", r->in.info);
8556                 ndr->depth++;
8557                 if (r->in.info) {
8558                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8559                         ndr_print_lsa_DomainInformationPolicy(ndr, "info", r->in.info);
8560                 }
8561                 ndr->depth--;
8562                 ndr->depth--;
8563         }
8564         if (flags & NDR_OUT) {
8565                 ndr_print_struct(ndr, "out", "lsa_SetDomainInformationPolicy");
8566                 ndr->depth++;
8567                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8568                 ndr->depth--;
8569         }
8570         ndr->depth--;
8571 }
8572
8573 NTSTATUS ndr_push_lsa_OpenTrustedDomainByName(struct ndr_push *ndr, int flags, const struct lsa_OpenTrustedDomainByName *r)
8574 {
8575         if (flags & NDR_IN) {
8576                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8577                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8578                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
8579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
8580         }
8581         if (flags & NDR_OUT) {
8582                 if (r->out.trustdom_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8583                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
8584                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8585         }
8586         return NT_STATUS_OK;
8587 }
8588
8589 NTSTATUS ndr_pull_lsa_OpenTrustedDomainByName(struct ndr_pull *ndr, int flags, struct lsa_OpenTrustedDomainByName *r)
8590 {
8591         TALLOC_CTX *_mem_save_handle_0;
8592         TALLOC_CTX *_mem_save_trustdom_handle_0;
8593         if (flags & NDR_IN) {
8594                 ZERO_STRUCT(r->out);
8595
8596                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8597                         NDR_PULL_ALLOC(ndr, r->in.handle);
8598                 }
8599                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8600                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8601                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8602                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8603                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
8604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
8605                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
8606                 ZERO_STRUCTP(r->out.trustdom_handle);
8607         }
8608         if (flags & NDR_OUT) {
8609                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8610                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
8611                 }
8612                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8613                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
8614                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
8615                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
8616                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8617         }
8618         return NT_STATUS_OK;
8619 }
8620
8621 _PUBLIC_ void ndr_print_lsa_OpenTrustedDomainByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenTrustedDomainByName *r)
8622 {
8623         ndr_print_struct(ndr, name, "lsa_OpenTrustedDomainByName");
8624         ndr->depth++;
8625         if (flags & NDR_SET_VALUES) {
8626                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8627         }
8628         if (flags & NDR_IN) {
8629                 ndr_print_struct(ndr, "in", "lsa_OpenTrustedDomainByName");
8630                 ndr->depth++;
8631                 ndr_print_ptr(ndr, "handle", r->in.handle);
8632                 ndr->depth++;
8633                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8634                 ndr->depth--;
8635                 ndr_print_lsa_String(ndr, "name", &r->in.name);
8636                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
8637                 ndr->depth--;
8638         }
8639         if (flags & NDR_OUT) {
8640                 ndr_print_struct(ndr, "out", "lsa_OpenTrustedDomainByName");
8641                 ndr->depth++;
8642                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
8643                 ndr->depth++;
8644                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
8645                 ndr->depth--;
8646                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8647                 ndr->depth--;
8648         }
8649         ndr->depth--;
8650 }
8651
8652 NTSTATUS ndr_push_lsa_TestCall(struct ndr_push *ndr, int flags, const struct lsa_TestCall *r)
8653 {
8654         if (flags & NDR_IN) {
8655         }
8656         if (flags & NDR_OUT) {
8657                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8658         }
8659         return NT_STATUS_OK;
8660 }
8661
8662 NTSTATUS ndr_pull_lsa_TestCall(struct ndr_pull *ndr, int flags, struct lsa_TestCall *r)
8663 {
8664         if (flags & NDR_IN) {
8665         }
8666         if (flags & NDR_OUT) {
8667                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8668         }
8669         return NT_STATUS_OK;
8670 }
8671
8672 _PUBLIC_ void ndr_print_lsa_TestCall(struct ndr_print *ndr, const char *name, int flags, const struct lsa_TestCall *r)
8673 {
8674         ndr_print_struct(ndr, name, "lsa_TestCall");
8675         ndr->depth++;
8676         if (flags & NDR_SET_VALUES) {
8677                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8678         }
8679         if (flags & NDR_IN) {
8680                 ndr_print_struct(ndr, "in", "lsa_TestCall");
8681                 ndr->depth++;
8682                 ndr->depth--;
8683         }
8684         if (flags & NDR_OUT) {
8685                 ndr_print_struct(ndr, "out", "lsa_TestCall");
8686                 ndr->depth++;
8687                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8688                 ndr->depth--;
8689         }
8690         ndr->depth--;
8691 }
8692
8693 NTSTATUS ndr_push_lsa_LookupSids2(struct ndr_push *ndr, int flags, const struct lsa_LookupSids2 *r)
8694 {
8695         if (flags & NDR_IN) {
8696                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8697                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8698                 if (r->in.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8699                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
8700                 if (r->in.names == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8701                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
8702                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
8703                 if (r->in.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
8705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
8706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
8707         }
8708         if (flags & NDR_OUT) {
8709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.domains));
8710                 if (r->out.domains) {
8711                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
8712                 }
8713                 if (r->out.names == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8714                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
8715                 if (r->out.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
8717                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8718         }
8719         return NT_STATUS_OK;
8720 }
8721
8722 NTSTATUS ndr_pull_lsa_LookupSids2(struct ndr_pull *ndr, int flags, struct lsa_LookupSids2 *r)
8723 {
8724         uint32_t _ptr_domains;
8725         TALLOC_CTX *_mem_save_handle_0;
8726         TALLOC_CTX *_mem_save_sids_0;
8727         TALLOC_CTX *_mem_save_domains_0;
8728         TALLOC_CTX *_mem_save_names_0;
8729         TALLOC_CTX *_mem_save_count_0;
8730         if (flags & NDR_IN) {
8731                 ZERO_STRUCT(r->out);
8732
8733                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8734                         NDR_PULL_ALLOC(ndr, r->in.handle);
8735                 }
8736                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8737                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8738                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8739                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8741                         NDR_PULL_ALLOC(ndr, r->in.sids);
8742                 }
8743                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8744                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
8745                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
8746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
8747                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8748                         NDR_PULL_ALLOC(ndr, r->in.names);
8749                 }
8750                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8751                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
8752                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
8753                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
8754                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
8755                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8756                         NDR_PULL_ALLOC(ndr, r->in.count);
8757                 }
8758                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
8759                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
8760                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
8761                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
8762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
8763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
8764                 NDR_PULL_ALLOC(ndr, r->out.names);
8765                 *r->out.names = *r->in.names;
8766                 NDR_PULL_ALLOC(ndr, r->out.count);
8767                 *r->out.count = *r->in.count;
8768         }
8769         if (flags & NDR_OUT) {
8770                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
8771                 if (_ptr_domains) {
8772                         NDR_PULL_ALLOC(ndr, r->out.domains);
8773                 } else {
8774                         r->out.domains = NULL;
8775                 }
8776                 if (r->out.domains) {
8777                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
8778                         NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, 0);
8779                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
8780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
8781                 }
8782                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8783                         NDR_PULL_ALLOC(ndr, r->out.names);
8784                 }
8785                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8786                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
8787                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
8788                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
8789                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8790                         NDR_PULL_ALLOC(ndr, r->out.count);
8791                 }
8792                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
8793                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
8794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
8795                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
8796                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8797         }
8798         return NT_STATUS_OK;
8799 }
8800
8801 _PUBLIC_ void ndr_print_lsa_LookupSids2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids2 *r)
8802 {
8803         ndr_print_struct(ndr, name, "lsa_LookupSids2");
8804         ndr->depth++;
8805         if (flags & NDR_SET_VALUES) {
8806                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8807         }
8808         if (flags & NDR_IN) {
8809                 ndr_print_struct(ndr, "in", "lsa_LookupSids2");
8810                 ndr->depth++;
8811                 ndr_print_ptr(ndr, "handle", r->in.handle);
8812                 ndr->depth++;
8813                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8814                 ndr->depth--;
8815                 ndr_print_ptr(ndr, "sids", r->in.sids);
8816                 ndr->depth++;
8817                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
8818                 ndr->depth--;
8819                 ndr_print_ptr(ndr, "names", r->in.names);
8820                 ndr->depth++;
8821                 ndr_print_lsa_TransNameArray2(ndr, "names", r->in.names);
8822                 ndr->depth--;
8823                 ndr_print_uint16(ndr, "level", r->in.level);
8824                 ndr_print_ptr(ndr, "count", r->in.count);
8825                 ndr->depth++;
8826                 ndr_print_uint32(ndr, "count", *r->in.count);
8827                 ndr->depth--;
8828                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
8829                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
8830                 ndr->depth--;
8831         }
8832         if (flags & NDR_OUT) {
8833                 ndr_print_struct(ndr, "out", "lsa_LookupSids2");
8834                 ndr->depth++;
8835                 ndr_print_ptr(ndr, "domains", r->out.domains);
8836                 ndr->depth++;
8837                 if (r->out.domains) {
8838                         ndr_print_lsa_RefDomainList(ndr, "domains", r->out.domains);
8839                 }
8840                 ndr->depth--;
8841                 ndr_print_ptr(ndr, "names", r->out.names);
8842                 ndr->depth++;
8843                 ndr_print_lsa_TransNameArray2(ndr, "names", r->out.names);
8844                 ndr->depth--;
8845                 ndr_print_ptr(ndr, "count", r->out.count);
8846                 ndr->depth++;
8847                 ndr_print_uint32(ndr, "count", *r->out.count);
8848                 ndr->depth--;
8849                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8850                 ndr->depth--;
8851         }
8852         ndr->depth--;
8853 }
8854
8855 NTSTATUS ndr_push_lsa_LookupNames2(struct ndr_push *ndr, int flags, const struct lsa_LookupNames2 *r)
8856 {
8857         uint32_t cntr_names_0;
8858         if (flags & NDR_IN) {
8859                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8860                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
8862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
8863                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
8864                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
8865                 }
8866                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
8867                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
8868                 }
8869                 if (r->in.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8870                 NDR_CHECK(ndr_push_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
8871                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
8872                 if (r->in.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
8874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
8875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
8876         }
8877         if (flags & NDR_OUT) {
8878                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.domains));
8879                 if (r->out.domains) {
8880                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
8881                 }
8882                 if (r->out.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8883                 NDR_CHECK(ndr_push_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8884                 if (r->out.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
8885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
8886                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8887         }
8888         return NT_STATUS_OK;
8889 }
8890
8891 NTSTATUS ndr_pull_lsa_LookupNames2(struct ndr_pull *ndr, int flags, struct lsa_LookupNames2 *r)
8892 {
8893         uint32_t cntr_names_0;
8894         uint32_t _ptr_domains;
8895         TALLOC_CTX *_mem_save_handle_0;
8896         TALLOC_CTX *_mem_save_names_0;
8897         TALLOC_CTX *_mem_save_domains_0;
8898         TALLOC_CTX *_mem_save_sids_0;
8899         TALLOC_CTX *_mem_save_count_0;
8900         if (flags & NDR_IN) {
8901                 ZERO_STRUCT(r->out);
8902
8903                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8904                         NDR_PULL_ALLOC(ndr, r->in.handle);
8905                 }
8906                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8907                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8908                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8909                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
8911                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
8912                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8913                 }
8914                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
8915                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
8916                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8917                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
8918                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
8919                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
8920                 }
8921                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
8922                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
8923                 }
8924                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
8925                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8926                         NDR_PULL_ALLOC(ndr, r->in.sids);
8927                 }
8928                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8929                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
8930                 NDR_CHECK(ndr_pull_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
8931                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
8932                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
8933                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8934                         NDR_PULL_ALLOC(ndr, r->in.count);
8935                 }
8936                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
8937                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
8938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
8939                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
8940                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
8941                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
8942                 NDR_PULL_ALLOC(ndr, r->out.sids);
8943                 *r->out.sids = *r->in.sids;
8944                 NDR_PULL_ALLOC(ndr, r->out.count);
8945                 *r->out.count = *r->in.count;
8946                 if (r->in.names) {
8947                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
8948                 }
8949         }
8950         if (flags & NDR_OUT) {
8951                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
8952                 if (_ptr_domains) {
8953                         NDR_PULL_ALLOC(ndr, r->out.domains);
8954                 } else {
8955                         r->out.domains = NULL;
8956                 }
8957                 if (r->out.domains) {
8958                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
8959                         NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, 0);
8960                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
8961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
8962                 }
8963                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8964                         NDR_PULL_ALLOC(ndr, r->out.sids);
8965                 }
8966                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
8967                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
8968                 NDR_CHECK(ndr_pull_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
8969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
8970                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8971                         NDR_PULL_ALLOC(ndr, r->out.count);
8972                 }
8973                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
8974                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
8975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
8976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
8977                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8978         }
8979         return NT_STATUS_OK;
8980 }
8981
8982 _PUBLIC_ void ndr_print_lsa_LookupNames2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames2 *r)
8983 {
8984         uint32_t cntr_names_0;
8985         ndr_print_struct(ndr, name, "lsa_LookupNames2");
8986         ndr->depth++;
8987         if (flags & NDR_SET_VALUES) {
8988                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8989         }
8990         if (flags & NDR_IN) {
8991                 ndr_print_struct(ndr, "in", "lsa_LookupNames2");
8992                 ndr->depth++;
8993                 ndr_print_ptr(ndr, "handle", r->in.handle);
8994                 ndr->depth++;
8995                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8996                 ndr->depth--;
8997                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
8998                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
8999                 ndr->depth++;
9000                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
9001                         char *idx_0=NULL;
9002                         asprintf(&idx_0, "[%d]", cntr_names_0);
9003                         if (idx_0) {
9004                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
9005                                 free(idx_0);
9006                         }
9007                 }
9008                 ndr->depth--;
9009                 ndr_print_ptr(ndr, "sids", r->in.sids);
9010                 ndr->depth++;
9011                 ndr_print_lsa_TransSidArray2(ndr, "sids", r->in.sids);
9012                 ndr->depth--;
9013                 ndr_print_uint16(ndr, "level", r->in.level);
9014                 ndr_print_ptr(ndr, "count", r->in.count);
9015                 ndr->depth++;
9016                 ndr_print_uint32(ndr, "count", *r->in.count);
9017                 ndr->depth--;
9018                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
9019                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
9020                 ndr->depth--;
9021         }
9022         if (flags & NDR_OUT) {
9023                 ndr_print_struct(ndr, "out", "lsa_LookupNames2");
9024                 ndr->depth++;
9025                 ndr_print_ptr(ndr, "domains", r->out.domains);
9026                 ndr->depth++;
9027                 if (r->out.domains) {
9028                         ndr_print_lsa_RefDomainList(ndr, "domains", r->out.domains);
9029                 }
9030                 ndr->depth--;
9031                 ndr_print_ptr(ndr, "sids", r->out.sids);
9032                 ndr->depth++;
9033                 ndr_print_lsa_TransSidArray2(ndr, "sids", r->out.sids);
9034                 ndr->depth--;
9035                 ndr_print_ptr(ndr, "count", r->out.count);
9036                 ndr->depth++;
9037                 ndr_print_uint32(ndr, "count", *r->out.count);
9038                 ndr->depth--;
9039                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9040                 ndr->depth--;
9041         }
9042         ndr->depth--;
9043 }
9044
9045 NTSTATUS ndr_push_lsa_CreateTrustedDomainEx2(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomainEx2 *r)
9046 {
9047         if (flags & NDR_IN) {
9048         }
9049         if (flags & NDR_OUT) {
9050                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9051         }
9052         return NT_STATUS_OK;
9053 }
9054
9055 NTSTATUS ndr_pull_lsa_CreateTrustedDomainEx2(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomainEx2 *r)
9056 {
9057         if (flags & NDR_IN) {
9058         }
9059         if (flags & NDR_OUT) {
9060                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9061         }
9062         return NT_STATUS_OK;
9063 }
9064
9065 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomainEx2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomainEx2 *r)
9066 {
9067         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomainEx2");
9068         ndr->depth++;
9069         if (flags & NDR_SET_VALUES) {
9070                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9071         }
9072         if (flags & NDR_IN) {
9073                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomainEx2");
9074                 ndr->depth++;
9075                 ndr->depth--;
9076         }
9077         if (flags & NDR_OUT) {
9078                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomainEx2");
9079                 ndr->depth++;
9080                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9081                 ndr->depth--;
9082         }
9083         ndr->depth--;
9084 }
9085
9086 NTSTATUS ndr_push_lsa_CREDRWRITE(struct ndr_push *ndr, int flags, const struct lsa_CREDRWRITE *r)
9087 {
9088         if (flags & NDR_IN) {
9089         }
9090         if (flags & NDR_OUT) {
9091                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9092         }
9093         return NT_STATUS_OK;
9094 }
9095
9096 NTSTATUS ndr_pull_lsa_CREDRWRITE(struct ndr_pull *ndr, int flags, struct lsa_CREDRWRITE *r)
9097 {
9098         if (flags & NDR_IN) {
9099         }
9100         if (flags & NDR_OUT) {
9101                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9102         }
9103         return NT_STATUS_OK;
9104 }
9105
9106 _PUBLIC_ void ndr_print_lsa_CREDRWRITE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRWRITE *r)
9107 {
9108         ndr_print_struct(ndr, name, "lsa_CREDRWRITE");
9109         ndr->depth++;
9110         if (flags & NDR_SET_VALUES) {
9111                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9112         }
9113         if (flags & NDR_IN) {
9114                 ndr_print_struct(ndr, "in", "lsa_CREDRWRITE");
9115                 ndr->depth++;
9116                 ndr->depth--;
9117         }
9118         if (flags & NDR_OUT) {
9119                 ndr_print_struct(ndr, "out", "lsa_CREDRWRITE");
9120                 ndr->depth++;
9121                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9122                 ndr->depth--;
9123         }
9124         ndr->depth--;
9125 }
9126
9127 NTSTATUS ndr_push_lsa_CREDRREAD(struct ndr_push *ndr, int flags, const struct lsa_CREDRREAD *r)
9128 {
9129         if (flags & NDR_IN) {
9130         }
9131         if (flags & NDR_OUT) {
9132                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9133         }
9134         return NT_STATUS_OK;
9135 }
9136
9137 NTSTATUS ndr_pull_lsa_CREDRREAD(struct ndr_pull *ndr, int flags, struct lsa_CREDRREAD *r)
9138 {
9139         if (flags & NDR_IN) {
9140         }
9141         if (flags & NDR_OUT) {
9142                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9143         }
9144         return NT_STATUS_OK;
9145 }
9146
9147 _PUBLIC_ void ndr_print_lsa_CREDRREAD(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRREAD *r)
9148 {
9149         ndr_print_struct(ndr, name, "lsa_CREDRREAD");
9150         ndr->depth++;
9151         if (flags & NDR_SET_VALUES) {
9152                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9153         }
9154         if (flags & NDR_IN) {
9155                 ndr_print_struct(ndr, "in", "lsa_CREDRREAD");
9156                 ndr->depth++;
9157                 ndr->depth--;
9158         }
9159         if (flags & NDR_OUT) {
9160                 ndr_print_struct(ndr, "out", "lsa_CREDRREAD");
9161                 ndr->depth++;
9162                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9163                 ndr->depth--;
9164         }
9165         ndr->depth--;
9166 }
9167
9168 NTSTATUS ndr_push_lsa_CREDRENUMERATE(struct ndr_push *ndr, int flags, const struct lsa_CREDRENUMERATE *r)
9169 {
9170         if (flags & NDR_IN) {
9171         }
9172         if (flags & NDR_OUT) {
9173                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9174         }
9175         return NT_STATUS_OK;
9176 }
9177
9178 NTSTATUS ndr_pull_lsa_CREDRENUMERATE(struct ndr_pull *ndr, int flags, struct lsa_CREDRENUMERATE *r)
9179 {
9180         if (flags & NDR_IN) {
9181         }
9182         if (flags & NDR_OUT) {
9183                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9184         }
9185         return NT_STATUS_OK;
9186 }
9187
9188 _PUBLIC_ void ndr_print_lsa_CREDRENUMERATE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRENUMERATE *r)
9189 {
9190         ndr_print_struct(ndr, name, "lsa_CREDRENUMERATE");
9191         ndr->depth++;
9192         if (flags & NDR_SET_VALUES) {
9193                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9194         }
9195         if (flags & NDR_IN) {
9196                 ndr_print_struct(ndr, "in", "lsa_CREDRENUMERATE");
9197                 ndr->depth++;
9198                 ndr->depth--;
9199         }
9200         if (flags & NDR_OUT) {
9201                 ndr_print_struct(ndr, "out", "lsa_CREDRENUMERATE");
9202                 ndr->depth++;
9203                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9204                 ndr->depth--;
9205         }
9206         ndr->depth--;
9207 }
9208
9209 NTSTATUS ndr_push_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_push *ndr, int flags, const struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
9210 {
9211         if (flags & NDR_IN) {
9212         }
9213         if (flags & NDR_OUT) {
9214                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9215         }
9216         return NT_STATUS_OK;
9217 }
9218
9219 NTSTATUS ndr_pull_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_pull *ndr, int flags, struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
9220 {
9221         if (flags & NDR_IN) {
9222         }
9223         if (flags & NDR_OUT) {
9224                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9225         }
9226         return NT_STATUS_OK;
9227 }
9228
9229 _PUBLIC_ void ndr_print_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
9230 {
9231         ndr_print_struct(ndr, name, "lsa_CREDRWRITEDOMAINCREDENTIALS");
9232         ndr->depth++;
9233         if (flags & NDR_SET_VALUES) {
9234                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9235         }
9236         if (flags & NDR_IN) {
9237                 ndr_print_struct(ndr, "in", "lsa_CREDRWRITEDOMAINCREDENTIALS");
9238                 ndr->depth++;
9239                 ndr->depth--;
9240         }
9241         if (flags & NDR_OUT) {
9242                 ndr_print_struct(ndr, "out", "lsa_CREDRWRITEDOMAINCREDENTIALS");
9243                 ndr->depth++;
9244                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9245                 ndr->depth--;
9246         }
9247         ndr->depth--;
9248 }
9249
9250 NTSTATUS ndr_push_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_push *ndr, int flags, const struct lsa_CREDRREADDOMAINCREDENTIALS *r)
9251 {
9252         if (flags & NDR_IN) {
9253         }
9254         if (flags & NDR_OUT) {
9255                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9256         }
9257         return NT_STATUS_OK;
9258 }
9259
9260 NTSTATUS ndr_pull_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_pull *ndr, int flags, struct lsa_CREDRREADDOMAINCREDENTIALS *r)
9261 {
9262         if (flags & NDR_IN) {
9263         }
9264         if (flags & NDR_OUT) {
9265                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9266         }
9267         return NT_STATUS_OK;
9268 }
9269
9270 _PUBLIC_ void ndr_print_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRREADDOMAINCREDENTIALS *r)
9271 {
9272         ndr_print_struct(ndr, name, "lsa_CREDRREADDOMAINCREDENTIALS");
9273         ndr->depth++;
9274         if (flags & NDR_SET_VALUES) {
9275                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9276         }
9277         if (flags & NDR_IN) {
9278                 ndr_print_struct(ndr, "in", "lsa_CREDRREADDOMAINCREDENTIALS");
9279                 ndr->depth++;
9280                 ndr->depth--;
9281         }
9282         if (flags & NDR_OUT) {
9283                 ndr_print_struct(ndr, "out", "lsa_CREDRREADDOMAINCREDENTIALS");
9284                 ndr->depth++;
9285                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9286                 ndr->depth--;
9287         }
9288         ndr->depth--;
9289 }
9290
9291 NTSTATUS ndr_push_lsa_CREDRDELETE(struct ndr_push *ndr, int flags, const struct lsa_CREDRDELETE *r)
9292 {
9293         if (flags & NDR_IN) {
9294         }
9295         if (flags & NDR_OUT) {
9296                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9297         }
9298         return NT_STATUS_OK;
9299 }
9300
9301 NTSTATUS ndr_pull_lsa_CREDRDELETE(struct ndr_pull *ndr, int flags, struct lsa_CREDRDELETE *r)
9302 {
9303         if (flags & NDR_IN) {
9304         }
9305         if (flags & NDR_OUT) {
9306                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9307         }
9308         return NT_STATUS_OK;
9309 }
9310
9311 _PUBLIC_ void ndr_print_lsa_CREDRDELETE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRDELETE *r)
9312 {
9313         ndr_print_struct(ndr, name, "lsa_CREDRDELETE");
9314         ndr->depth++;
9315         if (flags & NDR_SET_VALUES) {
9316                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9317         }
9318         if (flags & NDR_IN) {
9319                 ndr_print_struct(ndr, "in", "lsa_CREDRDELETE");
9320                 ndr->depth++;
9321                 ndr->depth--;
9322         }
9323         if (flags & NDR_OUT) {
9324                 ndr_print_struct(ndr, "out", "lsa_CREDRDELETE");
9325                 ndr->depth++;
9326                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9327                 ndr->depth--;
9328         }
9329         ndr->depth--;
9330 }
9331
9332 NTSTATUS ndr_push_lsa_CREDRGETTARGETINFO(struct ndr_push *ndr, int flags, const struct lsa_CREDRGETTARGETINFO *r)
9333 {
9334         if (flags & NDR_IN) {
9335         }
9336         if (flags & NDR_OUT) {
9337                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9338         }
9339         return NT_STATUS_OK;
9340 }
9341
9342 NTSTATUS ndr_pull_lsa_CREDRGETTARGETINFO(struct ndr_pull *ndr, int flags, struct lsa_CREDRGETTARGETINFO *r)
9343 {
9344         if (flags & NDR_IN) {
9345         }
9346         if (flags & NDR_OUT) {
9347                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9348         }
9349         return NT_STATUS_OK;
9350 }
9351
9352 _PUBLIC_ void ndr_print_lsa_CREDRGETTARGETINFO(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRGETTARGETINFO *r)
9353 {
9354         ndr_print_struct(ndr, name, "lsa_CREDRGETTARGETINFO");
9355         ndr->depth++;
9356         if (flags & NDR_SET_VALUES) {
9357                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9358         }
9359         if (flags & NDR_IN) {
9360                 ndr_print_struct(ndr, "in", "lsa_CREDRGETTARGETINFO");
9361                 ndr->depth++;
9362                 ndr->depth--;
9363         }
9364         if (flags & NDR_OUT) {
9365                 ndr_print_struct(ndr, "out", "lsa_CREDRGETTARGETINFO");
9366                 ndr->depth++;
9367                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9368                 ndr->depth--;
9369         }
9370         ndr->depth--;
9371 }
9372
9373 NTSTATUS ndr_push_lsa_CREDRPROFILELOADED(struct ndr_push *ndr, int flags, const struct lsa_CREDRPROFILELOADED *r)
9374 {
9375         if (flags & NDR_IN) {
9376         }
9377         if (flags & NDR_OUT) {
9378                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9379         }
9380         return NT_STATUS_OK;
9381 }
9382
9383 NTSTATUS ndr_pull_lsa_CREDRPROFILELOADED(struct ndr_pull *ndr, int flags, struct lsa_CREDRPROFILELOADED *r)
9384 {
9385         if (flags & NDR_IN) {
9386         }
9387         if (flags & NDR_OUT) {
9388                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9389         }
9390         return NT_STATUS_OK;
9391 }
9392
9393 _PUBLIC_ void ndr_print_lsa_CREDRPROFILELOADED(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRPROFILELOADED *r)
9394 {
9395         ndr_print_struct(ndr, name, "lsa_CREDRPROFILELOADED");
9396         ndr->depth++;
9397         if (flags & NDR_SET_VALUES) {
9398                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9399         }
9400         if (flags & NDR_IN) {
9401                 ndr_print_struct(ndr, "in", "lsa_CREDRPROFILELOADED");
9402                 ndr->depth++;
9403                 ndr->depth--;
9404         }
9405         if (flags & NDR_OUT) {
9406                 ndr_print_struct(ndr, "out", "lsa_CREDRPROFILELOADED");
9407                 ndr->depth++;
9408                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9409                 ndr->depth--;
9410         }
9411         ndr->depth--;
9412 }
9413
9414 NTSTATUS ndr_push_lsa_LookupNames3(struct ndr_push *ndr, int flags, const struct lsa_LookupNames3 *r)
9415 {
9416         uint32_t cntr_names_0;
9417         if (flags & NDR_IN) {
9418                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
9419                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
9421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
9422                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
9423                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
9424                 }
9425                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
9426                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
9427                 }
9428                 if (r->in.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
9429                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
9430                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9431                 if (r->in.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
9432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
9433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
9434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
9435         }
9436         if (flags & NDR_OUT) {
9437                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.domains));
9438                 if (r->out.domains) {
9439                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
9440                 }
9441                 if (r->out.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
9442                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
9443                 if (r->out.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
9444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
9445                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9446         }
9447         return NT_STATUS_OK;
9448 }
9449
9450 NTSTATUS ndr_pull_lsa_LookupNames3(struct ndr_pull *ndr, int flags, struct lsa_LookupNames3 *r)
9451 {
9452         uint32_t cntr_names_0;
9453         uint32_t _ptr_domains;
9454         TALLOC_CTX *_mem_save_handle_0;
9455         TALLOC_CTX *_mem_save_names_0;
9456         TALLOC_CTX *_mem_save_domains_0;
9457         TALLOC_CTX *_mem_save_sids_0;
9458         TALLOC_CTX *_mem_save_count_0;
9459         if (flags & NDR_IN) {
9460                 ZERO_STRUCT(r->out);
9461
9462                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9463                         NDR_PULL_ALLOC(ndr, r->in.handle);
9464                 }
9465                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9466                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9467                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
9470                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
9471                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9472                 }
9473                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
9474                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
9475                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9476                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
9477                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
9478                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
9479                 }
9480                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
9481                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
9482                 }
9483                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
9484                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9485                         NDR_PULL_ALLOC(ndr, r->in.sids);
9486                 }
9487                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9488                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
9489                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
9490                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
9491                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9492                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9493                         NDR_PULL_ALLOC(ndr, r->in.count);
9494                 }
9495                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
9496                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
9497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
9498                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
9499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
9500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
9501                 NDR_PULL_ALLOC(ndr, r->out.sids);
9502                 *r->out.sids = *r->in.sids;
9503                 NDR_PULL_ALLOC(ndr, r->out.count);
9504                 *r->out.count = *r->in.count;
9505                 if (r->in.names) {
9506                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
9507                 }
9508         }
9509         if (flags & NDR_OUT) {
9510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
9511                 if (_ptr_domains) {
9512                         NDR_PULL_ALLOC(ndr, r->out.domains);
9513                 } else {
9514                         r->out.domains = NULL;
9515                 }
9516                 if (r->out.domains) {
9517                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
9518                         NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, 0);
9519                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
9520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
9521                 }
9522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9523                         NDR_PULL_ALLOC(ndr, r->out.sids);
9524                 }
9525                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9526                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
9527                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
9528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
9529                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9530                         NDR_PULL_ALLOC(ndr, r->out.count);
9531                 }
9532                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
9533                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
9534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
9535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
9536                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9537         }
9538         return NT_STATUS_OK;
9539 }
9540
9541 _PUBLIC_ void ndr_print_lsa_LookupNames3(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames3 *r)
9542 {
9543         uint32_t cntr_names_0;
9544         ndr_print_struct(ndr, name, "lsa_LookupNames3");
9545         ndr->depth++;
9546         if (flags & NDR_SET_VALUES) {
9547                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9548         }
9549         if (flags & NDR_IN) {
9550                 ndr_print_struct(ndr, "in", "lsa_LookupNames3");
9551                 ndr->depth++;
9552                 ndr_print_ptr(ndr, "handle", r->in.handle);
9553                 ndr->depth++;
9554                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9555                 ndr->depth--;
9556                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
9557                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
9558                 ndr->depth++;
9559                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
9560                         char *idx_0=NULL;
9561                         asprintf(&idx_0, "[%d]", cntr_names_0);
9562                         if (idx_0) {
9563                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
9564                                 free(idx_0);
9565                         }
9566                 }
9567                 ndr->depth--;
9568                 ndr_print_ptr(ndr, "sids", r->in.sids);
9569                 ndr->depth++;
9570                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->in.sids);
9571                 ndr->depth--;
9572                 ndr_print_uint16(ndr, "level", r->in.level);
9573                 ndr_print_ptr(ndr, "count", r->in.count);
9574                 ndr->depth++;
9575                 ndr_print_uint32(ndr, "count", *r->in.count);
9576                 ndr->depth--;
9577                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
9578                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
9579                 ndr->depth--;
9580         }
9581         if (flags & NDR_OUT) {
9582                 ndr_print_struct(ndr, "out", "lsa_LookupNames3");
9583                 ndr->depth++;
9584                 ndr_print_ptr(ndr, "domains", r->out.domains);
9585                 ndr->depth++;
9586                 if (r->out.domains) {
9587                         ndr_print_lsa_RefDomainList(ndr, "domains", r->out.domains);
9588                 }
9589                 ndr->depth--;
9590                 ndr_print_ptr(ndr, "sids", r->out.sids);
9591                 ndr->depth++;
9592                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->out.sids);
9593                 ndr->depth--;
9594                 ndr_print_ptr(ndr, "count", r->out.count);
9595                 ndr->depth++;
9596                 ndr_print_uint32(ndr, "count", *r->out.count);
9597                 ndr->depth--;
9598                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9599                 ndr->depth--;
9600         }
9601         ndr->depth--;
9602 }
9603
9604 NTSTATUS ndr_push_lsa_CREDRGETSESSIONTYPES(struct ndr_push *ndr, int flags, const struct lsa_CREDRGETSESSIONTYPES *r)
9605 {
9606         if (flags & NDR_IN) {
9607         }
9608         if (flags & NDR_OUT) {
9609                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9610         }
9611         return NT_STATUS_OK;
9612 }
9613
9614 NTSTATUS ndr_pull_lsa_CREDRGETSESSIONTYPES(struct ndr_pull *ndr, int flags, struct lsa_CREDRGETSESSIONTYPES *r)
9615 {
9616         if (flags & NDR_IN) {
9617         }
9618         if (flags & NDR_OUT) {
9619                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9620         }
9621         return NT_STATUS_OK;
9622 }
9623
9624 _PUBLIC_ void ndr_print_lsa_CREDRGETSESSIONTYPES(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRGETSESSIONTYPES *r)
9625 {
9626         ndr_print_struct(ndr, name, "lsa_CREDRGETSESSIONTYPES");
9627         ndr->depth++;
9628         if (flags & NDR_SET_VALUES) {
9629                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9630         }
9631         if (flags & NDR_IN) {
9632                 ndr_print_struct(ndr, "in", "lsa_CREDRGETSESSIONTYPES");
9633                 ndr->depth++;
9634                 ndr->depth--;
9635         }
9636         if (flags & NDR_OUT) {
9637                 ndr_print_struct(ndr, "out", "lsa_CREDRGETSESSIONTYPES");
9638                 ndr->depth++;
9639                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9640                 ndr->depth--;
9641         }
9642         ndr->depth--;
9643 }
9644
9645 NTSTATUS ndr_push_lsa_LSARREGISTERAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARREGISTERAUDITEVENT *r)
9646 {
9647         if (flags & NDR_IN) {
9648         }
9649         if (flags & NDR_OUT) {
9650                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9651         }
9652         return NT_STATUS_OK;
9653 }
9654
9655 NTSTATUS ndr_pull_lsa_LSARREGISTERAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARREGISTERAUDITEVENT *r)
9656 {
9657         if (flags & NDR_IN) {
9658         }
9659         if (flags & NDR_OUT) {
9660                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9661         }
9662         return NT_STATUS_OK;
9663 }
9664
9665 _PUBLIC_ void ndr_print_lsa_LSARREGISTERAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARREGISTERAUDITEVENT *r)
9666 {
9667         ndr_print_struct(ndr, name, "lsa_LSARREGISTERAUDITEVENT");
9668         ndr->depth++;
9669         if (flags & NDR_SET_VALUES) {
9670                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9671         }
9672         if (flags & NDR_IN) {
9673                 ndr_print_struct(ndr, "in", "lsa_LSARREGISTERAUDITEVENT");
9674                 ndr->depth++;
9675                 ndr->depth--;
9676         }
9677         if (flags & NDR_OUT) {
9678                 ndr_print_struct(ndr, "out", "lsa_LSARREGISTERAUDITEVENT");
9679                 ndr->depth++;
9680                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9681                 ndr->depth--;
9682         }
9683         ndr->depth--;
9684 }
9685
9686 NTSTATUS ndr_push_lsa_LSARGENAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARGENAUDITEVENT *r)
9687 {
9688         if (flags & NDR_IN) {
9689         }
9690         if (flags & NDR_OUT) {
9691                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9692         }
9693         return NT_STATUS_OK;
9694 }
9695
9696 NTSTATUS ndr_pull_lsa_LSARGENAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARGENAUDITEVENT *r)
9697 {
9698         if (flags & NDR_IN) {
9699         }
9700         if (flags & NDR_OUT) {
9701                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9702         }
9703         return NT_STATUS_OK;
9704 }
9705
9706 _PUBLIC_ void ndr_print_lsa_LSARGENAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARGENAUDITEVENT *r)
9707 {
9708         ndr_print_struct(ndr, name, "lsa_LSARGENAUDITEVENT");
9709         ndr->depth++;
9710         if (flags & NDR_SET_VALUES) {
9711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9712         }
9713         if (flags & NDR_IN) {
9714                 ndr_print_struct(ndr, "in", "lsa_LSARGENAUDITEVENT");
9715                 ndr->depth++;
9716                 ndr->depth--;
9717         }
9718         if (flags & NDR_OUT) {
9719                 ndr_print_struct(ndr, "out", "lsa_LSARGENAUDITEVENT");
9720                 ndr->depth++;
9721                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9722                 ndr->depth--;
9723         }
9724         ndr->depth--;
9725 }
9726
9727 NTSTATUS ndr_push_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARUNREGISTERAUDITEVENT *r)
9728 {
9729         if (flags & NDR_IN) {
9730         }
9731         if (flags & NDR_OUT) {
9732                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9733         }
9734         return NT_STATUS_OK;
9735 }
9736
9737 NTSTATUS ndr_pull_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARUNREGISTERAUDITEVENT *r)
9738 {
9739         if (flags & NDR_IN) {
9740         }
9741         if (flags & NDR_OUT) {
9742                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9743         }
9744         return NT_STATUS_OK;
9745 }
9746
9747 _PUBLIC_ void ndr_print_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARUNREGISTERAUDITEVENT *r)
9748 {
9749         ndr_print_struct(ndr, name, "lsa_LSARUNREGISTERAUDITEVENT");
9750         ndr->depth++;
9751         if (flags & NDR_SET_VALUES) {
9752                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9753         }
9754         if (flags & NDR_IN) {
9755                 ndr_print_struct(ndr, "in", "lsa_LSARUNREGISTERAUDITEVENT");
9756                 ndr->depth++;
9757                 ndr->depth--;
9758         }
9759         if (flags & NDR_OUT) {
9760                 ndr_print_struct(ndr, "out", "lsa_LSARUNREGISTERAUDITEVENT");
9761                 ndr->depth++;
9762                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9763                 ndr->depth--;
9764         }
9765         ndr->depth--;
9766 }
9767
9768 NTSTATUS ndr_push_lsa_LSARQUERYFORESTTRUSTINFORMATION(struct ndr_push *ndr, int flags, const struct lsa_LSARQUERYFORESTTRUSTINFORMATION *r)
9769 {
9770         if (flags & NDR_IN) {
9771         }
9772         if (flags & NDR_OUT) {
9773                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9774         }
9775         return NT_STATUS_OK;
9776 }
9777
9778 NTSTATUS ndr_pull_lsa_LSARQUERYFORESTTRUSTINFORMATION(struct ndr_pull *ndr, int flags, struct lsa_LSARQUERYFORESTTRUSTINFORMATION *r)
9779 {
9780         if (flags & NDR_IN) {
9781         }
9782         if (flags & NDR_OUT) {
9783                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9784         }
9785         return NT_STATUS_OK;
9786 }
9787
9788 _PUBLIC_ void ndr_print_lsa_LSARQUERYFORESTTRUSTINFORMATION(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARQUERYFORESTTRUSTINFORMATION *r)
9789 {
9790         ndr_print_struct(ndr, name, "lsa_LSARQUERYFORESTTRUSTINFORMATION");
9791         ndr->depth++;
9792         if (flags & NDR_SET_VALUES) {
9793                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9794         }
9795         if (flags & NDR_IN) {
9796                 ndr_print_struct(ndr, "in", "lsa_LSARQUERYFORESTTRUSTINFORMATION");
9797                 ndr->depth++;
9798                 ndr->depth--;
9799         }
9800         if (flags & NDR_OUT) {
9801                 ndr_print_struct(ndr, "out", "lsa_LSARQUERYFORESTTRUSTINFORMATION");
9802                 ndr->depth++;
9803                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9804                 ndr->depth--;
9805         }
9806         ndr->depth--;
9807 }
9808
9809 NTSTATUS ndr_push_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_push *ndr, int flags, const struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
9810 {
9811         if (flags & NDR_IN) {
9812         }
9813         if (flags & NDR_OUT) {
9814                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9815         }
9816         return NT_STATUS_OK;
9817 }
9818
9819 NTSTATUS ndr_pull_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_pull *ndr, int flags, struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
9820 {
9821         if (flags & NDR_IN) {
9822         }
9823         if (flags & NDR_OUT) {
9824                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9825         }
9826         return NT_STATUS_OK;
9827 }
9828
9829 _PUBLIC_ void ndr_print_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
9830 {
9831         ndr_print_struct(ndr, name, "lsa_LSARSETFORESTTRUSTINFORMATION");
9832         ndr->depth++;
9833         if (flags & NDR_SET_VALUES) {
9834                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9835         }
9836         if (flags & NDR_IN) {
9837                 ndr_print_struct(ndr, "in", "lsa_LSARSETFORESTTRUSTINFORMATION");
9838                 ndr->depth++;
9839                 ndr->depth--;
9840         }
9841         if (flags & NDR_OUT) {
9842                 ndr_print_struct(ndr, "out", "lsa_LSARSETFORESTTRUSTINFORMATION");
9843                 ndr->depth++;
9844                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9845                 ndr->depth--;
9846         }
9847         ndr->depth--;
9848 }
9849
9850 NTSTATUS ndr_push_lsa_CREDRRENAME(struct ndr_push *ndr, int flags, const struct lsa_CREDRRENAME *r)
9851 {
9852         if (flags & NDR_IN) {
9853         }
9854         if (flags & NDR_OUT) {
9855                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9856         }
9857         return NT_STATUS_OK;
9858 }
9859
9860 NTSTATUS ndr_pull_lsa_CREDRRENAME(struct ndr_pull *ndr, int flags, struct lsa_CREDRRENAME *r)
9861 {
9862         if (flags & NDR_IN) {
9863         }
9864         if (flags & NDR_OUT) {
9865                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9866         }
9867         return NT_STATUS_OK;
9868 }
9869
9870 _PUBLIC_ void ndr_print_lsa_CREDRRENAME(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRRENAME *r)
9871 {
9872         ndr_print_struct(ndr, name, "lsa_CREDRRENAME");
9873         ndr->depth++;
9874         if (flags & NDR_SET_VALUES) {
9875                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9876         }
9877         if (flags & NDR_IN) {
9878                 ndr_print_struct(ndr, "in", "lsa_CREDRRENAME");
9879                 ndr->depth++;
9880                 ndr->depth--;
9881         }
9882         if (flags & NDR_OUT) {
9883                 ndr_print_struct(ndr, "out", "lsa_CREDRRENAME");
9884                 ndr->depth++;
9885                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9886                 ndr->depth--;
9887         }
9888         ndr->depth--;
9889 }
9890
9891 NTSTATUS ndr_push_lsa_LookupSids3(struct ndr_push *ndr, int flags, const struct lsa_LookupSids3 *r)
9892 {
9893         if (flags & NDR_IN) {
9894                 if (r->in.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
9895                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
9896                 if (r->in.names == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
9897                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
9898                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9899                 if (r->in.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
9900                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
9901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
9902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
9903         }
9904         if (flags & NDR_OUT) {
9905                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.domains));
9906                 if (r->out.domains) {
9907                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
9908                 }
9909                 if (r->out.names == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
9910                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
9911                 if (r->out.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
9912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
9913                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9914         }
9915         return NT_STATUS_OK;
9916 }
9917
9918 NTSTATUS ndr_pull_lsa_LookupSids3(struct ndr_pull *ndr, int flags, struct lsa_LookupSids3 *r)
9919 {
9920         uint32_t _ptr_domains;
9921         TALLOC_CTX *_mem_save_sids_0;
9922         TALLOC_CTX *_mem_save_domains_0;
9923         TALLOC_CTX *_mem_save_names_0;
9924         TALLOC_CTX *_mem_save_count_0;
9925         if (flags & NDR_IN) {
9926                 ZERO_STRUCT(r->out);
9927
9928                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9929                         NDR_PULL_ALLOC(ndr, r->in.sids);
9930                 }
9931                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9932                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
9933                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
9934                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
9935                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9936                         NDR_PULL_ALLOC(ndr, r->in.names);
9937                 }
9938                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9939                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
9940                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
9941                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
9942                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9943                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9944                         NDR_PULL_ALLOC(ndr, r->in.count);
9945                 }
9946                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
9947                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
9948                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
9949                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
9950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
9951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
9952                 NDR_PULL_ALLOC(ndr, r->out.names);
9953                 *r->out.names = *r->in.names;
9954                 NDR_PULL_ALLOC(ndr, r->out.count);
9955                 *r->out.count = *r->in.count;
9956         }
9957         if (flags & NDR_OUT) {
9958                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
9959                 if (_ptr_domains) {
9960                         NDR_PULL_ALLOC(ndr, r->out.domains);
9961                 } else {
9962                         r->out.domains = NULL;
9963                 }
9964                 if (r->out.domains) {
9965                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
9966                         NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, 0);
9967                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
9968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
9969                 }
9970                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9971                         NDR_PULL_ALLOC(ndr, r->out.names);
9972                 }
9973                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9974                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
9975                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
9976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
9977                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9978                         NDR_PULL_ALLOC(ndr, r->out.count);
9979                 }
9980                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
9981                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
9982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
9983                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
9984                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9985         }
9986         return NT_STATUS_OK;
9987 }
9988
9989 _PUBLIC_ void ndr_print_lsa_LookupSids3(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids3 *r)
9990 {
9991         ndr_print_struct(ndr, name, "lsa_LookupSids3");
9992         ndr->depth++;
9993         if (flags & NDR_SET_VALUES) {
9994                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9995         }
9996         if (flags & NDR_IN) {
9997                 ndr_print_struct(ndr, "in", "lsa_LookupSids3");
9998                 ndr->depth++;
9999                 ndr_print_ptr(ndr, "sids", r->in.sids);
10000                 ndr->depth++;
10001                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
10002                 ndr->depth--;
10003                 ndr_print_ptr(ndr, "names", r->in.names);
10004                 ndr->depth++;
10005                 ndr_print_lsa_TransNameArray2(ndr, "names", r->in.names);
10006                 ndr->depth--;
10007                 ndr_print_uint16(ndr, "level", r->in.level);
10008                 ndr_print_ptr(ndr, "count", r->in.count);
10009                 ndr->depth++;
10010                 ndr_print_uint32(ndr, "count", *r->in.count);
10011                 ndr->depth--;
10012                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
10013                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
10014                 ndr->depth--;
10015         }
10016         if (flags & NDR_OUT) {
10017                 ndr_print_struct(ndr, "out", "lsa_LookupSids3");
10018                 ndr->depth++;
10019                 ndr_print_ptr(ndr, "domains", r->out.domains);
10020                 ndr->depth++;
10021                 if (r->out.domains) {
10022                         ndr_print_lsa_RefDomainList(ndr, "domains", r->out.domains);
10023                 }
10024                 ndr->depth--;
10025                 ndr_print_ptr(ndr, "names", r->out.names);
10026                 ndr->depth++;
10027                 ndr_print_lsa_TransNameArray2(ndr, "names", r->out.names);
10028                 ndr->depth--;
10029                 ndr_print_ptr(ndr, "count", r->out.count);
10030                 ndr->depth++;
10031                 ndr_print_uint32(ndr, "count", *r->out.count);
10032                 ndr->depth--;
10033                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10034                 ndr->depth--;
10035         }
10036         ndr->depth--;
10037 }
10038
10039 NTSTATUS ndr_push_lsa_LookupNames4(struct ndr_push *ndr, int flags, const struct lsa_LookupNames4 *r)
10040 {
10041         uint32_t cntr_names_0;
10042         if (flags & NDR_IN) {
10043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10045                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10046                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
10047                 }
10048                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10049                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
10050                 }
10051                 if (r->in.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
10052                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10053                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
10054                 if (r->in.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
10055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
10056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
10057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
10058         }
10059         if (flags & NDR_OUT) {
10060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.domains));
10061                 if (r->out.domains) {
10062                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
10063                 }
10064                 if (r->out.sids == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
10065                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
10066                 if (r->out.count == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
10067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
10068                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10069         }
10070         return NT_STATUS_OK;
10071 }
10072
10073 NTSTATUS ndr_pull_lsa_LookupNames4(struct ndr_pull *ndr, int flags, struct lsa_LookupNames4 *r)
10074 {
10075         uint32_t cntr_names_0;
10076         uint32_t _ptr_domains;
10077         TALLOC_CTX *_mem_save_names_0;
10078         TALLOC_CTX *_mem_save_domains_0;
10079         TALLOC_CTX *_mem_save_sids_0;
10080         TALLOC_CTX *_mem_save_count_0;
10081         if (flags & NDR_IN) {
10082                 ZERO_STRUCT(r->out);
10083
10084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
10085                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
10086                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
10087                 }
10088                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
10089                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
10090                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10091                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
10092                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10093                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
10094                 }
10095                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10096                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
10097                 }
10098                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
10099                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10100                         NDR_PULL_ALLOC(ndr, r->in.sids);
10101                 }
10102                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10103                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10104                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10105                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10106                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
10107                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10108                         NDR_PULL_ALLOC(ndr, r->in.count);
10109                 }
10110                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10111                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
10112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
10113                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
10115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
10116                 NDR_PULL_ALLOC(ndr, r->out.sids);
10117                 *r->out.sids = *r->in.sids;
10118                 NDR_PULL_ALLOC(ndr, r->out.count);
10119                 *r->out.count = *r->in.count;
10120                 if (r->in.names) {
10121                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
10122                 }
10123         }
10124         if (flags & NDR_OUT) {
10125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
10126                 if (_ptr_domains) {
10127                         NDR_PULL_ALLOC(ndr, r->out.domains);
10128                 } else {
10129                         r->out.domains = NULL;
10130                 }
10131                 if (r->out.domains) {
10132                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
10133                         NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, 0);
10134                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
10135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
10136                 }
10137                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10138                         NDR_PULL_ALLOC(ndr, r->out.sids);
10139                 }
10140                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10141                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
10142                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
10143                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10144                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10145                         NDR_PULL_ALLOC(ndr, r->out.count);
10146                 }
10147                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10148                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
10149                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
10150                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10151                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10152         }
10153         return NT_STATUS_OK;
10154 }
10155
10156 _PUBLIC_ void ndr_print_lsa_LookupNames4(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames4 *r)
10157 {
10158         uint32_t cntr_names_0;
10159         ndr_print_struct(ndr, name, "lsa_LookupNames4");
10160         ndr->depth++;
10161         if (flags & NDR_SET_VALUES) {
10162                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10163         }
10164         if (flags & NDR_IN) {
10165                 ndr_print_struct(ndr, "in", "lsa_LookupNames4");
10166                 ndr->depth++;
10167                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
10168                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
10169                 ndr->depth++;
10170                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
10171                         char *idx_0=NULL;
10172                         asprintf(&idx_0, "[%d]", cntr_names_0);
10173                         if (idx_0) {
10174                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
10175                                 free(idx_0);
10176                         }
10177                 }
10178                 ndr->depth--;
10179                 ndr_print_ptr(ndr, "sids", r->in.sids);
10180                 ndr->depth++;
10181                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->in.sids);
10182                 ndr->depth--;
10183                 ndr_print_uint16(ndr, "level", r->in.level);
10184                 ndr_print_ptr(ndr, "count", r->in.count);
10185                 ndr->depth++;
10186                 ndr_print_uint32(ndr, "count", *r->in.count);
10187                 ndr->depth--;
10188                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
10189                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
10190                 ndr->depth--;
10191         }
10192         if (flags & NDR_OUT) {
10193                 ndr_print_struct(ndr, "out", "lsa_LookupNames4");
10194                 ndr->depth++;
10195                 ndr_print_ptr(ndr, "domains", r->out.domains);
10196                 ndr->depth++;
10197                 if (r->out.domains) {
10198                         ndr_print_lsa_RefDomainList(ndr, "domains", r->out.domains);
10199                 }
10200                 ndr->depth--;
10201                 ndr_print_ptr(ndr, "sids", r->out.sids);
10202                 ndr->depth++;
10203                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->out.sids);
10204                 ndr->depth--;
10205                 ndr_print_ptr(ndr, "count", r->out.count);
10206                 ndr->depth++;
10207                 ndr_print_uint32(ndr, "count", *r->out.count);
10208                 ndr->depth--;
10209                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10210                 ndr->depth--;
10211         }
10212         ndr->depth--;
10213 }
10214
10215 NTSTATUS ndr_push_lsa_LSAROPENPOLICYSCE(struct ndr_push *ndr, int flags, const struct lsa_LSAROPENPOLICYSCE *r)
10216 {
10217         if (flags & NDR_IN) {
10218         }
10219         if (flags & NDR_OUT) {
10220                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10221         }
10222         return NT_STATUS_OK;
10223 }
10224
10225 NTSTATUS ndr_pull_lsa_LSAROPENPOLICYSCE(struct ndr_pull *ndr, int flags, struct lsa_LSAROPENPOLICYSCE *r)
10226 {
10227         if (flags & NDR_IN) {
10228         }
10229         if (flags & NDR_OUT) {
10230                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10231         }
10232         return NT_STATUS_OK;
10233 }
10234
10235 _PUBLIC_ void ndr_print_lsa_LSAROPENPOLICYSCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSAROPENPOLICYSCE *r)
10236 {
10237         ndr_print_struct(ndr, name, "lsa_LSAROPENPOLICYSCE");
10238         ndr->depth++;
10239         if (flags & NDR_SET_VALUES) {
10240                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10241         }
10242         if (flags & NDR_IN) {
10243                 ndr_print_struct(ndr, "in", "lsa_LSAROPENPOLICYSCE");
10244                 ndr->depth++;
10245                 ndr->depth--;
10246         }
10247         if (flags & NDR_OUT) {
10248                 ndr_print_struct(ndr, "out", "lsa_LSAROPENPOLICYSCE");
10249                 ndr->depth++;
10250                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10251                 ndr->depth--;
10252         }
10253         ndr->depth--;
10254 }
10255
10256 NTSTATUS ndr_push_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_push *ndr, int flags, const struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
10257 {
10258         if (flags & NDR_IN) {
10259         }
10260         if (flags & NDR_OUT) {
10261                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10262         }
10263         return NT_STATUS_OK;
10264 }
10265
10266 NTSTATUS ndr_pull_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_pull *ndr, int flags, struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
10267 {
10268         if (flags & NDR_IN) {
10269         }
10270         if (flags & NDR_OUT) {
10271                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10272         }
10273         return NT_STATUS_OK;
10274 }
10275
10276 _PUBLIC_ void ndr_print_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
10277 {
10278         ndr_print_struct(ndr, name, "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
10279         ndr->depth++;
10280         if (flags & NDR_SET_VALUES) {
10281                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10282         }
10283         if (flags & NDR_IN) {
10284                 ndr_print_struct(ndr, "in", "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
10285                 ndr->depth++;
10286                 ndr->depth--;
10287         }
10288         if (flags & NDR_OUT) {
10289                 ndr_print_struct(ndr, "out", "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
10290                 ndr->depth++;
10291                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10292                 ndr->depth--;
10293         }
10294         ndr->depth--;
10295 }
10296
10297 NTSTATUS ndr_push_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_push *ndr, int flags, const struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
10298 {
10299         if (flags & NDR_IN) {
10300         }
10301         if (flags & NDR_OUT) {
10302                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10303         }
10304         return NT_STATUS_OK;
10305 }
10306
10307 NTSTATUS ndr_pull_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_pull *ndr, int flags, struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
10308 {
10309         if (flags & NDR_IN) {
10310         }
10311         if (flags & NDR_OUT) {
10312                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10313         }
10314         return NT_STATUS_OK;
10315 }
10316
10317 _PUBLIC_ void ndr_print_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
10318 {
10319         ndr_print_struct(ndr, name, "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
10320         ndr->depth++;
10321         if (flags & NDR_SET_VALUES) {
10322                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10323         }
10324         if (flags & NDR_IN) {
10325                 ndr_print_struct(ndr, "in", "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
10326                 ndr->depth++;
10327                 ndr->depth--;
10328         }
10329         if (flags & NDR_OUT) {
10330                 ndr_print_struct(ndr, "out", "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
10331                 ndr->depth++;
10332                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10333                 ndr->depth--;
10334         }
10335         ndr->depth--;
10336 }
10337
10338 NTSTATUS ndr_push_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARADTREPORTSECURITYEVENT *r)
10339 {
10340         if (flags & NDR_IN) {
10341         }
10342         if (flags & NDR_OUT) {
10343                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10344         }
10345         return NT_STATUS_OK;
10346 }
10347
10348 NTSTATUS ndr_pull_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARADTREPORTSECURITYEVENT *r)
10349 {
10350         if (flags & NDR_IN) {
10351         }
10352         if (flags & NDR_OUT) {
10353                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10354         }
10355         return NT_STATUS_OK;
10356 }
10357
10358 _PUBLIC_ void ndr_print_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTREPORTSECURITYEVENT *r)
10359 {
10360         ndr_print_struct(ndr, name, "lsa_LSARADTREPORTSECURITYEVENT");
10361         ndr->depth++;
10362         if (flags & NDR_SET_VALUES) {
10363                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10364         }
10365         if (flags & NDR_IN) {
10366                 ndr_print_struct(ndr, "in", "lsa_LSARADTREPORTSECURITYEVENT");
10367                 ndr->depth++;
10368                 ndr->depth--;
10369         }
10370         if (flags & NDR_OUT) {
10371                 ndr_print_struct(ndr, "out", "lsa_LSARADTREPORTSECURITYEVENT");
10372                 ndr->depth++;
10373                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10374                 ndr->depth--;
10375         }
10376         ndr->depth--;
10377 }
10378
10379 const struct ndr_interface_call lsarpc_calls[] = {
10380         {
10381                 "lsa_Close",
10382                 sizeof(struct lsa_Close),
10383                 (ndr_push_flags_fn_t) ndr_push_lsa_Close,
10384                 (ndr_pull_flags_fn_t) ndr_pull_lsa_Close,
10385                 (ndr_print_function_t) ndr_print_lsa_Close,
10386                 False,
10387         },
10388         {
10389                 "lsa_Delete",
10390                 sizeof(struct lsa_Delete),
10391                 (ndr_push_flags_fn_t) ndr_push_lsa_Delete,
10392                 (ndr_pull_flags_fn_t) ndr_pull_lsa_Delete,
10393                 (ndr_print_function_t) ndr_print_lsa_Delete,
10394                 False,
10395         },
10396         {
10397                 "lsa_EnumPrivs",
10398                 sizeof(struct lsa_EnumPrivs),
10399                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumPrivs,
10400                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumPrivs,
10401                 (ndr_print_function_t) ndr_print_lsa_EnumPrivs,
10402                 False,
10403         },
10404         {
10405                 "lsa_QuerySecurity",
10406                 sizeof(struct lsa_QuerySecurity),
10407                 (ndr_push_flags_fn_t) ndr_push_lsa_QuerySecurity,
10408                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QuerySecurity,
10409                 (ndr_print_function_t) ndr_print_lsa_QuerySecurity,
10410                 False,
10411         },
10412         {
10413                 "lsa_SetSecObj",
10414                 sizeof(struct lsa_SetSecObj),
10415                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSecObj,
10416                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSecObj,
10417                 (ndr_print_function_t) ndr_print_lsa_SetSecObj,
10418                 False,
10419         },
10420         {
10421                 "lsa_ChangePassword",
10422                 sizeof(struct lsa_ChangePassword),
10423                 (ndr_push_flags_fn_t) ndr_push_lsa_ChangePassword,
10424                 (ndr_pull_flags_fn_t) ndr_pull_lsa_ChangePassword,
10425                 (ndr_print_function_t) ndr_print_lsa_ChangePassword,
10426                 False,
10427         },
10428         {
10429                 "lsa_OpenPolicy",
10430                 sizeof(struct lsa_OpenPolicy),
10431                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenPolicy,
10432                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenPolicy,
10433                 (ndr_print_function_t) ndr_print_lsa_OpenPolicy,
10434                 False,
10435         },
10436         {
10437                 "lsa_QueryInfoPolicy",
10438                 sizeof(struct lsa_QueryInfoPolicy),
10439                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryInfoPolicy,
10440                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryInfoPolicy,
10441                 (ndr_print_function_t) ndr_print_lsa_QueryInfoPolicy,
10442                 False,
10443         },
10444         {
10445                 "lsa_SetInfoPolicy",
10446                 sizeof(struct lsa_SetInfoPolicy),
10447                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInfoPolicy,
10448                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInfoPolicy,
10449                 (ndr_print_function_t) ndr_print_lsa_SetInfoPolicy,
10450                 False,
10451         },
10452         {
10453                 "lsa_ClearAuditLog",
10454                 sizeof(struct lsa_ClearAuditLog),
10455                 (ndr_push_flags_fn_t) ndr_push_lsa_ClearAuditLog,
10456                 (ndr_pull_flags_fn_t) ndr_pull_lsa_ClearAuditLog,
10457                 (ndr_print_function_t) ndr_print_lsa_ClearAuditLog,
10458                 False,
10459         },
10460         {
10461                 "lsa_CreateAccount",
10462                 sizeof(struct lsa_CreateAccount),
10463                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateAccount,
10464                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateAccount,
10465                 (ndr_print_function_t) ndr_print_lsa_CreateAccount,
10466                 False,
10467         },
10468         {
10469                 "lsa_EnumAccounts",
10470                 sizeof(struct lsa_EnumAccounts),
10471                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccounts,
10472                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccounts,
10473                 (ndr_print_function_t) ndr_print_lsa_EnumAccounts,
10474                 False,
10475         },
10476         {
10477                 "lsa_CreateTrustedDomain",
10478                 sizeof(struct lsa_CreateTrustedDomain),
10479                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomain,
10480                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomain,
10481                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomain,
10482                 False,
10483         },
10484         {
10485                 "lsa_EnumTrustDom",
10486                 sizeof(struct lsa_EnumTrustDom),
10487                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumTrustDom,
10488                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumTrustDom,
10489                 (ndr_print_function_t) ndr_print_lsa_EnumTrustDom,
10490                 False,
10491         },
10492         {
10493                 "lsa_LookupNames",
10494                 sizeof(struct lsa_LookupNames),
10495                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames,
10496                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames,
10497                 (ndr_print_function_t) ndr_print_lsa_LookupNames,
10498                 False,
10499         },
10500         {
10501                 "lsa_LookupSids",
10502                 sizeof(struct lsa_LookupSids),
10503                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids,
10504                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids,
10505                 (ndr_print_function_t) ndr_print_lsa_LookupSids,
10506                 False,
10507         },
10508         {
10509                 "lsa_CreateSecret",
10510                 sizeof(struct lsa_CreateSecret),
10511                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateSecret,
10512                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateSecret,
10513                 (ndr_print_function_t) ndr_print_lsa_CreateSecret,
10514                 False,
10515         },
10516         {
10517                 "lsa_OpenAccount",
10518                 sizeof(struct lsa_OpenAccount),
10519                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenAccount,
10520                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenAccount,
10521                 (ndr_print_function_t) ndr_print_lsa_OpenAccount,
10522                 False,
10523         },
10524         {
10525                 "lsa_EnumPrivsAccount",
10526                 sizeof(struct lsa_EnumPrivsAccount),
10527                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumPrivsAccount,
10528                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumPrivsAccount,
10529                 (ndr_print_function_t) ndr_print_lsa_EnumPrivsAccount,
10530                 False,
10531         },
10532         {
10533                 "lsa_AddPrivilegesToAccount",
10534                 sizeof(struct lsa_AddPrivilegesToAccount),
10535                 (ndr_push_flags_fn_t) ndr_push_lsa_AddPrivilegesToAccount,
10536                 (ndr_pull_flags_fn_t) ndr_pull_lsa_AddPrivilegesToAccount,
10537                 (ndr_print_function_t) ndr_print_lsa_AddPrivilegesToAccount,
10538                 False,
10539         },
10540         {
10541                 "lsa_RemovePrivilegesFromAccount",
10542                 sizeof(struct lsa_RemovePrivilegesFromAccount),
10543                 (ndr_push_flags_fn_t) ndr_push_lsa_RemovePrivilegesFromAccount,
10544                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RemovePrivilegesFromAccount,
10545                 (ndr_print_function_t) ndr_print_lsa_RemovePrivilegesFromAccount,
10546                 False,
10547         },
10548         {
10549                 "lsa_GetQuotasForAccount",
10550                 sizeof(struct lsa_GetQuotasForAccount),
10551                 (ndr_push_flags_fn_t) ndr_push_lsa_GetQuotasForAccount,
10552                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetQuotasForAccount,
10553                 (ndr_print_function_t) ndr_print_lsa_GetQuotasForAccount,
10554                 False,
10555         },
10556         {
10557                 "lsa_SetQuotasForAccount",
10558                 sizeof(struct lsa_SetQuotasForAccount),
10559                 (ndr_push_flags_fn_t) ndr_push_lsa_SetQuotasForAccount,
10560                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetQuotasForAccount,
10561                 (ndr_print_function_t) ndr_print_lsa_SetQuotasForAccount,
10562                 False,
10563         },
10564         {
10565                 "lsa_GetSystemAccessAccount",
10566                 sizeof(struct lsa_GetSystemAccessAccount),
10567                 (ndr_push_flags_fn_t) ndr_push_lsa_GetSystemAccessAccount,
10568                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetSystemAccessAccount,
10569                 (ndr_print_function_t) ndr_print_lsa_GetSystemAccessAccount,
10570                 False,
10571         },
10572         {
10573                 "lsa_SetSystemAccessAccount",
10574                 sizeof(struct lsa_SetSystemAccessAccount),
10575                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSystemAccessAccount,
10576                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSystemAccessAccount,
10577                 (ndr_print_function_t) ndr_print_lsa_SetSystemAccessAccount,
10578                 False,
10579         },
10580         {
10581                 "lsa_OpenTrustedDomain",
10582                 sizeof(struct lsa_OpenTrustedDomain),
10583                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenTrustedDomain,
10584                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenTrustedDomain,
10585                 (ndr_print_function_t) ndr_print_lsa_OpenTrustedDomain,
10586                 False,
10587         },
10588         {
10589                 "lsa_QueryTrustedDomainInfo",
10590                 sizeof(struct lsa_QueryTrustedDomainInfo),
10591                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfo,
10592                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfo,
10593                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfo,
10594                 False,
10595         },
10596         {
10597                 "lsa_SetInformationTrustedDomain",
10598                 sizeof(struct lsa_SetInformationTrustedDomain),
10599                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInformationTrustedDomain,
10600                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInformationTrustedDomain,
10601                 (ndr_print_function_t) ndr_print_lsa_SetInformationTrustedDomain,
10602                 False,
10603         },
10604         {
10605                 "lsa_OpenSecret",
10606                 sizeof(struct lsa_OpenSecret),
10607                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenSecret,
10608                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenSecret,
10609                 (ndr_print_function_t) ndr_print_lsa_OpenSecret,
10610                 False,
10611         },
10612         {
10613                 "lsa_SetSecret",
10614                 sizeof(struct lsa_SetSecret),
10615                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSecret,
10616                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSecret,
10617                 (ndr_print_function_t) ndr_print_lsa_SetSecret,
10618                 False,
10619         },
10620         {
10621                 "lsa_QuerySecret",
10622                 sizeof(struct lsa_QuerySecret),
10623                 (ndr_push_flags_fn_t) ndr_push_lsa_QuerySecret,
10624                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QuerySecret,
10625                 (ndr_print_function_t) ndr_print_lsa_QuerySecret,
10626                 False,
10627         },
10628         {
10629                 "lsa_LookupPrivValue",
10630                 sizeof(struct lsa_LookupPrivValue),
10631                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivValue,
10632                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivValue,
10633                 (ndr_print_function_t) ndr_print_lsa_LookupPrivValue,
10634                 False,
10635         },
10636         {
10637                 "lsa_LookupPrivName",
10638                 sizeof(struct lsa_LookupPrivName),
10639                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivName,
10640                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivName,
10641                 (ndr_print_function_t) ndr_print_lsa_LookupPrivName,
10642                 False,
10643         },
10644         {
10645                 "lsa_LookupPrivDisplayName",
10646                 sizeof(struct lsa_LookupPrivDisplayName),
10647                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivDisplayName,
10648                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivDisplayName,
10649                 (ndr_print_function_t) ndr_print_lsa_LookupPrivDisplayName,
10650                 False,
10651         },
10652         {
10653                 "lsa_DeleteObject",
10654                 sizeof(struct lsa_DeleteObject),
10655                 (ndr_push_flags_fn_t) ndr_push_lsa_DeleteObject,
10656                 (ndr_pull_flags_fn_t) ndr_pull_lsa_DeleteObject,
10657                 (ndr_print_function_t) ndr_print_lsa_DeleteObject,
10658                 False,
10659         },
10660         {
10661                 "lsa_EnumAccountsWithUserRight",
10662                 sizeof(struct lsa_EnumAccountsWithUserRight),
10663                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccountsWithUserRight,
10664                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccountsWithUserRight,
10665                 (ndr_print_function_t) ndr_print_lsa_EnumAccountsWithUserRight,
10666                 False,
10667         },
10668         {
10669                 "lsa_EnumAccountRights",
10670                 sizeof(struct lsa_EnumAccountRights),
10671                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccountRights,
10672                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccountRights,
10673                 (ndr_print_function_t) ndr_print_lsa_EnumAccountRights,
10674                 False,
10675         },
10676         {
10677                 "lsa_AddAccountRights",
10678                 sizeof(struct lsa_AddAccountRights),
10679                 (ndr_push_flags_fn_t) ndr_push_lsa_AddAccountRights,
10680                 (ndr_pull_flags_fn_t) ndr_pull_lsa_AddAccountRights,
10681                 (ndr_print_function_t) ndr_print_lsa_AddAccountRights,
10682                 False,
10683         },
10684         {
10685                 "lsa_RemoveAccountRights",
10686                 sizeof(struct lsa_RemoveAccountRights),
10687                 (ndr_push_flags_fn_t) ndr_push_lsa_RemoveAccountRights,
10688                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RemoveAccountRights,
10689                 (ndr_print_function_t) ndr_print_lsa_RemoveAccountRights,
10690                 False,
10691         },
10692         {
10693                 "lsa_QueryTrustedDomainInfoBySid",
10694                 sizeof(struct lsa_QueryTrustedDomainInfoBySid),
10695                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfoBySid,
10696                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfoBySid,
10697                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfoBySid,
10698                 False,
10699         },
10700         {
10701                 "lsa_SetTrustedDomainInfo",
10702                 sizeof(struct lsa_SetTrustedDomainInfo),
10703                 (ndr_push_flags_fn_t) ndr_push_lsa_SetTrustedDomainInfo,
10704                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetTrustedDomainInfo,
10705                 (ndr_print_function_t) ndr_print_lsa_SetTrustedDomainInfo,
10706                 False,
10707         },
10708         {
10709                 "lsa_DeleteTrustedDomain",
10710                 sizeof(struct lsa_DeleteTrustedDomain),
10711                 (ndr_push_flags_fn_t) ndr_push_lsa_DeleteTrustedDomain,
10712                 (ndr_pull_flags_fn_t) ndr_pull_lsa_DeleteTrustedDomain,
10713                 (ndr_print_function_t) ndr_print_lsa_DeleteTrustedDomain,
10714                 False,
10715         },
10716         {
10717                 "lsa_StorePrivateData",
10718                 sizeof(struct lsa_StorePrivateData),
10719                 (ndr_push_flags_fn_t) ndr_push_lsa_StorePrivateData,
10720                 (ndr_pull_flags_fn_t) ndr_pull_lsa_StorePrivateData,
10721                 (ndr_print_function_t) ndr_print_lsa_StorePrivateData,
10722                 False,
10723         },
10724         {
10725                 "lsa_RetrievePrivateData",
10726                 sizeof(struct lsa_RetrievePrivateData),
10727                 (ndr_push_flags_fn_t) ndr_push_lsa_RetrievePrivateData,
10728                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RetrievePrivateData,
10729                 (ndr_print_function_t) ndr_print_lsa_RetrievePrivateData,
10730                 False,
10731         },
10732         {
10733                 "lsa_OpenPolicy2",
10734                 sizeof(struct lsa_OpenPolicy2),
10735                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenPolicy2,
10736                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenPolicy2,
10737                 (ndr_print_function_t) ndr_print_lsa_OpenPolicy2,
10738                 False,
10739         },
10740         {
10741                 "lsa_GetUserName",
10742                 sizeof(struct lsa_GetUserName),
10743                 (ndr_push_flags_fn_t) ndr_push_lsa_GetUserName,
10744                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetUserName,
10745                 (ndr_print_function_t) ndr_print_lsa_GetUserName,
10746                 False,
10747         },
10748         {
10749                 "lsa_QueryInfoPolicy2",
10750                 sizeof(struct lsa_QueryInfoPolicy2),
10751                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryInfoPolicy2,
10752                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryInfoPolicy2,
10753                 (ndr_print_function_t) ndr_print_lsa_QueryInfoPolicy2,
10754                 False,
10755         },
10756         {
10757                 "lsa_SetInfoPolicy2",
10758                 sizeof(struct lsa_SetInfoPolicy2),
10759                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInfoPolicy2,
10760                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInfoPolicy2,
10761                 (ndr_print_function_t) ndr_print_lsa_SetInfoPolicy2,
10762                 False,
10763         },
10764         {
10765                 "lsa_QueryTrustedDomainInfoByName",
10766                 sizeof(struct lsa_QueryTrustedDomainInfoByName),
10767                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfoByName,
10768                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfoByName,
10769                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfoByName,
10770                 False,
10771         },
10772         {
10773                 "lsa_SetTrustedDomainInfoByName",
10774                 sizeof(struct lsa_SetTrustedDomainInfoByName),
10775                 (ndr_push_flags_fn_t) ndr_push_lsa_SetTrustedDomainInfoByName,
10776                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetTrustedDomainInfoByName,
10777                 (ndr_print_function_t) ndr_print_lsa_SetTrustedDomainInfoByName,
10778                 False,
10779         },
10780         {
10781                 "lsa_EnumTrustedDomainsEx",
10782                 sizeof(struct lsa_EnumTrustedDomainsEx),
10783                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumTrustedDomainsEx,
10784                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumTrustedDomainsEx,
10785                 (ndr_print_function_t) ndr_print_lsa_EnumTrustedDomainsEx,
10786                 False,
10787         },
10788         {
10789                 "lsa_CreateTrustedDomainEx",
10790                 sizeof(struct lsa_CreateTrustedDomainEx),
10791                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomainEx,
10792                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomainEx,
10793                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomainEx,
10794                 False,
10795         },
10796         {
10797                 "lsa_CloseTrustedDomainEx",
10798                 sizeof(struct lsa_CloseTrustedDomainEx),
10799                 (ndr_push_flags_fn_t) ndr_push_lsa_CloseTrustedDomainEx,
10800                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CloseTrustedDomainEx,
10801                 (ndr_print_function_t) ndr_print_lsa_CloseTrustedDomainEx,
10802                 False,
10803         },
10804         {
10805                 "lsa_QueryDomainInformationPolicy",
10806                 sizeof(struct lsa_QueryDomainInformationPolicy),
10807                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryDomainInformationPolicy,
10808                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryDomainInformationPolicy,
10809                 (ndr_print_function_t) ndr_print_lsa_QueryDomainInformationPolicy,
10810                 False,
10811         },
10812         {
10813                 "lsa_SetDomainInformationPolicy",
10814                 sizeof(struct lsa_SetDomainInformationPolicy),
10815                 (ndr_push_flags_fn_t) ndr_push_lsa_SetDomainInformationPolicy,
10816                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetDomainInformationPolicy,
10817                 (ndr_print_function_t) ndr_print_lsa_SetDomainInformationPolicy,
10818                 False,
10819         },
10820         {
10821                 "lsa_OpenTrustedDomainByName",
10822                 sizeof(struct lsa_OpenTrustedDomainByName),
10823                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenTrustedDomainByName,
10824                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenTrustedDomainByName,
10825                 (ndr_print_function_t) ndr_print_lsa_OpenTrustedDomainByName,
10826                 False,
10827         },
10828         {
10829                 "lsa_TestCall",
10830                 sizeof(struct lsa_TestCall),
10831                 (ndr_push_flags_fn_t) ndr_push_lsa_TestCall,
10832                 (ndr_pull_flags_fn_t) ndr_pull_lsa_TestCall,
10833                 (ndr_print_function_t) ndr_print_lsa_TestCall,
10834                 False,
10835         },
10836         {
10837                 "lsa_LookupSids2",
10838                 sizeof(struct lsa_LookupSids2),
10839                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids2,
10840                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids2,
10841                 (ndr_print_function_t) ndr_print_lsa_LookupSids2,
10842                 False,
10843         },
10844         {
10845                 "lsa_LookupNames2",
10846                 sizeof(struct lsa_LookupNames2),
10847                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames2,
10848                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames2,
10849                 (ndr_print_function_t) ndr_print_lsa_LookupNames2,
10850                 False,
10851         },
10852         {
10853                 "lsa_CreateTrustedDomainEx2",
10854                 sizeof(struct lsa_CreateTrustedDomainEx2),
10855                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomainEx2,
10856                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomainEx2,
10857                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomainEx2,
10858                 False,
10859         },
10860         {
10861                 "lsa_CREDRWRITE",
10862                 sizeof(struct lsa_CREDRWRITE),
10863                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRWRITE,
10864                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRWRITE,
10865                 (ndr_print_function_t) ndr_print_lsa_CREDRWRITE,
10866                 False,
10867         },
10868         {
10869                 "lsa_CREDRREAD",
10870                 sizeof(struct lsa_CREDRREAD),
10871                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRREAD,
10872                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRREAD,
10873                 (ndr_print_function_t) ndr_print_lsa_CREDRREAD,
10874                 False,
10875         },
10876         {
10877                 "lsa_CREDRENUMERATE",
10878                 sizeof(struct lsa_CREDRENUMERATE),
10879                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRENUMERATE,
10880                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRENUMERATE,
10881                 (ndr_print_function_t) ndr_print_lsa_CREDRENUMERATE,
10882                 False,
10883         },
10884         {
10885                 "lsa_CREDRWRITEDOMAINCREDENTIALS",
10886                 sizeof(struct lsa_CREDRWRITEDOMAINCREDENTIALS),
10887                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRWRITEDOMAINCREDENTIALS,
10888                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRWRITEDOMAINCREDENTIALS,
10889                 (ndr_print_function_t) ndr_print_lsa_CREDRWRITEDOMAINCREDENTIALS,
10890                 False,
10891         },
10892         {
10893                 "lsa_CREDRREADDOMAINCREDENTIALS",
10894                 sizeof(struct lsa_CREDRREADDOMAINCREDENTIALS),
10895                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRREADDOMAINCREDENTIALS,
10896                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRREADDOMAINCREDENTIALS,
10897                 (ndr_print_function_t) ndr_print_lsa_CREDRREADDOMAINCREDENTIALS,
10898                 False,
10899         },
10900         {
10901                 "lsa_CREDRDELETE",
10902                 sizeof(struct lsa_CREDRDELETE),
10903                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRDELETE,
10904                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRDELETE,
10905                 (ndr_print_function_t) ndr_print_lsa_CREDRDELETE,
10906                 False,
10907         },
10908         {
10909                 "lsa_CREDRGETTARGETINFO",
10910                 sizeof(struct lsa_CREDRGETTARGETINFO),
10911                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRGETTARGETINFO,
10912                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRGETTARGETINFO,
10913                 (ndr_print_function_t) ndr_print_lsa_CREDRGETTARGETINFO,
10914                 False,
10915         },
10916         {
10917                 "lsa_CREDRPROFILELOADED",
10918                 sizeof(struct lsa_CREDRPROFILELOADED),
10919                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRPROFILELOADED,
10920                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRPROFILELOADED,
10921                 (ndr_print_function_t) ndr_print_lsa_CREDRPROFILELOADED,
10922                 False,
10923         },
10924         {
10925                 "lsa_LookupNames3",
10926                 sizeof(struct lsa_LookupNames3),
10927                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames3,
10928                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames3,
10929                 (ndr_print_function_t) ndr_print_lsa_LookupNames3,
10930                 False,
10931         },
10932         {
10933                 "lsa_CREDRGETSESSIONTYPES",
10934                 sizeof(struct lsa_CREDRGETSESSIONTYPES),
10935                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRGETSESSIONTYPES,
10936                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRGETSESSIONTYPES,
10937                 (ndr_print_function_t) ndr_print_lsa_CREDRGETSESSIONTYPES,
10938                 False,
10939         },
10940         {
10941                 "lsa_LSARREGISTERAUDITEVENT",
10942                 sizeof(struct lsa_LSARREGISTERAUDITEVENT),
10943                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARREGISTERAUDITEVENT,
10944                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARREGISTERAUDITEVENT,
10945                 (ndr_print_function_t) ndr_print_lsa_LSARREGISTERAUDITEVENT,
10946                 False,
10947         },
10948         {
10949                 "lsa_LSARGENAUDITEVENT",
10950                 sizeof(struct lsa_LSARGENAUDITEVENT),
10951                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARGENAUDITEVENT,
10952                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARGENAUDITEVENT,
10953                 (ndr_print_function_t) ndr_print_lsa_LSARGENAUDITEVENT,
10954                 False,
10955         },
10956         {
10957                 "lsa_LSARUNREGISTERAUDITEVENT",
10958                 sizeof(struct lsa_LSARUNREGISTERAUDITEVENT),
10959                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARUNREGISTERAUDITEVENT,
10960                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARUNREGISTERAUDITEVENT,
10961                 (ndr_print_function_t) ndr_print_lsa_LSARUNREGISTERAUDITEVENT,
10962                 False,
10963         },
10964         {
10965                 "lsa_LSARQUERYFORESTTRUSTINFORMATION",
10966                 sizeof(struct lsa_LSARQUERYFORESTTRUSTINFORMATION),
10967                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARQUERYFORESTTRUSTINFORMATION,
10968                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARQUERYFORESTTRUSTINFORMATION,
10969                 (ndr_print_function_t) ndr_print_lsa_LSARQUERYFORESTTRUSTINFORMATION,
10970                 False,
10971         },
10972         {
10973                 "lsa_LSARSETFORESTTRUSTINFORMATION",
10974                 sizeof(struct lsa_LSARSETFORESTTRUSTINFORMATION),
10975                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARSETFORESTTRUSTINFORMATION,
10976                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARSETFORESTTRUSTINFORMATION,
10977                 (ndr_print_function_t) ndr_print_lsa_LSARSETFORESTTRUSTINFORMATION,
10978                 False,
10979         },
10980         {
10981                 "lsa_CREDRRENAME",
10982                 sizeof(struct lsa_CREDRRENAME),
10983                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRRENAME,
10984                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRRENAME,
10985                 (ndr_print_function_t) ndr_print_lsa_CREDRRENAME,
10986                 False,
10987         },
10988         {
10989                 "lsa_LookupSids3",
10990                 sizeof(struct lsa_LookupSids3),
10991                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids3,
10992                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids3,
10993                 (ndr_print_function_t) ndr_print_lsa_LookupSids3,
10994                 False,
10995         },
10996         {
10997                 "lsa_LookupNames4",
10998                 sizeof(struct lsa_LookupNames4),
10999                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames4,
11000                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames4,
11001                 (ndr_print_function_t) ndr_print_lsa_LookupNames4,
11002                 False,
11003         },
11004         {
11005                 "lsa_LSAROPENPOLICYSCE",
11006                 sizeof(struct lsa_LSAROPENPOLICYSCE),
11007                 (ndr_push_flags_fn_t) ndr_push_lsa_LSAROPENPOLICYSCE,
11008                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSAROPENPOLICYSCE,
11009                 (ndr_print_function_t) ndr_print_lsa_LSAROPENPOLICYSCE,
11010                 False,
11011         },
11012         {
11013                 "lsa_LSARADTREGISTERSECURITYEVENTSOURCE",
11014                 sizeof(struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE),
11015                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
11016                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
11017                 (ndr_print_function_t) ndr_print_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
11018                 False,
11019         },
11020         {
11021                 "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE",
11022                 sizeof(struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE),
11023                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
11024                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
11025                 (ndr_print_function_t) ndr_print_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
11026                 False,
11027         },
11028         {
11029                 "lsa_LSARADTREPORTSECURITYEVENT",
11030                 sizeof(struct lsa_LSARADTREPORTSECURITYEVENT),
11031                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTREPORTSECURITYEVENT,
11032                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTREPORTSECURITYEVENT,
11033                 (ndr_print_function_t) ndr_print_lsa_LSARADTREPORTSECURITYEVENT,
11034                 False,
11035         },
11036         { NULL, 0, NULL, NULL, NULL, False }
11037 };
11038
11039 const char * const lsarpc_endpoint_strings[] = {
11040         "ncacn_np:[\\pipe\\lsarpc]",
11041         "ncacn_np:[\\pipe\\netlogon]",
11042         "ncacn_np:[\\pipe\\lsass]",
11043         "ncacn_ip_tcp:",
11044         "ncalrpc:",
11045 };
11046
11047 const struct ndr_interface_string_array lsarpc_endpoints = {
11048         .count  = 5,
11049         .names  = lsarpc_endpoint_strings
11050 };
11051
11052 const char * const lsarpc_authservice_strings[] = {
11053         "host",
11054 };
11055
11056 const struct ndr_interface_string_array lsarpc_authservices = {
11057         .count  = 5,
11058         .names  = lsarpc_authservice_strings
11059 };
11060
11061
11062 const struct dcerpc_interface_table dcerpc_table_lsarpc = {
11063         .name           = "lsarpc",
11064         .syntax_id      = {
11065                 {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
11066                 DCERPC_LSARPC_VERSION
11067         },
11068         .helpstring     = DCERPC_LSARPC_HELPSTRING,
11069         .num_calls      = 82,
11070         .calls          = lsarpc_calls,
11071         .endpoints      = &lsarpc_endpoints,
11072         .authservices   = &lsarpc_authservices
11073 };
11074