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