source/librpc/gen_ndr/ndr_lsa.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_lsa.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 _PUBLIC_ enum ndr_err_code ndr_push_lsa_String(struct ndr_push *ndr, int ndr_flags, const struct lsa_String *r)
   8 {
   9         if (ndr_flags & NDR_SCALARS) {
  10                 NDR_CHECK(ndr_push_align(ndr, 4));
  11                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  12                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  13                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
  14         }
  15         if (ndr_flags & NDR_BUFFERS) {
  16                 if (r->string) {
  17                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m(r->string) / 2));
  18                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  19                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m(r->string) / 2));
  20                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, 2 * strlen_m(r->string) / 2, sizeof(uint16_t), CH_UTF16));
  21                 }
  22         }
  23         return NDR_ERR_SUCCESS;
  24 }
  25
  26 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_String(struct ndr_pull *ndr, int ndr_flags, struct lsa_String *r)
  27 {
  28         uint32_t _ptr_string;
  29         TALLOC_CTX *_mem_save_string_0;
  30         if (ndr_flags & NDR_SCALARS) {
  31                 NDR_CHECK(ndr_pull_align(ndr, 4));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
  34                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
  35                 if (_ptr_string) {
  36                         NDR_PULL_ALLOC(ndr, r->string);
  37                 } else {
  38                         r->string = NULL;
  39                 }
  40         }
  41         if (ndr_flags & NDR_BUFFERS) {
  42                 if (r->string) {
  43                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
  44                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
  45                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
  46                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
  47                         if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
  48                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string), ndr_get_array_length(ndr, &r->string));
  49                         }
  50                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
  51                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
  52                 }
  53                 if (r->string) {
  54                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
  55                 }
  56                 if (r->string) {
  57                         NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->string, r->length / 2));
  58                 }
  59         }
  60         return NDR_ERR_SUCCESS;
  61 }
  62
  63 _PUBLIC_ void ndr_print_lsa_String(struct ndr_print *ndr, const char *name, const struct lsa_String *r)
  64 {
  65         ndr_print_struct(ndr, name, "lsa_String");
  66         ndr->depth++;
  67         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->length);
  68         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->size);
  69         ndr_print_ptr(ndr, "string", r->string);
  70         ndr->depth++;
  71         if (r->string) {
  72                 ndr_print_string(ndr, "string", r->string);
  73         }
  74         ndr->depth--;
  75         ndr->depth--;
  76 }
  77
  78 _PUBLIC_ enum ndr_err_code ndr_push_lsa_StringLarge(struct ndr_push *ndr, int ndr_flags, const struct lsa_StringLarge *r)
  79 {
  80         if (ndr_flags & NDR_SCALARS) {
  81                 NDR_CHECK(ndr_push_align(ndr, 4));
  82                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
  83                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * (strlen_m(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                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
 225                                 ndr_print_lsa_String(ndr, "names", &r->names[cntr_names_1]);
 226                                 free(idx_1);
 227                         }
 228                 }
 229                 ndr->depth--;
 230         }
 231         ndr->depth--;
 232         ndr->depth--;
 233 }
 234
 235 _PUBLIC_ enum ndr_err_code ndr_push_lsa_AsciiString(struct ndr_push *ndr, int ndr_flags, const struct lsa_AsciiString *r)
 236 {
 237         if (ndr_flags & NDR_SCALARS) {
 238                 NDR_CHECK(ndr_push_align(ndr, 4));
 239                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->string)));
 240                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->string)));
 241                 {
 242                         uint32_t _flags_save_string = ndr->flags;
 243                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_LEN4);
 244                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
 245                         ndr->flags = _flags_save_string;
 246                 }
 247         }
 248         if (ndr_flags & NDR_BUFFERS) {
 249                 {
 250                         uint32_t _flags_save_string = ndr->flags;
 251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_LEN4);
 252                         if (r->string) {
 253                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
 254                         }
 255                         ndr->flags = _flags_save_string;
 256                 }
 257         }
 258         return NDR_ERR_SUCCESS;
 259 }
 260
 261 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_AsciiString(struct ndr_pull *ndr, int ndr_flags, struct lsa_AsciiString *r)
 262 {
 263         uint32_t _ptr_string;
 264         TALLOC_CTX *_mem_save_string_0;
 265         if (ndr_flags & NDR_SCALARS) {
 266                 NDR_CHECK(ndr_pull_align(ndr, 4));
 267                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 268                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 269                 {
 270                         uint32_t _flags_save_string = ndr->flags;
 271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_LEN4);
 272                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
 273                         if (_ptr_string) {
 274                                 NDR_PULL_ALLOC(ndr, r->string);
 275                         } else {
 276                                 r->string = NULL;
 277                         }
 278                         ndr->flags = _flags_save_string;
 279                 }
 280         }
 281         if (ndr_flags & NDR_BUFFERS) {
 282                 {
 283                         uint32_t _flags_save_string = ndr->flags;
 284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_LEN4);
 285                         if (r->string) {
 286                                 _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
 287                                 NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
 288                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
 289                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
 290                         }
 291                         ndr->flags = _flags_save_string;
 292                 }
 293         }
 294         return NDR_ERR_SUCCESS;
 295 }
 296
 297 _PUBLIC_ void ndr_print_lsa_AsciiString(struct ndr_print *ndr, const char *name, const struct lsa_AsciiString *r)
 298 {
 299         ndr_print_struct(ndr, name, "lsa_AsciiString");
 300         ndr->depth++;
 301         ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->length);
 302         ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->size);
 303         ndr_print_ptr(ndr, "string", r->string);
 304         ndr->depth++;
 305         if (r->string) {
 306                 ndr_print_string(ndr, "string", r->string);
 307         }
 308         ndr->depth--;
 309         ndr->depth--;
 310 }
 311
 312 static enum ndr_err_code ndr_push_lsa_LUID(struct ndr_push *ndr, int ndr_flags, const struct lsa_LUID *r)
 313 {
 314         if (ndr_flags & NDR_SCALARS) {
 315                 NDR_CHECK(ndr_push_align(ndr, 4));
 316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->low));
 317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high));
 318         }
 319         if (ndr_flags & NDR_BUFFERS) {
 320         }
 321         return NDR_ERR_SUCCESS;
 322 }
 323
 324 static enum ndr_err_code ndr_pull_lsa_LUID(struct ndr_pull *ndr, int ndr_flags, struct lsa_LUID *r)
 325 {
 326         if (ndr_flags & NDR_SCALARS) {
 327                 NDR_CHECK(ndr_pull_align(ndr, 4));
 328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->low));
 329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high));
 330         }
 331         if (ndr_flags & NDR_BUFFERS) {
 332         }
 333         return NDR_ERR_SUCCESS;
 334 }
 335
 336 _PUBLIC_ void ndr_print_lsa_LUID(struct ndr_print *ndr, const char *name, const struct lsa_LUID *r)
 337 {
 338         ndr_print_struct(ndr, name, "lsa_LUID");
 339         ndr->depth++;
 340         ndr_print_uint32(ndr, "low", r->low);
 341         ndr_print_uint32(ndr, "high", r->high);
 342         ndr->depth--;
 343 }
 344
 345 static enum ndr_err_code ndr_push_lsa_PrivEntry(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivEntry *r)
 346 {
 347         if (ndr_flags & NDR_SCALARS) {
 348                 NDR_CHECK(ndr_push_align(ndr, 4));
 349                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 350                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
 351         }
 352         if (ndr_flags & NDR_BUFFERS) {
 353                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 354         }
 355         return NDR_ERR_SUCCESS;
 356 }
 357
 358 static enum ndr_err_code ndr_pull_lsa_PrivEntry(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivEntry *r)
 359 {
 360         if (ndr_flags & NDR_SCALARS) {
 361                 NDR_CHECK(ndr_pull_align(ndr, 4));
 362                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 363                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
 364         }
 365         if (ndr_flags & NDR_BUFFERS) {
 366                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 367         }
 368         return NDR_ERR_SUCCESS;
 369 }
 370
 371 _PUBLIC_ void ndr_print_lsa_PrivEntry(struct ndr_print *ndr, const char *name, const struct lsa_PrivEntry *r)
 372 {
 373         ndr_print_struct(ndr, name, "lsa_PrivEntry");
 374         ndr->depth++;
 375         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
 376         ndr_print_lsa_LUID(ndr, "luid", &r->luid);
 377         ndr->depth--;
 378 }
 379
 380 static enum ndr_err_code ndr_push_lsa_PrivArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivArray *r)
 381 {
 382         uint32_t cntr_privs_1;
 383         if (ndr_flags & NDR_SCALARS) {
 384                 NDR_CHECK(ndr_push_align(ndr, 4));
 385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->privs));
 387         }
 388         if (ndr_flags & NDR_BUFFERS) {
 389                 if (r->privs) {
 390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 391                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 392                                 NDR_CHECK(ndr_push_lsa_PrivEntry(ndr, NDR_SCALARS, &r->privs[cntr_privs_1]));
 393                         }
 394                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 395                                 NDR_CHECK(ndr_push_lsa_PrivEntry(ndr, NDR_BUFFERS, &r->privs[cntr_privs_1]));
 396                         }
 397                 }
 398         }
 399         return NDR_ERR_SUCCESS;
 400 }
 401
 402 static enum ndr_err_code ndr_pull_lsa_PrivArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivArray *r)
 403 {
 404         uint32_t _ptr_privs;
 405         uint32_t cntr_privs_1;
 406         TALLOC_CTX *_mem_save_privs_0;
 407         TALLOC_CTX *_mem_save_privs_1;
 408         if (ndr_flags & NDR_SCALARS) {
 409                 NDR_CHECK(ndr_pull_align(ndr, 4));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 411                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
 412                 if (_ptr_privs) {
 413                         NDR_PULL_ALLOC(ndr, r->privs);
 414                 } else {
 415                         r->privs = NULL;
 416                 }
 417         }
 418         if (ndr_flags & NDR_BUFFERS) {
 419                 if (r->privs) {
 420                         _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
 421                         NDR_PULL_SET_MEM_CTX(ndr, r->privs, 0);
 422                         NDR_CHECK(ndr_pull_array_size(ndr, &r->privs));
 423                         NDR_PULL_ALLOC_N(ndr, r->privs, ndr_get_array_size(ndr, &r->privs));
 424                         _mem_save_privs_1 = NDR_PULL_GET_MEM_CTX(ndr);
 425                         NDR_PULL_SET_MEM_CTX(ndr, r->privs, 0);
 426                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 427                                 NDR_CHECK(ndr_pull_lsa_PrivEntry(ndr, NDR_SCALARS, &r->privs[cntr_privs_1]));
 428                         }
 429                         for (cntr_privs_1 = 0; cntr_privs_1 < r->count; cntr_privs_1++) {
 430                                 NDR_CHECK(ndr_pull_lsa_PrivEntry(ndr, NDR_BUFFERS, &r->privs[cntr_privs_1]));
 431                         }
 432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_1, 0);
 433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, 0);
 434                 }
 435                 if (r->privs) {
 436                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->privs, r->count));
 437                 }
 438         }
 439         return NDR_ERR_SUCCESS;
 440 }
 441
 442 _PUBLIC_ void ndr_print_lsa_PrivArray(struct ndr_print *ndr, const char *name, const struct lsa_PrivArray *r)
 443 {
 444         uint32_t cntr_privs_1;
 445         ndr_print_struct(ndr, name, "lsa_PrivArray");
 446         ndr->depth++;
 447         ndr_print_uint32(ndr, "count", r->count);
 448         ndr_print_ptr(ndr, "privs", r->privs);
 449         ndr->depth++;
 450         if (r->privs) {
 451                 ndr->print(ndr, "%s: ARRAY(%d)", "privs", r->count);
 452                 ndr->depth++;
 453                 for (cntr_privs_1=0;cntr_privs_1<r->count;cntr_privs_1++) {
 454                         char *idx_1=NULL;
 455                         if (asprintf(&idx_1, "[%d]", cntr_privs_1) != -1) {
 456                                 ndr_print_lsa_PrivEntry(ndr, "privs", &r->privs[cntr_privs_1]);
 457                                 free(idx_1);
 458                         }
 459                 }
 460                 ndr->depth--;
 461         }
 462         ndr->depth--;
 463         ndr->depth--;
 464 }
 465
 466 static enum ndr_err_code ndr_push_lsa_QosInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_QosInfo *r)
 467 {
 468         if (ndr_flags & NDR_SCALARS) {
 469                 NDR_CHECK(ndr_push_align(ndr, 4));
 470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
 471                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->impersonation_level));
 472                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->context_mode));
 473                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->effective_only));
 474         }
 475         if (ndr_flags & NDR_BUFFERS) {
 476         }
 477         return NDR_ERR_SUCCESS;
 478 }
 479
 480 static enum ndr_err_code ndr_pull_lsa_QosInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_QosInfo *r)
 481 {
 482         if (ndr_flags & NDR_SCALARS) {
 483                 NDR_CHECK(ndr_pull_align(ndr, 4));
 484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
 485                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->impersonation_level));
 486                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->context_mode));
 487                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->effective_only));
 488         }
 489         if (ndr_flags & NDR_BUFFERS) {
 490         }
 491         return NDR_ERR_SUCCESS;
 492 }
 493
 494 _PUBLIC_ void ndr_print_lsa_QosInfo(struct ndr_print *ndr, const char *name, const struct lsa_QosInfo *r)
 495 {
 496         ndr_print_struct(ndr, name, "lsa_QosInfo");
 497         ndr->depth++;
 498         ndr_print_uint32(ndr, "len", r->len);
 499         ndr_print_uint16(ndr, "impersonation_level", r->impersonation_level);
 500         ndr_print_uint8(ndr, "context_mode", r->context_mode);
 501         ndr_print_uint8(ndr, "effective_only", r->effective_only);
 502         ndr->depth--;
 503 }
 504
 505 static enum ndr_err_code ndr_push_lsa_ObjectAttribute(struct ndr_push *ndr, int ndr_flags, const struct lsa_ObjectAttribute *r)
 506 {
 507         if (ndr_flags & NDR_SCALARS) {
 508                 NDR_CHECK(ndr_push_align(ndr, 4));
 509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
 510                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->root_dir));
 511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_name));
 512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attributes));
 513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sec_desc));
 514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sec_qos));
 515         }
 516         if (ndr_flags & NDR_BUFFERS) {
 517                 if (r->root_dir) {
 518                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->root_dir));
 519                 }
 520                 if (r->object_name) {
 521                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_name, CH_UTF16)));
 522                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 523                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->object_name, CH_UTF16)));
 524                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_name, ndr_charset_length(r->object_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 525                 }
 526                 if (r->sec_desc) {
 527                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sec_desc));
 528                 }
 529                 if (r->sec_qos) {
 530                         NDR_CHECK(ndr_push_lsa_QosInfo(ndr, NDR_SCALARS, r->sec_qos));
 531                 }
 532         }
 533         return NDR_ERR_SUCCESS;
 534 }
 535
 536 static enum ndr_err_code ndr_pull_lsa_ObjectAttribute(struct ndr_pull *ndr, int ndr_flags, struct lsa_ObjectAttribute *r)
 537 {
 538         uint32_t _ptr_root_dir;
 539         TALLOC_CTX *_mem_save_root_dir_0;
 540         uint32_t _ptr_object_name;
 541         TALLOC_CTX *_mem_save_object_name_0;
 542         uint32_t _ptr_sec_desc;
 543         TALLOC_CTX *_mem_save_sec_desc_0;
 544         uint32_t _ptr_sec_qos;
 545         TALLOC_CTX *_mem_save_sec_qos_0;
 546         if (ndr_flags & NDR_SCALARS) {
 547                 NDR_CHECK(ndr_pull_align(ndr, 4));
 548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
 549                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_root_dir));
 550                 if (_ptr_root_dir) {
 551                         NDR_PULL_ALLOC(ndr, r->root_dir);
 552                 } else {
 553                         r->root_dir = NULL;
 554                 }
 555                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_name));
 556                 if (_ptr_object_name) {
 557                         NDR_PULL_ALLOC(ndr, r->object_name);
 558                 } else {
 559                         r->object_name = NULL;
 560                 }
 561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attributes));
 562                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_desc));
 563                 if (_ptr_sec_desc) {
 564                         NDR_PULL_ALLOC(ndr, r->sec_desc);
 565                 } else {
 566                         r->sec_desc = NULL;
 567                 }
 568                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_qos));
 569                 if (_ptr_sec_qos) {
 570                         NDR_PULL_ALLOC(ndr, r->sec_qos);
 571                 } else {
 572                         r->sec_qos = NULL;
 573                 }
 574         }
 575         if (ndr_flags & NDR_BUFFERS) {
 576                 if (r->root_dir) {
 577                         _mem_save_root_dir_0 = NDR_PULL_GET_MEM_CTX(ndr);
 578                         NDR_PULL_SET_MEM_CTX(ndr, r->root_dir, 0);
 579                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->root_dir));
 580                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_root_dir_0, 0);
 581                 }
 582                 if (r->object_name) {
 583                         _mem_save_object_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 584                         NDR_PULL_SET_MEM_CTX(ndr, r->object_name, 0);
 585                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_name));
 586                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_name));
 587                         if (ndr_get_array_length(ndr, &r->object_name) > ndr_get_array_size(ndr, &r->object_name)) {
 588                                 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));
 589                         }
 590                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_name), sizeof(uint16_t)));
 591                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_name, ndr_get_array_length(ndr, &r->object_name), sizeof(uint16_t), CH_UTF16));
 592                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_name_0, 0);
 593                 }
 594                 if (r->sec_desc) {
 595                         _mem_save_sec_desc_0 = NDR_PULL_GET_MEM_CTX(ndr);
 596                         NDR_PULL_SET_MEM_CTX(ndr, r->sec_desc, 0);
 597                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sec_desc));
 598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_desc_0, 0);
 599                 }
 600                 if (r->sec_qos) {
 601                         _mem_save_sec_qos_0 = NDR_PULL_GET_MEM_CTX(ndr);
 602                         NDR_PULL_SET_MEM_CTX(ndr, r->sec_qos, 0);
 603                         NDR_CHECK(ndr_pull_lsa_QosInfo(ndr, NDR_SCALARS, r->sec_qos));
 604                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_qos_0, 0);
 605                 }
 606         }
 607         return NDR_ERR_SUCCESS;
 608 }
 609
 610 _PUBLIC_ void ndr_print_lsa_ObjectAttribute(struct ndr_print *ndr, const char *name, const struct lsa_ObjectAttribute *r)
 611 {
 612         ndr_print_struct(ndr, name, "lsa_ObjectAttribute");
 613         ndr->depth++;
 614         ndr_print_uint32(ndr, "len", r->len);
 615         ndr_print_ptr(ndr, "root_dir", r->root_dir);
 616         ndr->depth++;
 617         if (r->root_dir) {
 618                 ndr_print_uint8(ndr, "root_dir", *r->root_dir);
 619         }
 620         ndr->depth--;
 621         ndr_print_ptr(ndr, "object_name", r->object_name);
 622         ndr->depth++;
 623         if (r->object_name) {
 624                 ndr_print_string(ndr, "object_name", r->object_name);
 625         }
 626         ndr->depth--;
 627         ndr_print_uint32(ndr, "attributes", r->attributes);
 628         ndr_print_ptr(ndr, "sec_desc", r->sec_desc);
 629         ndr->depth++;
 630         if (r->sec_desc) {
 631                 ndr_print_security_descriptor(ndr, "sec_desc", r->sec_desc);
 632         }
 633         ndr->depth--;
 634         ndr_print_ptr(ndr, "sec_qos", r->sec_qos);
 635         ndr->depth++;
 636         if (r->sec_qos) {
 637                 ndr_print_lsa_QosInfo(ndr, "sec_qos", r->sec_qos);
 638         }
 639         ndr->depth--;
 640         ndr->depth--;
 641 }
 642
 643 static enum ndr_err_code ndr_push_lsa_AuditLogInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditLogInfo *r)
 644 {
 645         if (ndr_flags & NDR_SCALARS) {
 646                 NDR_CHECK(ndr_push_align(ndr, 4));
 647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->percent_full));
 648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->log_size));
 649                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->retention_time));
 650                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_in_progress));
 651                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time_to_shutdown));
 652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_audit_record));
 653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
 654         }
 655         if (ndr_flags & NDR_BUFFERS) {
 656         }
 657         return NDR_ERR_SUCCESS;
 658 }
 659
 660 static enum ndr_err_code ndr_pull_lsa_AuditLogInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditLogInfo *r)
 661 {
 662         if (ndr_flags & NDR_SCALARS) {
 663                 NDR_CHECK(ndr_pull_align(ndr, 4));
 664                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->percent_full));
 665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->log_size));
 666                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->retention_time));
 667                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_in_progress));
 668                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time_to_shutdown));
 669                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_audit_record));
 670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
 671         }
 672         if (ndr_flags & NDR_BUFFERS) {
 673         }
 674         return NDR_ERR_SUCCESS;
 675 }
 676
 677 _PUBLIC_ void ndr_print_lsa_AuditLogInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditLogInfo *r)
 678 {
 679         ndr_print_struct(ndr, name, "lsa_AuditLogInfo");
 680         ndr->depth++;
 681         ndr_print_uint32(ndr, "percent_full", r->percent_full);
 682         ndr_print_uint32(ndr, "log_size", r->log_size);
 683         ndr_print_NTTIME(ndr, "retention_time", r->retention_time);
 684         ndr_print_uint8(ndr, "shutdown_in_progress", r->shutdown_in_progress);
 685         ndr_print_NTTIME(ndr, "time_to_shutdown", r->time_to_shutdown);
 686         ndr_print_uint32(ndr, "next_audit_record", r->next_audit_record);
 687         ndr_print_uint32(ndr, "unknown", r->unknown);
 688         ndr->depth--;
 689 }
 690
 691 static enum ndr_err_code ndr_push_lsa_PolicyAuditPolicy(struct ndr_push *ndr, int ndr_flags, enum lsa_PolicyAuditPolicy r)
 692 {
 693         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 694         return NDR_ERR_SUCCESS;
 695 }
 696
 697 static enum ndr_err_code ndr_pull_lsa_PolicyAuditPolicy(struct ndr_pull *ndr, int ndr_flags, enum lsa_PolicyAuditPolicy *r)
 698 {
 699         uint32_t v;
 700         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 701         *r = v;
 702         return NDR_ERR_SUCCESS;
 703 }
 704
 705 _PUBLIC_ void ndr_print_lsa_PolicyAuditPolicy(struct ndr_print *ndr, const char *name, enum lsa_PolicyAuditPolicy r)
 706 {
 707         const char *val = NULL;
 708
 709         switch (r) {
 710                 case LSA_AUDIT_POLICY_NONE: val = "LSA_AUDIT_POLICY_NONE"; break;
 711                 case LSA_AUDIT_POLICY_SUCCESS: val = "LSA_AUDIT_POLICY_SUCCESS"; break;
 712                 case LSA_AUDIT_POLICY_FAILURE: val = "LSA_AUDIT_POLICY_FAILURE"; break;
 713                 case LSA_AUDIT_POLICY_ALL: val = "LSA_AUDIT_POLICY_ALL"; break;
 714                 case LSA_AUDIT_POLICY_CLEAR: val = "LSA_AUDIT_POLICY_CLEAR"; break;
 715         }
 716         ndr_print_enum(ndr, name, "ENUM", val, r);
 717 }
 718
 719 static enum ndr_err_code ndr_push_lsa_AuditEventsInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditEventsInfo *r)
 720 {
 721         uint32_t cntr_settings_1;
 722         if (ndr_flags & NDR_SCALARS) {
 723                 NDR_CHECK(ndr_push_align(ndr, 4));
 724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auditing_mode));
 725                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->settings));
 726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 727         }
 728         if (ndr_flags & NDR_BUFFERS) {
 729                 if (r->settings) {
 730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 731                         for (cntr_settings_1 = 0; cntr_settings_1 < r->count; cntr_settings_1++) {
 732                                 NDR_CHECK(ndr_push_lsa_PolicyAuditPolicy(ndr, NDR_SCALARS, r->settings[cntr_settings_1]));
 733                         }
 734                 }
 735         }
 736         return NDR_ERR_SUCCESS;
 737 }
 738
 739 static enum ndr_err_code ndr_pull_lsa_AuditEventsInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditEventsInfo *r)
 740 {
 741         uint32_t _ptr_settings;
 742         uint32_t cntr_settings_1;
 743         TALLOC_CTX *_mem_save_settings_0;
 744         TALLOC_CTX *_mem_save_settings_1;
 745         if (ndr_flags & NDR_SCALARS) {
 746                 NDR_CHECK(ndr_pull_align(ndr, 4));
 747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auditing_mode));
 748                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_settings));
 749                 if (_ptr_settings) {
 750                         NDR_PULL_ALLOC(ndr, r->settings);
 751                 } else {
 752                         r->settings = NULL;
 753                 }
 754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 755         }
 756         if (ndr_flags & NDR_BUFFERS) {
 757                 if (r->settings) {
 758                         _mem_save_settings_0 = NDR_PULL_GET_MEM_CTX(ndr);
 759                         NDR_PULL_SET_MEM_CTX(ndr, r->settings, 0);
 760                         NDR_CHECK(ndr_pull_array_size(ndr, &r->settings));
 761                         NDR_PULL_ALLOC_N(ndr, r->settings, ndr_get_array_size(ndr, &r->settings));
 762                         _mem_save_settings_1 = NDR_PULL_GET_MEM_CTX(ndr);
 763                         NDR_PULL_SET_MEM_CTX(ndr, r->settings, 0);
 764                         for (cntr_settings_1 = 0; cntr_settings_1 < r->count; cntr_settings_1++) {
 765                                 NDR_CHECK(ndr_pull_lsa_PolicyAuditPolicy(ndr, NDR_SCALARS, &r->settings[cntr_settings_1]));
 766                         }
 767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_settings_1, 0);
 768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_settings_0, 0);
 769                 }
 770                 if (r->settings) {
 771                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->settings, r->count));
 772                 }
 773         }
 774         return NDR_ERR_SUCCESS;
 775 }
 776
 777 _PUBLIC_ void ndr_print_lsa_AuditEventsInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditEventsInfo *r)
 778 {
 779         uint32_t cntr_settings_1;
 780         ndr_print_struct(ndr, name, "lsa_AuditEventsInfo");
 781         ndr->depth++;
 782         ndr_print_uint32(ndr, "auditing_mode", r->auditing_mode);
 783         ndr_print_ptr(ndr, "settings", r->settings);
 784         ndr->depth++;
 785         if (r->settings) {
 786                 ndr->print(ndr, "%s: ARRAY(%d)", "settings", r->count);
 787                 ndr->depth++;
 788                 for (cntr_settings_1=0;cntr_settings_1<r->count;cntr_settings_1++) {
 789                         char *idx_1=NULL;
 790                         if (asprintf(&idx_1, "[%d]", cntr_settings_1) != -1) {
 791                                 ndr_print_lsa_PolicyAuditPolicy(ndr, "settings", r->settings[cntr_settings_1]);
 792                                 free(idx_1);
 793                         }
 794                 }
 795                 ndr->depth--;
 796         }
 797         ndr->depth--;
 798         ndr_print_uint32(ndr, "count", r->count);
 799         ndr->depth--;
 800 }
 801
 802 static enum ndr_err_code ndr_push_lsa_DomainInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfo *r)
 803 {
 804         if (ndr_flags & NDR_SCALARS) {
 805                 NDR_CHECK(ndr_push_align(ndr, 4));
 806                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 807                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
 808         }
 809         if (ndr_flags & NDR_BUFFERS) {
 810                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 811                 if (r->sid) {
 812                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 813                 }
 814         }
 815         return NDR_ERR_SUCCESS;
 816 }
 817
 818 static enum ndr_err_code ndr_pull_lsa_DomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfo *r)
 819 {
 820         uint32_t _ptr_sid;
 821         TALLOC_CTX *_mem_save_sid_0;
 822         if (ndr_flags & NDR_SCALARS) {
 823                 NDR_CHECK(ndr_pull_align(ndr, 4));
 824                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
 825                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
 826                 if (_ptr_sid) {
 827                         NDR_PULL_ALLOC(ndr, r->sid);
 828                 } else {
 829                         r->sid = NULL;
 830                 }
 831         }
 832         if (ndr_flags & NDR_BUFFERS) {
 833                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
 834                 if (r->sid) {
 835                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 836                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
 837                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
 838                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
 839                 }
 840         }
 841         return NDR_ERR_SUCCESS;
 842 }
 843
 844 _PUBLIC_ void ndr_print_lsa_DomainInfo(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfo *r)
 845 {
 846         ndr_print_struct(ndr, name, "lsa_DomainInfo");
 847         ndr->depth++;
 848         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
 849         ndr_print_ptr(ndr, "sid", r->sid);
 850         ndr->depth++;
 851         if (r->sid) {
 852                 ndr_print_dom_sid2(ndr, "sid", r->sid);
 853         }
 854         ndr->depth--;
 855         ndr->depth--;
 856 }
 857
 858 static enum ndr_err_code ndr_push_lsa_PDAccountInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_PDAccountInfo *r)
 859 {
 860         if (ndr_flags & NDR_SCALARS) {
 861                 NDR_CHECK(ndr_push_align(ndr, 4));
 862                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
 863         }
 864         if (ndr_flags & NDR_BUFFERS) {
 865                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
 866         }
 867         return NDR_ERR_SUCCESS;
 868 }
 869
 870 static enum ndr_err_code ndr_pull_lsa_PDAccountInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_PDAccountInfo *r)
 871 {
 872         if (ndr_flags & NDR_SCALARS) {
 873                 NDR_CHECK(ndr_pull_align(ndr, 4));
 874                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
 875         }
 876         if (ndr_flags & NDR_BUFFERS) {
 877                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
 878         }
 879         return NDR_ERR_SUCCESS;
 880 }
 881
 882 _PUBLIC_ void ndr_print_lsa_PDAccountInfo(struct ndr_print *ndr, const char *name, const struct lsa_PDAccountInfo *r)
 883 {
 884         ndr_print_struct(ndr, name, "lsa_PDAccountInfo");
 885         ndr->depth++;
 886         ndr_print_lsa_String(ndr, "name", &r->name);
 887         ndr->depth--;
 888 }
 889
 890 static enum ndr_err_code ndr_push_lsa_ServerRole(struct ndr_push *ndr, int ndr_flags, const struct lsa_ServerRole *r)
 891 {
 892         if (ndr_flags & NDR_SCALARS) {
 893                 NDR_CHECK(ndr_push_align(ndr, 2));
 894                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown));
 895                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->role));
 896         }
 897         if (ndr_flags & NDR_BUFFERS) {
 898         }
 899         return NDR_ERR_SUCCESS;
 900 }
 901
 902 static enum ndr_err_code ndr_pull_lsa_ServerRole(struct ndr_pull *ndr, int ndr_flags, struct lsa_ServerRole *r)
 903 {
 904         if (ndr_flags & NDR_SCALARS) {
 905                 NDR_CHECK(ndr_pull_align(ndr, 2));
 906                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown));
 907                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->role));
 908         }
 909         if (ndr_flags & NDR_BUFFERS) {
 910         }
 911         return NDR_ERR_SUCCESS;
 912 }
 913
 914 _PUBLIC_ void ndr_print_lsa_ServerRole(struct ndr_print *ndr, const char *name, const struct lsa_ServerRole *r)
 915 {
 916         ndr_print_struct(ndr, name, "lsa_ServerRole");
 917         ndr->depth++;
 918         ndr_print_uint16(ndr, "unknown", r->unknown);
 919         ndr_print_uint16(ndr, "role", r->role);
 920         ndr->depth--;
 921 }
 922
 923 static enum ndr_err_code ndr_push_lsa_ReplicaSourceInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_ReplicaSourceInfo *r)
 924 {
 925         if (ndr_flags & NDR_SCALARS) {
 926                 NDR_CHECK(ndr_push_align(ndr, 4));
 927                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->source));
 928                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->account));
 929         }
 930         if (ndr_flags & NDR_BUFFERS) {
 931                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->source));
 932                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->account));
 933         }
 934         return NDR_ERR_SUCCESS;
 935 }
 936
 937 static enum ndr_err_code ndr_pull_lsa_ReplicaSourceInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ReplicaSourceInfo *r)
 938 {
 939         if (ndr_flags & NDR_SCALARS) {
 940                 NDR_CHECK(ndr_pull_align(ndr, 4));
 941                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->source));
 942                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->account));
 943         }
 944         if (ndr_flags & NDR_BUFFERS) {
 945                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->source));
 946                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->account));
 947         }
 948         return NDR_ERR_SUCCESS;
 949 }
 950
 951 _PUBLIC_ void ndr_print_lsa_ReplicaSourceInfo(struct ndr_print *ndr, const char *name, const struct lsa_ReplicaSourceInfo *r)
 952 {
 953         ndr_print_struct(ndr, name, "lsa_ReplicaSourceInfo");
 954         ndr->depth++;
 955         ndr_print_lsa_String(ndr, "source", &r->source);
 956         ndr_print_lsa_String(ndr, "account", &r->account);
 957         ndr->depth--;
 958 }
 959
 960 static enum ndr_err_code ndr_push_lsa_DefaultQuotaInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DefaultQuotaInfo *r)
 961 {
 962         if (ndr_flags & NDR_SCALARS) {
 963                 NDR_CHECK(ndr_push_align(ndr, 8));
 964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->paged_pool));
 965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->non_paged_pool));
 966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->min_wss));
 967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_wss));
 968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pagefile));
 969                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown));
 970         }
 971         if (ndr_flags & NDR_BUFFERS) {
 972         }
 973         return NDR_ERR_SUCCESS;
 974 }
 975
 976 static enum ndr_err_code ndr_pull_lsa_DefaultQuotaInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DefaultQuotaInfo *r)
 977 {
 978         if (ndr_flags & NDR_SCALARS) {
 979                 NDR_CHECK(ndr_pull_align(ndr, 8));
 980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->paged_pool));
 981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->non_paged_pool));
 982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->min_wss));
 983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_wss));
 984                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pagefile));
 985                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown));
 986         }
 987         if (ndr_flags & NDR_BUFFERS) {
 988         }
 989         return NDR_ERR_SUCCESS;
 990 }
 991
 992 _PUBLIC_ void ndr_print_lsa_DefaultQuotaInfo(struct ndr_print *ndr, const char *name, const struct lsa_DefaultQuotaInfo *r)
 993 {
 994         ndr_print_struct(ndr, name, "lsa_DefaultQuotaInfo");
 995         ndr->depth++;
 996         ndr_print_uint32(ndr, "paged_pool", r->paged_pool);
 997         ndr_print_uint32(ndr, "non_paged_pool", r->non_paged_pool);
 998         ndr_print_uint32(ndr, "min_wss", r->min_wss);
 999         ndr_print_uint32(ndr, "max_wss", r->max_wss);
1000         ndr_print_uint32(ndr, "pagefile", r->pagefile);
1001         ndr_print_hyper(ndr, "unknown", r->unknown);
1002         ndr->depth--;
1003 }
1004
1005 static enum ndr_err_code ndr_push_lsa_ModificationInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_ModificationInfo *r)
1006 {
1007         if (ndr_flags & NDR_SCALARS) {
1008                 NDR_CHECK(ndr_push_align(ndr, 8));
1009                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->modified_id));
1010                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->db_create_time));
1011         }
1012         if (ndr_flags & NDR_BUFFERS) {
1013         }
1014         return NDR_ERR_SUCCESS;
1015 }
1016
1017 static enum ndr_err_code ndr_pull_lsa_ModificationInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ModificationInfo *r)
1018 {
1019         if (ndr_flags & NDR_SCALARS) {
1020                 NDR_CHECK(ndr_pull_align(ndr, 8));
1021                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->modified_id));
1022                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->db_create_time));
1023         }
1024         if (ndr_flags & NDR_BUFFERS) {
1025         }
1026         return NDR_ERR_SUCCESS;
1027 }
1028
1029 _PUBLIC_ void ndr_print_lsa_ModificationInfo(struct ndr_print *ndr, const char *name, const struct lsa_ModificationInfo *r)
1030 {
1031         ndr_print_struct(ndr, name, "lsa_ModificationInfo");
1032         ndr->depth++;
1033         ndr_print_hyper(ndr, "modified_id", r->modified_id);
1034         ndr_print_NTTIME(ndr, "db_create_time", r->db_create_time);
1035         ndr->depth--;
1036 }
1037
1038 static enum ndr_err_code ndr_push_lsa_AuditFullSetInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditFullSetInfo *r)
1039 {
1040         if (ndr_flags & NDR_SCALARS) {
1041                 NDR_CHECK(ndr_push_align(ndr, 1));
1042                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_on_full));
1043         }
1044         if (ndr_flags & NDR_BUFFERS) {
1045         }
1046         return NDR_ERR_SUCCESS;
1047 }
1048
1049 static enum ndr_err_code ndr_pull_lsa_AuditFullSetInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditFullSetInfo *r)
1050 {
1051         if (ndr_flags & NDR_SCALARS) {
1052                 NDR_CHECK(ndr_pull_align(ndr, 1));
1053                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_on_full));
1054         }
1055         if (ndr_flags & NDR_BUFFERS) {
1056         }
1057         return NDR_ERR_SUCCESS;
1058 }
1059
1060 _PUBLIC_ void ndr_print_lsa_AuditFullSetInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditFullSetInfo *r)
1061 {
1062         ndr_print_struct(ndr, name, "lsa_AuditFullSetInfo");
1063         ndr->depth++;
1064         ndr_print_uint8(ndr, "shutdown_on_full", r->shutdown_on_full);
1065         ndr->depth--;
1066 }
1067
1068 static enum ndr_err_code ndr_push_lsa_AuditFullQueryInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_AuditFullQueryInfo *r)
1069 {
1070         if (ndr_flags & NDR_SCALARS) {
1071                 NDR_CHECK(ndr_push_align(ndr, 2));
1072                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown));
1073                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->shutdown_on_full));
1074                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->log_is_full));
1075         }
1076         if (ndr_flags & NDR_BUFFERS) {
1077         }
1078         return NDR_ERR_SUCCESS;
1079 }
1080
1081 static enum ndr_err_code ndr_pull_lsa_AuditFullQueryInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditFullQueryInfo *r)
1082 {
1083         if (ndr_flags & NDR_SCALARS) {
1084                 NDR_CHECK(ndr_pull_align(ndr, 2));
1085                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown));
1086                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->shutdown_on_full));
1087                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->log_is_full));
1088         }
1089         if (ndr_flags & NDR_BUFFERS) {
1090         }
1091         return NDR_ERR_SUCCESS;
1092 }
1093
1094 _PUBLIC_ void ndr_print_lsa_AuditFullQueryInfo(struct ndr_print *ndr, const char *name, const struct lsa_AuditFullQueryInfo *r)
1095 {
1096         ndr_print_struct(ndr, name, "lsa_AuditFullQueryInfo");
1097         ndr->depth++;
1098         ndr_print_uint16(ndr, "unknown", r->unknown);
1099         ndr_print_uint8(ndr, "shutdown_on_full", r->shutdown_on_full);
1100         ndr_print_uint8(ndr, "log_is_full", r->log_is_full);
1101         ndr->depth--;
1102 }
1103
1104 static enum ndr_err_code ndr_push_lsa_DnsDomainInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_DnsDomainInfo *r)
1105 {
1106         if (ndr_flags & NDR_SCALARS) {
1107                 NDR_CHECK(ndr_push_align(ndr, 4));
1108                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
1109                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain));
1110                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_forest));
1111                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_guid));
1112                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
1113         }
1114         if (ndr_flags & NDR_BUFFERS) {
1115                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1116                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain));
1117                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_forest));
1118                 NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->domain_guid));
1119                 if (r->sid) {
1120                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1121                 }
1122         }
1123         return NDR_ERR_SUCCESS;
1124 }
1125
1126 static enum ndr_err_code ndr_pull_lsa_DnsDomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DnsDomainInfo *r)
1127 {
1128         uint32_t _ptr_sid;
1129         TALLOC_CTX *_mem_save_sid_0;
1130         if (ndr_flags & NDR_SCALARS) {
1131                 NDR_CHECK(ndr_pull_align(ndr, 4));
1132                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->name));
1133                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain));
1134                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_forest));
1135                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_guid));
1136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
1137                 if (_ptr_sid) {
1138                         NDR_PULL_ALLOC(ndr, r->sid);
1139                 } else {
1140                         r->sid = NULL;
1141                 }
1142         }
1143         if (ndr_flags & NDR_BUFFERS) {
1144                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1145                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain));
1146                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_forest));
1147                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->domain_guid));
1148                 if (r->sid) {
1149                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1150                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1151                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1152                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1153                 }
1154         }
1155         return NDR_ERR_SUCCESS;
1156 }
1157
1158 _PUBLIC_ void ndr_print_lsa_DnsDomainInfo(struct ndr_print *ndr, const char *name, const struct lsa_DnsDomainInfo *r)
1159 {
1160         ndr_print_struct(ndr, name, "lsa_DnsDomainInfo");
1161         ndr->depth++;
1162         ndr_print_lsa_StringLarge(ndr, "name", &r->name);
1163         ndr_print_lsa_StringLarge(ndr, "dns_domain", &r->dns_domain);
1164         ndr_print_lsa_StringLarge(ndr, "dns_forest", &r->dns_forest);
1165         ndr_print_GUID(ndr, "domain_guid", &r->domain_guid);
1166         ndr_print_ptr(ndr, "sid", r->sid);
1167         ndr->depth++;
1168         if (r->sid) {
1169                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1170         }
1171         ndr->depth--;
1172         ndr->depth--;
1173 }
1174
1175 static enum ndr_err_code ndr_push_lsa_PolicyInfo(struct ndr_push *ndr, int ndr_flags, enum lsa_PolicyInfo r)
1176 {
1177         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1178         return NDR_ERR_SUCCESS;
1179 }
1180
1181 static enum ndr_err_code ndr_pull_lsa_PolicyInfo(struct ndr_pull *ndr, int ndr_flags, enum lsa_PolicyInfo *r)
1182 {
1183         uint16_t v;
1184         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1185         *r = v;
1186         return NDR_ERR_SUCCESS;
1187 }
1188
1189 _PUBLIC_ void ndr_print_lsa_PolicyInfo(struct ndr_print *ndr, const char *name, enum lsa_PolicyInfo r)
1190 {
1191         const char *val = NULL;
1192
1193         switch (r) {
1194                 case LSA_POLICY_INFO_AUDIT_LOG: val = "LSA_POLICY_INFO_AUDIT_LOG"; break;
1195                 case LSA_POLICY_INFO_AUDIT_EVENTS: val = "LSA_POLICY_INFO_AUDIT_EVENTS"; break;
1196                 case LSA_POLICY_INFO_DOMAIN: val = "LSA_POLICY_INFO_DOMAIN"; break;
1197                 case LSA_POLICY_INFO_PD: val = "LSA_POLICY_INFO_PD"; break;
1198                 case LSA_POLICY_INFO_ACCOUNT_DOMAIN: val = "LSA_POLICY_INFO_ACCOUNT_DOMAIN"; break;
1199                 case LSA_POLICY_INFO_ROLE: val = "LSA_POLICY_INFO_ROLE"; break;
1200                 case LSA_POLICY_INFO_REPLICA: val = "LSA_POLICY_INFO_REPLICA"; break;
1201                 case LSA_POLICY_INFO_QUOTA: val = "LSA_POLICY_INFO_QUOTA"; break;
1202                 case LSA_POLICY_INFO_DB: val = "LSA_POLICY_INFO_DB"; break;
1203                 case LSA_POLICY_INFO_AUDIT_FULL_SET: val = "LSA_POLICY_INFO_AUDIT_FULL_SET"; break;
1204                 case LSA_POLICY_INFO_AUDIT_FULL_QUERY: val = "LSA_POLICY_INFO_AUDIT_FULL_QUERY"; break;
1205                 case LSA_POLICY_INFO_DNS: val = "LSA_POLICY_INFO_DNS"; break;
1206         }
1207         ndr_print_enum(ndr, name, "ENUM", val, r);
1208 }
1209
1210 static enum ndr_err_code ndr_push_lsa_PolicyInformation(struct ndr_push *ndr, int ndr_flags, const union lsa_PolicyInformation *r)
1211 {
1212         if (ndr_flags & NDR_SCALARS) {
1213                 int level = ndr_push_get_switch_value(ndr, r);
1214                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
1215                 switch (level) {
1216                         case LSA_POLICY_INFO_AUDIT_LOG: {
1217                                 NDR_CHECK(ndr_push_lsa_AuditLogInfo(ndr, NDR_SCALARS, &r->audit_log));
1218                         break; }
1219
1220                         case LSA_POLICY_INFO_AUDIT_EVENTS: {
1221                                 NDR_CHECK(ndr_push_lsa_AuditEventsInfo(ndr, NDR_SCALARS, &r->audit_events));
1222                         break; }
1223
1224                         case LSA_POLICY_INFO_DOMAIN: {
1225                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domain));
1226                         break; }
1227
1228                         case LSA_POLICY_INFO_PD: {
1229                                 NDR_CHECK(ndr_push_lsa_PDAccountInfo(ndr, NDR_SCALARS, &r->pd));
1230                         break; }
1231
1232                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN: {
1233                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->account_domain));
1234                         break; }
1235
1236                         case LSA_POLICY_INFO_ROLE: {
1237                                 NDR_CHECK(ndr_push_lsa_ServerRole(ndr, NDR_SCALARS, &r->role));
1238                         break; }
1239
1240                         case LSA_POLICY_INFO_REPLICA: {
1241                                 NDR_CHECK(ndr_push_lsa_ReplicaSourceInfo(ndr, NDR_SCALARS, &r->replica));
1242                         break; }
1243
1244                         case LSA_POLICY_INFO_QUOTA: {
1245                                 NDR_CHECK(ndr_push_lsa_DefaultQuotaInfo(ndr, NDR_SCALARS, &r->quota));
1246                         break; }
1247
1248                         case LSA_POLICY_INFO_DB: {
1249                                 NDR_CHECK(ndr_push_lsa_ModificationInfo(ndr, NDR_SCALARS, &r->db));
1250                         break; }
1251
1252                         case LSA_POLICY_INFO_AUDIT_FULL_SET: {
1253                                 NDR_CHECK(ndr_push_lsa_AuditFullSetInfo(ndr, NDR_SCALARS, &r->auditfullset));
1254                         break; }
1255
1256                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY: {
1257                                 NDR_CHECK(ndr_push_lsa_AuditFullQueryInfo(ndr, NDR_SCALARS, &r->auditfullquery));
1258                         break; }
1259
1260                         case LSA_POLICY_INFO_DNS: {
1261                                 NDR_CHECK(ndr_push_lsa_DnsDomainInfo(ndr, NDR_SCALARS, &r->dns));
1262                         break; }
1263
1264                         default:
1265                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1266                 }
1267         }
1268         if (ndr_flags & NDR_BUFFERS) {
1269                 int level = ndr_push_get_switch_value(ndr, r);
1270                 switch (level) {
1271                         case LSA_POLICY_INFO_AUDIT_LOG:
1272                         break;
1273
1274                         case LSA_POLICY_INFO_AUDIT_EVENTS:
1275                                 NDR_CHECK(ndr_push_lsa_AuditEventsInfo(ndr, NDR_BUFFERS, &r->audit_events));
1276                         break;
1277
1278                         case LSA_POLICY_INFO_DOMAIN:
1279                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domain));
1280                         break;
1281
1282                         case LSA_POLICY_INFO_PD:
1283                                 NDR_CHECK(ndr_push_lsa_PDAccountInfo(ndr, NDR_BUFFERS, &r->pd));
1284                         break;
1285
1286                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1287                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->account_domain));
1288                         break;
1289
1290                         case LSA_POLICY_INFO_ROLE:
1291                         break;
1292
1293                         case LSA_POLICY_INFO_REPLICA:
1294                                 NDR_CHECK(ndr_push_lsa_ReplicaSourceInfo(ndr, NDR_BUFFERS, &r->replica));
1295                         break;
1296
1297                         case LSA_POLICY_INFO_QUOTA:
1298                         break;
1299
1300                         case LSA_POLICY_INFO_DB:
1301                         break;
1302
1303                         case LSA_POLICY_INFO_AUDIT_FULL_SET:
1304                         break;
1305
1306                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1307                         break;
1308
1309                         case LSA_POLICY_INFO_DNS:
1310                                 NDR_CHECK(ndr_push_lsa_DnsDomainInfo(ndr, NDR_BUFFERS, &r->dns));
1311                         break;
1312
1313                         default:
1314                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1315                 }
1316         }
1317         return NDR_ERR_SUCCESS;
1318 }
1319
1320 static enum ndr_err_code ndr_pull_lsa_PolicyInformation(struct ndr_pull *ndr, int ndr_flags, union lsa_PolicyInformation *r)
1321 {
1322         int level;
1323         uint16_t _level;
1324         level = ndr_pull_get_switch_value(ndr, r);
1325         if (ndr_flags & NDR_SCALARS) {
1326                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
1327                 if (_level != level) {
1328                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
1329                 }
1330                 switch (level) {
1331                         case LSA_POLICY_INFO_AUDIT_LOG: {
1332                                 NDR_CHECK(ndr_pull_lsa_AuditLogInfo(ndr, NDR_SCALARS, &r->audit_log));
1333                         break; }
1334
1335                         case LSA_POLICY_INFO_AUDIT_EVENTS: {
1336                                 NDR_CHECK(ndr_pull_lsa_AuditEventsInfo(ndr, NDR_SCALARS, &r->audit_events));
1337                         break; }
1338
1339                         case LSA_POLICY_INFO_DOMAIN: {
1340                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domain));
1341                         break; }
1342
1343                         case LSA_POLICY_INFO_PD: {
1344                                 NDR_CHECK(ndr_pull_lsa_PDAccountInfo(ndr, NDR_SCALARS, &r->pd));
1345                         break; }
1346
1347                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN: {
1348                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->account_domain));
1349                         break; }
1350
1351                         case LSA_POLICY_INFO_ROLE: {
1352                                 NDR_CHECK(ndr_pull_lsa_ServerRole(ndr, NDR_SCALARS, &r->role));
1353                         break; }
1354
1355                         case LSA_POLICY_INFO_REPLICA: {
1356                                 NDR_CHECK(ndr_pull_lsa_ReplicaSourceInfo(ndr, NDR_SCALARS, &r->replica));
1357                         break; }
1358
1359                         case LSA_POLICY_INFO_QUOTA: {
1360                                 NDR_CHECK(ndr_pull_lsa_DefaultQuotaInfo(ndr, NDR_SCALARS, &r->quota));
1361                         break; }
1362
1363                         case LSA_POLICY_INFO_DB: {
1364                                 NDR_CHECK(ndr_pull_lsa_ModificationInfo(ndr, NDR_SCALARS, &r->db));
1365                         break; }
1366
1367                         case LSA_POLICY_INFO_AUDIT_FULL_SET: {
1368                                 NDR_CHECK(ndr_pull_lsa_AuditFullSetInfo(ndr, NDR_SCALARS, &r->auditfullset));
1369                         break; }
1370
1371                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY: {
1372                                 NDR_CHECK(ndr_pull_lsa_AuditFullQueryInfo(ndr, NDR_SCALARS, &r->auditfullquery));
1373                         break; }
1374
1375                         case LSA_POLICY_INFO_DNS: {
1376                                 NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_SCALARS, &r->dns));
1377                         break; }
1378
1379                         default:
1380                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1381                 }
1382         }
1383         if (ndr_flags & NDR_BUFFERS) {
1384                 switch (level) {
1385                         case LSA_POLICY_INFO_AUDIT_LOG:
1386                         break;
1387
1388                         case LSA_POLICY_INFO_AUDIT_EVENTS:
1389                                 NDR_CHECK(ndr_pull_lsa_AuditEventsInfo(ndr, NDR_BUFFERS, &r->audit_events));
1390                         break;
1391
1392                         case LSA_POLICY_INFO_DOMAIN:
1393                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domain));
1394                         break;
1395
1396                         case LSA_POLICY_INFO_PD:
1397                                 NDR_CHECK(ndr_pull_lsa_PDAccountInfo(ndr, NDR_BUFFERS, &r->pd));
1398                         break;
1399
1400                         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1401                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->account_domain));
1402                         break;
1403
1404                         case LSA_POLICY_INFO_ROLE:
1405                         break;
1406
1407                         case LSA_POLICY_INFO_REPLICA:
1408                                 NDR_CHECK(ndr_pull_lsa_ReplicaSourceInfo(ndr, NDR_BUFFERS, &r->replica));
1409                         break;
1410
1411                         case LSA_POLICY_INFO_QUOTA:
1412                         break;
1413
1414                         case LSA_POLICY_INFO_DB:
1415                         break;
1416
1417                         case LSA_POLICY_INFO_AUDIT_FULL_SET:
1418                         break;
1419
1420                         case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1421                         break;
1422
1423                         case LSA_POLICY_INFO_DNS:
1424                                 NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_BUFFERS, &r->dns));
1425                         break;
1426
1427                         default:
1428                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
1429                 }
1430         }
1431         return NDR_ERR_SUCCESS;
1432 }
1433
1434 _PUBLIC_ void ndr_print_lsa_PolicyInformation(struct ndr_print *ndr, const char *name, const union lsa_PolicyInformation *r)
1435 {
1436         int level;
1437         level = ndr_print_get_switch_value(ndr, r);
1438         ndr_print_union(ndr, name, level, "lsa_PolicyInformation");
1439         switch (level) {
1440                 case LSA_POLICY_INFO_AUDIT_LOG:
1441                         ndr_print_lsa_AuditLogInfo(ndr, "audit_log", &r->audit_log);
1442                 break;
1443
1444                 case LSA_POLICY_INFO_AUDIT_EVENTS:
1445                         ndr_print_lsa_AuditEventsInfo(ndr, "audit_events", &r->audit_events);
1446                 break;
1447
1448                 case LSA_POLICY_INFO_DOMAIN:
1449                         ndr_print_lsa_DomainInfo(ndr, "domain", &r->domain);
1450                 break;
1451
1452                 case LSA_POLICY_INFO_PD:
1453                         ndr_print_lsa_PDAccountInfo(ndr, "pd", &r->pd);
1454                 break;
1455
1456                 case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
1457                         ndr_print_lsa_DomainInfo(ndr, "account_domain", &r->account_domain);
1458                 break;
1459
1460                 case LSA_POLICY_INFO_ROLE:
1461                         ndr_print_lsa_ServerRole(ndr, "role", &r->role);
1462                 break;
1463
1464                 case LSA_POLICY_INFO_REPLICA:
1465                         ndr_print_lsa_ReplicaSourceInfo(ndr, "replica", &r->replica);
1466                 break;
1467
1468                 case LSA_POLICY_INFO_QUOTA:
1469                         ndr_print_lsa_DefaultQuotaInfo(ndr, "quota", &r->quota);
1470                 break;
1471
1472                 case LSA_POLICY_INFO_DB:
1473                         ndr_print_lsa_ModificationInfo(ndr, "db", &r->db);
1474                 break;
1475
1476                 case LSA_POLICY_INFO_AUDIT_FULL_SET:
1477                         ndr_print_lsa_AuditFullSetInfo(ndr, "auditfullset", &r->auditfullset);
1478                 break;
1479
1480                 case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
1481                         ndr_print_lsa_AuditFullQueryInfo(ndr, "auditfullquery", &r->auditfullquery);
1482                 break;
1483
1484                 case LSA_POLICY_INFO_DNS:
1485                         ndr_print_lsa_DnsDomainInfo(ndr, "dns", &r->dns);
1486                 break;
1487
1488                 default:
1489                         ndr_print_bad_level(ndr, name, level);
1490         }
1491 }
1492
1493 static enum ndr_err_code ndr_push_lsa_SidPtr(struct ndr_push *ndr, int ndr_flags, const struct lsa_SidPtr *r)
1494 {
1495         if (ndr_flags & NDR_SCALARS) {
1496                 NDR_CHECK(ndr_push_align(ndr, 4));
1497                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
1498         }
1499         if (ndr_flags & NDR_BUFFERS) {
1500                 if (r->sid) {
1501                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1502                 }
1503         }
1504         return NDR_ERR_SUCCESS;
1505 }
1506
1507 static enum ndr_err_code ndr_pull_lsa_SidPtr(struct ndr_pull *ndr, int ndr_flags, struct lsa_SidPtr *r)
1508 {
1509         uint32_t _ptr_sid;
1510         TALLOC_CTX *_mem_save_sid_0;
1511         if (ndr_flags & NDR_SCALARS) {
1512                 NDR_CHECK(ndr_pull_align(ndr, 4));
1513                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
1514                 if (_ptr_sid) {
1515                         NDR_PULL_ALLOC(ndr, r->sid);
1516                 } else {
1517                         r->sid = NULL;
1518                 }
1519         }
1520         if (ndr_flags & NDR_BUFFERS) {
1521                 if (r->sid) {
1522                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1523                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
1524                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
1526                 }
1527         }
1528         return NDR_ERR_SUCCESS;
1529 }
1530
1531 _PUBLIC_ void ndr_print_lsa_SidPtr(struct ndr_print *ndr, const char *name, const struct lsa_SidPtr *r)
1532 {
1533         ndr_print_struct(ndr, name, "lsa_SidPtr");
1534         ndr->depth++;
1535         ndr_print_ptr(ndr, "sid", r->sid);
1536         ndr->depth++;
1537         if (r->sid) {
1538                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1539         }
1540         ndr->depth--;
1541         ndr->depth--;
1542 }
1543
1544 _PUBLIC_ enum ndr_err_code ndr_push_lsa_SidArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_SidArray *r)
1545 {
1546         uint32_t cntr_sids_1;
1547         if (ndr_flags & NDR_SCALARS) {
1548                 NDR_CHECK(ndr_push_align(ndr, 4));
1549                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
1550                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
1551         }
1552         if (ndr_flags & NDR_BUFFERS) {
1553                 if (r->sids) {
1554                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
1555                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1556                                 NDR_CHECK(ndr_push_lsa_SidPtr(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1557                         }
1558                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1559                                 NDR_CHECK(ndr_push_lsa_SidPtr(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
1560                         }
1561                 }
1562         }
1563         return NDR_ERR_SUCCESS;
1564 }
1565
1566 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_SidArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_SidArray *r)
1567 {
1568         uint32_t _ptr_sids;
1569         uint32_t cntr_sids_1;
1570         TALLOC_CTX *_mem_save_sids_0;
1571         TALLOC_CTX *_mem_save_sids_1;
1572         if (ndr_flags & NDR_SCALARS) {
1573                 NDR_CHECK(ndr_pull_align(ndr, 4));
1574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
1575                 if (r->num_sids < 0 || r->num_sids > 1000) {
1576                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1577                 }
1578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
1579                 if (_ptr_sids) {
1580                         NDR_PULL_ALLOC(ndr, r->sids);
1581                 } else {
1582                         r->sids = NULL;
1583                 }
1584         }
1585         if (ndr_flags & NDR_BUFFERS) {
1586                 if (r->sids) {
1587                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1588                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1589                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
1590                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
1591                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1592                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1593                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1594                                 NDR_CHECK(ndr_pull_lsa_SidPtr(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1595                         }
1596                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
1597                                 NDR_CHECK(ndr_pull_lsa_SidPtr(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
1598                         }
1599                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
1600                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
1601                 }
1602                 if (r->sids) {
1603                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
1604                 }
1605         }
1606         return NDR_ERR_SUCCESS;
1607 }
1608
1609 _PUBLIC_ void ndr_print_lsa_SidArray(struct ndr_print *ndr, const char *name, const struct lsa_SidArray *r)
1610 {
1611         uint32_t cntr_sids_1;
1612         ndr_print_struct(ndr, name, "lsa_SidArray");
1613         ndr->depth++;
1614         ndr_print_uint32(ndr, "num_sids", r->num_sids);
1615         ndr_print_ptr(ndr, "sids", r->sids);
1616         ndr->depth++;
1617         if (r->sids) {
1618                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->num_sids);
1619                 ndr->depth++;
1620                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
1621                         char *idx_1=NULL;
1622                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
1623                                 ndr_print_lsa_SidPtr(ndr, "sids", &r->sids[cntr_sids_1]);
1624                                 free(idx_1);
1625                         }
1626                 }
1627                 ndr->depth--;
1628         }
1629         ndr->depth--;
1630         ndr->depth--;
1631 }
1632
1633 static enum ndr_err_code ndr_push_lsa_DomainList(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainList *r)
1634 {
1635         uint32_t cntr_domains_1;
1636         if (ndr_flags & NDR_SCALARS) {
1637                 NDR_CHECK(ndr_push_align(ndr, 4));
1638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1639                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
1640         }
1641         if (ndr_flags & NDR_BUFFERS) {
1642                 if (r->domains) {
1643                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1644                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1645                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
1646                         }
1647                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1648                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
1649                         }
1650                 }
1651         }
1652         return NDR_ERR_SUCCESS;
1653 }
1654
1655 static enum ndr_err_code ndr_pull_lsa_DomainList(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainList *r)
1656 {
1657         uint32_t _ptr_domains;
1658         uint32_t cntr_domains_1;
1659         TALLOC_CTX *_mem_save_domains_0;
1660         TALLOC_CTX *_mem_save_domains_1;
1661         if (ndr_flags & NDR_SCALARS) {
1662                 NDR_CHECK(ndr_pull_align(ndr, 4));
1663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1664                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
1665                 if (_ptr_domains) {
1666                         NDR_PULL_ALLOC(ndr, r->domains);
1667                 } else {
1668                         r->domains = NULL;
1669                 }
1670         }
1671         if (ndr_flags & NDR_BUFFERS) {
1672                 if (r->domains) {
1673                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
1674                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1675                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
1676                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
1677                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
1678                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1679                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1680                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
1681                         }
1682                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1683                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
1684                         }
1685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
1686                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
1687                 }
1688                 if (r->domains) {
1689                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
1690                 }
1691         }
1692         return NDR_ERR_SUCCESS;
1693 }
1694
1695 _PUBLIC_ void ndr_print_lsa_DomainList(struct ndr_print *ndr, const char *name, const struct lsa_DomainList *r)
1696 {
1697         uint32_t cntr_domains_1;
1698         ndr_print_struct(ndr, name, "lsa_DomainList");
1699         ndr->depth++;
1700         ndr_print_uint32(ndr, "count", r->count);
1701         ndr_print_ptr(ndr, "domains", r->domains);
1702         ndr->depth++;
1703         if (r->domains) {
1704                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", r->count);
1705                 ndr->depth++;
1706                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
1707                         char *idx_1=NULL;
1708                         if (asprintf(&idx_1, "[%d]", cntr_domains_1) != -1) {
1709                                 ndr_print_lsa_DomainInfo(ndr, "domains", &r->domains[cntr_domains_1]);
1710                                 free(idx_1);
1711                         }
1712                 }
1713                 ndr->depth--;
1714         }
1715         ndr->depth--;
1716         ndr->depth--;
1717 }
1718
1719 static enum ndr_err_code ndr_push_lsa_SidType(struct ndr_push *ndr, int ndr_flags, enum lsa_SidType r)
1720 {
1721         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1722         return NDR_ERR_SUCCESS;
1723 }
1724
1725 static enum ndr_err_code ndr_pull_lsa_SidType(struct ndr_pull *ndr, int ndr_flags, enum lsa_SidType *r)
1726 {
1727         uint16_t v;
1728         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1729         *r = v;
1730         return NDR_ERR_SUCCESS;
1731 }
1732
1733 _PUBLIC_ void ndr_print_lsa_SidType(struct ndr_print *ndr, const char *name, enum lsa_SidType r)
1734 {
1735         const char *val = NULL;
1736
1737         switch (r) {
1738                 case SID_NAME_USE_NONE: val = "SID_NAME_USE_NONE"; break;
1739                 case SID_NAME_USER: val = "SID_NAME_USER"; break;
1740                 case SID_NAME_DOM_GRP: val = "SID_NAME_DOM_GRP"; break;
1741                 case SID_NAME_DOMAIN: val = "SID_NAME_DOMAIN"; break;
1742                 case SID_NAME_ALIAS: val = "SID_NAME_ALIAS"; break;
1743                 case SID_NAME_WKN_GRP: val = "SID_NAME_WKN_GRP"; break;
1744                 case SID_NAME_DELETED: val = "SID_NAME_DELETED"; break;
1745                 case SID_NAME_INVALID: val = "SID_NAME_INVALID"; break;
1746                 case SID_NAME_UNKNOWN: val = "SID_NAME_UNKNOWN"; break;
1747                 case SID_NAME_COMPUTER: val = "SID_NAME_COMPUTER"; break;
1748         }
1749         ndr_print_enum(ndr, name, "ENUM", val, r);
1750 }
1751
1752 static enum ndr_err_code ndr_push_lsa_TranslatedSid(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid *r)
1753 {
1754         if (ndr_flags & NDR_SCALARS) {
1755                 NDR_CHECK(ndr_push_align(ndr, 4));
1756                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
1757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
1758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
1759         }
1760         if (ndr_flags & NDR_BUFFERS) {
1761         }
1762         return NDR_ERR_SUCCESS;
1763 }
1764
1765 static enum ndr_err_code ndr_pull_lsa_TranslatedSid(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid *r)
1766 {
1767         if (ndr_flags & NDR_SCALARS) {
1768                 NDR_CHECK(ndr_pull_align(ndr, 4));
1769                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
1770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
1771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
1772         }
1773         if (ndr_flags & NDR_BUFFERS) {
1774         }
1775         return NDR_ERR_SUCCESS;
1776 }
1777
1778 _PUBLIC_ void ndr_print_lsa_TranslatedSid(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid *r)
1779 {
1780         ndr_print_struct(ndr, name, "lsa_TranslatedSid");
1781         ndr->depth++;
1782         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
1783         ndr_print_uint32(ndr, "rid", r->rid);
1784         ndr_print_uint32(ndr, "sid_index", r->sid_index);
1785         ndr->depth--;
1786 }
1787
1788 static enum ndr_err_code ndr_push_lsa_TransSidArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray *r)
1789 {
1790         uint32_t cntr_sids_1;
1791         if (ndr_flags & NDR_SCALARS) {
1792                 NDR_CHECK(ndr_push_align(ndr, 4));
1793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1794                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
1795         }
1796         if (ndr_flags & NDR_BUFFERS) {
1797                 if (r->sids) {
1798                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1799                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
1800                                 NDR_CHECK(ndr_push_lsa_TranslatedSid(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1801                         }
1802                 }
1803         }
1804         return NDR_ERR_SUCCESS;
1805 }
1806
1807 static enum ndr_err_code ndr_pull_lsa_TransSidArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray *r)
1808 {
1809         uint32_t _ptr_sids;
1810         uint32_t cntr_sids_1;
1811         TALLOC_CTX *_mem_save_sids_0;
1812         TALLOC_CTX *_mem_save_sids_1;
1813         if (ndr_flags & NDR_SCALARS) {
1814                 NDR_CHECK(ndr_pull_align(ndr, 4));
1815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1816                 if (r->count < 0 || r->count > 1000) {
1817                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1818                 }
1819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
1820                 if (_ptr_sids) {
1821                         NDR_PULL_ALLOC(ndr, r->sids);
1822                 } else {
1823                         r->sids = NULL;
1824                 }
1825         }
1826         if (ndr_flags & NDR_BUFFERS) {
1827                 if (r->sids) {
1828                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1829                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1830                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
1831                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
1832                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
1833                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
1834                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
1835                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
1836                         }
1837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
1838                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
1839                 }
1840                 if (r->sids) {
1841                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
1842                 }
1843         }
1844         return NDR_ERR_SUCCESS;
1845 }
1846
1847 _PUBLIC_ void ndr_print_lsa_TransSidArray(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray *r)
1848 {
1849         uint32_t cntr_sids_1;
1850         ndr_print_struct(ndr, name, "lsa_TransSidArray");
1851         ndr->depth++;
1852         ndr_print_uint32(ndr, "count", r->count);
1853         ndr_print_ptr(ndr, "sids", r->sids);
1854         ndr->depth++;
1855         if (r->sids) {
1856                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->count);
1857                 ndr->depth++;
1858                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
1859                         char *idx_1=NULL;
1860                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
1861                                 ndr_print_lsa_TranslatedSid(ndr, "sids", &r->sids[cntr_sids_1]);
1862                                 free(idx_1);
1863                         }
1864                 }
1865                 ndr->depth--;
1866         }
1867         ndr->depth--;
1868         ndr->depth--;
1869 }
1870
1871 static enum ndr_err_code ndr_push_lsa_RefDomainList(struct ndr_push *ndr, int ndr_flags, const struct lsa_RefDomainList *r)
1872 {
1873         uint32_t cntr_domains_1;
1874         if (ndr_flags & NDR_SCALARS) {
1875                 NDR_CHECK(ndr_push_align(ndr, 4));
1876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1877                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
1878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_size));
1879         }
1880         if (ndr_flags & NDR_BUFFERS) {
1881                 if (r->domains) {
1882                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1883                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1884                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
1885                         }
1886                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1887                                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
1888                         }
1889                 }
1890         }
1891         return NDR_ERR_SUCCESS;
1892 }
1893
1894 static enum ndr_err_code ndr_pull_lsa_RefDomainList(struct ndr_pull *ndr, int ndr_flags, struct lsa_RefDomainList *r)
1895 {
1896         uint32_t _ptr_domains;
1897         uint32_t cntr_domains_1;
1898         TALLOC_CTX *_mem_save_domains_0;
1899         TALLOC_CTX *_mem_save_domains_1;
1900         if (ndr_flags & NDR_SCALARS) {
1901                 NDR_CHECK(ndr_pull_align(ndr, 4));
1902                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1903                 if (r->count < 0 || r->count > 1000) {
1904                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1905                 }
1906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
1907                 if (_ptr_domains) {
1908                         NDR_PULL_ALLOC(ndr, r->domains);
1909                 } else {
1910                         r->domains = NULL;
1911                 }
1912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_size));
1913         }
1914         if (ndr_flags & NDR_BUFFERS) {
1915                 if (r->domains) {
1916                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
1917                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1918                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
1919                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
1920                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
1921                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
1922                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1923                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
1924                         }
1925                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
1926                                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
1927                         }
1928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
1929                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
1930                 }
1931                 if (r->domains) {
1932                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
1933                 }
1934         }
1935         return NDR_ERR_SUCCESS;
1936 }
1937
1938 _PUBLIC_ void ndr_print_lsa_RefDomainList(struct ndr_print *ndr, const char *name, const struct lsa_RefDomainList *r)
1939 {
1940         uint32_t cntr_domains_1;
1941         ndr_print_struct(ndr, name, "lsa_RefDomainList");
1942         ndr->depth++;
1943         ndr_print_uint32(ndr, "count", r->count);
1944         ndr_print_ptr(ndr, "domains", r->domains);
1945         ndr->depth++;
1946         if (r->domains) {
1947                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", r->count);
1948                 ndr->depth++;
1949                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
1950                         char *idx_1=NULL;
1951                         if (asprintf(&idx_1, "[%d]", cntr_domains_1) != -1) {
1952                                 ndr_print_lsa_DomainInfo(ndr, "domains", &r->domains[cntr_domains_1]);
1953                                 free(idx_1);
1954                         }
1955                 }
1956                 ndr->depth--;
1957         }
1958         ndr->depth--;
1959         ndr_print_uint32(ndr, "max_size", r->max_size);
1960         ndr->depth--;
1961 }
1962
1963 static enum ndr_err_code ndr_push_lsa_LookupNamesLevel(struct ndr_push *ndr, int ndr_flags, enum lsa_LookupNamesLevel r)
1964 {
1965         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
1966         return NDR_ERR_SUCCESS;
1967 }
1968
1969 static enum ndr_err_code ndr_pull_lsa_LookupNamesLevel(struct ndr_pull *ndr, int ndr_flags, enum lsa_LookupNamesLevel *r)
1970 {
1971         uint16_t v;
1972         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
1973         *r = v;
1974         return NDR_ERR_SUCCESS;
1975 }
1976
1977 _PUBLIC_ void ndr_print_lsa_LookupNamesLevel(struct ndr_print *ndr, const char *name, enum lsa_LookupNamesLevel r)
1978 {
1979         const char *val = NULL;
1980
1981         switch (r) {
1982                 case LSA_LOOKUP_NAMES_ALL: val = "LSA_LOOKUP_NAMES_ALL"; break;
1983                 case LSA_LOOKUP_NAMES_DOMAINS_ONLY: val = "LSA_LOOKUP_NAMES_DOMAINS_ONLY"; break;
1984                 case LSA_LOOKUP_NAMES_PRIMARY_DOMAIN_ONLY: val = "LSA_LOOKUP_NAMES_PRIMARY_DOMAIN_ONLY"; break;
1985                 case LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY: val = "LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY"; break;
1986                 case LSA_LOOKUP_NAMES_FOREST_TRUSTS_ONLY: val = "LSA_LOOKUP_NAMES_FOREST_TRUSTS_ONLY"; break;
1987                 case LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY2: val = "LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY2"; break;
1988         }
1989         ndr_print_enum(ndr, name, "ENUM", val, r);
1990 }
1991
1992 static enum ndr_err_code ndr_push_lsa_TranslatedName(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedName *r)
1993 {
1994         if (ndr_flags & NDR_SCALARS) {
1995                 NDR_CHECK(ndr_push_align(ndr, 4));
1996                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
1997                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
1998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
1999         }
2000         if (ndr_flags & NDR_BUFFERS) {
2001                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
2002         }
2003         return NDR_ERR_SUCCESS;
2004 }
2005
2006 static enum ndr_err_code ndr_pull_lsa_TranslatedName(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedName *r)
2007 {
2008         if (ndr_flags & NDR_SCALARS) {
2009                 NDR_CHECK(ndr_pull_align(ndr, 4));
2010                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
2011                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
2012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
2013         }
2014         if (ndr_flags & NDR_BUFFERS) {
2015                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
2016         }
2017         return NDR_ERR_SUCCESS;
2018 }
2019
2020 _PUBLIC_ void ndr_print_lsa_TranslatedName(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedName *r)
2021 {
2022         ndr_print_struct(ndr, name, "lsa_TranslatedName");
2023         ndr->depth++;
2024         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
2025         ndr_print_lsa_String(ndr, "name", &r->name);
2026         ndr_print_uint32(ndr, "sid_index", r->sid_index);
2027         ndr->depth--;
2028 }
2029
2030 static enum ndr_err_code ndr_push_lsa_TransNameArray(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransNameArray *r)
2031 {
2032         uint32_t cntr_names_1;
2033         if (ndr_flags & NDR_SCALARS) {
2034                 NDR_CHECK(ndr_push_align(ndr, 4));
2035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
2037         }
2038         if (ndr_flags & NDR_BUFFERS) {
2039                 if (r->names) {
2040                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2041                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2042                                 NDR_CHECK(ndr_push_lsa_TranslatedName(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
2043                         }
2044                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2045                                 NDR_CHECK(ndr_push_lsa_TranslatedName(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
2046                         }
2047                 }
2048         }
2049         return NDR_ERR_SUCCESS;
2050 }
2051
2052 static enum ndr_err_code ndr_pull_lsa_TransNameArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransNameArray *r)
2053 {
2054         uint32_t _ptr_names;
2055         uint32_t cntr_names_1;
2056         TALLOC_CTX *_mem_save_names_0;
2057         TALLOC_CTX *_mem_save_names_1;
2058         if (ndr_flags & NDR_SCALARS) {
2059                 NDR_CHECK(ndr_pull_align(ndr, 4));
2060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2061                 if (r->count < 0 || r->count > 1000) {
2062                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2063                 }
2064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
2065                 if (_ptr_names) {
2066                         NDR_PULL_ALLOC(ndr, r->names);
2067                 } else {
2068                         r->names = NULL;
2069                 }
2070         }
2071         if (ndr_flags & NDR_BUFFERS) {
2072                 if (r->names) {
2073                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
2074                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
2075                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
2076                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
2077                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
2078                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
2079                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2080                                 NDR_CHECK(ndr_pull_lsa_TranslatedName(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
2081                         }
2082                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
2083                                 NDR_CHECK(ndr_pull_lsa_TranslatedName(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
2084                         }
2085                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
2086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
2087                 }
2088                 if (r->names) {
2089                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
2090                 }
2091         }
2092         return NDR_ERR_SUCCESS;
2093 }
2094
2095 _PUBLIC_ void ndr_print_lsa_TransNameArray(struct ndr_print *ndr, const char *name, const struct lsa_TransNameArray *r)
2096 {
2097         uint32_t cntr_names_1;
2098         ndr_print_struct(ndr, name, "lsa_TransNameArray");
2099         ndr->depth++;
2100         ndr_print_uint32(ndr, "count", r->count);
2101         ndr_print_ptr(ndr, "names", r->names);
2102         ndr->depth++;
2103         if (r->names) {
2104                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->count);
2105                 ndr->depth++;
2106                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
2107                         char *idx_1=NULL;
2108                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
2109                                 ndr_print_lsa_TranslatedName(ndr, "names", &r->names[cntr_names_1]);
2110                                 free(idx_1);
2111                         }
2112                 }
2113                 ndr->depth--;
2114         }
2115         ndr->depth--;
2116         ndr->depth--;
2117 }
2118
2119 static enum ndr_err_code ndr_push_lsa_LUIDAttribute(struct ndr_push *ndr, int ndr_flags, const struct lsa_LUIDAttribute *r)
2120 {
2121         if (ndr_flags & NDR_SCALARS) {
2122                 NDR_CHECK(ndr_push_align(ndr, 4));
2123                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
2124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attribute));
2125         }
2126         if (ndr_flags & NDR_BUFFERS) {
2127         }
2128         return NDR_ERR_SUCCESS;
2129 }
2130
2131 static enum ndr_err_code ndr_pull_lsa_LUIDAttribute(struct ndr_pull *ndr, int ndr_flags, struct lsa_LUIDAttribute *r)
2132 {
2133         if (ndr_flags & NDR_SCALARS) {
2134                 NDR_CHECK(ndr_pull_align(ndr, 4));
2135                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
2136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attribute));
2137         }
2138         if (ndr_flags & NDR_BUFFERS) {
2139         }
2140         return NDR_ERR_SUCCESS;
2141 }
2142
2143 _PUBLIC_ void ndr_print_lsa_LUIDAttribute(struct ndr_print *ndr, const char *name, const struct lsa_LUIDAttribute *r)
2144 {
2145         ndr_print_struct(ndr, name, "lsa_LUIDAttribute");
2146         ndr->depth++;
2147         ndr_print_lsa_LUID(ndr, "luid", &r->luid);
2148         ndr_print_uint32(ndr, "attribute", r->attribute);
2149         ndr->depth--;
2150 }
2151
2152 static enum ndr_err_code ndr_push_lsa_PrivilegeSet(struct ndr_push *ndr, int ndr_flags, const struct lsa_PrivilegeSet *r)
2153 {
2154         uint32_t cntr_set_0;
2155         if (ndr_flags & NDR_SCALARS) {
2156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2157                 NDR_CHECK(ndr_push_align(ndr, 4));
2158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
2160                 for (cntr_set_0 = 0; cntr_set_0 < r->count; cntr_set_0++) {
2161                         NDR_CHECK(ndr_push_lsa_LUIDAttribute(ndr, NDR_SCALARS, &r->set[cntr_set_0]));
2162                 }
2163         }
2164         if (ndr_flags & NDR_BUFFERS) {
2165         }
2166         return NDR_ERR_SUCCESS;
2167 }
2168
2169 static enum ndr_err_code ndr_pull_lsa_PrivilegeSet(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivilegeSet *r)
2170 {
2171         uint32_t cntr_set_0;
2172         TALLOC_CTX *_mem_save_set_0;
2173         if (ndr_flags & NDR_SCALARS) {
2174                 NDR_CHECK(ndr_pull_array_size(ndr, &r->set));
2175                 NDR_CHECK(ndr_pull_align(ndr, 4));
2176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2177                 if (r->count < 0 || r->count > 1000) {
2178                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2179                 }
2180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
2181                 NDR_PULL_ALLOC_N(ndr, r->set, ndr_get_array_size(ndr, &r->set));
2182                 _mem_save_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
2183                 NDR_PULL_SET_MEM_CTX(ndr, r->set, 0);
2184                 for (cntr_set_0 = 0; cntr_set_0 < r->count; cntr_set_0++) {
2185                         NDR_CHECK(ndr_pull_lsa_LUIDAttribute(ndr, NDR_SCALARS, &r->set[cntr_set_0]));
2186                 }
2187                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_set_0, 0);
2188                 if (r->set) {
2189                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->set, r->count));
2190                 }
2191         }
2192         if (ndr_flags & NDR_BUFFERS) {
2193         }
2194         return NDR_ERR_SUCCESS;
2195 }
2196
2197 _PUBLIC_ void ndr_print_lsa_PrivilegeSet(struct ndr_print *ndr, const char *name, const struct lsa_PrivilegeSet *r)
2198 {
2199         uint32_t cntr_set_0;
2200         ndr_print_struct(ndr, name, "lsa_PrivilegeSet");
2201         ndr->depth++;
2202         ndr_print_uint32(ndr, "count", r->count);
2203         ndr_print_uint32(ndr, "unknown", r->unknown);
2204         ndr->print(ndr, "%s: ARRAY(%d)", "set", r->count);
2205         ndr->depth++;
2206         for (cntr_set_0=0;cntr_set_0<r->count;cntr_set_0++) {
2207                 char *idx_0=NULL;
2208                 if (asprintf(&idx_0, "[%d]", cntr_set_0) != -1) {
2209                         ndr_print_lsa_LUIDAttribute(ndr, "set", &r->set[cntr_set_0]);
2210                         free(idx_0);
2211                 }
2212         }
2213         ndr->depth--;
2214         ndr->depth--;
2215 }
2216
2217 static enum ndr_err_code ndr_push_lsa_DATA_BUF(struct ndr_push *ndr, int ndr_flags, const struct lsa_DATA_BUF *r)
2218 {
2219         {
2220                 uint32_t _flags_save_STRUCT = ndr->flags;
2221                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2222                 if (ndr_flags & NDR_SCALARS) {
2223                         NDR_CHECK(ndr_push_align(ndr, 4));
2224                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
2225                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2226                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
2227                 }
2228                 if (ndr_flags & NDR_BUFFERS) {
2229                         if (r->data) {
2230                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2231                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2232                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
2233                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
2234                         }
2235                 }
2236                 ndr->flags = _flags_save_STRUCT;
2237         }
2238         return NDR_ERR_SUCCESS;
2239 }
2240
2241 static enum ndr_err_code ndr_pull_lsa_DATA_BUF(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF *r)
2242 {
2243         uint32_t _ptr_data;
2244         TALLOC_CTX *_mem_save_data_0;
2245         {
2246                 uint32_t _flags_save_STRUCT = ndr->flags;
2247                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2248                 if (ndr_flags & NDR_SCALARS) {
2249                         NDR_CHECK(ndr_pull_align(ndr, 4));
2250                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
2251                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2252                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2253                         if (_ptr_data) {
2254                                 NDR_PULL_ALLOC(ndr, r->data);
2255                         } else {
2256                                 r->data = NULL;
2257                         }
2258                 }
2259                 if (ndr_flags & NDR_BUFFERS) {
2260                         if (r->data) {
2261                                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2262                                 NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
2263                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
2264                                 NDR_CHECK(ndr_pull_array_length(ndr, &r->data));
2265                                 if (ndr_get_array_length(ndr, &r->data) > ndr_get_array_size(ndr, &r->data)) {
2266                                         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));
2267                                 }
2268                                 NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
2269                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_length(ndr, &r->data)));
2270                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2271                         }
2272                         if (r->data) {
2273                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
2274                         }
2275                         if (r->data) {
2276                                 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->data, r->length));
2277                         }
2278                 }
2279                 ndr->flags = _flags_save_STRUCT;
2280         }
2281         return NDR_ERR_SUCCESS;
2282 }
2283
2284 _PUBLIC_ void ndr_print_lsa_DATA_BUF(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF *r)
2285 {
2286         ndr_print_struct(ndr, name, "lsa_DATA_BUF");
2287         {
2288                 uint32_t _flags_save_STRUCT = ndr->flags;
2289                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2290                 ndr->depth++;
2291                 ndr_print_uint32(ndr, "length", r->length);
2292                 ndr_print_uint32(ndr, "size", r->size);
2293                 ndr_print_ptr(ndr, "data", r->data);
2294                 ndr->depth++;
2295                 if (r->data) {
2296                         ndr_print_array_uint8(ndr, "data", r->data, r->length);
2297                 }
2298                 ndr->depth--;
2299                 ndr->depth--;
2300                 ndr->flags = _flags_save_STRUCT;
2301         }
2302 }
2303
2304 static enum ndr_err_code ndr_push_lsa_DATA_BUF2(struct ndr_push *ndr, int ndr_flags, const struct lsa_DATA_BUF2 *r)
2305 {
2306         {
2307                 uint32_t _flags_save_STRUCT = ndr->flags;
2308                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2309                 if (ndr_flags & NDR_SCALARS) {
2310                         NDR_CHECK(ndr_push_align(ndr, 4));
2311                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2312                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
2313                 }
2314                 if (ndr_flags & NDR_BUFFERS) {
2315                         if (r->data) {
2316                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2317                                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
2318                         }
2319                 }
2320                 ndr->flags = _flags_save_STRUCT;
2321         }
2322         return NDR_ERR_SUCCESS;
2323 }
2324
2325 static enum ndr_err_code ndr_pull_lsa_DATA_BUF2(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF2 *r)
2326 {
2327         uint32_t _ptr_data;
2328         TALLOC_CTX *_mem_save_data_0;
2329         {
2330                 uint32_t _flags_save_STRUCT = ndr->flags;
2331                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2332                 if (ndr_flags & NDR_SCALARS) {
2333                         NDR_CHECK(ndr_pull_align(ndr, 4));
2334                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2335                         if (r->size < 0 || r->size > 65536) {
2336                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2337                         }
2338                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2339                         if (_ptr_data) {
2340                                 NDR_PULL_ALLOC(ndr, r->data);
2341                         } else {
2342                                 r->data = NULL;
2343                         }
2344                 }
2345                 if (ndr_flags & NDR_BUFFERS) {
2346                         if (r->data) {
2347                                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2348                                 NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
2349                                 NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
2350                                 NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
2351                                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
2352                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2353                         }
2354                         if (r->data) {
2355                                 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
2356                         }
2357                 }
2358                 ndr->flags = _flags_save_STRUCT;
2359         }
2360         return NDR_ERR_SUCCESS;
2361 }
2362
2363 _PUBLIC_ void ndr_print_lsa_DATA_BUF2(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF2 *r)
2364 {
2365         ndr_print_struct(ndr, name, "lsa_DATA_BUF2");
2366         {
2367                 uint32_t _flags_save_STRUCT = ndr->flags;
2368                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2369                 ndr->depth++;
2370                 ndr_print_uint32(ndr, "size", r->size);
2371                 ndr_print_ptr(ndr, "data", r->data);
2372                 ndr->depth++;
2373                 if (r->data) {
2374                         ndr_print_array_uint8(ndr, "data", r->data, r->size);
2375                 }
2376                 ndr->depth--;
2377                 ndr->depth--;
2378                 ndr->flags = _flags_save_STRUCT;
2379         }
2380 }
2381
2382 static enum ndr_err_code ndr_push_lsa_TrustDomInfoEnum(struct ndr_push *ndr, int ndr_flags, enum lsa_TrustDomInfoEnum r)
2383 {
2384         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
2385         return NDR_ERR_SUCCESS;
2386 }
2387
2388 static enum ndr_err_code ndr_pull_lsa_TrustDomInfoEnum(struct ndr_pull *ndr, int ndr_flags, enum lsa_TrustDomInfoEnum *r)
2389 {
2390         uint16_t v;
2391         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
2392         *r = v;
2393         return NDR_ERR_SUCCESS;
2394 }
2395
2396 _PUBLIC_ void ndr_print_lsa_TrustDomInfoEnum(struct ndr_print *ndr, const char *name, enum lsa_TrustDomInfoEnum r)
2397 {
2398         const char *val = NULL;
2399
2400         switch (r) {
2401                 case LSA_TRUSTED_DOMAIN_INFO_NAME: val = "LSA_TRUSTED_DOMAIN_INFO_NAME"; break;
2402                 case LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS_INFO: val = "LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS_INFO"; break;
2403                 case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET: val = "LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET"; break;
2404                 case LSA_TRUSTED_DOMAIN_INFO_PASSWORD: val = "LSA_TRUSTED_DOMAIN_INFO_PASSWORD"; break;
2405                 case LSA_TRUSTED_DOMAIN_INFO_BASIC: val = "LSA_TRUSTED_DOMAIN_INFO_BASIC"; break;
2406                 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX: val = "LSA_TRUSTED_DOMAIN_INFO_INFO_EX"; break;
2407                 case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO: val = "LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO"; break;
2408                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO: val = "LSA_TRUSTED_DOMAIN_INFO_FULL_INFO"; break;
2409                 case LSA_TRUSTED_DOMAIN_INFO_11: val = "LSA_TRUSTED_DOMAIN_INFO_11"; break;
2410                 case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL: val = "LSA_TRUSTED_DOMAIN_INFO_INFO_ALL"; break;
2411         }
2412         ndr_print_enum(ndr, name, "ENUM", val, r);
2413 }
2414
2415 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoName(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoName *r)
2416 {
2417         if (ndr_flags & NDR_SCALARS) {
2418                 NDR_CHECK(ndr_push_align(ndr, 4));
2419                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2420         }
2421         if (ndr_flags & NDR_BUFFERS) {
2422                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2423         }
2424         return NDR_ERR_SUCCESS;
2425 }
2426
2427 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoName(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoName *r)
2428 {
2429         if (ndr_flags & NDR_SCALARS) {
2430                 NDR_CHECK(ndr_pull_align(ndr, 4));
2431                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2432         }
2433         if (ndr_flags & NDR_BUFFERS) {
2434                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2435         }
2436         return NDR_ERR_SUCCESS;
2437 }
2438
2439 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoName(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoName *r)
2440 {
2441         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoName");
2442         ndr->depth++;
2443         ndr_print_lsa_StringLarge(ndr, "netbios_name", &r->netbios_name);
2444         ndr->depth--;
2445 }
2446
2447 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoPosixOffset(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoPosixOffset *r)
2448 {
2449         if (ndr_flags & NDR_SCALARS) {
2450                 NDR_CHECK(ndr_push_align(ndr, 4));
2451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->posix_offset));
2452         }
2453         if (ndr_flags & NDR_BUFFERS) {
2454         }
2455         return NDR_ERR_SUCCESS;
2456 }
2457
2458 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoPosixOffset(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoPosixOffset *r)
2459 {
2460         if (ndr_flags & NDR_SCALARS) {
2461                 NDR_CHECK(ndr_pull_align(ndr, 4));
2462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->posix_offset));
2463         }
2464         if (ndr_flags & NDR_BUFFERS) {
2465         }
2466         return NDR_ERR_SUCCESS;
2467 }
2468
2469 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoPosixOffset(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoPosixOffset *r)
2470 {
2471         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoPosixOffset");
2472         ndr->depth++;
2473         ndr_print_uint32(ndr, "posix_offset", r->posix_offset);
2474         ndr->depth--;
2475 }
2476
2477 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoPassword(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoPassword *r)
2478 {
2479         if (ndr_flags & NDR_SCALARS) {
2480                 NDR_CHECK(ndr_push_align(ndr, 4));
2481                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->password));
2482                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->old_password));
2483         }
2484         if (ndr_flags & NDR_BUFFERS) {
2485                 if (r->password) {
2486                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->password));
2487                 }
2488                 if (r->old_password) {
2489                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->old_password));
2490                 }
2491         }
2492         return NDR_ERR_SUCCESS;
2493 }
2494
2495 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoPassword(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoPassword *r)
2496 {
2497         uint32_t _ptr_password;
2498         TALLOC_CTX *_mem_save_password_0;
2499         uint32_t _ptr_old_password;
2500         TALLOC_CTX *_mem_save_old_password_0;
2501         if (ndr_flags & NDR_SCALARS) {
2502                 NDR_CHECK(ndr_pull_align(ndr, 4));
2503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
2504                 if (_ptr_password) {
2505                         NDR_PULL_ALLOC(ndr, r->password);
2506                 } else {
2507                         r->password = NULL;
2508                 }
2509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_password));
2510                 if (_ptr_old_password) {
2511                         NDR_PULL_ALLOC(ndr, r->old_password);
2512                 } else {
2513                         r->old_password = NULL;
2514                 }
2515         }
2516         if (ndr_flags & NDR_BUFFERS) {
2517                 if (r->password) {
2518                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
2519                         NDR_PULL_SET_MEM_CTX(ndr, r->password, 0);
2520                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->password));
2521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
2522                 }
2523                 if (r->old_password) {
2524                         _mem_save_old_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
2525                         NDR_PULL_SET_MEM_CTX(ndr, r->old_password, 0);
2526                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->old_password));
2527                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_password_0, 0);
2528                 }
2529         }
2530         return NDR_ERR_SUCCESS;
2531 }
2532
2533 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoPassword(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoPassword *r)
2534 {
2535         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoPassword");
2536         ndr->depth++;
2537         ndr_print_ptr(ndr, "password", r->password);
2538         ndr->depth++;
2539         if (r->password) {
2540                 ndr_print_lsa_DATA_BUF(ndr, "password", r->password);
2541         }
2542         ndr->depth--;
2543         ndr_print_ptr(ndr, "old_password", r->old_password);
2544         ndr->depth++;
2545         if (r->old_password) {
2546                 ndr_print_lsa_DATA_BUF(ndr, "old_password", r->old_password);
2547         }
2548         ndr->depth--;
2549         ndr->depth--;
2550 }
2551
2552 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoBasic(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoBasic *r)
2553 {
2554         if (ndr_flags & NDR_SCALARS) {
2555                 NDR_CHECK(ndr_push_align(ndr, 4));
2556                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->netbios_name));
2557                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2558         }
2559         if (ndr_flags & NDR_BUFFERS) {
2560                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->netbios_name));
2561                 if (r->sid) {
2562                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2563                 }
2564         }
2565         return NDR_ERR_SUCCESS;
2566 }
2567
2568 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoBasic(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoBasic *r)
2569 {
2570         uint32_t _ptr_sid;
2571         TALLOC_CTX *_mem_save_sid_0;
2572         if (ndr_flags & NDR_SCALARS) {
2573                 NDR_CHECK(ndr_pull_align(ndr, 4));
2574                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->netbios_name));
2575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2576                 if (_ptr_sid) {
2577                         NDR_PULL_ALLOC(ndr, r->sid);
2578                 } else {
2579                         r->sid = NULL;
2580                 }
2581         }
2582         if (ndr_flags & NDR_BUFFERS) {
2583                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->netbios_name));
2584                 if (r->sid) {
2585                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2586                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2587                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2588                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2589                 }
2590         }
2591         return NDR_ERR_SUCCESS;
2592 }
2593
2594 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoBasic(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoBasic *r)
2595 {
2596         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoBasic");
2597         ndr->depth++;
2598         ndr_print_lsa_String(ndr, "netbios_name", &r->netbios_name);
2599         ndr_print_ptr(ndr, "sid", r->sid);
2600         ndr->depth++;
2601         if (r->sid) {
2602                 ndr_print_dom_sid2(ndr, "sid", r->sid);
2603         }
2604         ndr->depth--;
2605         ndr->depth--;
2606 }
2607
2608 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoInfoEx(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoInfoEx *r)
2609 {
2610         if (ndr_flags & NDR_SCALARS) {
2611                 NDR_CHECK(ndr_push_align(ndr, 4));
2612                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->domain_name));
2613                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2614                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
2615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->trust_direction));
2616                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->trust_type));
2617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->trust_attributes));
2618         }
2619         if (ndr_flags & NDR_BUFFERS) {
2620                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domain_name));
2621                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2622                 if (r->sid) {
2623                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2624                 }
2625         }
2626         return NDR_ERR_SUCCESS;
2627 }
2628
2629 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoInfoEx(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoInfoEx *r)
2630 {
2631         uint32_t _ptr_sid;
2632         TALLOC_CTX *_mem_save_sid_0;
2633         if (ndr_flags & NDR_SCALARS) {
2634                 NDR_CHECK(ndr_pull_align(ndr, 4));
2635                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->domain_name));
2636                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_name));
2637                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
2638                 if (_ptr_sid) {
2639                         NDR_PULL_ALLOC(ndr, r->sid);
2640                 } else {
2641                         r->sid = NULL;
2642                 }
2643                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->trust_direction));
2644                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->trust_type));
2645                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->trust_attributes));
2646         }
2647         if (ndr_flags & NDR_BUFFERS) {
2648                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->domain_name));
2649                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_name));
2650                 if (r->sid) {
2651                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2652                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
2653                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
2654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
2655                 }
2656         }
2657         return NDR_ERR_SUCCESS;
2658 }
2659
2660 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoInfoEx(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoInfoEx *r)
2661 {
2662         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoInfoEx");
2663         ndr->depth++;
2664         ndr_print_lsa_StringLarge(ndr, "domain_name", &r->domain_name);
2665         ndr_print_lsa_StringLarge(ndr, "netbios_name", &r->netbios_name);
2666         ndr_print_ptr(ndr, "sid", r->sid);
2667         ndr->depth++;
2668         if (r->sid) {
2669                 ndr_print_dom_sid2(ndr, "sid", r->sid);
2670         }
2671         ndr->depth--;
2672         ndr_print_uint32(ndr, "trust_direction", r->trust_direction);
2673         ndr_print_uint32(ndr, "trust_type", r->trust_type);
2674         ndr_print_uint32(ndr, "trust_attributes", r->trust_attributes);
2675         ndr->depth--;
2676 }
2677
2678 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoBuffer(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoBuffer *r)
2679 {
2680         if (ndr_flags & NDR_SCALARS) {
2681                 NDR_CHECK(ndr_push_align(ndr, 8));
2682                 NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, r->last_update_time));
2683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secret_type));
2684                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data));
2685         }
2686         if (ndr_flags & NDR_BUFFERS) {
2687                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data));
2688         }
2689         return NDR_ERR_SUCCESS;
2690 }
2691
2692 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoBuffer(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoBuffer *r)
2693 {
2694         if (ndr_flags & NDR_SCALARS) {
2695                 NDR_CHECK(ndr_pull_align(ndr, 8));
2696                 NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, &r->last_update_time));
2697                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secret_type));
2698                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data));
2699         }
2700         if (ndr_flags & NDR_BUFFERS) {
2701                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data));
2702         }
2703         return NDR_ERR_SUCCESS;
2704 }
2705
2706 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoBuffer(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoBuffer *r)
2707 {
2708         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoBuffer");
2709         ndr->depth++;
2710         ndr_print_NTTIME_hyper(ndr, "last_update_time", r->last_update_time);
2711         ndr_print_uint32(ndr, "secret_type", r->secret_type);
2712         ndr_print_lsa_DATA_BUF2(ndr, "data", &r->data);
2713         ndr->depth--;
2714 }
2715
2716 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoAuthInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoAuthInfo *r)
2717 {
2718         if (ndr_flags & NDR_SCALARS) {
2719                 NDR_CHECK(ndr_push_align(ndr, 4));
2720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->incoming_count));
2721                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->incoming_current_auth_info));
2722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->incoming_previous_auth_info));
2723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->outgoing_count));
2724                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->outgoing_current_auth_info));
2725                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->outgoing_previous_auth_info));
2726         }
2727         if (ndr_flags & NDR_BUFFERS) {
2728                 if (r->incoming_current_auth_info) {
2729                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_current_auth_info));
2730                 }
2731                 if (r->incoming_previous_auth_info) {
2732                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_previous_auth_info));
2733                 }
2734                 if (r->outgoing_current_auth_info) {
2735                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_current_auth_info));
2736                 }
2737                 if (r->outgoing_previous_auth_info) {
2738                         NDR_CHECK(ndr_push_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_previous_auth_info));
2739                 }
2740         }
2741         return NDR_ERR_SUCCESS;
2742 }
2743
2744 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoAuthInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoAuthInfo *r)
2745 {
2746         uint32_t _ptr_incoming_current_auth_info;
2747         TALLOC_CTX *_mem_save_incoming_current_auth_info_0;
2748         uint32_t _ptr_incoming_previous_auth_info;
2749         TALLOC_CTX *_mem_save_incoming_previous_auth_info_0;
2750         uint32_t _ptr_outgoing_current_auth_info;
2751         TALLOC_CTX *_mem_save_outgoing_current_auth_info_0;
2752         uint32_t _ptr_outgoing_previous_auth_info;
2753         TALLOC_CTX *_mem_save_outgoing_previous_auth_info_0;
2754         if (ndr_flags & NDR_SCALARS) {
2755                 NDR_CHECK(ndr_pull_align(ndr, 4));
2756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->incoming_count));
2757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_incoming_current_auth_info));
2758                 if (_ptr_incoming_current_auth_info) {
2759                         NDR_PULL_ALLOC(ndr, r->incoming_current_auth_info);
2760                 } else {
2761                         r->incoming_current_auth_info = NULL;
2762                 }
2763                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_incoming_previous_auth_info));
2764                 if (_ptr_incoming_previous_auth_info) {
2765                         NDR_PULL_ALLOC(ndr, r->incoming_previous_auth_info);
2766                 } else {
2767                         r->incoming_previous_auth_info = NULL;
2768                 }
2769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->outgoing_count));
2770                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_outgoing_current_auth_info));
2771                 if (_ptr_outgoing_current_auth_info) {
2772                         NDR_PULL_ALLOC(ndr, r->outgoing_current_auth_info);
2773                 } else {
2774                         r->outgoing_current_auth_info = NULL;
2775                 }
2776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_outgoing_previous_auth_info));
2777                 if (_ptr_outgoing_previous_auth_info) {
2778                         NDR_PULL_ALLOC(ndr, r->outgoing_previous_auth_info);
2779                 } else {
2780                         r->outgoing_previous_auth_info = NULL;
2781                 }
2782         }
2783         if (ndr_flags & NDR_BUFFERS) {
2784                 if (r->incoming_current_auth_info) {
2785                         _mem_save_incoming_current_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2786                         NDR_PULL_SET_MEM_CTX(ndr, r->incoming_current_auth_info, 0);
2787                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_current_auth_info));
2788                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_incoming_current_auth_info_0, 0);
2789                 }
2790                 if (r->incoming_previous_auth_info) {
2791                         _mem_save_incoming_previous_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2792                         NDR_PULL_SET_MEM_CTX(ndr, r->incoming_previous_auth_info, 0);
2793                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->incoming_previous_auth_info));
2794                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_incoming_previous_auth_info_0, 0);
2795                 }
2796                 if (r->outgoing_current_auth_info) {
2797                         _mem_save_outgoing_current_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2798                         NDR_PULL_SET_MEM_CTX(ndr, r->outgoing_current_auth_info, 0);
2799                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_current_auth_info));
2800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_outgoing_current_auth_info_0, 0);
2801                 }
2802                 if (r->outgoing_previous_auth_info) {
2803                         _mem_save_outgoing_previous_auth_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
2804                         NDR_PULL_SET_MEM_CTX(ndr, r->outgoing_previous_auth_info, 0);
2805                         NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBuffer(ndr, NDR_SCALARS|NDR_BUFFERS, r->outgoing_previous_auth_info));
2806                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_outgoing_previous_auth_info_0, 0);
2807                 }
2808         }
2809         return NDR_ERR_SUCCESS;
2810 }
2811
2812 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoAuthInfo(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoAuthInfo *r)
2813 {
2814         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoAuthInfo");
2815         ndr->depth++;
2816         ndr_print_uint32(ndr, "incoming_count", r->incoming_count);
2817         ndr_print_ptr(ndr, "incoming_current_auth_info", r->incoming_current_auth_info);
2818         ndr->depth++;
2819         if (r->incoming_current_auth_info) {
2820                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "incoming_current_auth_info", r->incoming_current_auth_info);
2821         }
2822         ndr->depth--;
2823         ndr_print_ptr(ndr, "incoming_previous_auth_info", r->incoming_previous_auth_info);
2824         ndr->depth++;
2825         if (r->incoming_previous_auth_info) {
2826                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "incoming_previous_auth_info", r->incoming_previous_auth_info);
2827         }
2828         ndr->depth--;
2829         ndr_print_uint32(ndr, "outgoing_count", r->outgoing_count);
2830         ndr_print_ptr(ndr, "outgoing_current_auth_info", r->outgoing_current_auth_info);
2831         ndr->depth++;
2832         if (r->outgoing_current_auth_info) {
2833                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "outgoing_current_auth_info", r->outgoing_current_auth_info);
2834         }
2835         ndr->depth--;
2836         ndr_print_ptr(ndr, "outgoing_previous_auth_info", r->outgoing_previous_auth_info);
2837         ndr->depth++;
2838         if (r->outgoing_previous_auth_info) {
2839                 ndr_print_lsa_TrustDomainInfoBuffer(ndr, "outgoing_previous_auth_info", r->outgoing_previous_auth_info);
2840         }
2841         ndr->depth--;
2842         ndr->depth--;
2843 }
2844
2845 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoFullInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoFullInfo *r)
2846 {
2847         if (ndr_flags & NDR_SCALARS) {
2848                 NDR_CHECK(ndr_push_align(ndr, 4));
2849                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2850                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
2851                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
2852         }
2853         if (ndr_flags & NDR_BUFFERS) {
2854                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2855                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
2856         }
2857         return NDR_ERR_SUCCESS;
2858 }
2859
2860 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoFullInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoFullInfo *r)
2861 {
2862         if (ndr_flags & NDR_SCALARS) {
2863                 NDR_CHECK(ndr_pull_align(ndr, 4));
2864                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2865                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
2866                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
2867         }
2868         if (ndr_flags & NDR_BUFFERS) {
2869                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2870                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
2871         }
2872         return NDR_ERR_SUCCESS;
2873 }
2874
2875 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoFullInfo(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoFullInfo *r)
2876 {
2877         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoFullInfo");
2878         ndr->depth++;
2879         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
2880         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
2881         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
2882         ndr->depth--;
2883 }
2884
2885 static enum ndr_err_code ndr_push_lsa_TrustDomainInfo11(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfo11 *r)
2886 {
2887         if (ndr_flags & NDR_SCALARS) {
2888                 NDR_CHECK(ndr_push_align(ndr, 4));
2889                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2890                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
2891         }
2892         if (ndr_flags & NDR_BUFFERS) {
2893                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2894                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
2895         }
2896         return NDR_ERR_SUCCESS;
2897 }
2898
2899 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfo11(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfo11 *r)
2900 {
2901         if (ndr_flags & NDR_SCALARS) {
2902                 NDR_CHECK(ndr_pull_align(ndr, 4));
2903                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2904                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
2905         }
2906         if (ndr_flags & NDR_BUFFERS) {
2907                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2908                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
2909         }
2910         return NDR_ERR_SUCCESS;
2911 }
2912
2913 _PUBLIC_ void ndr_print_lsa_TrustDomainInfo11(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfo11 *r)
2914 {
2915         ndr_print_struct(ndr, name, "lsa_TrustDomainInfo11");
2916         ndr->depth++;
2917         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
2918         ndr_print_lsa_DATA_BUF2(ndr, "data1", &r->data1);
2919         ndr->depth--;
2920 }
2921
2922 static enum ndr_err_code ndr_push_lsa_TrustDomainInfoInfoAll(struct ndr_push *ndr, int ndr_flags, const struct lsa_TrustDomainInfoInfoAll *r)
2923 {
2924         if (ndr_flags & NDR_SCALARS) {
2925                 NDR_CHECK(ndr_push_align(ndr, 4));
2926                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2927                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
2928                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
2929                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
2930         }
2931         if (ndr_flags & NDR_BUFFERS) {
2932                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2933                 NDR_CHECK(ndr_push_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
2934                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
2935         }
2936         return NDR_ERR_SUCCESS;
2937 }
2938
2939 static enum ndr_err_code ndr_pull_lsa_TrustDomainInfoInfoAll(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustDomainInfoInfoAll *r)
2940 {
2941         if (ndr_flags & NDR_SCALARS) {
2942                 NDR_CHECK(ndr_pull_align(ndr, 4));
2943                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2944                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_SCALARS, &r->data1));
2945                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
2946                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
2947         }
2948         if (ndr_flags & NDR_BUFFERS) {
2949                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
2950                 NDR_CHECK(ndr_pull_lsa_DATA_BUF2(ndr, NDR_BUFFERS, &r->data1));
2951                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
2952         }
2953         return NDR_ERR_SUCCESS;
2954 }
2955
2956 _PUBLIC_ void ndr_print_lsa_TrustDomainInfoInfoAll(struct ndr_print *ndr, const char *name, const struct lsa_TrustDomainInfoInfoAll *r)
2957 {
2958         ndr_print_struct(ndr, name, "lsa_TrustDomainInfoInfoAll");
2959         ndr->depth++;
2960         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
2961         ndr_print_lsa_DATA_BUF2(ndr, "data1", &r->data1);
2962         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
2963         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
2964         ndr->depth--;
2965 }
2966
2967 static enum ndr_err_code ndr_push_lsa_TrustedDomainInfo(struct ndr_push *ndr, int ndr_flags, const union lsa_TrustedDomainInfo *r)
2968 {
2969         if (ndr_flags & NDR_SCALARS) {
2970                 int level = ndr_push_get_switch_value(ndr, r);
2971                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, level));
2972                 switch (level) {
2973                         case LSA_TRUSTED_DOMAIN_INFO_NAME: {
2974                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoName(ndr, NDR_SCALARS, &r->name));
2975                         break; }
2976
2977                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET: {
2978                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
2979                         break; }
2980
2981                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD: {
2982                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPassword(ndr, NDR_SCALARS, &r->password));
2983                         break; }
2984
2985                         case LSA_TRUSTED_DOMAIN_INFO_BASIC: {
2986                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoBasic(ndr, NDR_SCALARS, &r->info_basic));
2987                         break; }
2988
2989                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX: {
2990                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
2991                         break; }
2992
2993                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO: {
2994                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
2995                         break; }
2996
2997                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO: {
2998                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfo(ndr, NDR_SCALARS, &r->full_info));
2999                         break; }
3000
3001                         case LSA_TRUSTED_DOMAIN_INFO_11: {
3002                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfo11(ndr, NDR_SCALARS, &r->info11));
3003                         break; }
3004
3005                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL: {
3006                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoAll(ndr, NDR_SCALARS, &r->info_all));
3007                         break; }
3008
3009                         default:
3010                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3011                 }
3012         }
3013         if (ndr_flags & NDR_BUFFERS) {
3014                 int level = ndr_push_get_switch_value(ndr, r);
3015                 switch (level) {
3016                         case LSA_TRUSTED_DOMAIN_INFO_NAME:
3017                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoName(ndr, NDR_BUFFERS, &r->name));
3018                         break;
3019
3020                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
3021                         break;
3022
3023                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
3024                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoPassword(ndr, NDR_BUFFERS, &r->password));
3025                         break;
3026
3027                         case LSA_TRUSTED_DOMAIN_INFO_BASIC:
3028                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoBasic(ndr, NDR_BUFFERS, &r->info_basic));
3029                         break;
3030
3031                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
3032                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3033                         break;
3034
3035                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
3036                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3037                         break;
3038
3039                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
3040                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoFullInfo(ndr, NDR_BUFFERS, &r->full_info));
3041                         break;
3042
3043                         case LSA_TRUSTED_DOMAIN_INFO_11:
3044                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfo11(ndr, NDR_BUFFERS, &r->info11));
3045                         break;
3046
3047                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL:
3048                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoAll(ndr, NDR_BUFFERS, &r->info_all));
3049                         break;
3050
3051                         default:
3052                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3053                 }
3054         }
3055         return NDR_ERR_SUCCESS;
3056 }
3057
3058 static enum ndr_err_code ndr_pull_lsa_TrustedDomainInfo(struct ndr_pull *ndr, int ndr_flags, union lsa_TrustedDomainInfo *r)
3059 {
3060         int level;
3061         uint16_t _level;
3062         level = ndr_pull_get_switch_value(ndr, r);
3063         if (ndr_flags & NDR_SCALARS) {
3064                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3065                 if (_level != level) {
3066                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3067                 }
3068                 switch (level) {
3069                         case LSA_TRUSTED_DOMAIN_INFO_NAME: {
3070                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoName(ndr, NDR_SCALARS, &r->name));
3071                         break; }
3072
3073                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET: {
3074                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPosixOffset(ndr, NDR_SCALARS, &r->posix_offset));
3075                         break; }
3076
3077                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD: {
3078                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPassword(ndr, NDR_SCALARS, &r->password));
3079                         break; }
3080
3081                         case LSA_TRUSTED_DOMAIN_INFO_BASIC: {
3082                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBasic(ndr, NDR_SCALARS, &r->info_basic));
3083                         break; }
3084
3085                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX: {
3086                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->info_ex));
3087                         break; }
3088
3089                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO: {
3090                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_SCALARS, &r->auth_info));
3091                         break; }
3092
3093                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO: {
3094                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfo(ndr, NDR_SCALARS, &r->full_info));
3095                         break; }
3096
3097                         case LSA_TRUSTED_DOMAIN_INFO_11: {
3098                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfo11(ndr, NDR_SCALARS, &r->info11));
3099                         break; }
3100
3101                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL: {
3102                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoAll(ndr, NDR_SCALARS, &r->info_all));
3103                         break; }
3104
3105                         default:
3106                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3107                 }
3108         }
3109         if (ndr_flags & NDR_BUFFERS) {
3110                 switch (level) {
3111                         case LSA_TRUSTED_DOMAIN_INFO_NAME:
3112                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoName(ndr, NDR_BUFFERS, &r->name));
3113                         break;
3114
3115                         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
3116                         break;
3117
3118                         case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
3119                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoPassword(ndr, NDR_BUFFERS, &r->password));
3120                         break;
3121
3122                         case LSA_TRUSTED_DOMAIN_INFO_BASIC:
3123                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoBasic(ndr, NDR_BUFFERS, &r->info_basic));
3124                         break;
3125
3126                         case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
3127                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->info_ex));
3128                         break;
3129
3130                         case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
3131                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoAuthInfo(ndr, NDR_BUFFERS, &r->auth_info));
3132                         break;
3133
3134                         case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
3135                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoFullInfo(ndr, NDR_BUFFERS, &r->full_info));
3136                         break;
3137
3138                         case LSA_TRUSTED_DOMAIN_INFO_11:
3139                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfo11(ndr, NDR_BUFFERS, &r->info11));
3140                         break;
3141
3142                         case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL:
3143                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoAll(ndr, NDR_BUFFERS, &r->info_all));
3144                         break;
3145
3146                         default:
3147                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3148                 }
3149         }
3150         return NDR_ERR_SUCCESS;
3151 }
3152
3153 _PUBLIC_ void ndr_print_lsa_TrustedDomainInfo(struct ndr_print *ndr, const char *name, const union lsa_TrustedDomainInfo *r)
3154 {
3155         int level;
3156         level = ndr_print_get_switch_value(ndr, r);
3157         ndr_print_union(ndr, name, level, "lsa_TrustedDomainInfo");
3158         switch (level) {
3159                 case LSA_TRUSTED_DOMAIN_INFO_NAME:
3160                         ndr_print_lsa_TrustDomainInfoName(ndr, "name", &r->name);
3161                 break;
3162
3163                 case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
3164                         ndr_print_lsa_TrustDomainInfoPosixOffset(ndr, "posix_offset", &r->posix_offset);
3165                 break;
3166
3167                 case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
3168                         ndr_print_lsa_TrustDomainInfoPassword(ndr, "password", &r->password);
3169                 break;
3170
3171                 case LSA_TRUSTED_DOMAIN_INFO_BASIC:
3172                         ndr_print_lsa_TrustDomainInfoBasic(ndr, "info_basic", &r->info_basic);
3173                 break;
3174
3175                 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
3176                         ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "info_ex", &r->info_ex);
3177                 break;
3178
3179                 case LSA_TRUSTED_DOMAIN_INFO_AUTH_INFO:
3180                         ndr_print_lsa_TrustDomainInfoAuthInfo(ndr, "auth_info", &r->auth_info);
3181                 break;
3182
3183                 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
3184                         ndr_print_lsa_TrustDomainInfoFullInfo(ndr, "full_info", &r->full_info);
3185                 break;
3186
3187                 case LSA_TRUSTED_DOMAIN_INFO_11:
3188                         ndr_print_lsa_TrustDomainInfo11(ndr, "info11", &r->info11);
3189                 break;
3190
3191                 case LSA_TRUSTED_DOMAIN_INFO_INFO_ALL:
3192                         ndr_print_lsa_TrustDomainInfoInfoAll(ndr, "info_all", &r->info_all);
3193                 break;
3194
3195                 default:
3196                         ndr_print_bad_level(ndr, name, level);
3197         }
3198 }
3199
3200 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)
3201 {
3202         if (ndr_flags & NDR_SCALARS) {
3203                 NDR_CHECK(ndr_push_align(ndr, 4));
3204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->buf));
3205         }
3206         if (ndr_flags & NDR_BUFFERS) {
3207                 if (r->buf) {
3208                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->buf));
3209                 }
3210         }
3211         return NDR_ERR_SUCCESS;
3212 }
3213
3214 static enum ndr_err_code ndr_pull_lsa_DATA_BUF_PTR(struct ndr_pull *ndr, int ndr_flags, struct lsa_DATA_BUF_PTR *r)
3215 {
3216         uint32_t _ptr_buf;
3217         TALLOC_CTX *_mem_save_buf_0;
3218         if (ndr_flags & NDR_SCALARS) {
3219                 NDR_CHECK(ndr_pull_align(ndr, 4));
3220                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buf));
3221                 if (_ptr_buf) {
3222                         NDR_PULL_ALLOC(ndr, r->buf);
3223                 } else {
3224                         r->buf = NULL;
3225                 }
3226         }
3227         if (ndr_flags & NDR_BUFFERS) {
3228                 if (r->buf) {
3229                         _mem_save_buf_0 = NDR_PULL_GET_MEM_CTX(ndr);
3230                         NDR_PULL_SET_MEM_CTX(ndr, r->buf, 0);
3231                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->buf));
3232                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buf_0, 0);
3233                 }
3234         }
3235         return NDR_ERR_SUCCESS;
3236 }
3237
3238 _PUBLIC_ void ndr_print_lsa_DATA_BUF_PTR(struct ndr_print *ndr, const char *name, const struct lsa_DATA_BUF_PTR *r)
3239 {
3240         ndr_print_struct(ndr, name, "lsa_DATA_BUF_PTR");
3241         ndr->depth++;
3242         ndr_print_ptr(ndr, "buf", r->buf);
3243         ndr->depth++;
3244         if (r->buf) {
3245                 ndr_print_lsa_DATA_BUF(ndr, "buf", r->buf);
3246         }
3247         ndr->depth--;
3248         ndr->depth--;
3249 }
3250
3251 static enum ndr_err_code ndr_push_lsa_RightSet(struct ndr_push *ndr, int ndr_flags, const struct lsa_RightSet *r)
3252 {
3253         uint32_t cntr_names_1;
3254         if (ndr_flags & NDR_SCALARS) {
3255                 NDR_CHECK(ndr_push_align(ndr, 4));
3256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3257                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
3258         }
3259         if (ndr_flags & NDR_BUFFERS) {
3260                 if (r->names) {
3261                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3262                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3263                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3264                         }
3265                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3266                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3267                         }
3268                 }
3269         }
3270         return NDR_ERR_SUCCESS;
3271 }
3272
3273 static enum ndr_err_code ndr_pull_lsa_RightSet(struct ndr_pull *ndr, int ndr_flags, struct lsa_RightSet *r)
3274 {
3275         uint32_t _ptr_names;
3276         uint32_t cntr_names_1;
3277         TALLOC_CTX *_mem_save_names_0;
3278         TALLOC_CTX *_mem_save_names_1;
3279         if (ndr_flags & NDR_SCALARS) {
3280                 NDR_CHECK(ndr_pull_align(ndr, 4));
3281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3282                 if (r->count < 0 || r->count > 256) {
3283                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3284                 }
3285                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
3286                 if (_ptr_names) {
3287                         NDR_PULL_ALLOC(ndr, r->names);
3288                 } else {
3289                         r->names = NULL;
3290                 }
3291         }
3292         if (ndr_flags & NDR_BUFFERS) {
3293                 if (r->names) {
3294                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
3295                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3296                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
3297                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
3298                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
3299                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3300                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3301                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3302                         }
3303                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3304                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3305                         }
3306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
3307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
3308                 }
3309                 if (r->names) {
3310                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
3311                 }
3312         }
3313         return NDR_ERR_SUCCESS;
3314 }
3315
3316 _PUBLIC_ void ndr_print_lsa_RightSet(struct ndr_print *ndr, const char *name, const struct lsa_RightSet *r)
3317 {
3318         uint32_t cntr_names_1;
3319         ndr_print_struct(ndr, name, "lsa_RightSet");
3320         ndr->depth++;
3321         ndr_print_uint32(ndr, "count", r->count);
3322         ndr_print_ptr(ndr, "names", r->names);
3323         ndr->depth++;
3324         if (r->names) {
3325                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->count);
3326                 ndr->depth++;
3327                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
3328                         char *idx_1=NULL;
3329                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
3330                                 ndr_print_lsa_StringLarge(ndr, "names", &r->names[cntr_names_1]);
3331                                 free(idx_1);
3332                         }
3333                 }
3334                 ndr->depth--;
3335         }
3336         ndr->depth--;
3337         ndr->depth--;
3338 }
3339
3340 static enum ndr_err_code ndr_push_lsa_DomainListEx(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainListEx *r)
3341 {
3342         uint32_t cntr_domains_1;
3343         if (ndr_flags & NDR_SCALARS) {
3344                 NDR_CHECK(ndr_push_align(ndr, 4));
3345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3346                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domains));
3347         }
3348         if (ndr_flags & NDR_BUFFERS) {
3349                 if (r->domains) {
3350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3351                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3352                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
3353                         }
3354                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3355                                 NDR_CHECK(ndr_push_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
3356                         }
3357                 }
3358         }
3359         return NDR_ERR_SUCCESS;
3360 }
3361
3362 static enum ndr_err_code ndr_pull_lsa_DomainListEx(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainListEx *r)
3363 {
3364         uint32_t _ptr_domains;
3365         uint32_t cntr_domains_1;
3366         TALLOC_CTX *_mem_save_domains_0;
3367         TALLOC_CTX *_mem_save_domains_1;
3368         if (ndr_flags & NDR_SCALARS) {
3369                 NDR_CHECK(ndr_pull_align(ndr, 4));
3370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
3372                 if (_ptr_domains) {
3373                         NDR_PULL_ALLOC(ndr, r->domains);
3374                 } else {
3375                         r->domains = NULL;
3376                 }
3377         }
3378         if (ndr_flags & NDR_BUFFERS) {
3379                 if (r->domains) {
3380                         _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
3381                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
3382                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domains));
3383                         NDR_PULL_ALLOC_N(ndr, r->domains, ndr_get_array_size(ndr, &r->domains));
3384                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
3385                         NDR_PULL_SET_MEM_CTX(ndr, r->domains, 0);
3386                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3387                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_SCALARS, &r->domains[cntr_domains_1]));
3388                         }
3389                         for (cntr_domains_1 = 0; cntr_domains_1 < r->count; cntr_domains_1++) {
3390                                 NDR_CHECK(ndr_pull_lsa_TrustDomainInfoInfoEx(ndr, NDR_BUFFERS, &r->domains[cntr_domains_1]));
3391                         }
3392                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
3393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, 0);
3394                 }
3395                 if (r->domains) {
3396                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->domains, r->count));
3397                 }
3398         }
3399         return NDR_ERR_SUCCESS;
3400 }
3401
3402 _PUBLIC_ void ndr_print_lsa_DomainListEx(struct ndr_print *ndr, const char *name, const struct lsa_DomainListEx *r)
3403 {
3404         uint32_t cntr_domains_1;
3405         ndr_print_struct(ndr, name, "lsa_DomainListEx");
3406         ndr->depth++;
3407         ndr_print_uint32(ndr, "count", r->count);
3408         ndr_print_ptr(ndr, "domains", r->domains);
3409         ndr->depth++;
3410         if (r->domains) {
3411                 ndr->print(ndr, "%s: ARRAY(%d)", "domains", r->count);
3412                 ndr->depth++;
3413                 for (cntr_domains_1=0;cntr_domains_1<r->count;cntr_domains_1++) {
3414                         char *idx_1=NULL;
3415                         if (asprintf(&idx_1, "[%d]", cntr_domains_1) != -1) {
3416                                 ndr_print_lsa_TrustDomainInfoInfoEx(ndr, "domains", &r->domains[cntr_domains_1]);
3417                                 free(idx_1);
3418                         }
3419                 }
3420                 ndr->depth--;
3421         }
3422         ndr->depth--;
3423         ndr->depth--;
3424 }
3425
3426 static enum ndr_err_code ndr_push_lsa_DomainInfoKerberos(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfoKerberos *r)
3427 {
3428         if (ndr_flags & NDR_SCALARS) {
3429                 NDR_CHECK(ndr_push_align(ndr, 8));
3430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enforce_restrictions));
3431                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->service_tkt_lifetime));
3432                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->user_tkt_lifetime));
3433                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->user_tkt_renewaltime));
3434                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->clock_skew));
3435                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown6));
3436         }
3437         if (ndr_flags & NDR_BUFFERS) {
3438         }
3439         return NDR_ERR_SUCCESS;
3440 }
3441
3442 static enum ndr_err_code ndr_pull_lsa_DomainInfoKerberos(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfoKerberos *r)
3443 {
3444         if (ndr_flags & NDR_SCALARS) {
3445                 NDR_CHECK(ndr_pull_align(ndr, 8));
3446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enforce_restrictions));
3447                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->service_tkt_lifetime));
3448                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->user_tkt_lifetime));
3449                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->user_tkt_renewaltime));
3450                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->clock_skew));
3451                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown6));
3452         }
3453         if (ndr_flags & NDR_BUFFERS) {
3454         }
3455         return NDR_ERR_SUCCESS;
3456 }
3457
3458 _PUBLIC_ void ndr_print_lsa_DomainInfoKerberos(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfoKerberos *r)
3459 {
3460         ndr_print_struct(ndr, name, "lsa_DomainInfoKerberos");
3461         ndr->depth++;
3462         ndr_print_uint32(ndr, "enforce_restrictions", r->enforce_restrictions);
3463         ndr_print_hyper(ndr, "service_tkt_lifetime", r->service_tkt_lifetime);
3464         ndr_print_hyper(ndr, "user_tkt_lifetime", r->user_tkt_lifetime);
3465         ndr_print_hyper(ndr, "user_tkt_renewaltime", r->user_tkt_renewaltime);
3466         ndr_print_hyper(ndr, "clock_skew", r->clock_skew);
3467         ndr_print_hyper(ndr, "unknown6", r->unknown6);
3468         ndr->depth--;
3469 }
3470
3471 static enum ndr_err_code ndr_push_lsa_DomainInfoEfs(struct ndr_push *ndr, int ndr_flags, const struct lsa_DomainInfoEfs *r)
3472 {
3473         if (ndr_flags & NDR_SCALARS) {
3474                 NDR_CHECK(ndr_push_align(ndr, 4));
3475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->blob_size));
3476                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->efs_blob));
3477         }
3478         if (ndr_flags & NDR_BUFFERS) {
3479                 if (r->efs_blob) {
3480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->blob_size));
3481                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->efs_blob, r->blob_size));
3482                 }
3483         }
3484         return NDR_ERR_SUCCESS;
3485 }
3486
3487 static enum ndr_err_code ndr_pull_lsa_DomainInfoEfs(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfoEfs *r)
3488 {
3489         uint32_t _ptr_efs_blob;
3490         TALLOC_CTX *_mem_save_efs_blob_0;
3491         if (ndr_flags & NDR_SCALARS) {
3492                 NDR_CHECK(ndr_pull_align(ndr, 4));
3493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->blob_size));
3494                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_efs_blob));
3495                 if (_ptr_efs_blob) {
3496                         NDR_PULL_ALLOC(ndr, r->efs_blob);
3497                 } else {
3498                         r->efs_blob = NULL;
3499                 }
3500         }
3501         if (ndr_flags & NDR_BUFFERS) {
3502                 if (r->efs_blob) {
3503                         _mem_save_efs_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
3504                         NDR_PULL_SET_MEM_CTX(ndr, r->efs_blob, 0);
3505                         NDR_CHECK(ndr_pull_array_size(ndr, &r->efs_blob));
3506                         NDR_PULL_ALLOC_N(ndr, r->efs_blob, ndr_get_array_size(ndr, &r->efs_blob));
3507                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->efs_blob, ndr_get_array_size(ndr, &r->efs_blob)));
3508                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_efs_blob_0, 0);
3509                 }
3510                 if (r->efs_blob) {
3511                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->efs_blob, r->blob_size));
3512                 }
3513         }
3514         return NDR_ERR_SUCCESS;
3515 }
3516
3517 _PUBLIC_ void ndr_print_lsa_DomainInfoEfs(struct ndr_print *ndr, const char *name, const struct lsa_DomainInfoEfs *r)
3518 {
3519         ndr_print_struct(ndr, name, "lsa_DomainInfoEfs");
3520         ndr->depth++;
3521         ndr_print_uint32(ndr, "blob_size", r->blob_size);
3522         ndr_print_ptr(ndr, "efs_blob", r->efs_blob);
3523         ndr->depth++;
3524         if (r->efs_blob) {
3525                 ndr_print_array_uint8(ndr, "efs_blob", r->efs_blob, r->blob_size);
3526         }
3527         ndr->depth--;
3528         ndr->depth--;
3529 }
3530
3531 static enum ndr_err_code ndr_push_lsa_DomainInformationPolicy(struct ndr_push *ndr, int ndr_flags, const union lsa_DomainInformationPolicy *r)
3532 {
3533         if (ndr_flags & NDR_SCALARS) {
3534                 int level = ndr_push_get_switch_value(ndr, r);
3535                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
3536                 switch (level) {
3537                         case LSA_DOMAIN_INFO_POLICY_EFS: {
3538                                 NDR_CHECK(ndr_push_lsa_DomainInfoEfs(ndr, NDR_SCALARS, &r->efs_info));
3539                         break; }
3540
3541                         case LSA_DOMAIN_INFO_POLICY_KERBEROS: {
3542                                 NDR_CHECK(ndr_push_lsa_DomainInfoKerberos(ndr, NDR_SCALARS, &r->kerberos_info));
3543                         break; }
3544
3545                         default:
3546                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3547                 }
3548         }
3549         if (ndr_flags & NDR_BUFFERS) {
3550                 int level = ndr_push_get_switch_value(ndr, r);
3551                 switch (level) {
3552                         case LSA_DOMAIN_INFO_POLICY_EFS:
3553                                 NDR_CHECK(ndr_push_lsa_DomainInfoEfs(ndr, NDR_BUFFERS, &r->efs_info));
3554                         break;
3555
3556                         case LSA_DOMAIN_INFO_POLICY_KERBEROS:
3557                         break;
3558
3559                         default:
3560                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3561                 }
3562         }
3563         return NDR_ERR_SUCCESS;
3564 }
3565
3566 static enum ndr_err_code ndr_pull_lsa_DomainInformationPolicy(struct ndr_pull *ndr, int ndr_flags, union lsa_DomainInformationPolicy *r)
3567 {
3568         int level;
3569         uint16_t _level;
3570         level = ndr_pull_get_switch_value(ndr, r);
3571         if (ndr_flags & NDR_SCALARS) {
3572                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
3573                 if (_level != level) {
3574                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3575                 }
3576                 switch (level) {
3577                         case LSA_DOMAIN_INFO_POLICY_EFS: {
3578                                 NDR_CHECK(ndr_pull_lsa_DomainInfoEfs(ndr, NDR_SCALARS, &r->efs_info));
3579                         break; }
3580
3581                         case LSA_DOMAIN_INFO_POLICY_KERBEROS: {
3582                                 NDR_CHECK(ndr_pull_lsa_DomainInfoKerberos(ndr, NDR_SCALARS, &r->kerberos_info));
3583                         break; }
3584
3585                         default:
3586                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3587                 }
3588         }
3589         if (ndr_flags & NDR_BUFFERS) {
3590                 switch (level) {
3591                         case LSA_DOMAIN_INFO_POLICY_EFS:
3592                                 NDR_CHECK(ndr_pull_lsa_DomainInfoEfs(ndr, NDR_BUFFERS, &r->efs_info));
3593                         break;
3594
3595                         case LSA_DOMAIN_INFO_POLICY_KERBEROS:
3596                         break;
3597
3598                         default:
3599                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
3600                 }
3601         }
3602         return NDR_ERR_SUCCESS;
3603 }
3604
3605 _PUBLIC_ void ndr_print_lsa_DomainInformationPolicy(struct ndr_print *ndr, const char *name, const union lsa_DomainInformationPolicy *r)
3606 {
3607         int level;
3608         level = ndr_print_get_switch_value(ndr, r);
3609         ndr_print_union(ndr, name, level, "lsa_DomainInformationPolicy");
3610         switch (level) {
3611                 case LSA_DOMAIN_INFO_POLICY_EFS:
3612                         ndr_print_lsa_DomainInfoEfs(ndr, "efs_info", &r->efs_info);
3613                 break;
3614
3615                 case LSA_DOMAIN_INFO_POLICY_KERBEROS:
3616                         ndr_print_lsa_DomainInfoKerberos(ndr, "kerberos_info", &r->kerberos_info);
3617                 break;
3618
3619                 default:
3620                         ndr_print_bad_level(ndr, name, level);
3621         }
3622 }
3623
3624 static enum ndr_err_code ndr_push_lsa_TranslatedName2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedName2 *r)
3625 {
3626         if (ndr_flags & NDR_SCALARS) {
3627                 NDR_CHECK(ndr_push_align(ndr, 4));
3628                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
3629                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->name));
3630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
3631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
3632         }
3633         if (ndr_flags & NDR_BUFFERS) {
3634                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->name));
3635         }
3636         return NDR_ERR_SUCCESS;
3637 }
3638
3639 static enum ndr_err_code ndr_pull_lsa_TranslatedName2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedName2 *r)
3640 {
3641         if (ndr_flags & NDR_SCALARS) {
3642                 NDR_CHECK(ndr_pull_align(ndr, 4));
3643                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
3644                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->name));
3645                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
3646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
3647         }
3648         if (ndr_flags & NDR_BUFFERS) {
3649                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->name));
3650         }
3651         return NDR_ERR_SUCCESS;
3652 }
3653
3654 _PUBLIC_ void ndr_print_lsa_TranslatedName2(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedName2 *r)
3655 {
3656         ndr_print_struct(ndr, name, "lsa_TranslatedName2");
3657         ndr->depth++;
3658         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
3659         ndr_print_lsa_String(ndr, "name", &r->name);
3660         ndr_print_uint32(ndr, "sid_index", r->sid_index);
3661         ndr_print_uint32(ndr, "unknown", r->unknown);
3662         ndr->depth--;
3663 }
3664
3665 static enum ndr_err_code ndr_push_lsa_TransNameArray2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransNameArray2 *r)
3666 {
3667         uint32_t cntr_names_1;
3668         if (ndr_flags & NDR_SCALARS) {
3669                 NDR_CHECK(ndr_push_align(ndr, 4));
3670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
3672         }
3673         if (ndr_flags & NDR_BUFFERS) {
3674                 if (r->names) {
3675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3676                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3677                                 NDR_CHECK(ndr_push_lsa_TranslatedName2(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3678                         }
3679                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3680                                 NDR_CHECK(ndr_push_lsa_TranslatedName2(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3681                         }
3682                 }
3683         }
3684         return NDR_ERR_SUCCESS;
3685 }
3686
3687 static enum ndr_err_code ndr_pull_lsa_TransNameArray2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransNameArray2 *r)
3688 {
3689         uint32_t _ptr_names;
3690         uint32_t cntr_names_1;
3691         TALLOC_CTX *_mem_save_names_0;
3692         TALLOC_CTX *_mem_save_names_1;
3693         if (ndr_flags & NDR_SCALARS) {
3694                 NDR_CHECK(ndr_pull_align(ndr, 4));
3695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3696                 if (r->count < 0 || r->count > 1000) {
3697                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3698                 }
3699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
3700                 if (_ptr_names) {
3701                         NDR_PULL_ALLOC(ndr, r->names);
3702                 } else {
3703                         r->names = NULL;
3704                 }
3705         }
3706         if (ndr_flags & NDR_BUFFERS) {
3707                 if (r->names) {
3708                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
3709                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3710                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
3711                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
3712                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
3713                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
3714                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3715                                 NDR_CHECK(ndr_pull_lsa_TranslatedName2(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
3716                         }
3717                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
3718                                 NDR_CHECK(ndr_pull_lsa_TranslatedName2(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
3719                         }
3720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
3721                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
3722                 }
3723                 if (r->names) {
3724                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
3725                 }
3726         }
3727         return NDR_ERR_SUCCESS;
3728 }
3729
3730 _PUBLIC_ void ndr_print_lsa_TransNameArray2(struct ndr_print *ndr, const char *name, const struct lsa_TransNameArray2 *r)
3731 {
3732         uint32_t cntr_names_1;
3733         ndr_print_struct(ndr, name, "lsa_TransNameArray2");
3734         ndr->depth++;
3735         ndr_print_uint32(ndr, "count", r->count);
3736         ndr_print_ptr(ndr, "names", r->names);
3737         ndr->depth++;
3738         if (r->names) {
3739                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->count);
3740                 ndr->depth++;
3741                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
3742                         char *idx_1=NULL;
3743                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
3744                                 ndr_print_lsa_TranslatedName2(ndr, "names", &r->names[cntr_names_1]);
3745                                 free(idx_1);
3746                         }
3747                 }
3748                 ndr->depth--;
3749         }
3750         ndr->depth--;
3751         ndr->depth--;
3752 }
3753
3754 static enum ndr_err_code ndr_push_lsa_TranslatedSid2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid2 *r)
3755 {
3756         if (ndr_flags & NDR_SCALARS) {
3757                 NDR_CHECK(ndr_push_align(ndr, 4));
3758                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
3759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->rid));
3760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
3761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
3762         }
3763         if (ndr_flags & NDR_BUFFERS) {
3764         }
3765         return NDR_ERR_SUCCESS;
3766 }
3767
3768 static enum ndr_err_code ndr_pull_lsa_TranslatedSid2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid2 *r)
3769 {
3770         if (ndr_flags & NDR_SCALARS) {
3771                 NDR_CHECK(ndr_pull_align(ndr, 4));
3772                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
3773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->rid));
3774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
3775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
3776         }
3777         if (ndr_flags & NDR_BUFFERS) {
3778         }
3779         return NDR_ERR_SUCCESS;
3780 }
3781
3782 _PUBLIC_ void ndr_print_lsa_TranslatedSid2(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid2 *r)
3783 {
3784         ndr_print_struct(ndr, name, "lsa_TranslatedSid2");
3785         ndr->depth++;
3786         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
3787         ndr_print_uint32(ndr, "rid", r->rid);
3788         ndr_print_uint32(ndr, "sid_index", r->sid_index);
3789         ndr_print_uint32(ndr, "unknown", r->unknown);
3790         ndr->depth--;
3791 }
3792
3793 static enum ndr_err_code ndr_push_lsa_TransSidArray2(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray2 *r)
3794 {
3795         uint32_t cntr_sids_1;
3796         if (ndr_flags & NDR_SCALARS) {
3797                 NDR_CHECK(ndr_push_align(ndr, 4));
3798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
3800         }
3801         if (ndr_flags & NDR_BUFFERS) {
3802                 if (r->sids) {
3803                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3804                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3805                                 NDR_CHECK(ndr_push_lsa_TranslatedSid2(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
3806                         }
3807                 }
3808         }
3809         return NDR_ERR_SUCCESS;
3810 }
3811
3812 static enum ndr_err_code ndr_pull_lsa_TransSidArray2(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray2 *r)
3813 {
3814         uint32_t _ptr_sids;
3815         uint32_t cntr_sids_1;
3816         TALLOC_CTX *_mem_save_sids_0;
3817         TALLOC_CTX *_mem_save_sids_1;
3818         if (ndr_flags & NDR_SCALARS) {
3819                 NDR_CHECK(ndr_pull_align(ndr, 4));
3820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3821                 if (r->count < 0 || r->count > 1000) {
3822                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3823                 }
3824                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
3825                 if (_ptr_sids) {
3826                         NDR_PULL_ALLOC(ndr, r->sids);
3827                 } else {
3828                         r->sids = NULL;
3829                 }
3830         }
3831         if (ndr_flags & NDR_BUFFERS) {
3832                 if (r->sids) {
3833                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
3834                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3835                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
3836                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
3837                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
3838                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3839                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3840                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid2(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
3841                         }
3842                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
3843                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
3844                 }
3845                 if (r->sids) {
3846                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
3847                 }
3848         }
3849         return NDR_ERR_SUCCESS;
3850 }
3851
3852 _PUBLIC_ void ndr_print_lsa_TransSidArray2(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray2 *r)
3853 {
3854         uint32_t cntr_sids_1;
3855         ndr_print_struct(ndr, name, "lsa_TransSidArray2");
3856         ndr->depth++;
3857         ndr_print_uint32(ndr, "count", r->count);
3858         ndr_print_ptr(ndr, "sids", r->sids);
3859         ndr->depth++;
3860         if (r->sids) {
3861                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->count);
3862                 ndr->depth++;
3863                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
3864                         char *idx_1=NULL;
3865                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
3866                                 ndr_print_lsa_TranslatedSid2(ndr, "sids", &r->sids[cntr_sids_1]);
3867                                 free(idx_1);
3868                         }
3869                 }
3870                 ndr->depth--;
3871         }
3872         ndr->depth--;
3873         ndr->depth--;
3874 }
3875
3876 static enum ndr_err_code ndr_push_lsa_TranslatedSid3(struct ndr_push *ndr, int ndr_flags, const struct lsa_TranslatedSid3 *r)
3877 {
3878         if (ndr_flags & NDR_SCALARS) {
3879                 NDR_CHECK(ndr_push_align(ndr, 4));
3880                 NDR_CHECK(ndr_push_lsa_SidType(ndr, NDR_SCALARS, r->sid_type));
3881                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sid));
3882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_index));
3883                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
3884         }
3885         if (ndr_flags & NDR_BUFFERS) {
3886                 if (r->sid) {
3887                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
3888                 }
3889         }
3890         return NDR_ERR_SUCCESS;
3891 }
3892
3893 static enum ndr_err_code ndr_pull_lsa_TranslatedSid3(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid3 *r)
3894 {
3895         uint32_t _ptr_sid;
3896         TALLOC_CTX *_mem_save_sid_0;
3897         if (ndr_flags & NDR_SCALARS) {
3898                 NDR_CHECK(ndr_pull_align(ndr, 4));
3899                 NDR_CHECK(ndr_pull_lsa_SidType(ndr, NDR_SCALARS, &r->sid_type));
3900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sid));
3901                 if (_ptr_sid) {
3902                         NDR_PULL_ALLOC(ndr, r->sid);
3903                 } else {
3904                         r->sid = NULL;
3905                 }
3906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_index));
3907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
3908         }
3909         if (ndr_flags & NDR_BUFFERS) {
3910                 if (r->sid) {
3911                         _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
3912                         NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
3913                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
3914                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, 0);
3915                 }
3916         }
3917         return NDR_ERR_SUCCESS;
3918 }
3919
3920 _PUBLIC_ void ndr_print_lsa_TranslatedSid3(struct ndr_print *ndr, const char *name, const struct lsa_TranslatedSid3 *r)
3921 {
3922         ndr_print_struct(ndr, name, "lsa_TranslatedSid3");
3923         ndr->depth++;
3924         ndr_print_lsa_SidType(ndr, "sid_type", r->sid_type);
3925         ndr_print_ptr(ndr, "sid", r->sid);
3926         ndr->depth++;
3927         if (r->sid) {
3928                 ndr_print_dom_sid2(ndr, "sid", r->sid);
3929         }
3930         ndr->depth--;
3931         ndr_print_uint32(ndr, "sid_index", r->sid_index);
3932         ndr_print_uint32(ndr, "unknown", r->unknown);
3933         ndr->depth--;
3934 }
3935
3936 static enum ndr_err_code ndr_push_lsa_TransSidArray3(struct ndr_push *ndr, int ndr_flags, const struct lsa_TransSidArray3 *r)
3937 {
3938         uint32_t cntr_sids_1;
3939         if (ndr_flags & NDR_SCALARS) {
3940                 NDR_CHECK(ndr_push_align(ndr, 4));
3941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
3943         }
3944         if (ndr_flags & NDR_BUFFERS) {
3945                 if (r->sids) {
3946                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
3947                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3948                                 NDR_CHECK(ndr_push_lsa_TranslatedSid3(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
3949                         }
3950                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3951                                 NDR_CHECK(ndr_push_lsa_TranslatedSid3(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
3952                         }
3953                 }
3954         }
3955         return NDR_ERR_SUCCESS;
3956 }
3957
3958 static enum ndr_err_code ndr_pull_lsa_TransSidArray3(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray3 *r)
3959 {
3960         uint32_t _ptr_sids;
3961         uint32_t cntr_sids_1;
3962         TALLOC_CTX *_mem_save_sids_0;
3963         TALLOC_CTX *_mem_save_sids_1;
3964         if (ndr_flags & NDR_SCALARS) {
3965                 NDR_CHECK(ndr_pull_align(ndr, 4));
3966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3967                 if (r->count < 0 || r->count > 1000) {
3968                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3969                 }
3970                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
3971                 if (_ptr_sids) {
3972                         NDR_PULL_ALLOC(ndr, r->sids);
3973                 } else {
3974                         r->sids = NULL;
3975                 }
3976         }
3977         if (ndr_flags & NDR_BUFFERS) {
3978                 if (r->sids) {
3979                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
3980                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3981                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
3982                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
3983                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
3984                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
3985                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3986                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid3(ndr, NDR_SCALARS, &r->sids[cntr_sids_1]));
3987                         }
3988                         for (cntr_sids_1 = 0; cntr_sids_1 < r->count; cntr_sids_1++) {
3989                                 NDR_CHECK(ndr_pull_lsa_TranslatedSid3(ndr, NDR_BUFFERS, &r->sids[cntr_sids_1]));
3990                         }
3991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
3992                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
3993                 }
3994                 if (r->sids) {
3995                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->count));
3996                 }
3997         }
3998         return NDR_ERR_SUCCESS;
3999 }
4000
4001 _PUBLIC_ void ndr_print_lsa_TransSidArray3(struct ndr_print *ndr, const char *name, const struct lsa_TransSidArray3 *r)
4002 {
4003         uint32_t cntr_sids_1;
4004         ndr_print_struct(ndr, name, "lsa_TransSidArray3");
4005         ndr->depth++;
4006         ndr_print_uint32(ndr, "count", r->count);
4007         ndr_print_ptr(ndr, "sids", r->sids);
4008         ndr->depth++;
4009         if (r->sids) {
4010                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", r->count);
4011                 ndr->depth++;
4012                 for (cntr_sids_1=0;cntr_sids_1<r->count;cntr_sids_1++) {
4013                         char *idx_1=NULL;
4014                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4015                                 ndr_print_lsa_TranslatedSid3(ndr, "sids", &r->sids[cntr_sids_1]);
4016                                 free(idx_1);
4017                         }
4018                 }
4019                 ndr->depth--;
4020         }
4021         ndr->depth--;
4022         ndr->depth--;
4023 }
4024
4025 static enum ndr_err_code ndr_push_lsa_ForestTrustBinaryData(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustBinaryData *r)
4026 {
4027         if (ndr_flags & NDR_SCALARS) {
4028                 NDR_CHECK(ndr_push_align(ndr, 4));
4029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
4031         }
4032         if (ndr_flags & NDR_BUFFERS) {
4033                 if (r->data) {
4034                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
4035                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
4036                 }
4037         }
4038         return NDR_ERR_SUCCESS;
4039 }
4040
4041 static enum ndr_err_code ndr_pull_lsa_ForestTrustBinaryData(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustBinaryData *r)
4042 {
4043         uint32_t _ptr_data;
4044         TALLOC_CTX *_mem_save_data_0;
4045         if (ndr_flags & NDR_SCALARS) {
4046                 NDR_CHECK(ndr_pull_align(ndr, 4));
4047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
4048                 if (r->length < 0 || r->length > 131072) {
4049                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4050                 }
4051                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
4052                 if (_ptr_data) {
4053                         NDR_PULL_ALLOC(ndr, r->data);
4054                 } else {
4055                         r->data = NULL;
4056                 }
4057         }
4058         if (ndr_flags & NDR_BUFFERS) {
4059                 if (r->data) {
4060                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
4061                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
4062                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
4063                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
4064                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
4065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
4066                 }
4067                 if (r->data) {
4068                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
4069                 }
4070         }
4071         return NDR_ERR_SUCCESS;
4072 }
4073
4074 _PUBLIC_ void ndr_print_lsa_ForestTrustBinaryData(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustBinaryData *r)
4075 {
4076         ndr_print_struct(ndr, name, "lsa_ForestTrustBinaryData");
4077         ndr->depth++;
4078         ndr_print_uint32(ndr, "length", r->length);
4079         ndr_print_ptr(ndr, "data", r->data);
4080         ndr->depth++;
4081         if (r->data) {
4082                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
4083         }
4084         ndr->depth--;
4085         ndr->depth--;
4086 }
4087
4088 static enum ndr_err_code ndr_push_lsa_ForestTrustDomainInfo(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustDomainInfo *r)
4089 {
4090         if (ndr_flags & NDR_SCALARS) {
4091                 NDR_CHECK(ndr_push_align(ndr, 4));
4092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_sid));
4093                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain_name));
4094                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_domain_name));
4095         }
4096         if (ndr_flags & NDR_BUFFERS) {
4097                 if (r->domain_sid) {
4098                         NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
4099                 }
4100                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain_name));
4101                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_domain_name));
4102         }
4103         return NDR_ERR_SUCCESS;
4104 }
4105
4106 static enum ndr_err_code ndr_pull_lsa_ForestTrustDomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustDomainInfo *r)
4107 {
4108         uint32_t _ptr_domain_sid;
4109         TALLOC_CTX *_mem_save_domain_sid_0;
4110         if (ndr_flags & NDR_SCALARS) {
4111                 NDR_CHECK(ndr_pull_align(ndr, 4));
4112                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_sid));
4113                 if (_ptr_domain_sid) {
4114                         NDR_PULL_ALLOC(ndr, r->domain_sid);
4115                 } else {
4116                         r->domain_sid = NULL;
4117                 }
4118                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->dns_domain_name));
4119                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->netbios_domain_name));
4120         }
4121         if (ndr_flags & NDR_BUFFERS) {
4122                 if (r->domain_sid) {
4123                         _mem_save_domain_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
4124                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_sid, 0);
4125                         NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain_sid));
4126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_sid_0, 0);
4127                 }
4128                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain_name));
4129                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->netbios_domain_name));
4130         }
4131         return NDR_ERR_SUCCESS;
4132 }
4133
4134 _PUBLIC_ void ndr_print_lsa_ForestTrustDomainInfo(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustDomainInfo *r)
4135 {
4136         ndr_print_struct(ndr, name, "lsa_ForestTrustDomainInfo");
4137         ndr->depth++;
4138         ndr_print_ptr(ndr, "domain_sid", r->domain_sid);
4139         ndr->depth++;
4140         if (r->domain_sid) {
4141                 ndr_print_dom_sid2(ndr, "domain_sid", r->domain_sid);
4142         }
4143         ndr->depth--;
4144         ndr_print_lsa_StringLarge(ndr, "dns_domain_name", &r->dns_domain_name);
4145         ndr_print_lsa_StringLarge(ndr, "netbios_domain_name", &r->netbios_domain_name);
4146         ndr->depth--;
4147 }
4148
4149 static enum ndr_err_code ndr_push_lsa_ForestTrustData(struct ndr_push *ndr, int ndr_flags, const union lsa_ForestTrustData *r)
4150 {
4151         if (ndr_flags & NDR_SCALARS) {
4152                 int level = ndr_push_get_switch_value(ndr, r);
4153                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
4154                 switch (level) {
4155                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME: {
4156                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->top_level_name));
4157                         break; }
4158
4159                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX: {
4160                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS, &r->top_level_name_ex));
4161                         break; }
4162
4163                         case LSA_FOREST_TRUST_DOMAIN_INFO: {
4164                                 NDR_CHECK(ndr_push_lsa_ForestTrustDomainInfo(ndr, NDR_SCALARS, &r->domain_info));
4165                         break; }
4166
4167                         default: {
4168                                 NDR_CHECK(ndr_push_lsa_ForestTrustBinaryData(ndr, NDR_SCALARS, &r->data));
4169                         break; }
4170
4171                 }
4172         }
4173         if (ndr_flags & NDR_BUFFERS) {
4174                 int level = ndr_push_get_switch_value(ndr, r);
4175                 switch (level) {
4176                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME:
4177                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->top_level_name));
4178                         break;
4179
4180                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX:
4181                                 NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->top_level_name_ex));
4182                         break;
4183
4184                         case LSA_FOREST_TRUST_DOMAIN_INFO:
4185                                 NDR_CHECK(ndr_push_lsa_ForestTrustDomainInfo(ndr, NDR_BUFFERS, &r->domain_info));
4186                         break;
4187
4188                         default:
4189                                 NDR_CHECK(ndr_push_lsa_ForestTrustBinaryData(ndr, NDR_BUFFERS, &r->data));
4190                         break;
4191
4192                 }
4193         }
4194         return NDR_ERR_SUCCESS;
4195 }
4196
4197 static enum ndr_err_code ndr_pull_lsa_ForestTrustData(struct ndr_pull *ndr, int ndr_flags, union lsa_ForestTrustData *r)
4198 {
4199         int level;
4200         uint32_t _level;
4201         level = ndr_pull_get_switch_value(ndr, r);
4202         if (ndr_flags & NDR_SCALARS) {
4203                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
4204                 if (_level != level) {
4205                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
4206                 }
4207                 switch (level) {
4208                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME: {
4209                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->top_level_name));
4210                         break; }
4211
4212                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX: {
4213                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS, &r->top_level_name_ex));
4214                         break; }
4215
4216                         case LSA_FOREST_TRUST_DOMAIN_INFO: {
4217                                 NDR_CHECK(ndr_pull_lsa_ForestTrustDomainInfo(ndr, NDR_SCALARS, &r->domain_info));
4218                         break; }
4219
4220                         default: {
4221                                 NDR_CHECK(ndr_pull_lsa_ForestTrustBinaryData(ndr, NDR_SCALARS, &r->data));
4222                         break; }
4223
4224                 }
4225         }
4226         if (ndr_flags & NDR_BUFFERS) {
4227                 switch (level) {
4228                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME:
4229                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->top_level_name));
4230                         break;
4231
4232                         case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX:
4233                                 NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->top_level_name_ex));
4234                         break;
4235
4236                         case LSA_FOREST_TRUST_DOMAIN_INFO:
4237                                 NDR_CHECK(ndr_pull_lsa_ForestTrustDomainInfo(ndr, NDR_BUFFERS, &r->domain_info));
4238                         break;
4239
4240                         default:
4241                                 NDR_CHECK(ndr_pull_lsa_ForestTrustBinaryData(ndr, NDR_BUFFERS, &r->data));
4242                         break;
4243
4244                 }
4245         }
4246         return NDR_ERR_SUCCESS;
4247 }
4248
4249 _PUBLIC_ void ndr_print_lsa_ForestTrustData(struct ndr_print *ndr, const char *name, const union lsa_ForestTrustData *r)
4250 {
4251         int level;
4252         level = ndr_print_get_switch_value(ndr, r);
4253         ndr_print_union(ndr, name, level, "lsa_ForestTrustData");
4254         switch (level) {
4255                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME:
4256                         ndr_print_lsa_String(ndr, "top_level_name", &r->top_level_name);
4257                 break;
4258
4259                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX:
4260                         ndr_print_lsa_StringLarge(ndr, "top_level_name_ex", &r->top_level_name_ex);
4261                 break;
4262
4263                 case LSA_FOREST_TRUST_DOMAIN_INFO:
4264                         ndr_print_lsa_ForestTrustDomainInfo(ndr, "domain_info", &r->domain_info);
4265                 break;
4266
4267                 default:
4268                         ndr_print_lsa_ForestTrustBinaryData(ndr, "data", &r->data);
4269                 break;
4270
4271         }
4272 }
4273
4274 static enum ndr_err_code ndr_push_lsa_ForestTrustRecordType(struct ndr_push *ndr, int ndr_flags, enum lsa_ForestTrustRecordType r)
4275 {
4276         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4277         return NDR_ERR_SUCCESS;
4278 }
4279
4280 static enum ndr_err_code ndr_pull_lsa_ForestTrustRecordType(struct ndr_pull *ndr, int ndr_flags, enum lsa_ForestTrustRecordType *r)
4281 {
4282         uint32_t v;
4283         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4284         *r = v;
4285         return NDR_ERR_SUCCESS;
4286 }
4287
4288 _PUBLIC_ void ndr_print_lsa_ForestTrustRecordType(struct ndr_print *ndr, const char *name, enum lsa_ForestTrustRecordType r)
4289 {
4290         const char *val = NULL;
4291
4292         switch (r) {
4293                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME: val = "LSA_FOREST_TRUST_TOP_LEVEL_NAME"; break;
4294                 case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX: val = "LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX"; break;
4295                 case LSA_FOREST_TRUST_DOMAIN_INFO: val = "LSA_FOREST_TRUST_DOMAIN_INFO"; break;
4296                 case LSA_FOREST_TRUST_RECORD_TYPE_LAST: val = "LSA_FOREST_TRUST_RECORD_TYPE_LAST"; break;
4297         }
4298         ndr_print_enum(ndr, name, "ENUM", val, r);
4299 }
4300
4301 static enum ndr_err_code ndr_push_lsa_ForestTrustRecord(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustRecord *r)
4302 {
4303         if (ndr_flags & NDR_SCALARS) {
4304                 NDR_CHECK(ndr_push_align(ndr, 8));
4305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4306                 NDR_CHECK(ndr_push_lsa_ForestTrustRecordType(ndr, NDR_SCALARS, r->level));
4307                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown));
4308                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->forest_trust_data, r->level));
4309                 NDR_CHECK(ndr_push_lsa_ForestTrustData(ndr, NDR_SCALARS, &r->forest_trust_data));
4310         }
4311         if (ndr_flags & NDR_BUFFERS) {
4312                 NDR_CHECK(ndr_push_lsa_ForestTrustData(ndr, NDR_BUFFERS, &r->forest_trust_data));
4313         }
4314         return NDR_ERR_SUCCESS;
4315 }
4316
4317 static enum ndr_err_code ndr_pull_lsa_ForestTrustRecord(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustRecord *r)
4318 {
4319         if (ndr_flags & NDR_SCALARS) {
4320                 NDR_CHECK(ndr_pull_align(ndr, 8));
4321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
4322                 NDR_CHECK(ndr_pull_lsa_ForestTrustRecordType(ndr, NDR_SCALARS, &r->level));
4323                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown));
4324                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->forest_trust_data, r->level));
4325                 NDR_CHECK(ndr_pull_lsa_ForestTrustData(ndr, NDR_SCALARS, &r->forest_trust_data));
4326         }
4327         if (ndr_flags & NDR_BUFFERS) {
4328                 NDR_CHECK(ndr_pull_lsa_ForestTrustData(ndr, NDR_BUFFERS, &r->forest_trust_data));
4329         }
4330         return NDR_ERR_SUCCESS;
4331 }
4332
4333 _PUBLIC_ void ndr_print_lsa_ForestTrustRecord(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustRecord *r)
4334 {
4335         ndr_print_struct(ndr, name, "lsa_ForestTrustRecord");
4336         ndr->depth++;
4337         ndr_print_uint32(ndr, "flags", r->flags);
4338         ndr_print_lsa_ForestTrustRecordType(ndr, "level", r->level);
4339         ndr_print_hyper(ndr, "unknown", r->unknown);
4340         ndr_print_set_switch_value(ndr, &r->forest_trust_data, r->level);
4341         ndr_print_lsa_ForestTrustData(ndr, "forest_trust_data", &r->forest_trust_data);
4342         ndr->depth--;
4343 }
4344
4345 _PUBLIC_ enum ndr_err_code ndr_push_lsa_ForestTrustInformation(struct ndr_push *ndr, int ndr_flags, const struct lsa_ForestTrustInformation *r)
4346 {
4347         uint32_t cntr_entries_1;
4348         if (ndr_flags & NDR_SCALARS) {
4349                 NDR_CHECK(ndr_push_align(ndr, 4));
4350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries));
4352         }
4353         if (ndr_flags & NDR_BUFFERS) {
4354                 if (r->entries) {
4355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4356                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4357                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->entries[cntr_entries_1]));
4358                         }
4359                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4360                                 if (r->entries[cntr_entries_1]) {
4361                                         NDR_CHECK(ndr_push_lsa_ForestTrustRecord(ndr, NDR_SCALARS|NDR_BUFFERS, r->entries[cntr_entries_1]));
4362                                 }
4363                         }
4364                 }
4365         }
4366         return NDR_ERR_SUCCESS;
4367 }
4368
4369 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_ForestTrustInformation(struct ndr_pull *ndr, int ndr_flags, struct lsa_ForestTrustInformation *r)
4370 {
4371         uint32_t _ptr_entries;
4372         uint32_t cntr_entries_1;
4373         TALLOC_CTX *_mem_save_entries_0;
4374         TALLOC_CTX *_mem_save_entries_1;
4375         TALLOC_CTX *_mem_save_entries_2;
4376         if (ndr_flags & NDR_SCALARS) {
4377                 NDR_CHECK(ndr_pull_align(ndr, 4));
4378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4379                 if (r->count < 0 || r->count > 4000) {
4380                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4381                 }
4382                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4383                 if (_ptr_entries) {
4384                         NDR_PULL_ALLOC(ndr, r->entries);
4385                 } else {
4386                         r->entries = NULL;
4387                 }
4388         }
4389         if (ndr_flags & NDR_BUFFERS) {
4390                 if (r->entries) {
4391                         _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
4392                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4393                         NDR_CHECK(ndr_pull_array_size(ndr, &r->entries));
4394                         NDR_PULL_ALLOC_N(ndr, r->entries, ndr_get_array_size(ndr, &r->entries));
4395                         _mem_save_entries_1 = NDR_PULL_GET_MEM_CTX(ndr);
4396                         NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
4397                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4398                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_entries));
4399                                 if (_ptr_entries) {
4400                                         NDR_PULL_ALLOC(ndr, r->entries[cntr_entries_1]);
4401                                 } else {
4402                                         r->entries[cntr_entries_1] = NULL;
4403                                 }
4404                         }
4405                         for (cntr_entries_1 = 0; cntr_entries_1 < r->count; cntr_entries_1++) {
4406                                 if (r->entries[cntr_entries_1]) {
4407                                         _mem_save_entries_2 = NDR_PULL_GET_MEM_CTX(ndr);
4408                                         NDR_PULL_SET_MEM_CTX(ndr, r->entries[cntr_entries_1], 0);
4409                                         NDR_CHECK(ndr_pull_lsa_ForestTrustRecord(ndr, NDR_SCALARS|NDR_BUFFERS, r->entries[cntr_entries_1]));
4410                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_2, 0);
4411                                 }
4412                         }
4413                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_1, 0);
4414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
4415                 }
4416                 if (r->entries) {
4417                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->entries, r->count));
4418                 }
4419         }
4420         return NDR_ERR_SUCCESS;
4421 }
4422
4423 _PUBLIC_ void ndr_print_lsa_ForestTrustInformation(struct ndr_print *ndr, const char *name, const struct lsa_ForestTrustInformation *r)
4424 {
4425         uint32_t cntr_entries_1;
4426         ndr_print_struct(ndr, name, "lsa_ForestTrustInformation");
4427         ndr->depth++;
4428         ndr_print_uint32(ndr, "count", r->count);
4429         ndr_print_ptr(ndr, "entries", r->entries);
4430         ndr->depth++;
4431         if (r->entries) {
4432                 ndr->print(ndr, "%s: ARRAY(%d)", "entries", r->count);
4433                 ndr->depth++;
4434                 for (cntr_entries_1=0;cntr_entries_1<r->count;cntr_entries_1++) {
4435                         char *idx_1=NULL;
4436                         if (asprintf(&idx_1, "[%d]", cntr_entries_1) != -1) {
4437                                 ndr_print_ptr(ndr, "entries", r->entries[cntr_entries_1]);
4438                                 ndr->depth++;
4439                                 if (r->entries[cntr_entries_1]) {
4440                                         ndr_print_lsa_ForestTrustRecord(ndr, "entries", r->entries[cntr_entries_1]);
4441                                 }
4442                                 ndr->depth--;
4443                                 free(idx_1);
4444                         }
4445                 }
4446                 ndr->depth--;
4447         }
4448         ndr->depth--;
4449         ndr->depth--;
4450 }
4451
4452 static enum ndr_err_code ndr_push_lsa_Close(struct ndr_push *ndr, int flags, const struct lsa_Close *r)
4453 {
4454         if (flags & NDR_IN) {
4455                 if (r->in.handle == NULL) {
4456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4457                 }
4458                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4459         }
4460         if (flags & NDR_OUT) {
4461                 if (r->out.handle == NULL) {
4462                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4463                 }
4464                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
4465                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4466         }
4467         return NDR_ERR_SUCCESS;
4468 }
4469
4470 static enum ndr_err_code ndr_pull_lsa_Close(struct ndr_pull *ndr, int flags, struct lsa_Close *r)
4471 {
4472         TALLOC_CTX *_mem_save_handle_0;
4473         if (flags & NDR_IN) {
4474                 ZERO_STRUCT(r->out);
4475
4476                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4477                         NDR_PULL_ALLOC(ndr, r->in.handle);
4478                 }
4479                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4480                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4481                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4482                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4483                 NDR_PULL_ALLOC(ndr, r->out.handle);
4484                 *r->out.handle = *r->in.handle;
4485         }
4486         if (flags & NDR_OUT) {
4487                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4488                         NDR_PULL_ALLOC(ndr, r->out.handle);
4489                 }
4490                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4491                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
4492                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
4493                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4494                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4495         }
4496         return NDR_ERR_SUCCESS;
4497 }
4498
4499 _PUBLIC_ void ndr_print_lsa_Close(struct ndr_print *ndr, const char *name, int flags, const struct lsa_Close *r)
4500 {
4501         ndr_print_struct(ndr, name, "lsa_Close");
4502         ndr->depth++;
4503         if (flags & NDR_SET_VALUES) {
4504                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4505         }
4506         if (flags & NDR_IN) {
4507                 ndr_print_struct(ndr, "in", "lsa_Close");
4508                 ndr->depth++;
4509                 ndr_print_ptr(ndr, "handle", r->in.handle);
4510                 ndr->depth++;
4511                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4512                 ndr->depth--;
4513                 ndr->depth--;
4514         }
4515         if (flags & NDR_OUT) {
4516                 ndr_print_struct(ndr, "out", "lsa_Close");
4517                 ndr->depth++;
4518                 ndr_print_ptr(ndr, "handle", r->out.handle);
4519                 ndr->depth++;
4520                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
4521                 ndr->depth--;
4522                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4523                 ndr->depth--;
4524         }
4525         ndr->depth--;
4526 }
4527
4528 _PUBLIC_ enum ndr_err_code ndr_push_lsa_Delete(struct ndr_push *ndr, int flags, const struct lsa_Delete *r)
4529 {
4530         if (flags & NDR_IN) {
4531                 if (r->in.handle == NULL) {
4532                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4533                 }
4534                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4535         }
4536         if (flags & NDR_OUT) {
4537                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4538         }
4539         return NDR_ERR_SUCCESS;
4540 }
4541
4542 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_Delete(struct ndr_pull *ndr, int flags, struct lsa_Delete *r)
4543 {
4544         TALLOC_CTX *_mem_save_handle_0;
4545         if (flags & NDR_IN) {
4546                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4547                         NDR_PULL_ALLOC(ndr, r->in.handle);
4548                 }
4549                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4550                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4551                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4552                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4553         }
4554         if (flags & NDR_OUT) {
4555                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4556         }
4557         return NDR_ERR_SUCCESS;
4558 }
4559
4560 _PUBLIC_ void ndr_print_lsa_Delete(struct ndr_print *ndr, const char *name, int flags, const struct lsa_Delete *r)
4561 {
4562         ndr_print_struct(ndr, name, "lsa_Delete");
4563         ndr->depth++;
4564         if (flags & NDR_SET_VALUES) {
4565                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4566         }
4567         if (flags & NDR_IN) {
4568                 ndr_print_struct(ndr, "in", "lsa_Delete");
4569                 ndr->depth++;
4570                 ndr_print_ptr(ndr, "handle", r->in.handle);
4571                 ndr->depth++;
4572                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4573                 ndr->depth--;
4574                 ndr->depth--;
4575         }
4576         if (flags & NDR_OUT) {
4577                 ndr_print_struct(ndr, "out", "lsa_Delete");
4578                 ndr->depth++;
4579                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4580                 ndr->depth--;
4581         }
4582         ndr->depth--;
4583 }
4584
4585 _PUBLIC_ enum ndr_err_code ndr_push_lsa_EnumPrivs(struct ndr_push *ndr, int flags, const struct lsa_EnumPrivs *r)
4586 {
4587         if (flags & NDR_IN) {
4588                 if (r->in.handle == NULL) {
4589                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4590                 }
4591                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4592                 if (r->in.resume_handle == NULL) {
4593                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4594                 }
4595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
4596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_count));
4597         }
4598         if (flags & NDR_OUT) {
4599                 if (r->out.resume_handle == NULL) {
4600                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4601                 }
4602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
4603                 if (r->out.privs == NULL) {
4604                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4605                 }
4606                 NDR_CHECK(ndr_push_lsa_PrivArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.privs));
4607                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4608         }
4609         return NDR_ERR_SUCCESS;
4610 }
4611
4612 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_EnumPrivs(struct ndr_pull *ndr, int flags, struct lsa_EnumPrivs *r)
4613 {
4614         TALLOC_CTX *_mem_save_handle_0;
4615         TALLOC_CTX *_mem_save_resume_handle_0;
4616         TALLOC_CTX *_mem_save_privs_0;
4617         if (flags & NDR_IN) {
4618                 ZERO_STRUCT(r->out);
4619
4620                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4621                         NDR_PULL_ALLOC(ndr, r->in.handle);
4622                 }
4623                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4624                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4625                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4626                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4627                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4628                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
4629                 }
4630                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4631                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
4632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
4633                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
4634                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_count));
4635                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
4636                 *r->out.resume_handle = *r->in.resume_handle;
4637                 NDR_PULL_ALLOC(ndr, r->out.privs);
4638                 ZERO_STRUCTP(r->out.privs);
4639         }
4640         if (flags & NDR_OUT) {
4641                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4642                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
4643                 }
4644                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4645                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
4646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
4647                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
4648                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4649                         NDR_PULL_ALLOC(ndr, r->out.privs);
4650                 }
4651                 _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4652                 NDR_PULL_SET_MEM_CTX(ndr, r->out.privs, LIBNDR_FLAG_REF_ALLOC);
4653                 NDR_CHECK(ndr_pull_lsa_PrivArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.privs));
4654                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, LIBNDR_FLAG_REF_ALLOC);
4655                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4656         }
4657         return NDR_ERR_SUCCESS;
4658 }
4659
4660 _PUBLIC_ void ndr_print_lsa_EnumPrivs(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumPrivs *r)
4661 {
4662         ndr_print_struct(ndr, name, "lsa_EnumPrivs");
4663         ndr->depth++;
4664         if (flags & NDR_SET_VALUES) {
4665                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4666         }
4667         if (flags & NDR_IN) {
4668                 ndr_print_struct(ndr, "in", "lsa_EnumPrivs");
4669                 ndr->depth++;
4670                 ndr_print_ptr(ndr, "handle", r->in.handle);
4671                 ndr->depth++;
4672                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4673                 ndr->depth--;
4674                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
4675                 ndr->depth++;
4676                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
4677                 ndr->depth--;
4678                 ndr_print_uint32(ndr, "max_count", r->in.max_count);
4679                 ndr->depth--;
4680         }
4681         if (flags & NDR_OUT) {
4682                 ndr_print_struct(ndr, "out", "lsa_EnumPrivs");
4683                 ndr->depth++;
4684                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
4685                 ndr->depth++;
4686                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
4687                 ndr->depth--;
4688                 ndr_print_ptr(ndr, "privs", r->out.privs);
4689                 ndr->depth++;
4690                 ndr_print_lsa_PrivArray(ndr, "privs", r->out.privs);
4691                 ndr->depth--;
4692                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4693                 ndr->depth--;
4694         }
4695         ndr->depth--;
4696 }
4697
4698 static enum ndr_err_code ndr_push_lsa_QuerySecurity(struct ndr_push *ndr, int flags, const struct lsa_QuerySecurity *r)
4699 {
4700         if (flags & NDR_IN) {
4701                 if (r->in.handle == NULL) {
4702                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4703                 }
4704                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4705                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
4706         }
4707         if (flags & NDR_OUT) {
4708                 if (r->out.sdbuf == NULL) {
4709                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4710                 }
4711                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.sdbuf));
4712                 if (*r->out.sdbuf) {
4713                         NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
4714                 }
4715                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4716         }
4717         return NDR_ERR_SUCCESS;
4718 }
4719
4720 static enum ndr_err_code ndr_pull_lsa_QuerySecurity(struct ndr_pull *ndr, int flags, struct lsa_QuerySecurity *r)
4721 {
4722         uint32_t _ptr_sdbuf;
4723         TALLOC_CTX *_mem_save_handle_0;
4724         TALLOC_CTX *_mem_save_sdbuf_0;
4725         TALLOC_CTX *_mem_save_sdbuf_1;
4726         if (flags & NDR_IN) {
4727                 ZERO_STRUCT(r->out);
4728
4729                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4730                         NDR_PULL_ALLOC(ndr, r->in.handle);
4731                 }
4732                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4733                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4734                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4735                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4736                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
4737                 NDR_PULL_ALLOC(ndr, r->out.sdbuf);
4738                 ZERO_STRUCTP(r->out.sdbuf);
4739         }
4740         if (flags & NDR_OUT) {
4741                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4742                         NDR_PULL_ALLOC(ndr, r->out.sdbuf);
4743                 }
4744                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
4745                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sdbuf, LIBNDR_FLAG_REF_ALLOC);
4746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sdbuf));
4747                 if (_ptr_sdbuf) {
4748                         NDR_PULL_ALLOC(ndr, *r->out.sdbuf);
4749                 } else {
4750                         *r->out.sdbuf = NULL;
4751                 }
4752                 if (*r->out.sdbuf) {
4753                         _mem_save_sdbuf_1 = NDR_PULL_GET_MEM_CTX(ndr);
4754                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.sdbuf, 0);
4755                         NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.sdbuf));
4756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_1, 0);
4757                 }
4758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
4759                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4760         }
4761         return NDR_ERR_SUCCESS;
4762 }
4763
4764 _PUBLIC_ void ndr_print_lsa_QuerySecurity(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QuerySecurity *r)
4765 {
4766         ndr_print_struct(ndr, name, "lsa_QuerySecurity");
4767         ndr->depth++;
4768         if (flags & NDR_SET_VALUES) {
4769                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4770         }
4771         if (flags & NDR_IN) {
4772                 ndr_print_struct(ndr, "in", "lsa_QuerySecurity");
4773                 ndr->depth++;
4774                 ndr_print_ptr(ndr, "handle", r->in.handle);
4775                 ndr->depth++;
4776                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4777                 ndr->depth--;
4778                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
4779                 ndr->depth--;
4780         }
4781         if (flags & NDR_OUT) {
4782                 ndr_print_struct(ndr, "out", "lsa_QuerySecurity");
4783                 ndr->depth++;
4784                 ndr_print_ptr(ndr, "sdbuf", r->out.sdbuf);
4785                 ndr->depth++;
4786                 ndr_print_ptr(ndr, "sdbuf", *r->out.sdbuf);
4787                 ndr->depth++;
4788                 if (*r->out.sdbuf) {
4789                         ndr_print_sec_desc_buf(ndr, "sdbuf", *r->out.sdbuf);
4790                 }
4791                 ndr->depth--;
4792                 ndr->depth--;
4793                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4794                 ndr->depth--;
4795         }
4796         ndr->depth--;
4797 }
4798
4799 static enum ndr_err_code ndr_push_lsa_SetSecObj(struct ndr_push *ndr, int flags, const struct lsa_SetSecObj *r)
4800 {
4801         if (flags & NDR_IN) {
4802                 if (r->in.handle == NULL) {
4803                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4804                 }
4805                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4806                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
4807                 if (r->in.sdbuf == NULL) {
4808                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4809                 }
4810                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
4811         }
4812         if (flags & NDR_OUT) {
4813                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4814         }
4815         return NDR_ERR_SUCCESS;
4816 }
4817
4818 static enum ndr_err_code ndr_pull_lsa_SetSecObj(struct ndr_pull *ndr, int flags, struct lsa_SetSecObj *r)
4819 {
4820         TALLOC_CTX *_mem_save_handle_0;
4821         TALLOC_CTX *_mem_save_sdbuf_0;
4822         if (flags & NDR_IN) {
4823                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4824                         NDR_PULL_ALLOC(ndr, r->in.handle);
4825                 }
4826                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4827                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4828                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4829                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4830                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
4831                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4832                         NDR_PULL_ALLOC(ndr, r->in.sdbuf);
4833                 }
4834                 _mem_save_sdbuf_0 = NDR_PULL_GET_MEM_CTX(ndr);
4835                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sdbuf, LIBNDR_FLAG_REF_ALLOC);
4836                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sdbuf));
4837                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sdbuf_0, LIBNDR_FLAG_REF_ALLOC);
4838         }
4839         if (flags & NDR_OUT) {
4840                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4841         }
4842         return NDR_ERR_SUCCESS;
4843 }
4844
4845 _PUBLIC_ void ndr_print_lsa_SetSecObj(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSecObj *r)
4846 {
4847         ndr_print_struct(ndr, name, "lsa_SetSecObj");
4848         ndr->depth++;
4849         if (flags & NDR_SET_VALUES) {
4850                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4851         }
4852         if (flags & NDR_IN) {
4853                 ndr_print_struct(ndr, "in", "lsa_SetSecObj");
4854                 ndr->depth++;
4855                 ndr_print_ptr(ndr, "handle", r->in.handle);
4856                 ndr->depth++;
4857                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4858                 ndr->depth--;
4859                 ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
4860                 ndr_print_ptr(ndr, "sdbuf", r->in.sdbuf);
4861                 ndr->depth++;
4862                 ndr_print_sec_desc_buf(ndr, "sdbuf", r->in.sdbuf);
4863                 ndr->depth--;
4864                 ndr->depth--;
4865         }
4866         if (flags & NDR_OUT) {
4867                 ndr_print_struct(ndr, "out", "lsa_SetSecObj");
4868                 ndr->depth++;
4869                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4870                 ndr->depth--;
4871         }
4872         ndr->depth--;
4873 }
4874
4875 static enum ndr_err_code ndr_push_lsa_ChangePassword(struct ndr_push *ndr, int flags, const struct lsa_ChangePassword *r)
4876 {
4877         if (flags & NDR_IN) {
4878         }
4879         if (flags & NDR_OUT) {
4880                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4881         }
4882         return NDR_ERR_SUCCESS;
4883 }
4884
4885 static enum ndr_err_code ndr_pull_lsa_ChangePassword(struct ndr_pull *ndr, int flags, struct lsa_ChangePassword *r)
4886 {
4887         if (flags & NDR_IN) {
4888         }
4889         if (flags & NDR_OUT) {
4890                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4891         }
4892         return NDR_ERR_SUCCESS;
4893 }
4894
4895 _PUBLIC_ void ndr_print_lsa_ChangePassword(struct ndr_print *ndr, const char *name, int flags, const struct lsa_ChangePassword *r)
4896 {
4897         ndr_print_struct(ndr, name, "lsa_ChangePassword");
4898         ndr->depth++;
4899         if (flags & NDR_SET_VALUES) {
4900                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4901         }
4902         if (flags & NDR_IN) {
4903                 ndr_print_struct(ndr, "in", "lsa_ChangePassword");
4904                 ndr->depth++;
4905                 ndr->depth--;
4906         }
4907         if (flags & NDR_OUT) {
4908                 ndr_print_struct(ndr, "out", "lsa_ChangePassword");
4909                 ndr->depth++;
4910                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
4911                 ndr->depth--;
4912         }
4913         ndr->depth--;
4914 }
4915
4916 _PUBLIC_ enum ndr_err_code ndr_push_lsa_OpenPolicy(struct ndr_push *ndr, int flags, const struct lsa_OpenPolicy *r)
4917 {
4918         if (flags & NDR_IN) {
4919                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
4920                 if (r->in.system_name) {
4921                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
4922                 }
4923                 if (r->in.attr == NULL) {
4924                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4925                 }
4926                 NDR_CHECK(ndr_push_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
4927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
4928         }
4929         if (flags & NDR_OUT) {
4930                 if (r->out.handle == NULL) {
4931                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4932                 }
4933                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
4934                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4935         }
4936         return NDR_ERR_SUCCESS;
4937 }
4938
4939 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_OpenPolicy(struct ndr_pull *ndr, int flags, struct lsa_OpenPolicy *r)
4940 {
4941         uint32_t _ptr_system_name;
4942         TALLOC_CTX *_mem_save_system_name_0;
4943         TALLOC_CTX *_mem_save_attr_0;
4944         TALLOC_CTX *_mem_save_handle_0;
4945         if (flags & NDR_IN) {
4946                 ZERO_STRUCT(r->out);
4947
4948                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
4949                 if (_ptr_system_name) {
4950                         NDR_PULL_ALLOC(ndr, r->in.system_name);
4951                 } else {
4952                         r->in.system_name = NULL;
4953                 }
4954                 if (r->in.system_name) {
4955                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4956                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
4957                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
4958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
4959                 }
4960                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4961                         NDR_PULL_ALLOC(ndr, r->in.attr);
4962                 }
4963                 _mem_save_attr_0 = NDR_PULL_GET_MEM_CTX(ndr);
4964                 NDR_PULL_SET_MEM_CTX(ndr, r->in.attr, LIBNDR_FLAG_REF_ALLOC);
4965                 NDR_CHECK(ndr_pull_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
4966                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attr_0, LIBNDR_FLAG_REF_ALLOC);
4967                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
4968                 NDR_PULL_ALLOC(ndr, r->out.handle);
4969                 ZERO_STRUCTP(r->out.handle);
4970         }
4971         if (flags & NDR_OUT) {
4972                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4973                         NDR_PULL_ALLOC(ndr, r->out.handle);
4974                 }
4975                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4976                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
4977                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
4978                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4979                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4980         }
4981         return NDR_ERR_SUCCESS;
4982 }
4983
4984 _PUBLIC_ void ndr_print_lsa_OpenPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenPolicy *r)
4985 {
4986         ndr_print_struct(ndr, name, "lsa_OpenPolicy");
4987         ndr->depth++;
4988         if (flags & NDR_SET_VALUES) {
4989                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4990         }
4991         if (flags & NDR_IN) {
4992                 ndr_print_struct(ndr, "in", "lsa_OpenPolicy");
4993                 ndr->depth++;
4994                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
4995                 ndr->depth++;
4996                 if (r->in.system_name) {
4997                         ndr_print_uint16(ndr, "system_name", *r->in.system_name);
4998                 }
4999                 ndr->depth--;
5000                 ndr_print_ptr(ndr, "attr", r->in.attr);
5001                 ndr->depth++;
5002                 ndr_print_lsa_ObjectAttribute(ndr, "attr", r->in.attr);
5003                 ndr->depth--;
5004                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
5005                 ndr->depth--;
5006         }
5007         if (flags & NDR_OUT) {
5008                 ndr_print_struct(ndr, "out", "lsa_OpenPolicy");
5009                 ndr->depth++;
5010                 ndr_print_ptr(ndr, "handle", r->out.handle);
5011                 ndr->depth++;
5012                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
5013                 ndr->depth--;
5014                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5015                 ndr->depth--;
5016         }
5017         ndr->depth--;
5018 }
5019
5020 static enum ndr_err_code ndr_push_lsa_QueryInfoPolicy(struct ndr_push *ndr, int flags, const struct lsa_QueryInfoPolicy *r)
5021 {
5022         if (flags & NDR_IN) {
5023                 if (r->in.handle == NULL) {
5024                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5025                 }
5026                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5027                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
5028         }
5029         if (flags & NDR_OUT) {
5030                 if (r->out.info == NULL) {
5031                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5032                 }
5033                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
5034                 if (*r->out.info) {
5035                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
5036                         NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
5037                 }
5038                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5039         }
5040         return NDR_ERR_SUCCESS;
5041 }
5042
5043 static enum ndr_err_code ndr_pull_lsa_QueryInfoPolicy(struct ndr_pull *ndr, int flags, struct lsa_QueryInfoPolicy *r)
5044 {
5045         uint32_t _ptr_info;
5046         TALLOC_CTX *_mem_save_handle_0;
5047         TALLOC_CTX *_mem_save_info_0;
5048         TALLOC_CTX *_mem_save_info_1;
5049         if (flags & NDR_IN) {
5050                 ZERO_STRUCT(r->out);
5051
5052                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5053                         NDR_PULL_ALLOC(ndr, r->in.handle);
5054                 }
5055                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5056                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5057                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5058                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5059                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
5060                 NDR_PULL_ALLOC(ndr, r->out.info);
5061                 ZERO_STRUCTP(r->out.info);
5062         }
5063         if (flags & NDR_OUT) {
5064                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5065                         NDR_PULL_ALLOC(ndr, r->out.info);
5066                 }
5067                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5068                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
5069                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
5070                 if (_ptr_info) {
5071                         NDR_PULL_ALLOC(ndr, *r->out.info);
5072                 } else {
5073                         *r->out.info = NULL;
5074                 }
5075                 if (*r->out.info) {
5076                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
5077                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
5078                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
5079                         NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
5080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
5081                 }
5082                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5083                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5084         }
5085         return NDR_ERR_SUCCESS;
5086 }
5087
5088 _PUBLIC_ void ndr_print_lsa_QueryInfoPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryInfoPolicy *r)
5089 {
5090         ndr_print_struct(ndr, name, "lsa_QueryInfoPolicy");
5091         ndr->depth++;
5092         if (flags & NDR_SET_VALUES) {
5093                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5094         }
5095         if (flags & NDR_IN) {
5096                 ndr_print_struct(ndr, "in", "lsa_QueryInfoPolicy");
5097                 ndr->depth++;
5098                 ndr_print_ptr(ndr, "handle", r->in.handle);
5099                 ndr->depth++;
5100                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5101                 ndr->depth--;
5102                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
5103                 ndr->depth--;
5104         }
5105         if (flags & NDR_OUT) {
5106                 ndr_print_struct(ndr, "out", "lsa_QueryInfoPolicy");
5107                 ndr->depth++;
5108                 ndr_print_ptr(ndr, "info", r->out.info);
5109                 ndr->depth++;
5110                 ndr_print_ptr(ndr, "info", *r->out.info);
5111                 ndr->depth++;
5112                 if (*r->out.info) {
5113                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
5114                         ndr_print_lsa_PolicyInformation(ndr, "info", *r->out.info);
5115                 }
5116                 ndr->depth--;
5117                 ndr->depth--;
5118                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5119                 ndr->depth--;
5120         }
5121         ndr->depth--;
5122 }
5123
5124 static enum ndr_err_code ndr_push_lsa_SetInfoPolicy(struct ndr_push *ndr, int flags, const struct lsa_SetInfoPolicy *r)
5125 {
5126         if (flags & NDR_IN) {
5127                 if (r->in.handle == NULL) {
5128                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5129                 }
5130                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5131                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
5132                 if (r->in.info == NULL) {
5133                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5134                 }
5135                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
5136                 NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5137         }
5138         if (flags & NDR_OUT) {
5139                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5140         }
5141         return NDR_ERR_SUCCESS;
5142 }
5143
5144 static enum ndr_err_code ndr_pull_lsa_SetInfoPolicy(struct ndr_pull *ndr, int flags, struct lsa_SetInfoPolicy *r)
5145 {
5146         TALLOC_CTX *_mem_save_handle_0;
5147         TALLOC_CTX *_mem_save_info_0;
5148         if (flags & NDR_IN) {
5149                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5150                         NDR_PULL_ALLOC(ndr, r->in.handle);
5151                 }
5152                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5153                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5154                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5155                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5156                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
5157                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5158                         NDR_PULL_ALLOC(ndr, r->in.info);
5159                 }
5160                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5161                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5162                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
5163                 NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5164                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5165         }
5166         if (flags & NDR_OUT) {
5167                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5168         }
5169         return NDR_ERR_SUCCESS;
5170 }
5171
5172 _PUBLIC_ void ndr_print_lsa_SetInfoPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInfoPolicy *r)
5173 {
5174         ndr_print_struct(ndr, name, "lsa_SetInfoPolicy");
5175         ndr->depth++;
5176         if (flags & NDR_SET_VALUES) {
5177                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5178         }
5179         if (flags & NDR_IN) {
5180                 ndr_print_struct(ndr, "in", "lsa_SetInfoPolicy");
5181                 ndr->depth++;
5182                 ndr_print_ptr(ndr, "handle", r->in.handle);
5183                 ndr->depth++;
5184                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5185                 ndr->depth--;
5186                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
5187                 ndr_print_ptr(ndr, "info", r->in.info);
5188                 ndr->depth++;
5189                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
5190                 ndr_print_lsa_PolicyInformation(ndr, "info", r->in.info);
5191                 ndr->depth--;
5192                 ndr->depth--;
5193         }
5194         if (flags & NDR_OUT) {
5195                 ndr_print_struct(ndr, "out", "lsa_SetInfoPolicy");
5196                 ndr->depth++;
5197                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5198                 ndr->depth--;
5199         }
5200         ndr->depth--;
5201 }
5202
5203 static enum ndr_err_code ndr_push_lsa_ClearAuditLog(struct ndr_push *ndr, int flags, const struct lsa_ClearAuditLog *r)
5204 {
5205         if (flags & NDR_IN) {
5206         }
5207         if (flags & NDR_OUT) {
5208                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5209         }
5210         return NDR_ERR_SUCCESS;
5211 }
5212
5213 static enum ndr_err_code ndr_pull_lsa_ClearAuditLog(struct ndr_pull *ndr, int flags, struct lsa_ClearAuditLog *r)
5214 {
5215         if (flags & NDR_IN) {
5216         }
5217         if (flags & NDR_OUT) {
5218                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5219         }
5220         return NDR_ERR_SUCCESS;
5221 }
5222
5223 _PUBLIC_ void ndr_print_lsa_ClearAuditLog(struct ndr_print *ndr, const char *name, int flags, const struct lsa_ClearAuditLog *r)
5224 {
5225         ndr_print_struct(ndr, name, "lsa_ClearAuditLog");
5226         ndr->depth++;
5227         if (flags & NDR_SET_VALUES) {
5228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5229         }
5230         if (flags & NDR_IN) {
5231                 ndr_print_struct(ndr, "in", "lsa_ClearAuditLog");
5232                 ndr->depth++;
5233                 ndr->depth--;
5234         }
5235         if (flags & NDR_OUT) {
5236                 ndr_print_struct(ndr, "out", "lsa_ClearAuditLog");
5237                 ndr->depth++;
5238                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5239                 ndr->depth--;
5240         }
5241         ndr->depth--;
5242 }
5243
5244 _PUBLIC_ enum ndr_err_code ndr_push_lsa_CreateAccount(struct ndr_push *ndr, int flags, const struct lsa_CreateAccount *r)
5245 {
5246         if (flags & NDR_IN) {
5247                 if (r->in.handle == NULL) {
5248                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5249                 }
5250                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5251                 if (r->in.sid == NULL) {
5252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5253                 }
5254                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
5255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
5256         }
5257         if (flags & NDR_OUT) {
5258                 if (r->out.acct_handle == NULL) {
5259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5260                 }
5261                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
5262                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5263         }
5264         return NDR_ERR_SUCCESS;
5265 }
5266
5267 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_CreateAccount(struct ndr_pull *ndr, int flags, struct lsa_CreateAccount *r)
5268 {
5269         TALLOC_CTX *_mem_save_handle_0;
5270         TALLOC_CTX *_mem_save_sid_0;
5271         TALLOC_CTX *_mem_save_acct_handle_0;
5272         if (flags & NDR_IN) {
5273                 ZERO_STRUCT(r->out);
5274
5275                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5276                         NDR_PULL_ALLOC(ndr, r->in.handle);
5277                 }
5278                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5279                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5280                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5281                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5282                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5283                         NDR_PULL_ALLOC(ndr, r->in.sid);
5284                 }
5285                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
5286                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
5287                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
5288                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
5289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
5290                 NDR_PULL_ALLOC(ndr, r->out.acct_handle);
5291                 ZERO_STRUCTP(r->out.acct_handle);
5292         }
5293         if (flags & NDR_OUT) {
5294                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5295                         NDR_PULL_ALLOC(ndr, r->out.acct_handle);
5296                 }
5297                 _mem_save_acct_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5298                 NDR_PULL_SET_MEM_CTX(ndr, r->out.acct_handle, LIBNDR_FLAG_REF_ALLOC);
5299                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
5300                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_handle_0, LIBNDR_FLAG_REF_ALLOC);
5301                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5302         }
5303         return NDR_ERR_SUCCESS;
5304 }
5305
5306 _PUBLIC_ void ndr_print_lsa_CreateAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateAccount *r)
5307 {
5308         ndr_print_struct(ndr, name, "lsa_CreateAccount");
5309         ndr->depth++;
5310         if (flags & NDR_SET_VALUES) {
5311                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5312         }
5313         if (flags & NDR_IN) {
5314                 ndr_print_struct(ndr, "in", "lsa_CreateAccount");
5315                 ndr->depth++;
5316                 ndr_print_ptr(ndr, "handle", r->in.handle);
5317                 ndr->depth++;
5318                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5319                 ndr->depth--;
5320                 ndr_print_ptr(ndr, "sid", r->in.sid);
5321                 ndr->depth++;
5322                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
5323                 ndr->depth--;
5324                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
5325                 ndr->depth--;
5326         }
5327         if (flags & NDR_OUT) {
5328                 ndr_print_struct(ndr, "out", "lsa_CreateAccount");
5329                 ndr->depth++;
5330                 ndr_print_ptr(ndr, "acct_handle", r->out.acct_handle);
5331                 ndr->depth++;
5332                 ndr_print_policy_handle(ndr, "acct_handle", r->out.acct_handle);
5333                 ndr->depth--;
5334                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5335                 ndr->depth--;
5336         }
5337         ndr->depth--;
5338 }
5339
5340 _PUBLIC_ enum ndr_err_code ndr_push_lsa_EnumAccounts(struct ndr_push *ndr, int flags, const struct lsa_EnumAccounts *r)
5341 {
5342         if (flags & NDR_IN) {
5343                 if (r->in.handle == NULL) {
5344                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5345                 }
5346                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5347                 if (r->in.resume_handle == NULL) {
5348                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5349                 }
5350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_entries));
5352         }
5353         if (flags & NDR_OUT) {
5354                 if (r->out.resume_handle == NULL) {
5355                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5356                 }
5357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5358                 if (r->out.sids == NULL) {
5359                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5360                 }
5361                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
5362                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5363         }
5364         return NDR_ERR_SUCCESS;
5365 }
5366
5367 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_EnumAccounts(struct ndr_pull *ndr, int flags, struct lsa_EnumAccounts *r)
5368 {
5369         TALLOC_CTX *_mem_save_handle_0;
5370         TALLOC_CTX *_mem_save_resume_handle_0;
5371         TALLOC_CTX *_mem_save_sids_0;
5372         if (flags & NDR_IN) {
5373                 ZERO_STRUCT(r->out);
5374
5375                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5376                         NDR_PULL_ALLOC(ndr, r->in.handle);
5377                 }
5378                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5379                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5380                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5381                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5382                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5383                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5384                 }
5385                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5386                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5388                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_entries));
5390                 if (r->in.num_entries < 0 || r->in.num_entries > 8192) {
5391                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5392                 }
5393                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5394                 *r->out.resume_handle = *r->in.resume_handle;
5395                 NDR_PULL_ALLOC(ndr, r->out.sids);
5396                 ZERO_STRUCTP(r->out.sids);
5397         }
5398         if (flags & NDR_OUT) {
5399                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5400                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5401                 }
5402                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5403                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5404                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5405                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5406                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5407                         NDR_PULL_ALLOC(ndr, r->out.sids);
5408                 }
5409                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
5410                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
5411                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
5412                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
5413                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5414         }
5415         return NDR_ERR_SUCCESS;
5416 }
5417
5418 _PUBLIC_ void ndr_print_lsa_EnumAccounts(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccounts *r)
5419 {
5420         ndr_print_struct(ndr, name, "lsa_EnumAccounts");
5421         ndr->depth++;
5422         if (flags & NDR_SET_VALUES) {
5423                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5424         }
5425         if (flags & NDR_IN) {
5426                 ndr_print_struct(ndr, "in", "lsa_EnumAccounts");
5427                 ndr->depth++;
5428                 ndr_print_ptr(ndr, "handle", r->in.handle);
5429                 ndr->depth++;
5430                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5431                 ndr->depth--;
5432                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5433                 ndr->depth++;
5434                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5435                 ndr->depth--;
5436                 ndr_print_uint32(ndr, "num_entries", r->in.num_entries);
5437                 ndr->depth--;
5438         }
5439         if (flags & NDR_OUT) {
5440                 ndr_print_struct(ndr, "out", "lsa_EnumAccounts");
5441                 ndr->depth++;
5442                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5443                 ndr->depth++;
5444                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5445                 ndr->depth--;
5446                 ndr_print_ptr(ndr, "sids", r->out.sids);
5447                 ndr->depth++;
5448                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
5449                 ndr->depth--;
5450                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5451                 ndr->depth--;
5452         }
5453         ndr->depth--;
5454 }
5455
5456 _PUBLIC_ enum ndr_err_code ndr_push_lsa_CreateTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomain *r)
5457 {
5458         if (flags & NDR_IN) {
5459                 if (r->in.handle == NULL) {
5460                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5461                 }
5462                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5463                 if (r->in.info == NULL) {
5464                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5465                 }
5466                 NDR_CHECK(ndr_push_lsa_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
5468         }
5469         if (flags & NDR_OUT) {
5470                 if (r->out.trustdom_handle == NULL) {
5471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5472                 }
5473                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
5474                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5475         }
5476         return NDR_ERR_SUCCESS;
5477 }
5478
5479 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_CreateTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomain *r)
5480 {
5481         TALLOC_CTX *_mem_save_handle_0;
5482         TALLOC_CTX *_mem_save_info_0;
5483         TALLOC_CTX *_mem_save_trustdom_handle_0;
5484         if (flags & NDR_IN) {
5485                 ZERO_STRUCT(r->out);
5486
5487                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5488                         NDR_PULL_ALLOC(ndr, r->in.handle);
5489                 }
5490                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5491                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5492                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5493                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5494                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5495                         NDR_PULL_ALLOC(ndr, r->in.info);
5496                 }
5497                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
5498                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
5499                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
5500                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
5501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
5502                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
5503                 ZERO_STRUCTP(r->out.trustdom_handle);
5504         }
5505         if (flags & NDR_OUT) {
5506                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5507                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
5508                 }
5509                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5510                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
5511                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
5512                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
5513                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5514         }
5515         return NDR_ERR_SUCCESS;
5516 }
5517
5518 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomain *r)
5519 {
5520         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomain");
5521         ndr->depth++;
5522         if (flags & NDR_SET_VALUES) {
5523                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5524         }
5525         if (flags & NDR_IN) {
5526                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomain");
5527                 ndr->depth++;
5528                 ndr_print_ptr(ndr, "handle", r->in.handle);
5529                 ndr->depth++;
5530                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5531                 ndr->depth--;
5532                 ndr_print_ptr(ndr, "info", r->in.info);
5533                 ndr->depth++;
5534                 ndr_print_lsa_DomainInfo(ndr, "info", r->in.info);
5535                 ndr->depth--;
5536                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
5537                 ndr->depth--;
5538         }
5539         if (flags & NDR_OUT) {
5540                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomain");
5541                 ndr->depth++;
5542                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
5543                 ndr->depth++;
5544                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
5545                 ndr->depth--;
5546                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5547                 ndr->depth--;
5548         }
5549         ndr->depth--;
5550 }
5551
5552 static enum ndr_err_code ndr_push_lsa_EnumTrustDom(struct ndr_push *ndr, int flags, const struct lsa_EnumTrustDom *r)
5553 {
5554         if (flags & NDR_IN) {
5555                 if (r->in.handle == NULL) {
5556                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5557                 }
5558                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5559                 if (r->in.resume_handle == NULL) {
5560                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5561                 }
5562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
5564         }
5565         if (flags & NDR_OUT) {
5566                 if (r->out.resume_handle == NULL) {
5567                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5568                 }
5569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5570                 if (r->out.domains == NULL) {
5571                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5572                 }
5573                 NDR_CHECK(ndr_push_lsa_DomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
5574                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5575         }
5576         return NDR_ERR_SUCCESS;
5577 }
5578
5579 static enum ndr_err_code ndr_pull_lsa_EnumTrustDom(struct ndr_pull *ndr, int flags, struct lsa_EnumTrustDom *r)
5580 {
5581         TALLOC_CTX *_mem_save_handle_0;
5582         TALLOC_CTX *_mem_save_resume_handle_0;
5583         TALLOC_CTX *_mem_save_domains_0;
5584         if (flags & NDR_IN) {
5585                 ZERO_STRUCT(r->out);
5586
5587                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5588                         NDR_PULL_ALLOC(ndr, r->in.handle);
5589                 }
5590                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5591                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5592                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5593                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5594                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5595                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5596                 }
5597                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5598                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
5602                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5603                 *r->out.resume_handle = *r->in.resume_handle;
5604                 NDR_PULL_ALLOC(ndr, r->out.domains);
5605                 ZERO_STRUCTP(r->out.domains);
5606         }
5607         if (flags & NDR_OUT) {
5608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5609                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5610                 }
5611                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5612                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
5613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
5615                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5616                         NDR_PULL_ALLOC(ndr, r->out.domains);
5617                 }
5618                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
5619                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
5620                 NDR_CHECK(ndr_pull_lsa_DomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
5621                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
5622                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5623         }
5624         return NDR_ERR_SUCCESS;
5625 }
5626
5627 _PUBLIC_ void ndr_print_lsa_EnumTrustDom(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumTrustDom *r)
5628 {
5629         ndr_print_struct(ndr, name, "lsa_EnumTrustDom");
5630         ndr->depth++;
5631         if (flags & NDR_SET_VALUES) {
5632                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5633         }
5634         if (flags & NDR_IN) {
5635                 ndr_print_struct(ndr, "in", "lsa_EnumTrustDom");
5636                 ndr->depth++;
5637                 ndr_print_ptr(ndr, "handle", r->in.handle);
5638                 ndr->depth++;
5639                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5640                 ndr->depth--;
5641                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5642                 ndr->depth++;
5643                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5644                 ndr->depth--;
5645                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
5646                 ndr->depth--;
5647         }
5648         if (flags & NDR_OUT) {
5649                 ndr_print_struct(ndr, "out", "lsa_EnumTrustDom");
5650                 ndr->depth++;
5651                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5652                 ndr->depth++;
5653                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5654                 ndr->depth--;
5655                 ndr_print_ptr(ndr, "domains", r->out.domains);
5656                 ndr->depth++;
5657                 ndr_print_lsa_DomainList(ndr, "domains", r->out.domains);
5658                 ndr->depth--;
5659                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5660                 ndr->depth--;
5661         }
5662         ndr->depth--;
5663 }
5664
5665 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupNames(struct ndr_push *ndr, int flags, const struct lsa_LookupNames *r)
5666 {
5667         uint32_t cntr_names_0;
5668         if (flags & NDR_IN) {
5669                 if (r->in.handle == NULL) {
5670                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5671                 }
5672                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
5674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
5675                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5676                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
5677                 }
5678                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5679                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
5680                 }
5681                 if (r->in.sids == NULL) {
5682                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5683                 }
5684                 NDR_CHECK(ndr_push_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
5685                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
5686                 if (r->in.count == NULL) {
5687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5688                 }
5689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
5690         }
5691         if (flags & NDR_OUT) {
5692                 if (r->out.domains == NULL) {
5693                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5694                 }
5695                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
5696                 if (*r->out.domains) {
5697                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
5698                 }
5699                 if (r->out.sids == NULL) {
5700                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5701                 }
5702                 NDR_CHECK(ndr_push_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
5703                 if (r->out.count == NULL) {
5704                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5705                 }
5706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
5707                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5708         }
5709         return NDR_ERR_SUCCESS;
5710 }
5711
5712 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupNames(struct ndr_pull *ndr, int flags, struct lsa_LookupNames *r)
5713 {
5714         uint32_t cntr_names_0;
5715         uint32_t _ptr_domains;
5716         TALLOC_CTX *_mem_save_handle_0;
5717         TALLOC_CTX *_mem_save_names_0;
5718         TALLOC_CTX *_mem_save_domains_0;
5719         TALLOC_CTX *_mem_save_domains_1;
5720         TALLOC_CTX *_mem_save_sids_0;
5721         TALLOC_CTX *_mem_save_count_0;
5722         if (flags & NDR_IN) {
5723                 ZERO_STRUCT(r->out);
5724
5725                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5726                         NDR_PULL_ALLOC(ndr, r->in.handle);
5727                 }
5728                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5729                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5730                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5731                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5732                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
5733                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
5734                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5735                 }
5736                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
5737                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
5738                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5739                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
5740                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5741                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
5742                 }
5743                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5744                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
5745                 }
5746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5747                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5748                         NDR_PULL_ALLOC(ndr, r->in.sids);
5749                 }
5750                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
5751                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
5752                 NDR_CHECK(ndr_pull_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
5753                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
5754                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
5755                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5756                         NDR_PULL_ALLOC(ndr, r->in.count);
5757                 }
5758                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
5759                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
5760                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
5761                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
5762                 NDR_PULL_ALLOC(ndr, r->out.domains);
5763                 ZERO_STRUCTP(r->out.domains);
5764                 NDR_PULL_ALLOC(ndr, r->out.sids);
5765                 *r->out.sids = *r->in.sids;
5766                 NDR_PULL_ALLOC(ndr, r->out.count);
5767                 *r->out.count = *r->in.count;
5768                 if (r->in.names) {
5769                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
5770                 }
5771         }
5772         if (flags & NDR_OUT) {
5773                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5774                         NDR_PULL_ALLOC(ndr, r->out.domains);
5775                 }
5776                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
5777                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
5778                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
5779                 if (_ptr_domains) {
5780                         NDR_PULL_ALLOC(ndr, *r->out.domains);
5781                 } else {
5782                         *r->out.domains = NULL;
5783                 }
5784                 if (*r->out.domains) {
5785                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
5786                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
5787                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
5788                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
5789                 }
5790                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
5791                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5792                         NDR_PULL_ALLOC(ndr, r->out.sids);
5793                 }
5794                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
5795                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
5796                 NDR_CHECK(ndr_pull_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
5797                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
5798                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5799                         NDR_PULL_ALLOC(ndr, r->out.count);
5800                 }
5801                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
5802                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
5803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
5804                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
5805                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5806         }
5807         return NDR_ERR_SUCCESS;
5808 }
5809
5810 _PUBLIC_ void ndr_print_lsa_LookupNames(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames *r)
5811 {
5812         uint32_t cntr_names_0;
5813         ndr_print_struct(ndr, name, "lsa_LookupNames");
5814         ndr->depth++;
5815         if (flags & NDR_SET_VALUES) {
5816                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5817         }
5818         if (flags & NDR_IN) {
5819                 ndr_print_struct(ndr, "in", "lsa_LookupNames");
5820                 ndr->depth++;
5821                 ndr_print_ptr(ndr, "handle", r->in.handle);
5822                 ndr->depth++;
5823                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5824                 ndr->depth--;
5825                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
5826                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
5827                 ndr->depth++;
5828                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
5829                         char *idx_0=NULL;
5830                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
5831                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
5832                                 free(idx_0);
5833                         }
5834                 }
5835                 ndr->depth--;
5836                 ndr_print_ptr(ndr, "sids", r->in.sids);
5837                 ndr->depth++;
5838                 ndr_print_lsa_TransSidArray(ndr, "sids", r->in.sids);
5839                 ndr->depth--;
5840                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
5841                 ndr_print_ptr(ndr, "count", r->in.count);
5842                 ndr->depth++;
5843                 ndr_print_uint32(ndr, "count", *r->in.count);
5844                 ndr->depth--;
5845                 ndr->depth--;
5846         }
5847         if (flags & NDR_OUT) {
5848                 ndr_print_struct(ndr, "out", "lsa_LookupNames");
5849                 ndr->depth++;
5850                 ndr_print_ptr(ndr, "domains", r->out.domains);
5851                 ndr->depth++;
5852                 ndr_print_ptr(ndr, "domains", *r->out.domains);
5853                 ndr->depth++;
5854                 if (*r->out.domains) {
5855                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
5856                 }
5857                 ndr->depth--;
5858                 ndr->depth--;
5859                 ndr_print_ptr(ndr, "sids", r->out.sids);
5860                 ndr->depth++;
5861                 ndr_print_lsa_TransSidArray(ndr, "sids", r->out.sids);
5862                 ndr->depth--;
5863                 ndr_print_ptr(ndr, "count", r->out.count);
5864                 ndr->depth++;
5865                 ndr_print_uint32(ndr, "count", *r->out.count);
5866                 ndr->depth--;
5867                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
5868                 ndr->depth--;
5869         }
5870         ndr->depth--;
5871 }
5872
5873 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupSids(struct ndr_push *ndr, int flags, const struct lsa_LookupSids *r)
5874 {
5875         if (flags & NDR_IN) {
5876                 if (r->in.handle == NULL) {
5877                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5878                 }
5879                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5880                 if (r->in.sids == NULL) {
5881                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5882                 }
5883                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
5884                 if (r->in.names == NULL) {
5885                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5886                 }
5887                 NDR_CHECK(ndr_push_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
5888                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
5889                 if (r->in.count == NULL) {
5890                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5891                 }
5892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
5893         }
5894         if (flags & NDR_OUT) {
5895                 if (r->out.domains == NULL) {
5896                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5897                 }
5898                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
5899                 if (*r->out.domains) {
5900                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
5901                 }
5902                 if (r->out.names == NULL) {
5903                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5904                 }
5905                 NDR_CHECK(ndr_push_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
5906                 if (r->out.count == NULL) {
5907                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5908                 }
5909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
5910                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5911         }
5912         return NDR_ERR_SUCCESS;
5913 }
5914
5915 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupSids(struct ndr_pull *ndr, int flags, struct lsa_LookupSids *r)
5916 {
5917         uint32_t _ptr_domains;
5918         TALLOC_CTX *_mem_save_handle_0;
5919         TALLOC_CTX *_mem_save_sids_0;
5920         TALLOC_CTX *_mem_save_domains_0;
5921         TALLOC_CTX *_mem_save_domains_1;
5922         TALLOC_CTX *_mem_save_names_0;
5923         TALLOC_CTX *_mem_save_count_0;
5924         if (flags & NDR_IN) {
5925                 ZERO_STRUCT(r->out);
5926
5927                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5928                         NDR_PULL_ALLOC(ndr, r->in.handle);
5929                 }
5930                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5931                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5932                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
5933                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5934                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5935                         NDR_PULL_ALLOC(ndr, r->in.sids);
5936                 }
5937                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
5938                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
5939                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
5940                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
5941                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5942                         NDR_PULL_ALLOC(ndr, r->in.names);
5943                 }
5944                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5945                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
5946                 NDR_CHECK(ndr_pull_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
5947                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
5948                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
5949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5950                         NDR_PULL_ALLOC(ndr, r->in.count);
5951                 }
5952                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
5953                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
5954                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
5955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
5956                 NDR_PULL_ALLOC(ndr, r->out.domains);
5957                 ZERO_STRUCTP(r->out.domains);
5958                 NDR_PULL_ALLOC(ndr, r->out.names);
5959                 *r->out.names = *r->in.names;
5960                 NDR_PULL_ALLOC(ndr, r->out.count);
5961                 *r->out.count = *r->in.count;
5962         }
5963         if (flags & NDR_OUT) {
5964                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5965                         NDR_PULL_ALLOC(ndr, r->out.domains);
5966                 }
5967                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
5968                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
5969                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
5970                 if (_ptr_domains) {
5971                         NDR_PULL_ALLOC(ndr, *r->out.domains);
5972                 } else {
5973                         *r->out.domains = NULL;
5974                 }
5975                 if (*r->out.domains) {
5976                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
5977                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
5978                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
5979                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
5980                 }
5981                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
5982                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5983                         NDR_PULL_ALLOC(ndr, r->out.names);
5984                 }
5985                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5986                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
5987                 NDR_CHECK(ndr_pull_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
5988                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
5989                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5990                         NDR_PULL_ALLOC(ndr, r->out.count);
5991                 }
5992                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
5993                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
5994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
5995                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
5996                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5997         }
5998         return NDR_ERR_SUCCESS;
5999 }
6000
6001 _PUBLIC_ void ndr_print_lsa_LookupSids(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids *r)
6002 {
6003         ndr_print_struct(ndr, name, "lsa_LookupSids");
6004         ndr->depth++;
6005         if (flags & NDR_SET_VALUES) {
6006                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6007         }
6008         if (flags & NDR_IN) {
6009                 ndr_print_struct(ndr, "in", "lsa_LookupSids");
6010                 ndr->depth++;
6011                 ndr_print_ptr(ndr, "handle", r->in.handle);
6012                 ndr->depth++;
6013                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6014                 ndr->depth--;
6015                 ndr_print_ptr(ndr, "sids", r->in.sids);
6016                 ndr->depth++;
6017                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
6018                 ndr->depth--;
6019                 ndr_print_ptr(ndr, "names", r->in.names);
6020                 ndr->depth++;
6021                 ndr_print_lsa_TransNameArray(ndr, "names", r->in.names);
6022                 ndr->depth--;
6023                 ndr_print_uint16(ndr, "level", r->in.level);
6024                 ndr_print_ptr(ndr, "count", r->in.count);
6025                 ndr->depth++;
6026                 ndr_print_uint32(ndr, "count", *r->in.count);
6027                 ndr->depth--;
6028                 ndr->depth--;
6029         }
6030         if (flags & NDR_OUT) {
6031                 ndr_print_struct(ndr, "out", "lsa_LookupSids");
6032                 ndr->depth++;
6033                 ndr_print_ptr(ndr, "domains", r->out.domains);
6034                 ndr->depth++;
6035                 ndr_print_ptr(ndr, "domains", *r->out.domains);
6036                 ndr->depth++;
6037                 if (*r->out.domains) {
6038                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
6039                 }
6040                 ndr->depth--;
6041                 ndr->depth--;
6042                 ndr_print_ptr(ndr, "names", r->out.names);
6043                 ndr->depth++;
6044                 ndr_print_lsa_TransNameArray(ndr, "names", r->out.names);
6045                 ndr->depth--;
6046                 ndr_print_ptr(ndr, "count", r->out.count);
6047                 ndr->depth++;
6048                 ndr_print_uint32(ndr, "count", *r->out.count);
6049                 ndr->depth--;
6050                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6051                 ndr->depth--;
6052         }
6053         ndr->depth--;
6054 }
6055
6056 _PUBLIC_ enum ndr_err_code ndr_push_lsa_CreateSecret(struct ndr_push *ndr, int flags, const struct lsa_CreateSecret *r)
6057 {
6058         if (flags & NDR_IN) {
6059                 if (r->in.handle == NULL) {
6060                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6061                 }
6062                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6063                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6065         }
6066         if (flags & NDR_OUT) {
6067                 if (r->out.sec_handle == NULL) {
6068                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6069                 }
6070                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
6071                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6072         }
6073         return NDR_ERR_SUCCESS;
6074 }
6075
6076 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_CreateSecret(struct ndr_pull *ndr, int flags, struct lsa_CreateSecret *r)
6077 {
6078         TALLOC_CTX *_mem_save_handle_0;
6079         TALLOC_CTX *_mem_save_sec_handle_0;
6080         if (flags & NDR_IN) {
6081                 ZERO_STRUCT(r->out);
6082
6083                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6084                         NDR_PULL_ALLOC(ndr, r->in.handle);
6085                 }
6086                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6087                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6088                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6090                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6091                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6092                 NDR_PULL_ALLOC(ndr, r->out.sec_handle);
6093                 ZERO_STRUCTP(r->out.sec_handle);
6094         }
6095         if (flags & NDR_OUT) {
6096                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6097                         NDR_PULL_ALLOC(ndr, r->out.sec_handle);
6098                 }
6099                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6100                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sec_handle, LIBNDR_FLAG_REF_ALLOC);
6101                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
6102                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
6103                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6104         }
6105         return NDR_ERR_SUCCESS;
6106 }
6107
6108 _PUBLIC_ void ndr_print_lsa_CreateSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateSecret *r)
6109 {
6110         ndr_print_struct(ndr, name, "lsa_CreateSecret");
6111         ndr->depth++;
6112         if (flags & NDR_SET_VALUES) {
6113                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6114         }
6115         if (flags & NDR_IN) {
6116                 ndr_print_struct(ndr, "in", "lsa_CreateSecret");
6117                 ndr->depth++;
6118                 ndr_print_ptr(ndr, "handle", r->in.handle);
6119                 ndr->depth++;
6120                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6121                 ndr->depth--;
6122                 ndr_print_lsa_String(ndr, "name", &r->in.name);
6123                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
6124                 ndr->depth--;
6125         }
6126         if (flags & NDR_OUT) {
6127                 ndr_print_struct(ndr, "out", "lsa_CreateSecret");
6128                 ndr->depth++;
6129                 ndr_print_ptr(ndr, "sec_handle", r->out.sec_handle);
6130                 ndr->depth++;
6131                 ndr_print_policy_handle(ndr, "sec_handle", r->out.sec_handle);
6132                 ndr->depth--;
6133                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6134                 ndr->depth--;
6135         }
6136         ndr->depth--;
6137 }
6138
6139 static enum ndr_err_code ndr_push_lsa_OpenAccount(struct ndr_push *ndr, int flags, const struct lsa_OpenAccount *r)
6140 {
6141         if (flags & NDR_IN) {
6142                 if (r->in.handle == NULL) {
6143                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6144                 }
6145                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6146                 if (r->in.sid == NULL) {
6147                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6148                 }
6149                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6151         }
6152         if (flags & NDR_OUT) {
6153                 if (r->out.acct_handle == NULL) {
6154                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6155                 }
6156                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
6157                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6158         }
6159         return NDR_ERR_SUCCESS;
6160 }
6161
6162 static enum ndr_err_code ndr_pull_lsa_OpenAccount(struct ndr_pull *ndr, int flags, struct lsa_OpenAccount *r)
6163 {
6164         TALLOC_CTX *_mem_save_handle_0;
6165         TALLOC_CTX *_mem_save_sid_0;
6166         TALLOC_CTX *_mem_save_acct_handle_0;
6167         if (flags & NDR_IN) {
6168                 ZERO_STRUCT(r->out);
6169
6170                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6171                         NDR_PULL_ALLOC(ndr, r->in.handle);
6172                 }
6173                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6174                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6175                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6176                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6177                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6178                         NDR_PULL_ALLOC(ndr, r->in.sid);
6179                 }
6180                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6181                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6182                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6183                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6185                 NDR_PULL_ALLOC(ndr, r->out.acct_handle);
6186                 ZERO_STRUCTP(r->out.acct_handle);
6187         }
6188         if (flags & NDR_OUT) {
6189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6190                         NDR_PULL_ALLOC(ndr, r->out.acct_handle);
6191                 }
6192                 _mem_save_acct_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6193                 NDR_PULL_SET_MEM_CTX(ndr, r->out.acct_handle, LIBNDR_FLAG_REF_ALLOC);
6194                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
6195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_handle_0, LIBNDR_FLAG_REF_ALLOC);
6196                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6197         }
6198         return NDR_ERR_SUCCESS;
6199 }
6200
6201 _PUBLIC_ void ndr_print_lsa_OpenAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenAccount *r)
6202 {
6203         ndr_print_struct(ndr, name, "lsa_OpenAccount");
6204         ndr->depth++;
6205         if (flags & NDR_SET_VALUES) {
6206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6207         }
6208         if (flags & NDR_IN) {
6209                 ndr_print_struct(ndr, "in", "lsa_OpenAccount");
6210                 ndr->depth++;
6211                 ndr_print_ptr(ndr, "handle", r->in.handle);
6212                 ndr->depth++;
6213                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6214                 ndr->depth--;
6215                 ndr_print_ptr(ndr, "sid", r->in.sid);
6216                 ndr->depth++;
6217                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6218                 ndr->depth--;
6219                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
6220                 ndr->depth--;
6221         }
6222         if (flags & NDR_OUT) {
6223                 ndr_print_struct(ndr, "out", "lsa_OpenAccount");
6224                 ndr->depth++;
6225                 ndr_print_ptr(ndr, "acct_handle", r->out.acct_handle);
6226                 ndr->depth++;
6227                 ndr_print_policy_handle(ndr, "acct_handle", r->out.acct_handle);
6228                 ndr->depth--;
6229                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6230                 ndr->depth--;
6231         }
6232         ndr->depth--;
6233 }
6234
6235 static enum ndr_err_code ndr_push_lsa_EnumPrivsAccount(struct ndr_push *ndr, int flags, const struct lsa_EnumPrivsAccount *r)
6236 {
6237         if (flags & NDR_IN) {
6238                 if (r->in.handle == NULL) {
6239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6240                 }
6241                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6242         }
6243         if (flags & NDR_OUT) {
6244                 if (r->out.privs == NULL) {
6245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6246                 }
6247                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.privs));
6248                 if (*r->out.privs) {
6249                         NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, *r->out.privs));
6250                 }
6251                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6252         }
6253         return NDR_ERR_SUCCESS;
6254 }
6255
6256 static enum ndr_err_code ndr_pull_lsa_EnumPrivsAccount(struct ndr_pull *ndr, int flags, struct lsa_EnumPrivsAccount *r)
6257 {
6258         uint32_t _ptr_privs;
6259         TALLOC_CTX *_mem_save_handle_0;
6260         TALLOC_CTX *_mem_save_privs_0;
6261         TALLOC_CTX *_mem_save_privs_1;
6262         if (flags & NDR_IN) {
6263                 ZERO_STRUCT(r->out);
6264
6265                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6266                         NDR_PULL_ALLOC(ndr, r->in.handle);
6267                 }
6268                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6269                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6270                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6271                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6272                 NDR_PULL_ALLOC(ndr, r->out.privs);
6273                 ZERO_STRUCTP(r->out.privs);
6274         }
6275         if (flags & NDR_OUT) {
6276                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6277                         NDR_PULL_ALLOC(ndr, r->out.privs);
6278                 }
6279                 _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
6280                 NDR_PULL_SET_MEM_CTX(ndr, r->out.privs, LIBNDR_FLAG_REF_ALLOC);
6281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
6282                 if (_ptr_privs) {
6283                         NDR_PULL_ALLOC(ndr, *r->out.privs);
6284                 } else {
6285                         *r->out.privs = NULL;
6286                 }
6287                 if (*r->out.privs) {
6288                         _mem_save_privs_1 = NDR_PULL_GET_MEM_CTX(ndr);
6289                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.privs, 0);
6290                         NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, *r->out.privs));
6291                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_1, 0);
6292                 }
6293                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, LIBNDR_FLAG_REF_ALLOC);
6294                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6295         }
6296         return NDR_ERR_SUCCESS;
6297 }
6298
6299 _PUBLIC_ void ndr_print_lsa_EnumPrivsAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumPrivsAccount *r)
6300 {
6301         ndr_print_struct(ndr, name, "lsa_EnumPrivsAccount");
6302         ndr->depth++;
6303         if (flags & NDR_SET_VALUES) {
6304                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6305         }
6306         if (flags & NDR_IN) {
6307                 ndr_print_struct(ndr, "in", "lsa_EnumPrivsAccount");
6308                 ndr->depth++;
6309                 ndr_print_ptr(ndr, "handle", r->in.handle);
6310                 ndr->depth++;
6311                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6312                 ndr->depth--;
6313                 ndr->depth--;
6314         }
6315         if (flags & NDR_OUT) {
6316                 ndr_print_struct(ndr, "out", "lsa_EnumPrivsAccount");
6317                 ndr->depth++;
6318                 ndr_print_ptr(ndr, "privs", r->out.privs);
6319                 ndr->depth++;
6320                 ndr_print_ptr(ndr, "privs", *r->out.privs);
6321                 ndr->depth++;
6322                 if (*r->out.privs) {
6323                         ndr_print_lsa_PrivilegeSet(ndr, "privs", *r->out.privs);
6324                 }
6325                 ndr->depth--;
6326                 ndr->depth--;
6327                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6328                 ndr->depth--;
6329         }
6330         ndr->depth--;
6331 }
6332
6333 static enum ndr_err_code ndr_push_lsa_AddPrivilegesToAccount(struct ndr_push *ndr, int flags, const struct lsa_AddPrivilegesToAccount *r)
6334 {
6335         if (flags & NDR_IN) {
6336                 if (r->in.handle == NULL) {
6337                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6338                 }
6339                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6340                 if (r->in.privs == NULL) {
6341                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6342                 }
6343                 NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
6344         }
6345         if (flags & NDR_OUT) {
6346                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6347         }
6348         return NDR_ERR_SUCCESS;
6349 }
6350
6351 static enum ndr_err_code ndr_pull_lsa_AddPrivilegesToAccount(struct ndr_pull *ndr, int flags, struct lsa_AddPrivilegesToAccount *r)
6352 {
6353         TALLOC_CTX *_mem_save_handle_0;
6354         TALLOC_CTX *_mem_save_privs_0;
6355         if (flags & NDR_IN) {
6356                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6357                         NDR_PULL_ALLOC(ndr, r->in.handle);
6358                 }
6359                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6360                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6361                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6362                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6364                         NDR_PULL_ALLOC(ndr, r->in.privs);
6365                 }
6366                 _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
6367                 NDR_PULL_SET_MEM_CTX(ndr, r->in.privs, LIBNDR_FLAG_REF_ALLOC);
6368                 NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
6369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, LIBNDR_FLAG_REF_ALLOC);
6370         }
6371         if (flags & NDR_OUT) {
6372                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6373         }
6374         return NDR_ERR_SUCCESS;
6375 }
6376
6377 _PUBLIC_ void ndr_print_lsa_AddPrivilegesToAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_AddPrivilegesToAccount *r)
6378 {
6379         ndr_print_struct(ndr, name, "lsa_AddPrivilegesToAccount");
6380         ndr->depth++;
6381         if (flags & NDR_SET_VALUES) {
6382                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6383         }
6384         if (flags & NDR_IN) {
6385                 ndr_print_struct(ndr, "in", "lsa_AddPrivilegesToAccount");
6386                 ndr->depth++;
6387                 ndr_print_ptr(ndr, "handle", r->in.handle);
6388                 ndr->depth++;
6389                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6390                 ndr->depth--;
6391                 ndr_print_ptr(ndr, "privs", r->in.privs);
6392                 ndr->depth++;
6393                 ndr_print_lsa_PrivilegeSet(ndr, "privs", r->in.privs);
6394                 ndr->depth--;
6395                 ndr->depth--;
6396         }
6397         if (flags & NDR_OUT) {
6398                 ndr_print_struct(ndr, "out", "lsa_AddPrivilegesToAccount");
6399                 ndr->depth++;
6400                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6401                 ndr->depth--;
6402         }
6403         ndr->depth--;
6404 }
6405
6406 static enum ndr_err_code ndr_push_lsa_RemovePrivilegesFromAccount(struct ndr_push *ndr, int flags, const struct lsa_RemovePrivilegesFromAccount *r)
6407 {
6408         if (flags & NDR_IN) {
6409                 if (r->in.handle == NULL) {
6410                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6411                 }
6412                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6413                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.remove_all));
6414                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.privs));
6415                 if (r->in.privs) {
6416                         NDR_CHECK(ndr_push_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
6417                 }
6418         }
6419         if (flags & NDR_OUT) {
6420                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6421         }
6422         return NDR_ERR_SUCCESS;
6423 }
6424
6425 static enum ndr_err_code ndr_pull_lsa_RemovePrivilegesFromAccount(struct ndr_pull *ndr, int flags, struct lsa_RemovePrivilegesFromAccount *r)
6426 {
6427         uint32_t _ptr_privs;
6428         TALLOC_CTX *_mem_save_handle_0;
6429         TALLOC_CTX *_mem_save_privs_0;
6430         if (flags & NDR_IN) {
6431                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6432                         NDR_PULL_ALLOC(ndr, r->in.handle);
6433                 }
6434                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6435                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6436                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6437                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6438                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.remove_all));
6439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
6440                 if (_ptr_privs) {
6441                         NDR_PULL_ALLOC(ndr, r->in.privs);
6442                 } else {
6443                         r->in.privs = NULL;
6444                 }
6445                 if (r->in.privs) {
6446                         _mem_save_privs_0 = NDR_PULL_GET_MEM_CTX(ndr);
6447                         NDR_PULL_SET_MEM_CTX(ndr, r->in.privs, 0);
6448                         NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS, r->in.privs));
6449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_privs_0, 0);
6450                 }
6451         }
6452         if (flags & NDR_OUT) {
6453                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6454         }
6455         return NDR_ERR_SUCCESS;
6456 }
6457
6458 _PUBLIC_ void ndr_print_lsa_RemovePrivilegesFromAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RemovePrivilegesFromAccount *r)
6459 {
6460         ndr_print_struct(ndr, name, "lsa_RemovePrivilegesFromAccount");
6461         ndr->depth++;
6462         if (flags & NDR_SET_VALUES) {
6463                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6464         }
6465         if (flags & NDR_IN) {
6466                 ndr_print_struct(ndr, "in", "lsa_RemovePrivilegesFromAccount");
6467                 ndr->depth++;
6468                 ndr_print_ptr(ndr, "handle", r->in.handle);
6469                 ndr->depth++;
6470                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6471                 ndr->depth--;
6472                 ndr_print_uint8(ndr, "remove_all", r->in.remove_all);
6473                 ndr_print_ptr(ndr, "privs", r->in.privs);
6474                 ndr->depth++;
6475                 if (r->in.privs) {
6476                         ndr_print_lsa_PrivilegeSet(ndr, "privs", r->in.privs);
6477                 }
6478                 ndr->depth--;
6479                 ndr->depth--;
6480         }
6481         if (flags & NDR_OUT) {
6482                 ndr_print_struct(ndr, "out", "lsa_RemovePrivilegesFromAccount");
6483                 ndr->depth++;
6484                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6485                 ndr->depth--;
6486         }
6487         ndr->depth--;
6488 }
6489
6490 static enum ndr_err_code ndr_push_lsa_GetQuotasForAccount(struct ndr_push *ndr, int flags, const struct lsa_GetQuotasForAccount *r)
6491 {
6492         if (flags & NDR_IN) {
6493         }
6494         if (flags & NDR_OUT) {
6495                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6496         }
6497         return NDR_ERR_SUCCESS;
6498 }
6499
6500 static enum ndr_err_code ndr_pull_lsa_GetQuotasForAccount(struct ndr_pull *ndr, int flags, struct lsa_GetQuotasForAccount *r)
6501 {
6502         if (flags & NDR_IN) {
6503         }
6504         if (flags & NDR_OUT) {
6505                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6506         }
6507         return NDR_ERR_SUCCESS;
6508 }
6509
6510 _PUBLIC_ void ndr_print_lsa_GetQuotasForAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetQuotasForAccount *r)
6511 {
6512         ndr_print_struct(ndr, name, "lsa_GetQuotasForAccount");
6513         ndr->depth++;
6514         if (flags & NDR_SET_VALUES) {
6515                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6516         }
6517         if (flags & NDR_IN) {
6518                 ndr_print_struct(ndr, "in", "lsa_GetQuotasForAccount");
6519                 ndr->depth++;
6520                 ndr->depth--;
6521         }
6522         if (flags & NDR_OUT) {
6523                 ndr_print_struct(ndr, "out", "lsa_GetQuotasForAccount");
6524                 ndr->depth++;
6525                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6526                 ndr->depth--;
6527         }
6528         ndr->depth--;
6529 }
6530
6531 static enum ndr_err_code ndr_push_lsa_SetQuotasForAccount(struct ndr_push *ndr, int flags, const struct lsa_SetQuotasForAccount *r)
6532 {
6533         if (flags & NDR_IN) {
6534         }
6535         if (flags & NDR_OUT) {
6536                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6537         }
6538         return NDR_ERR_SUCCESS;
6539 }
6540
6541 static enum ndr_err_code ndr_pull_lsa_SetQuotasForAccount(struct ndr_pull *ndr, int flags, struct lsa_SetQuotasForAccount *r)
6542 {
6543         if (flags & NDR_IN) {
6544         }
6545         if (flags & NDR_OUT) {
6546                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6547         }
6548         return NDR_ERR_SUCCESS;
6549 }
6550
6551 _PUBLIC_ void ndr_print_lsa_SetQuotasForAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetQuotasForAccount *r)
6552 {
6553         ndr_print_struct(ndr, name, "lsa_SetQuotasForAccount");
6554         ndr->depth++;
6555         if (flags & NDR_SET_VALUES) {
6556                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6557         }
6558         if (flags & NDR_IN) {
6559                 ndr_print_struct(ndr, "in", "lsa_SetQuotasForAccount");
6560                 ndr->depth++;
6561                 ndr->depth--;
6562         }
6563         if (flags & NDR_OUT) {
6564                 ndr_print_struct(ndr, "out", "lsa_SetQuotasForAccount");
6565                 ndr->depth++;
6566                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6567                 ndr->depth--;
6568         }
6569         ndr->depth--;
6570 }
6571
6572 static enum ndr_err_code ndr_push_lsa_GetSystemAccessAccount(struct ndr_push *ndr, int flags, const struct lsa_GetSystemAccessAccount *r)
6573 {
6574         if (flags & NDR_IN) {
6575                 if (r->in.handle == NULL) {
6576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6577                 }
6578                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6579         }
6580         if (flags & NDR_OUT) {
6581                 if (r->out.access_mask == NULL) {
6582                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6583                 }
6584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.access_mask));
6585                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6586         }
6587         return NDR_ERR_SUCCESS;
6588 }
6589
6590 static enum ndr_err_code ndr_pull_lsa_GetSystemAccessAccount(struct ndr_pull *ndr, int flags, struct lsa_GetSystemAccessAccount *r)
6591 {
6592         TALLOC_CTX *_mem_save_handle_0;
6593         TALLOC_CTX *_mem_save_access_mask_0;
6594         if (flags & NDR_IN) {
6595                 ZERO_STRUCT(r->out);
6596
6597                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6598                         NDR_PULL_ALLOC(ndr, r->in.handle);
6599                 }
6600                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6601                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6602                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6604                 NDR_PULL_ALLOC(ndr, r->out.access_mask);
6605                 ZERO_STRUCTP(r->out.access_mask);
6606         }
6607         if (flags & NDR_OUT) {
6608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6609                         NDR_PULL_ALLOC(ndr, r->out.access_mask);
6610                 }
6611                 _mem_save_access_mask_0 = NDR_PULL_GET_MEM_CTX(ndr);
6612                 NDR_PULL_SET_MEM_CTX(ndr, r->out.access_mask, LIBNDR_FLAG_REF_ALLOC);
6613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.access_mask));
6614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_access_mask_0, LIBNDR_FLAG_REF_ALLOC);
6615                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6616         }
6617         return NDR_ERR_SUCCESS;
6618 }
6619
6620 _PUBLIC_ void ndr_print_lsa_GetSystemAccessAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetSystemAccessAccount *r)
6621 {
6622         ndr_print_struct(ndr, name, "lsa_GetSystemAccessAccount");
6623         ndr->depth++;
6624         if (flags & NDR_SET_VALUES) {
6625                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6626         }
6627         if (flags & NDR_IN) {
6628                 ndr_print_struct(ndr, "in", "lsa_GetSystemAccessAccount");
6629                 ndr->depth++;
6630                 ndr_print_ptr(ndr, "handle", r->in.handle);
6631                 ndr->depth++;
6632                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6633                 ndr->depth--;
6634                 ndr->depth--;
6635         }
6636         if (flags & NDR_OUT) {
6637                 ndr_print_struct(ndr, "out", "lsa_GetSystemAccessAccount");
6638                 ndr->depth++;
6639                 ndr_print_ptr(ndr, "access_mask", r->out.access_mask);
6640                 ndr->depth++;
6641                 ndr_print_uint32(ndr, "access_mask", *r->out.access_mask);
6642                 ndr->depth--;
6643                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6644                 ndr->depth--;
6645         }
6646         ndr->depth--;
6647 }
6648
6649 static enum ndr_err_code ndr_push_lsa_SetSystemAccessAccount(struct ndr_push *ndr, int flags, const struct lsa_SetSystemAccessAccount *r)
6650 {
6651         if (flags & NDR_IN) {
6652                 if (r->in.handle == NULL) {
6653                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6654                 }
6655                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6657         }
6658         if (flags & NDR_OUT) {
6659                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6660         }
6661         return NDR_ERR_SUCCESS;
6662 }
6663
6664 static enum ndr_err_code ndr_pull_lsa_SetSystemAccessAccount(struct ndr_pull *ndr, int flags, struct lsa_SetSystemAccessAccount *r)
6665 {
6666         TALLOC_CTX *_mem_save_handle_0;
6667         if (flags & NDR_IN) {
6668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6669                         NDR_PULL_ALLOC(ndr, r->in.handle);
6670                 }
6671                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6672                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6673                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6676         }
6677         if (flags & NDR_OUT) {
6678                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6679         }
6680         return NDR_ERR_SUCCESS;
6681 }
6682
6683 _PUBLIC_ void ndr_print_lsa_SetSystemAccessAccount(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSystemAccessAccount *r)
6684 {
6685         ndr_print_struct(ndr, name, "lsa_SetSystemAccessAccount");
6686         ndr->depth++;
6687         if (flags & NDR_SET_VALUES) {
6688                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6689         }
6690         if (flags & NDR_IN) {
6691                 ndr_print_struct(ndr, "in", "lsa_SetSystemAccessAccount");
6692                 ndr->depth++;
6693                 ndr_print_ptr(ndr, "handle", r->in.handle);
6694                 ndr->depth++;
6695                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6696                 ndr->depth--;
6697                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
6698                 ndr->depth--;
6699         }
6700         if (flags & NDR_OUT) {
6701                 ndr_print_struct(ndr, "out", "lsa_SetSystemAccessAccount");
6702                 ndr->depth++;
6703                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6704                 ndr->depth--;
6705         }
6706         ndr->depth--;
6707 }
6708
6709 static enum ndr_err_code ndr_push_lsa_OpenTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_OpenTrustedDomain *r)
6710 {
6711         if (flags & NDR_IN) {
6712                 if (r->in.handle == NULL) {
6713                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6714                 }
6715                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6716                 if (r->in.sid == NULL) {
6717                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6718                 }
6719                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6721         }
6722         if (flags & NDR_OUT) {
6723                 if (r->out.trustdom_handle == NULL) {
6724                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6725                 }
6726                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
6727                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6728         }
6729         return NDR_ERR_SUCCESS;
6730 }
6731
6732 static enum ndr_err_code ndr_pull_lsa_OpenTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_OpenTrustedDomain *r)
6733 {
6734         TALLOC_CTX *_mem_save_handle_0;
6735         TALLOC_CTX *_mem_save_sid_0;
6736         TALLOC_CTX *_mem_save_trustdom_handle_0;
6737         if (flags & NDR_IN) {
6738                 ZERO_STRUCT(r->out);
6739
6740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6741                         NDR_PULL_ALLOC(ndr, r->in.handle);
6742                 }
6743                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6744                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6745                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6747                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6748                         NDR_PULL_ALLOC(ndr, r->in.sid);
6749                 }
6750                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6751                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
6752                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
6753                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
6754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6755                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
6756                 ZERO_STRUCTP(r->out.trustdom_handle);
6757         }
6758         if (flags & NDR_OUT) {
6759                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6760                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
6761                 }
6762                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6763                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
6764                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
6765                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
6766                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6767         }
6768         return NDR_ERR_SUCCESS;
6769 }
6770
6771 _PUBLIC_ void ndr_print_lsa_OpenTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenTrustedDomain *r)
6772 {
6773         ndr_print_struct(ndr, name, "lsa_OpenTrustedDomain");
6774         ndr->depth++;
6775         if (flags & NDR_SET_VALUES) {
6776                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6777         }
6778         if (flags & NDR_IN) {
6779                 ndr_print_struct(ndr, "in", "lsa_OpenTrustedDomain");
6780                 ndr->depth++;
6781                 ndr_print_ptr(ndr, "handle", r->in.handle);
6782                 ndr->depth++;
6783                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6784                 ndr->depth--;
6785                 ndr_print_ptr(ndr, "sid", r->in.sid);
6786                 ndr->depth++;
6787                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
6788                 ndr->depth--;
6789                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
6790                 ndr->depth--;
6791         }
6792         if (flags & NDR_OUT) {
6793                 ndr_print_struct(ndr, "out", "lsa_OpenTrustedDomain");
6794                 ndr->depth++;
6795                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
6796                 ndr->depth++;
6797                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
6798                 ndr->depth--;
6799                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6800                 ndr->depth--;
6801         }
6802         ndr->depth--;
6803 }
6804
6805 static enum ndr_err_code ndr_push_lsa_QueryTrustedDomainInfo(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfo *r)
6806 {
6807         if (flags & NDR_IN) {
6808                 if (r->in.trustdom_handle == NULL) {
6809                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6810                 }
6811                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trustdom_handle));
6812                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
6813         }
6814         if (flags & NDR_OUT) {
6815                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
6816                 if (r->out.info) {
6817                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
6818                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6819                 }
6820                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6821         }
6822         return NDR_ERR_SUCCESS;
6823 }
6824
6825 static enum ndr_err_code ndr_pull_lsa_QueryTrustedDomainInfo(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfo *r)
6826 {
6827         uint32_t _ptr_info;
6828         TALLOC_CTX *_mem_save_trustdom_handle_0;
6829         TALLOC_CTX *_mem_save_info_0;
6830         if (flags & NDR_IN) {
6831                 ZERO_STRUCT(r->out);
6832
6833                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6834                         NDR_PULL_ALLOC(ndr, r->in.trustdom_handle);
6835                 }
6836                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6837                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
6838                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trustdom_handle));
6839                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
6840                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
6841         }
6842         if (flags & NDR_OUT) {
6843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6844                 if (_ptr_info) {
6845                         NDR_PULL_ALLOC(ndr, r->out.info);
6846                 } else {
6847                         r->out.info = NULL;
6848                 }
6849                 if (r->out.info) {
6850                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6851                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
6852                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
6853                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
6854                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
6855                 }
6856                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6857         }
6858         return NDR_ERR_SUCCESS;
6859 }
6860
6861 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfo *r)
6862 {
6863         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfo");
6864         ndr->depth++;
6865         if (flags & NDR_SET_VALUES) {
6866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6867         }
6868         if (flags & NDR_IN) {
6869                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfo");
6870                 ndr->depth++;
6871                 ndr_print_ptr(ndr, "trustdom_handle", r->in.trustdom_handle);
6872                 ndr->depth++;
6873                 ndr_print_policy_handle(ndr, "trustdom_handle", r->in.trustdom_handle);
6874                 ndr->depth--;
6875                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
6876                 ndr->depth--;
6877         }
6878         if (flags & NDR_OUT) {
6879                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfo");
6880                 ndr->depth++;
6881                 ndr_print_ptr(ndr, "info", r->out.info);
6882                 ndr->depth++;
6883                 if (r->out.info) {
6884                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
6885                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->out.info);
6886                 }
6887                 ndr->depth--;
6888                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6889                 ndr->depth--;
6890         }
6891         ndr->depth--;
6892 }
6893
6894 static enum ndr_err_code ndr_push_lsa_SetInformationTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_SetInformationTrustedDomain *r)
6895 {
6896         if (flags & NDR_IN) {
6897         }
6898         if (flags & NDR_OUT) {
6899                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6900         }
6901         return NDR_ERR_SUCCESS;
6902 }
6903
6904 static enum ndr_err_code ndr_pull_lsa_SetInformationTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_SetInformationTrustedDomain *r)
6905 {
6906         if (flags & NDR_IN) {
6907         }
6908         if (flags & NDR_OUT) {
6909                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6910         }
6911         return NDR_ERR_SUCCESS;
6912 }
6913
6914 _PUBLIC_ void ndr_print_lsa_SetInformationTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInformationTrustedDomain *r)
6915 {
6916         ndr_print_struct(ndr, name, "lsa_SetInformationTrustedDomain");
6917         ndr->depth++;
6918         if (flags & NDR_SET_VALUES) {
6919                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6920         }
6921         if (flags & NDR_IN) {
6922                 ndr_print_struct(ndr, "in", "lsa_SetInformationTrustedDomain");
6923                 ndr->depth++;
6924                 ndr->depth--;
6925         }
6926         if (flags & NDR_OUT) {
6927                 ndr_print_struct(ndr, "out", "lsa_SetInformationTrustedDomain");
6928                 ndr->depth++;
6929                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
6930                 ndr->depth--;
6931         }
6932         ndr->depth--;
6933 }
6934
6935 _PUBLIC_ enum ndr_err_code ndr_push_lsa_OpenSecret(struct ndr_push *ndr, int flags, const struct lsa_OpenSecret *r)
6936 {
6937         if (flags & NDR_IN) {
6938                 if (r->in.handle == NULL) {
6939                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6940                 }
6941                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6942                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6944         }
6945         if (flags & NDR_OUT) {
6946                 if (r->out.sec_handle == NULL) {
6947                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6948                 }
6949                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
6950                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6951         }
6952         return NDR_ERR_SUCCESS;
6953 }
6954
6955 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_OpenSecret(struct ndr_pull *ndr, int flags, struct lsa_OpenSecret *r)
6956 {
6957         TALLOC_CTX *_mem_save_handle_0;
6958         TALLOC_CTX *_mem_save_sec_handle_0;
6959         if (flags & NDR_IN) {
6960                 ZERO_STRUCT(r->out);
6961
6962                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6963                         NDR_PULL_ALLOC(ndr, r->in.handle);
6964                 }
6965                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6966                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6967                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
6968                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6969                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6971                 NDR_PULL_ALLOC(ndr, r->out.sec_handle);
6972                 ZERO_STRUCTP(r->out.sec_handle);
6973         }
6974         if (flags & NDR_OUT) {
6975                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6976                         NDR_PULL_ALLOC(ndr, r->out.sec_handle);
6977                 }
6978                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6979                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sec_handle, LIBNDR_FLAG_REF_ALLOC);
6980                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
6981                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
6982                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6983         }
6984         return NDR_ERR_SUCCESS;
6985 }
6986
6987 _PUBLIC_ void ndr_print_lsa_OpenSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenSecret *r)
6988 {
6989         ndr_print_struct(ndr, name, "lsa_OpenSecret");
6990         ndr->depth++;
6991         if (flags & NDR_SET_VALUES) {
6992                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6993         }
6994         if (flags & NDR_IN) {
6995                 ndr_print_struct(ndr, "in", "lsa_OpenSecret");
6996                 ndr->depth++;
6997                 ndr_print_ptr(ndr, "handle", r->in.handle);
6998                 ndr->depth++;
6999                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7000                 ndr->depth--;
7001                 ndr_print_lsa_String(ndr, "name", &r->in.name);
7002                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
7003                 ndr->depth--;
7004         }
7005         if (flags & NDR_OUT) {
7006                 ndr_print_struct(ndr, "out", "lsa_OpenSecret");
7007                 ndr->depth++;
7008                 ndr_print_ptr(ndr, "sec_handle", r->out.sec_handle);
7009                 ndr->depth++;
7010                 ndr_print_policy_handle(ndr, "sec_handle", r->out.sec_handle);
7011                 ndr->depth--;
7012                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7013                 ndr->depth--;
7014         }
7015         ndr->depth--;
7016 }
7017
7018 _PUBLIC_ enum ndr_err_code ndr_push_lsa_SetSecret(struct ndr_push *ndr, int flags, const struct lsa_SetSecret *r)
7019 {
7020         if (flags & NDR_IN) {
7021                 if (r->in.sec_handle == NULL) {
7022                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7023                 }
7024                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
7025                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_val));
7026                 if (r->in.new_val) {
7027                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7028                 }
7029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_val));
7030                 if (r->in.old_val) {
7031                         NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7032                 }
7033         }
7034         if (flags & NDR_OUT) {
7035                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7036         }
7037         return NDR_ERR_SUCCESS;
7038 }
7039
7040 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_SetSecret(struct ndr_pull *ndr, int flags, struct lsa_SetSecret *r)
7041 {
7042         uint32_t _ptr_new_val;
7043         uint32_t _ptr_old_val;
7044         TALLOC_CTX *_mem_save_sec_handle_0;
7045         TALLOC_CTX *_mem_save_new_val_0;
7046         TALLOC_CTX *_mem_save_old_val_0;
7047         if (flags & NDR_IN) {
7048                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7049                         NDR_PULL_ALLOC(ndr, r->in.sec_handle);
7050                 }
7051                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7052                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_handle, LIBNDR_FLAG_REF_ALLOC);
7053                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
7054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
7055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
7056                 if (_ptr_new_val) {
7057                         NDR_PULL_ALLOC(ndr, r->in.new_val);
7058                 } else {
7059                         r->in.new_val = NULL;
7060                 }
7061                 if (r->in.new_val) {
7062                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7063                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_val, 0);
7064                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
7066                 }
7067                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
7068                 if (_ptr_old_val) {
7069                         NDR_PULL_ALLOC(ndr, r->in.old_val);
7070                 } else {
7071                         r->in.old_val = NULL;
7072                 }
7073                 if (r->in.old_val) {
7074                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7075                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_val, 0);
7076                         NDR_CHECK(ndr_pull_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7077                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
7078                 }
7079         }
7080         if (flags & NDR_OUT) {
7081                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7082         }
7083         return NDR_ERR_SUCCESS;
7084 }
7085
7086 _PUBLIC_ void ndr_print_lsa_SetSecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetSecret *r)
7087 {
7088         ndr_print_struct(ndr, name, "lsa_SetSecret");
7089         ndr->depth++;
7090         if (flags & NDR_SET_VALUES) {
7091                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7092         }
7093         if (flags & NDR_IN) {
7094                 ndr_print_struct(ndr, "in", "lsa_SetSecret");
7095                 ndr->depth++;
7096                 ndr_print_ptr(ndr, "sec_handle", r->in.sec_handle);
7097                 ndr->depth++;
7098                 ndr_print_policy_handle(ndr, "sec_handle", r->in.sec_handle);
7099                 ndr->depth--;
7100                 ndr_print_ptr(ndr, "new_val", r->in.new_val);
7101                 ndr->depth++;
7102                 if (r->in.new_val) {
7103                         ndr_print_lsa_DATA_BUF(ndr, "new_val", r->in.new_val);
7104                 }
7105                 ndr->depth--;
7106                 ndr_print_ptr(ndr, "old_val", r->in.old_val);
7107                 ndr->depth++;
7108                 if (r->in.old_val) {
7109                         ndr_print_lsa_DATA_BUF(ndr, "old_val", r->in.old_val);
7110                 }
7111                 ndr->depth--;
7112                 ndr->depth--;
7113         }
7114         if (flags & NDR_OUT) {
7115                 ndr_print_struct(ndr, "out", "lsa_SetSecret");
7116                 ndr->depth++;
7117                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7118                 ndr->depth--;
7119         }
7120         ndr->depth--;
7121 }
7122
7123 _PUBLIC_ enum ndr_err_code ndr_push_lsa_QuerySecret(struct ndr_push *ndr, int flags, const struct lsa_QuerySecret *r)
7124 {
7125         if (flags & NDR_IN) {
7126                 if (r->in.sec_handle == NULL) {
7127                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7128                 }
7129                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
7130                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_val));
7131                 if (r->in.new_val) {
7132                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7133                 }
7134                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_mtime));
7135                 if (r->in.new_mtime) {
7136                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->in.new_mtime));
7137                 }
7138                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_val));
7139                 if (r->in.old_val) {
7140                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7141                 }
7142                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.old_mtime));
7143                 if (r->in.old_mtime) {
7144                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->in.old_mtime));
7145                 }
7146         }
7147         if (flags & NDR_OUT) {
7148                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.new_val));
7149                 if (r->out.new_val) {
7150                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.new_val));
7151                 }
7152                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.new_mtime));
7153                 if (r->out.new_mtime) {
7154                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->out.new_mtime));
7155                 }
7156                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.old_val));
7157                 if (r->out.old_val) {
7158                         NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.old_val));
7159                 }
7160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.old_mtime));
7161                 if (r->out.old_mtime) {
7162                         NDR_CHECK(ndr_push_NTTIME_hyper(ndr, NDR_SCALARS, *r->out.old_mtime));
7163                 }
7164                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7165         }
7166         return NDR_ERR_SUCCESS;
7167 }
7168
7169 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_QuerySecret(struct ndr_pull *ndr, int flags, struct lsa_QuerySecret *r)
7170 {
7171         uint32_t _ptr_new_val;
7172         uint32_t _ptr_new_mtime;
7173         uint32_t _ptr_old_val;
7174         uint32_t _ptr_old_mtime;
7175         TALLOC_CTX *_mem_save_sec_handle_0;
7176         TALLOC_CTX *_mem_save_new_val_0;
7177         TALLOC_CTX *_mem_save_new_mtime_0;
7178         TALLOC_CTX *_mem_save_old_val_0;
7179         TALLOC_CTX *_mem_save_old_mtime_0;
7180         if (flags & NDR_IN) {
7181                 ZERO_STRUCT(r->out);
7182
7183                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7184                         NDR_PULL_ALLOC(ndr, r->in.sec_handle);
7185                 }
7186                 _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7187                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_handle, LIBNDR_FLAG_REF_ALLOC);
7188                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
7189                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
7190                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
7191                 if (_ptr_new_val) {
7192                         NDR_PULL_ALLOC(ndr, r->in.new_val);
7193                 } else {
7194                         r->in.new_val = NULL;
7195                 }
7196                 if (r->in.new_val) {
7197                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7198                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_val, 0);
7199                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
7201                 }
7202                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_mtime));
7203                 if (_ptr_new_mtime) {
7204                         NDR_PULL_ALLOC(ndr, r->in.new_mtime);
7205                 } else {
7206                         r->in.new_mtime = NULL;
7207                 }
7208                 if (r->in.new_mtime) {
7209                         _mem_save_new_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
7210                         NDR_PULL_SET_MEM_CTX(ndr, r->in.new_mtime, 0);
7211                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->in.new_mtime));
7212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_mtime_0, 0);
7213                 }
7214                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
7215                 if (_ptr_old_val) {
7216                         NDR_PULL_ALLOC(ndr, r->in.old_val);
7217                 } else {
7218                         r->in.old_val = NULL;
7219                 }
7220                 if (r->in.old_val) {
7221                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7222                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_val, 0);
7223                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.old_val));
7224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
7225                 }
7226                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_mtime));
7227                 if (_ptr_old_mtime) {
7228                         NDR_PULL_ALLOC(ndr, r->in.old_mtime);
7229                 } else {
7230                         r->in.old_mtime = NULL;
7231                 }
7232                 if (r->in.old_mtime) {
7233                         _mem_save_old_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
7234                         NDR_PULL_SET_MEM_CTX(ndr, r->in.old_mtime, 0);
7235                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->in.old_mtime));
7236                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_mtime_0, 0);
7237                 }
7238         }
7239         if (flags & NDR_OUT) {
7240                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
7241                 if (_ptr_new_val) {
7242                         NDR_PULL_ALLOC(ndr, r->out.new_val);
7243                 } else {
7244                         r->out.new_val = NULL;
7245                 }
7246                 if (r->out.new_val) {
7247                         _mem_save_new_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7248                         NDR_PULL_SET_MEM_CTX(ndr, r->out.new_val, 0);
7249                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.new_val));
7250                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_val_0, 0);
7251                 }
7252                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_mtime));
7253                 if (_ptr_new_mtime) {
7254                         NDR_PULL_ALLOC(ndr, r->out.new_mtime);
7255                 } else {
7256                         r->out.new_mtime = NULL;
7257                 }
7258                 if (r->out.new_mtime) {
7259                         _mem_save_new_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
7260                         NDR_PULL_SET_MEM_CTX(ndr, r->out.new_mtime, 0);
7261                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->out.new_mtime));
7262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_mtime_0, 0);
7263                 }
7264                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_val));
7265                 if (_ptr_old_val) {
7266                         NDR_PULL_ALLOC(ndr, r->out.old_val);
7267                 } else {
7268                         r->out.old_val = NULL;
7269                 }
7270                 if (r->out.old_val) {
7271                         _mem_save_old_val_0 = NDR_PULL_GET_MEM_CTX(ndr);
7272                         NDR_PULL_SET_MEM_CTX(ndr, r->out.old_val, 0);
7273                         NDR_CHECK(ndr_pull_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.old_val));
7274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_val_0, 0);
7275                 }
7276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_old_mtime));
7277                 if (_ptr_old_mtime) {
7278                         NDR_PULL_ALLOC(ndr, r->out.old_mtime);
7279                 } else {
7280                         r->out.old_mtime = NULL;
7281                 }
7282                 if (r->out.old_mtime) {
7283                         _mem_save_old_mtime_0 = NDR_PULL_GET_MEM_CTX(ndr);
7284                         NDR_PULL_SET_MEM_CTX(ndr, r->out.old_mtime, 0);
7285                         NDR_CHECK(ndr_pull_NTTIME_hyper(ndr, NDR_SCALARS, r->out.old_mtime));
7286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_mtime_0, 0);
7287                 }
7288                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7289         }
7290         return NDR_ERR_SUCCESS;
7291 }
7292
7293 _PUBLIC_ void ndr_print_lsa_QuerySecret(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QuerySecret *r)
7294 {
7295         ndr_print_struct(ndr, name, "lsa_QuerySecret");
7296         ndr->depth++;
7297         if (flags & NDR_SET_VALUES) {
7298                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7299         }
7300         if (flags & NDR_IN) {
7301                 ndr_print_struct(ndr, "in", "lsa_QuerySecret");
7302                 ndr->depth++;
7303                 ndr_print_ptr(ndr, "sec_handle", r->in.sec_handle);
7304                 ndr->depth++;
7305                 ndr_print_policy_handle(ndr, "sec_handle", r->in.sec_handle);
7306                 ndr->depth--;
7307                 ndr_print_ptr(ndr, "new_val", r->in.new_val);
7308                 ndr->depth++;
7309                 if (r->in.new_val) {
7310                         ndr_print_lsa_DATA_BUF_PTR(ndr, "new_val", r->in.new_val);
7311                 }
7312                 ndr->depth--;
7313                 ndr_print_ptr(ndr, "new_mtime", r->in.new_mtime);
7314                 ndr->depth++;
7315                 if (r->in.new_mtime) {
7316                         ndr_print_NTTIME_hyper(ndr, "new_mtime", *r->in.new_mtime);
7317                 }
7318                 ndr->depth--;
7319                 ndr_print_ptr(ndr, "old_val", r->in.old_val);
7320                 ndr->depth++;
7321                 if (r->in.old_val) {
7322                         ndr_print_lsa_DATA_BUF_PTR(ndr, "old_val", r->in.old_val);
7323                 }
7324                 ndr->depth--;
7325                 ndr_print_ptr(ndr, "old_mtime", r->in.old_mtime);
7326                 ndr->depth++;
7327                 if (r->in.old_mtime) {
7328                         ndr_print_NTTIME_hyper(ndr, "old_mtime", *r->in.old_mtime);
7329                 }
7330                 ndr->depth--;
7331                 ndr->depth--;
7332         }
7333         if (flags & NDR_OUT) {
7334                 ndr_print_struct(ndr, "out", "lsa_QuerySecret");
7335                 ndr->depth++;
7336                 ndr_print_ptr(ndr, "new_val", r->out.new_val);
7337                 ndr->depth++;
7338                 if (r->out.new_val) {
7339                         ndr_print_lsa_DATA_BUF_PTR(ndr, "new_val", r->out.new_val);
7340                 }
7341                 ndr->depth--;
7342                 ndr_print_ptr(ndr, "new_mtime", r->out.new_mtime);
7343                 ndr->depth++;
7344                 if (r->out.new_mtime) {
7345                         ndr_print_NTTIME_hyper(ndr, "new_mtime", *r->out.new_mtime);
7346                 }
7347                 ndr->depth--;
7348                 ndr_print_ptr(ndr, "old_val", r->out.old_val);
7349                 ndr->depth++;
7350                 if (r->out.old_val) {
7351                         ndr_print_lsa_DATA_BUF_PTR(ndr, "old_val", r->out.old_val);
7352                 }
7353                 ndr->depth--;
7354                 ndr_print_ptr(ndr, "old_mtime", r->out.old_mtime);
7355                 ndr->depth++;
7356                 if (r->out.old_mtime) {
7357                         ndr_print_NTTIME_hyper(ndr, "old_mtime", *r->out.old_mtime);
7358                 }
7359                 ndr->depth--;
7360                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7361                 ndr->depth--;
7362         }
7363         ndr->depth--;
7364 }
7365
7366 static enum ndr_err_code ndr_push_lsa_LookupPrivValue(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivValue *r)
7367 {
7368         if (flags & NDR_IN) {
7369                 if (r->in.handle == NULL) {
7370                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7371                 }
7372                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7373                 if (r->in.name == NULL) {
7374                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7375                 }
7376                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
7377         }
7378         if (flags & NDR_OUT) {
7379                 if (r->out.luid == NULL) {
7380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7381                 }
7382                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, r->out.luid));
7383                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7384         }
7385         return NDR_ERR_SUCCESS;
7386 }
7387
7388 static enum ndr_err_code ndr_pull_lsa_LookupPrivValue(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivValue *r)
7389 {
7390         TALLOC_CTX *_mem_save_handle_0;
7391         TALLOC_CTX *_mem_save_name_0;
7392         TALLOC_CTX *_mem_save_luid_0;
7393         if (flags & NDR_IN) {
7394                 ZERO_STRUCT(r->out);
7395
7396                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7397                         NDR_PULL_ALLOC(ndr, r->in.handle);
7398                 }
7399                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7400                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7401                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7402                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7403                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7404                         NDR_PULL_ALLOC(ndr, r->in.name);
7405                 }
7406                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7407                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
7408                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
7409                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
7410                 NDR_PULL_ALLOC(ndr, r->out.luid);
7411                 ZERO_STRUCTP(r->out.luid);
7412         }
7413         if (flags & NDR_OUT) {
7414                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7415                         NDR_PULL_ALLOC(ndr, r->out.luid);
7416                 }
7417                 _mem_save_luid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7418                 NDR_PULL_SET_MEM_CTX(ndr, r->out.luid, LIBNDR_FLAG_REF_ALLOC);
7419                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, r->out.luid));
7420                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_luid_0, LIBNDR_FLAG_REF_ALLOC);
7421                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7422         }
7423         return NDR_ERR_SUCCESS;
7424 }
7425
7426 _PUBLIC_ void ndr_print_lsa_LookupPrivValue(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivValue *r)
7427 {
7428         ndr_print_struct(ndr, name, "lsa_LookupPrivValue");
7429         ndr->depth++;
7430         if (flags & NDR_SET_VALUES) {
7431                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7432         }
7433         if (flags & NDR_IN) {
7434                 ndr_print_struct(ndr, "in", "lsa_LookupPrivValue");
7435                 ndr->depth++;
7436                 ndr_print_ptr(ndr, "handle", r->in.handle);
7437                 ndr->depth++;
7438                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7439                 ndr->depth--;
7440                 ndr_print_ptr(ndr, "name", r->in.name);
7441                 ndr->depth++;
7442                 ndr_print_lsa_String(ndr, "name", r->in.name);
7443                 ndr->depth--;
7444                 ndr->depth--;
7445         }
7446         if (flags & NDR_OUT) {
7447                 ndr_print_struct(ndr, "out", "lsa_LookupPrivValue");
7448                 ndr->depth++;
7449                 ndr_print_ptr(ndr, "luid", r->out.luid);
7450                 ndr->depth++;
7451                 ndr_print_lsa_LUID(ndr, "luid", r->out.luid);
7452                 ndr->depth--;
7453                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7454                 ndr->depth--;
7455         }
7456         ndr->depth--;
7457 }
7458
7459 static enum ndr_err_code ndr_push_lsa_LookupPrivName(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivName *r)
7460 {
7461         if (flags & NDR_IN) {
7462                 if (r->in.handle == NULL) {
7463                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7464                 }
7465                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7466                 if (r->in.luid == NULL) {
7467                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7468                 }
7469                 NDR_CHECK(ndr_push_lsa_LUID(ndr, NDR_SCALARS, r->in.luid));
7470         }
7471         if (flags & NDR_OUT) {
7472                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.name));
7473                 if (r->out.name) {
7474                         NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
7475                 }
7476                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7477         }
7478         return NDR_ERR_SUCCESS;
7479 }
7480
7481 static enum ndr_err_code ndr_pull_lsa_LookupPrivName(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivName *r)
7482 {
7483         uint32_t _ptr_name;
7484         TALLOC_CTX *_mem_save_handle_0;
7485         TALLOC_CTX *_mem_save_luid_0;
7486         TALLOC_CTX *_mem_save_name_0;
7487         if (flags & NDR_IN) {
7488                 ZERO_STRUCT(r->out);
7489
7490                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7491                         NDR_PULL_ALLOC(ndr, r->in.handle);
7492                 }
7493                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7494                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7495                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7496                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7497                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7498                         NDR_PULL_ALLOC(ndr, r->in.luid);
7499                 }
7500                 _mem_save_luid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7501                 NDR_PULL_SET_MEM_CTX(ndr, r->in.luid, LIBNDR_FLAG_REF_ALLOC);
7502                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, r->in.luid));
7503                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_luid_0, LIBNDR_FLAG_REF_ALLOC);
7504         }
7505         if (flags & NDR_OUT) {
7506                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
7507                 if (_ptr_name) {
7508                         NDR_PULL_ALLOC(ndr, r->out.name);
7509                 } else {
7510                         r->out.name = NULL;
7511                 }
7512                 if (r->out.name) {
7513                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7514                         NDR_PULL_SET_MEM_CTX(ndr, r->out.name, 0);
7515                         NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
7516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
7517                 }
7518                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7519         }
7520         return NDR_ERR_SUCCESS;
7521 }
7522
7523 _PUBLIC_ void ndr_print_lsa_LookupPrivName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivName *r)
7524 {
7525         ndr_print_struct(ndr, name, "lsa_LookupPrivName");
7526         ndr->depth++;
7527         if (flags & NDR_SET_VALUES) {
7528                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7529         }
7530         if (flags & NDR_IN) {
7531                 ndr_print_struct(ndr, "in", "lsa_LookupPrivName");
7532                 ndr->depth++;
7533                 ndr_print_ptr(ndr, "handle", r->in.handle);
7534                 ndr->depth++;
7535                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7536                 ndr->depth--;
7537                 ndr_print_ptr(ndr, "luid", r->in.luid);
7538                 ndr->depth++;
7539                 ndr_print_lsa_LUID(ndr, "luid", r->in.luid);
7540                 ndr->depth--;
7541                 ndr->depth--;
7542         }
7543         if (flags & NDR_OUT) {
7544                 ndr_print_struct(ndr, "out", "lsa_LookupPrivName");
7545                 ndr->depth++;
7546                 ndr_print_ptr(ndr, "name", r->out.name);
7547                 ndr->depth++;
7548                 if (r->out.name) {
7549                         ndr_print_lsa_StringLarge(ndr, "name", r->out.name);
7550                 }
7551                 ndr->depth--;
7552                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7553                 ndr->depth--;
7554         }
7555         ndr->depth--;
7556 }
7557
7558 static enum ndr_err_code ndr_push_lsa_LookupPrivDisplayName(struct ndr_push *ndr, int flags, const struct lsa_LookupPrivDisplayName *r)
7559 {
7560         if (flags & NDR_IN) {
7561                 if (r->in.handle == NULL) {
7562                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7563                 }
7564                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7565                 if (r->in.name == NULL) {
7566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7567                 }
7568                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
7569                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.language_id));
7570                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.language_id_sys));
7571         }
7572         if (flags & NDR_OUT) {
7573                 if (r->out.disp_name == NULL) {
7574                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7575                 }
7576                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.disp_name));
7577                 if (*r->out.disp_name) {
7578                         NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.disp_name));
7579                 }
7580                 if (r->out.returned_language_id == NULL) {
7581                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7582                 }
7583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->out.returned_language_id));
7584                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7585         }
7586         return NDR_ERR_SUCCESS;
7587 }
7588
7589 static enum ndr_err_code ndr_pull_lsa_LookupPrivDisplayName(struct ndr_pull *ndr, int flags, struct lsa_LookupPrivDisplayName *r)
7590 {
7591         uint32_t _ptr_disp_name;
7592         TALLOC_CTX *_mem_save_handle_0;
7593         TALLOC_CTX *_mem_save_name_0;
7594         TALLOC_CTX *_mem_save_disp_name_0;
7595         TALLOC_CTX *_mem_save_disp_name_1;
7596         TALLOC_CTX *_mem_save_returned_language_id_0;
7597         if (flags & NDR_IN) {
7598                 ZERO_STRUCT(r->out);
7599
7600                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7601                         NDR_PULL_ALLOC(ndr, r->in.handle);
7602                 }
7603                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7604                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7605                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7606                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7607                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7608                         NDR_PULL_ALLOC(ndr, r->in.name);
7609                 }
7610                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7611                 NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
7612                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
7613                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
7614                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.language_id));
7615                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.language_id_sys));
7616                 NDR_PULL_ALLOC(ndr, r->out.disp_name);
7617                 ZERO_STRUCTP(r->out.disp_name);
7618                 NDR_PULL_ALLOC(ndr, r->out.returned_language_id);
7619                 ZERO_STRUCTP(r->out.returned_language_id);
7620         }
7621         if (flags & NDR_OUT) {
7622                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7623                         NDR_PULL_ALLOC(ndr, r->out.disp_name);
7624                 }
7625                 _mem_save_disp_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7626                 NDR_PULL_SET_MEM_CTX(ndr, r->out.disp_name, LIBNDR_FLAG_REF_ALLOC);
7627                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_disp_name));
7628                 if (_ptr_disp_name) {
7629                         NDR_PULL_ALLOC(ndr, *r->out.disp_name);
7630                 } else {
7631                         *r->out.disp_name = NULL;
7632                 }
7633                 if (*r->out.disp_name) {
7634                         _mem_save_disp_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
7635                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.disp_name, 0);
7636                         NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.disp_name));
7637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disp_name_1, 0);
7638                 }
7639                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_disp_name_0, LIBNDR_FLAG_REF_ALLOC);
7640                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7641                         NDR_PULL_ALLOC(ndr, r->out.returned_language_id);
7642                 }
7643                 _mem_save_returned_language_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
7644                 NDR_PULL_SET_MEM_CTX(ndr, r->out.returned_language_id, LIBNDR_FLAG_REF_ALLOC);
7645                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->out.returned_language_id));
7646                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_returned_language_id_0, LIBNDR_FLAG_REF_ALLOC);
7647                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7648         }
7649         return NDR_ERR_SUCCESS;
7650 }
7651
7652 _PUBLIC_ void ndr_print_lsa_LookupPrivDisplayName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupPrivDisplayName *r)
7653 {
7654         ndr_print_struct(ndr, name, "lsa_LookupPrivDisplayName");
7655         ndr->depth++;
7656         if (flags & NDR_SET_VALUES) {
7657                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7658         }
7659         if (flags & NDR_IN) {
7660                 ndr_print_struct(ndr, "in", "lsa_LookupPrivDisplayName");
7661                 ndr->depth++;
7662                 ndr_print_ptr(ndr, "handle", r->in.handle);
7663                 ndr->depth++;
7664                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7665                 ndr->depth--;
7666                 ndr_print_ptr(ndr, "name", r->in.name);
7667                 ndr->depth++;
7668                 ndr_print_lsa_String(ndr, "name", r->in.name);
7669                 ndr->depth--;
7670                 ndr_print_uint16(ndr, "language_id", r->in.language_id);
7671                 ndr_print_uint16(ndr, "language_id_sys", r->in.language_id_sys);
7672                 ndr->depth--;
7673         }
7674         if (flags & NDR_OUT) {
7675                 ndr_print_struct(ndr, "out", "lsa_LookupPrivDisplayName");
7676                 ndr->depth++;
7677                 ndr_print_ptr(ndr, "disp_name", r->out.disp_name);
7678                 ndr->depth++;
7679                 ndr_print_ptr(ndr, "disp_name", *r->out.disp_name);
7680                 ndr->depth++;
7681                 if (*r->out.disp_name) {
7682                         ndr_print_lsa_StringLarge(ndr, "disp_name", *r->out.disp_name);
7683                 }
7684                 ndr->depth--;
7685                 ndr->depth--;
7686                 ndr_print_ptr(ndr, "returned_language_id", r->out.returned_language_id);
7687                 ndr->depth++;
7688                 ndr_print_uint16(ndr, "returned_language_id", *r->out.returned_language_id);
7689                 ndr->depth--;
7690                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7691                 ndr->depth--;
7692         }
7693         ndr->depth--;
7694 }
7695
7696 static enum ndr_err_code ndr_push_lsa_DeleteObject(struct ndr_push *ndr, int flags, const struct lsa_DeleteObject *r)
7697 {
7698         if (flags & NDR_IN) {
7699                 if (r->in.handle == NULL) {
7700                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7701                 }
7702                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7703         }
7704         if (flags & NDR_OUT) {
7705                 if (r->out.handle == NULL) {
7706                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7707                 }
7708                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
7709                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7710         }
7711         return NDR_ERR_SUCCESS;
7712 }
7713
7714 static enum ndr_err_code ndr_pull_lsa_DeleteObject(struct ndr_pull *ndr, int flags, struct lsa_DeleteObject *r)
7715 {
7716         TALLOC_CTX *_mem_save_handle_0;
7717         if (flags & NDR_IN) {
7718                 ZERO_STRUCT(r->out);
7719
7720                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7721                         NDR_PULL_ALLOC(ndr, r->in.handle);
7722                 }
7723                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7724                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7725                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7726                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7727                 NDR_PULL_ALLOC(ndr, r->out.handle);
7728                 *r->out.handle = *r->in.handle;
7729         }
7730         if (flags & NDR_OUT) {
7731                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7732                         NDR_PULL_ALLOC(ndr, r->out.handle);
7733                 }
7734                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7735                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
7736                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
7737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7738                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7739         }
7740         return NDR_ERR_SUCCESS;
7741 }
7742
7743 _PUBLIC_ void ndr_print_lsa_DeleteObject(struct ndr_print *ndr, const char *name, int flags, const struct lsa_DeleteObject *r)
7744 {
7745         ndr_print_struct(ndr, name, "lsa_DeleteObject");
7746         ndr->depth++;
7747         if (flags & NDR_SET_VALUES) {
7748                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7749         }
7750         if (flags & NDR_IN) {
7751                 ndr_print_struct(ndr, "in", "lsa_DeleteObject");
7752                 ndr->depth++;
7753                 ndr_print_ptr(ndr, "handle", r->in.handle);
7754                 ndr->depth++;
7755                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7756                 ndr->depth--;
7757                 ndr->depth--;
7758         }
7759         if (flags & NDR_OUT) {
7760                 ndr_print_struct(ndr, "out", "lsa_DeleteObject");
7761                 ndr->depth++;
7762                 ndr_print_ptr(ndr, "handle", r->out.handle);
7763                 ndr->depth++;
7764                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
7765                 ndr->depth--;
7766                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7767                 ndr->depth--;
7768         }
7769         ndr->depth--;
7770 }
7771
7772 static enum ndr_err_code ndr_push_lsa_EnumAccountsWithUserRight(struct ndr_push *ndr, int flags, const struct lsa_EnumAccountsWithUserRight *r)
7773 {
7774         if (flags & NDR_IN) {
7775                 if (r->in.handle == NULL) {
7776                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7777                 }
7778                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7779                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
7780                 if (r->in.name) {
7781                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
7782                 }
7783         }
7784         if (flags & NDR_OUT) {
7785                 if (r->out.sids == NULL) {
7786                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7787                 }
7788                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
7789                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7790         }
7791         return NDR_ERR_SUCCESS;
7792 }
7793
7794 static enum ndr_err_code ndr_pull_lsa_EnumAccountsWithUserRight(struct ndr_pull *ndr, int flags, struct lsa_EnumAccountsWithUserRight *r)
7795 {
7796         uint32_t _ptr_name;
7797         TALLOC_CTX *_mem_save_handle_0;
7798         TALLOC_CTX *_mem_save_name_0;
7799         TALLOC_CTX *_mem_save_sids_0;
7800         if (flags & NDR_IN) {
7801                 ZERO_STRUCT(r->out);
7802
7803                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7804                         NDR_PULL_ALLOC(ndr, r->in.handle);
7805                 }
7806                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7807                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7808                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7810                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
7811                 if (_ptr_name) {
7812                         NDR_PULL_ALLOC(ndr, r->in.name);
7813                 } else {
7814                         r->in.name = NULL;
7815                 }
7816                 if (r->in.name) {
7817                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7818                         NDR_PULL_SET_MEM_CTX(ndr, r->in.name, 0);
7819                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
7820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
7821                 }
7822                 NDR_PULL_ALLOC(ndr, r->out.sids);
7823                 ZERO_STRUCTP(r->out.sids);
7824         }
7825         if (flags & NDR_OUT) {
7826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7827                         NDR_PULL_ALLOC(ndr, r->out.sids);
7828                 }
7829                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
7830                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
7831                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
7832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
7833                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7834         }
7835         return NDR_ERR_SUCCESS;
7836 }
7837
7838 _PUBLIC_ void ndr_print_lsa_EnumAccountsWithUserRight(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccountsWithUserRight *r)
7839 {
7840         ndr_print_struct(ndr, name, "lsa_EnumAccountsWithUserRight");
7841         ndr->depth++;
7842         if (flags & NDR_SET_VALUES) {
7843                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7844         }
7845         if (flags & NDR_IN) {
7846                 ndr_print_struct(ndr, "in", "lsa_EnumAccountsWithUserRight");
7847                 ndr->depth++;
7848                 ndr_print_ptr(ndr, "handle", r->in.handle);
7849                 ndr->depth++;
7850                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7851                 ndr->depth--;
7852                 ndr_print_ptr(ndr, "name", r->in.name);
7853                 ndr->depth++;
7854                 if (r->in.name) {
7855                         ndr_print_lsa_String(ndr, "name", r->in.name);
7856                 }
7857                 ndr->depth--;
7858                 ndr->depth--;
7859         }
7860         if (flags & NDR_OUT) {
7861                 ndr_print_struct(ndr, "out", "lsa_EnumAccountsWithUserRight");
7862                 ndr->depth++;
7863                 ndr_print_ptr(ndr, "sids", r->out.sids);
7864                 ndr->depth++;
7865                 ndr_print_lsa_SidArray(ndr, "sids", r->out.sids);
7866                 ndr->depth--;
7867                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7868                 ndr->depth--;
7869         }
7870         ndr->depth--;
7871 }
7872
7873 static enum ndr_err_code ndr_push_lsa_EnumAccountRights(struct ndr_push *ndr, int flags, const struct lsa_EnumAccountRights *r)
7874 {
7875         if (flags & NDR_IN) {
7876                 if (r->in.handle == NULL) {
7877                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7878                 }
7879                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7880                 if (r->in.sid == NULL) {
7881                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7882                 }
7883                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
7884         }
7885         if (flags & NDR_OUT) {
7886                 if (r->out.rights == NULL) {
7887                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7888                 }
7889                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rights));
7890                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7891         }
7892         return NDR_ERR_SUCCESS;
7893 }
7894
7895 static enum ndr_err_code ndr_pull_lsa_EnumAccountRights(struct ndr_pull *ndr, int flags, struct lsa_EnumAccountRights *r)
7896 {
7897         TALLOC_CTX *_mem_save_handle_0;
7898         TALLOC_CTX *_mem_save_sid_0;
7899         TALLOC_CTX *_mem_save_rights_0;
7900         if (flags & NDR_IN) {
7901                 ZERO_STRUCT(r->out);
7902
7903                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7904                         NDR_PULL_ALLOC(ndr, r->in.handle);
7905                 }
7906                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7907                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7908                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7909                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7910                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7911                         NDR_PULL_ALLOC(ndr, r->in.sid);
7912                 }
7913                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7914                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
7915                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
7916                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
7917                 NDR_PULL_ALLOC(ndr, r->out.rights);
7918                 ZERO_STRUCTP(r->out.rights);
7919         }
7920         if (flags & NDR_OUT) {
7921                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7922                         NDR_PULL_ALLOC(ndr, r->out.rights);
7923                 }
7924                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
7925                 NDR_PULL_SET_MEM_CTX(ndr, r->out.rights, LIBNDR_FLAG_REF_ALLOC);
7926                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rights));
7927                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
7928                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7929         }
7930         return NDR_ERR_SUCCESS;
7931 }
7932
7933 _PUBLIC_ void ndr_print_lsa_EnumAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumAccountRights *r)
7934 {
7935         ndr_print_struct(ndr, name, "lsa_EnumAccountRights");
7936         ndr->depth++;
7937         if (flags & NDR_SET_VALUES) {
7938                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7939         }
7940         if (flags & NDR_IN) {
7941                 ndr_print_struct(ndr, "in", "lsa_EnumAccountRights");
7942                 ndr->depth++;
7943                 ndr_print_ptr(ndr, "handle", r->in.handle);
7944                 ndr->depth++;
7945                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
7946                 ndr->depth--;
7947                 ndr_print_ptr(ndr, "sid", r->in.sid);
7948                 ndr->depth++;
7949                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
7950                 ndr->depth--;
7951                 ndr->depth--;
7952         }
7953         if (flags & NDR_OUT) {
7954                 ndr_print_struct(ndr, "out", "lsa_EnumAccountRights");
7955                 ndr->depth++;
7956                 ndr_print_ptr(ndr, "rights", r->out.rights);
7957                 ndr->depth++;
7958                 ndr_print_lsa_RightSet(ndr, "rights", r->out.rights);
7959                 ndr->depth--;
7960                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
7961                 ndr->depth--;
7962         }
7963         ndr->depth--;
7964 }
7965
7966 static enum ndr_err_code ndr_push_lsa_AddAccountRights(struct ndr_push *ndr, int flags, const struct lsa_AddAccountRights *r)
7967 {
7968         if (flags & NDR_IN) {
7969                 if (r->in.handle == NULL) {
7970                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7971                 }
7972                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
7973                 if (r->in.sid == NULL) {
7974                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7975                 }
7976                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
7977                 if (r->in.rights == NULL) {
7978                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7979                 }
7980                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
7981         }
7982         if (flags & NDR_OUT) {
7983                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7984         }
7985         return NDR_ERR_SUCCESS;
7986 }
7987
7988 static enum ndr_err_code ndr_pull_lsa_AddAccountRights(struct ndr_pull *ndr, int flags, struct lsa_AddAccountRights *r)
7989 {
7990         TALLOC_CTX *_mem_save_handle_0;
7991         TALLOC_CTX *_mem_save_sid_0;
7992         TALLOC_CTX *_mem_save_rights_0;
7993         if (flags & NDR_IN) {
7994                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7995                         NDR_PULL_ALLOC(ndr, r->in.handle);
7996                 }
7997                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7998                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7999                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8000                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8001                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8002                         NDR_PULL_ALLOC(ndr, r->in.sid);
8003                 }
8004                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8005                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8006                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8007                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8009                         NDR_PULL_ALLOC(ndr, r->in.rights);
8010                 }
8011                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
8012                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rights, LIBNDR_FLAG_REF_ALLOC);
8013                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
8014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
8015         }
8016         if (flags & NDR_OUT) {
8017                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8018         }
8019         return NDR_ERR_SUCCESS;
8020 }
8021
8022 _PUBLIC_ void ndr_print_lsa_AddAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_AddAccountRights *r)
8023 {
8024         ndr_print_struct(ndr, name, "lsa_AddAccountRights");
8025         ndr->depth++;
8026         if (flags & NDR_SET_VALUES) {
8027                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8028         }
8029         if (flags & NDR_IN) {
8030                 ndr_print_struct(ndr, "in", "lsa_AddAccountRights");
8031                 ndr->depth++;
8032                 ndr_print_ptr(ndr, "handle", r->in.handle);
8033                 ndr->depth++;
8034                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8035                 ndr->depth--;
8036                 ndr_print_ptr(ndr, "sid", r->in.sid);
8037                 ndr->depth++;
8038                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8039                 ndr->depth--;
8040                 ndr_print_ptr(ndr, "rights", r->in.rights);
8041                 ndr->depth++;
8042                 ndr_print_lsa_RightSet(ndr, "rights", r->in.rights);
8043                 ndr->depth--;
8044                 ndr->depth--;
8045         }
8046         if (flags & NDR_OUT) {
8047                 ndr_print_struct(ndr, "out", "lsa_AddAccountRights");
8048                 ndr->depth++;
8049                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8050                 ndr->depth--;
8051         }
8052         ndr->depth--;
8053 }
8054
8055 static enum ndr_err_code ndr_push_lsa_RemoveAccountRights(struct ndr_push *ndr, int flags, const struct lsa_RemoveAccountRights *r)
8056 {
8057         if (flags & NDR_IN) {
8058                 if (r->in.handle == NULL) {
8059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8060                 }
8061                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8062                 if (r->in.sid == NULL) {
8063                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8064                 }
8065                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8066                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.remove_all));
8067                 if (r->in.rights == NULL) {
8068                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8069                 }
8070                 NDR_CHECK(ndr_push_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
8071         }
8072         if (flags & NDR_OUT) {
8073                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8074         }
8075         return NDR_ERR_SUCCESS;
8076 }
8077
8078 static enum ndr_err_code ndr_pull_lsa_RemoveAccountRights(struct ndr_pull *ndr, int flags, struct lsa_RemoveAccountRights *r)
8079 {
8080         TALLOC_CTX *_mem_save_handle_0;
8081         TALLOC_CTX *_mem_save_sid_0;
8082         TALLOC_CTX *_mem_save_rights_0;
8083         if (flags & NDR_IN) {
8084                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8085                         NDR_PULL_ALLOC(ndr, r->in.handle);
8086                 }
8087                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8088                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8089                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8090                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8091                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8092                         NDR_PULL_ALLOC(ndr, r->in.sid);
8093                 }
8094                 _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8095                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sid, LIBNDR_FLAG_REF_ALLOC);
8096                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sid));
8097                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sid_0, LIBNDR_FLAG_REF_ALLOC);
8098                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.remove_all));
8099                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8100                         NDR_PULL_ALLOC(ndr, r->in.rights);
8101                 }
8102                 _mem_save_rights_0 = NDR_PULL_GET_MEM_CTX(ndr);
8103                 NDR_PULL_SET_MEM_CTX(ndr, r->in.rights, LIBNDR_FLAG_REF_ALLOC);
8104                 NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.rights));
8105                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rights_0, LIBNDR_FLAG_REF_ALLOC);
8106         }
8107         if (flags & NDR_OUT) {
8108                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8109         }
8110         return NDR_ERR_SUCCESS;
8111 }
8112
8113 _PUBLIC_ void ndr_print_lsa_RemoveAccountRights(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RemoveAccountRights *r)
8114 {
8115         ndr_print_struct(ndr, name, "lsa_RemoveAccountRights");
8116         ndr->depth++;
8117         if (flags & NDR_SET_VALUES) {
8118                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8119         }
8120         if (flags & NDR_IN) {
8121                 ndr_print_struct(ndr, "in", "lsa_RemoveAccountRights");
8122                 ndr->depth++;
8123                 ndr_print_ptr(ndr, "handle", r->in.handle);
8124                 ndr->depth++;
8125                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8126                 ndr->depth--;
8127                 ndr_print_ptr(ndr, "sid", r->in.sid);
8128                 ndr->depth++;
8129                 ndr_print_dom_sid2(ndr, "sid", r->in.sid);
8130                 ndr->depth--;
8131                 ndr_print_uint8(ndr, "remove_all", r->in.remove_all);
8132                 ndr_print_ptr(ndr, "rights", r->in.rights);
8133                 ndr->depth++;
8134                 ndr_print_lsa_RightSet(ndr, "rights", r->in.rights);
8135                 ndr->depth--;
8136                 ndr->depth--;
8137         }
8138         if (flags & NDR_OUT) {
8139                 ndr_print_struct(ndr, "out", "lsa_RemoveAccountRights");
8140                 ndr->depth++;
8141                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8142                 ndr->depth--;
8143         }
8144         ndr->depth--;
8145 }
8146
8147 static enum ndr_err_code ndr_push_lsa_QueryTrustedDomainInfoBySid(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfoBySid *r)
8148 {
8149         if (flags & NDR_IN) {
8150                 if (r->in.handle == NULL) {
8151                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8152                 }
8153                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8154                 if (r->in.dom_sid == NULL) {
8155                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8156                 }
8157                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
8158                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
8159         }
8160         if (flags & NDR_OUT) {
8161                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
8162                 if (r->out.info) {
8163                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
8164                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
8165                 }
8166                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8167         }
8168         return NDR_ERR_SUCCESS;
8169 }
8170
8171 static enum ndr_err_code ndr_pull_lsa_QueryTrustedDomainInfoBySid(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfoBySid *r)
8172 {
8173         uint32_t _ptr_info;
8174         TALLOC_CTX *_mem_save_handle_0;
8175         TALLOC_CTX *_mem_save_dom_sid_0;
8176         TALLOC_CTX *_mem_save_info_0;
8177         if (flags & NDR_IN) {
8178                 ZERO_STRUCT(r->out);
8179
8180                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8181                         NDR_PULL_ALLOC(ndr, r->in.handle);
8182                 }
8183                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8184                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8185                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8188                         NDR_PULL_ALLOC(ndr, r->in.dom_sid);
8189                 }
8190                 _mem_save_dom_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8191                 NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_sid, LIBNDR_FLAG_REF_ALLOC);
8192                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
8193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_sid_0, LIBNDR_FLAG_REF_ALLOC);
8194                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
8195         }
8196         if (flags & NDR_OUT) {
8197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8198                 if (_ptr_info) {
8199                         NDR_PULL_ALLOC(ndr, r->out.info);
8200                 } else {
8201                         r->out.info = NULL;
8202                 }
8203                 if (r->out.info) {
8204                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8205                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
8206                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
8207                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
8208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8209                 }
8210                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8211         }
8212         return NDR_ERR_SUCCESS;
8213 }
8214
8215 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfoBySid(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfoBySid *r)
8216 {
8217         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfoBySid");
8218         ndr->depth++;
8219         if (flags & NDR_SET_VALUES) {
8220                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8221         }
8222         if (flags & NDR_IN) {
8223                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfoBySid");
8224                 ndr->depth++;
8225                 ndr_print_ptr(ndr, "handle", r->in.handle);
8226                 ndr->depth++;
8227                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8228                 ndr->depth--;
8229                 ndr_print_ptr(ndr, "dom_sid", r->in.dom_sid);
8230                 ndr->depth++;
8231                 ndr_print_dom_sid2(ndr, "dom_sid", r->in.dom_sid);
8232                 ndr->depth--;
8233                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
8234                 ndr->depth--;
8235         }
8236         if (flags & NDR_OUT) {
8237                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfoBySid");
8238                 ndr->depth++;
8239                 ndr_print_ptr(ndr, "info", r->out.info);
8240                 ndr->depth++;
8241                 if (r->out.info) {
8242                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
8243                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->out.info);
8244                 }
8245                 ndr->depth--;
8246                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8247                 ndr->depth--;
8248         }
8249         ndr->depth--;
8250 }
8251
8252 static enum ndr_err_code ndr_push_lsa_SetTrustedDomainInfo(struct ndr_push *ndr, int flags, const struct lsa_SetTrustedDomainInfo *r)
8253 {
8254         if (flags & NDR_IN) {
8255         }
8256         if (flags & NDR_OUT) {
8257                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8258         }
8259         return NDR_ERR_SUCCESS;
8260 }
8261
8262 static enum ndr_err_code ndr_pull_lsa_SetTrustedDomainInfo(struct ndr_pull *ndr, int flags, struct lsa_SetTrustedDomainInfo *r)
8263 {
8264         if (flags & NDR_IN) {
8265         }
8266         if (flags & NDR_OUT) {
8267                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8268         }
8269         return NDR_ERR_SUCCESS;
8270 }
8271
8272 _PUBLIC_ void ndr_print_lsa_SetTrustedDomainInfo(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetTrustedDomainInfo *r)
8273 {
8274         ndr_print_struct(ndr, name, "lsa_SetTrustedDomainInfo");
8275         ndr->depth++;
8276         if (flags & NDR_SET_VALUES) {
8277                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8278         }
8279         if (flags & NDR_IN) {
8280                 ndr_print_struct(ndr, "in", "lsa_SetTrustedDomainInfo");
8281                 ndr->depth++;
8282                 ndr->depth--;
8283         }
8284         if (flags & NDR_OUT) {
8285                 ndr_print_struct(ndr, "out", "lsa_SetTrustedDomainInfo");
8286                 ndr->depth++;
8287                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8288                 ndr->depth--;
8289         }
8290         ndr->depth--;
8291 }
8292
8293 static enum ndr_err_code ndr_push_lsa_DeleteTrustedDomain(struct ndr_push *ndr, int flags, const struct lsa_DeleteTrustedDomain *r)
8294 {
8295         if (flags & NDR_IN) {
8296                 if (r->in.handle == NULL) {
8297                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8298                 }
8299                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8300                 if (r->in.dom_sid == NULL) {
8301                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8302                 }
8303                 NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
8304         }
8305         if (flags & NDR_OUT) {
8306                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8307         }
8308         return NDR_ERR_SUCCESS;
8309 }
8310
8311 static enum ndr_err_code ndr_pull_lsa_DeleteTrustedDomain(struct ndr_pull *ndr, int flags, struct lsa_DeleteTrustedDomain *r)
8312 {
8313         TALLOC_CTX *_mem_save_handle_0;
8314         TALLOC_CTX *_mem_save_dom_sid_0;
8315         if (flags & NDR_IN) {
8316                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8317                         NDR_PULL_ALLOC(ndr, r->in.handle);
8318                 }
8319                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8320                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8321                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8322                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8323                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8324                         NDR_PULL_ALLOC(ndr, r->in.dom_sid);
8325                 }
8326                 _mem_save_dom_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
8327                 NDR_PULL_SET_MEM_CTX(ndr, r->in.dom_sid, LIBNDR_FLAG_REF_ALLOC);
8328                 NDR_CHECK(ndr_pull_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.dom_sid));
8329                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dom_sid_0, LIBNDR_FLAG_REF_ALLOC);
8330         }
8331         if (flags & NDR_OUT) {
8332                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8333         }
8334         return NDR_ERR_SUCCESS;
8335 }
8336
8337 _PUBLIC_ void ndr_print_lsa_DeleteTrustedDomain(struct ndr_print *ndr, const char *name, int flags, const struct lsa_DeleteTrustedDomain *r)
8338 {
8339         ndr_print_struct(ndr, name, "lsa_DeleteTrustedDomain");
8340         ndr->depth++;
8341         if (flags & NDR_SET_VALUES) {
8342                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8343         }
8344         if (flags & NDR_IN) {
8345                 ndr_print_struct(ndr, "in", "lsa_DeleteTrustedDomain");
8346                 ndr->depth++;
8347                 ndr_print_ptr(ndr, "handle", r->in.handle);
8348                 ndr->depth++;
8349                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8350                 ndr->depth--;
8351                 ndr_print_ptr(ndr, "dom_sid", r->in.dom_sid);
8352                 ndr->depth++;
8353                 ndr_print_dom_sid2(ndr, "dom_sid", r->in.dom_sid);
8354                 ndr->depth--;
8355                 ndr->depth--;
8356         }
8357         if (flags & NDR_OUT) {
8358                 ndr_print_struct(ndr, "out", "lsa_DeleteTrustedDomain");
8359                 ndr->depth++;
8360                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8361                 ndr->depth--;
8362         }
8363         ndr->depth--;
8364 }
8365
8366 static enum ndr_err_code ndr_push_lsa_StorePrivateData(struct ndr_push *ndr, int flags, const struct lsa_StorePrivateData *r)
8367 {
8368         if (flags & NDR_IN) {
8369         }
8370         if (flags & NDR_OUT) {
8371                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8372         }
8373         return NDR_ERR_SUCCESS;
8374 }
8375
8376 static enum ndr_err_code ndr_pull_lsa_StorePrivateData(struct ndr_pull *ndr, int flags, struct lsa_StorePrivateData *r)
8377 {
8378         if (flags & NDR_IN) {
8379         }
8380         if (flags & NDR_OUT) {
8381                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8382         }
8383         return NDR_ERR_SUCCESS;
8384 }
8385
8386 _PUBLIC_ void ndr_print_lsa_StorePrivateData(struct ndr_print *ndr, const char *name, int flags, const struct lsa_StorePrivateData *r)
8387 {
8388         ndr_print_struct(ndr, name, "lsa_StorePrivateData");
8389         ndr->depth++;
8390         if (flags & NDR_SET_VALUES) {
8391                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8392         }
8393         if (flags & NDR_IN) {
8394                 ndr_print_struct(ndr, "in", "lsa_StorePrivateData");
8395                 ndr->depth++;
8396                 ndr->depth--;
8397         }
8398         if (flags & NDR_OUT) {
8399                 ndr_print_struct(ndr, "out", "lsa_StorePrivateData");
8400                 ndr->depth++;
8401                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8402                 ndr->depth--;
8403         }
8404         ndr->depth--;
8405 }
8406
8407 static enum ndr_err_code ndr_push_lsa_RetrievePrivateData(struct ndr_push *ndr, int flags, const struct lsa_RetrievePrivateData *r)
8408 {
8409         if (flags & NDR_IN) {
8410         }
8411         if (flags & NDR_OUT) {
8412                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8413         }
8414         return NDR_ERR_SUCCESS;
8415 }
8416
8417 static enum ndr_err_code ndr_pull_lsa_RetrievePrivateData(struct ndr_pull *ndr, int flags, struct lsa_RetrievePrivateData *r)
8418 {
8419         if (flags & NDR_IN) {
8420         }
8421         if (flags & NDR_OUT) {
8422                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8423         }
8424         return NDR_ERR_SUCCESS;
8425 }
8426
8427 _PUBLIC_ void ndr_print_lsa_RetrievePrivateData(struct ndr_print *ndr, const char *name, int flags, const struct lsa_RetrievePrivateData *r)
8428 {
8429         ndr_print_struct(ndr, name, "lsa_RetrievePrivateData");
8430         ndr->depth++;
8431         if (flags & NDR_SET_VALUES) {
8432                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8433         }
8434         if (flags & NDR_IN) {
8435                 ndr_print_struct(ndr, "in", "lsa_RetrievePrivateData");
8436                 ndr->depth++;
8437                 ndr->depth--;
8438         }
8439         if (flags & NDR_OUT) {
8440                 ndr_print_struct(ndr, "out", "lsa_RetrievePrivateData");
8441                 ndr->depth++;
8442                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8443                 ndr->depth--;
8444         }
8445         ndr->depth--;
8446 }
8447
8448 _PUBLIC_ enum ndr_err_code ndr_push_lsa_OpenPolicy2(struct ndr_push *ndr, int flags, const struct lsa_OpenPolicy2 *r)
8449 {
8450         if (flags & NDR_IN) {
8451                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
8452                 if (r->in.system_name) {
8453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
8454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
8456                         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));
8457                 }
8458                 if (r->in.attr == NULL) {
8459                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8460                 }
8461                 NDR_CHECK(ndr_push_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
8462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
8463         }
8464         if (flags & NDR_OUT) {
8465                 if (r->out.handle == NULL) {
8466                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8467                 }
8468                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
8469                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8470         }
8471         return NDR_ERR_SUCCESS;
8472 }
8473
8474 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_OpenPolicy2(struct ndr_pull *ndr, int flags, struct lsa_OpenPolicy2 *r)
8475 {
8476         uint32_t _ptr_system_name;
8477         TALLOC_CTX *_mem_save_system_name_0;
8478         TALLOC_CTX *_mem_save_attr_0;
8479         TALLOC_CTX *_mem_save_handle_0;
8480         if (flags & NDR_IN) {
8481                 ZERO_STRUCT(r->out);
8482
8483                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
8484                 if (_ptr_system_name) {
8485                         NDR_PULL_ALLOC(ndr, r->in.system_name);
8486                 } else {
8487                         r->in.system_name = NULL;
8488                 }
8489                 if (r->in.system_name) {
8490                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8491                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
8492                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
8493                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
8494                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
8495                                 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));
8496                         }
8497                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
8498                         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));
8499                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
8500                 }
8501                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8502                         NDR_PULL_ALLOC(ndr, r->in.attr);
8503                 }
8504                 _mem_save_attr_0 = NDR_PULL_GET_MEM_CTX(ndr);
8505                 NDR_PULL_SET_MEM_CTX(ndr, r->in.attr, LIBNDR_FLAG_REF_ALLOC);
8506                 NDR_CHECK(ndr_pull_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
8507                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attr_0, LIBNDR_FLAG_REF_ALLOC);
8508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
8509                 NDR_PULL_ALLOC(ndr, r->out.handle);
8510                 ZERO_STRUCTP(r->out.handle);
8511         }
8512         if (flags & NDR_OUT) {
8513                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8514                         NDR_PULL_ALLOC(ndr, r->out.handle);
8515                 }
8516                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8517                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
8518                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
8519                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8520                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8521         }
8522         return NDR_ERR_SUCCESS;
8523 }
8524
8525 _PUBLIC_ void ndr_print_lsa_OpenPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenPolicy2 *r)
8526 {
8527         ndr_print_struct(ndr, name, "lsa_OpenPolicy2");
8528         ndr->depth++;
8529         if (flags & NDR_SET_VALUES) {
8530                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8531         }
8532         if (flags & NDR_IN) {
8533                 ndr_print_struct(ndr, "in", "lsa_OpenPolicy2");
8534                 ndr->depth++;
8535                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
8536                 ndr->depth++;
8537                 if (r->in.system_name) {
8538                         ndr_print_string(ndr, "system_name", r->in.system_name);
8539                 }
8540                 ndr->depth--;
8541                 ndr_print_ptr(ndr, "attr", r->in.attr);
8542                 ndr->depth++;
8543                 ndr_print_lsa_ObjectAttribute(ndr, "attr", r->in.attr);
8544                 ndr->depth--;
8545                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
8546                 ndr->depth--;
8547         }
8548         if (flags & NDR_OUT) {
8549                 ndr_print_struct(ndr, "out", "lsa_OpenPolicy2");
8550                 ndr->depth++;
8551                 ndr_print_ptr(ndr, "handle", r->out.handle);
8552                 ndr->depth++;
8553                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
8554                 ndr->depth--;
8555                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8556                 ndr->depth--;
8557         }
8558         ndr->depth--;
8559 }
8560
8561 static enum ndr_err_code ndr_push_lsa_GetUserName(struct ndr_push *ndr, int flags, const struct lsa_GetUserName *r)
8562 {
8563         if (flags & NDR_IN) {
8564                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
8565                 if (r->in.system_name) {
8566                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
8567                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8568                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.system_name, CH_UTF16)));
8569                         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));
8570                 }
8571                 if (r->in.account_name == NULL) {
8572                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8573                 }
8574                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.account_name));
8575                 if (*r->in.account_name) {
8576                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.account_name));
8577                 }
8578                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.authority_name));
8579                 if (r->in.authority_name) {
8580                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->in.authority_name));
8581                         if (*r->in.authority_name) {
8582                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.authority_name));
8583                         }
8584                 }
8585         }
8586         if (flags & NDR_OUT) {
8587                 if (r->out.account_name == NULL) {
8588                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8589                 }
8590                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.account_name));
8591                 if (*r->out.account_name) {
8592                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.account_name));
8593                 }
8594                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.authority_name));
8595                 if (r->out.authority_name) {
8596                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.authority_name));
8597                         if (*r->out.authority_name) {
8598                                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.authority_name));
8599                         }
8600                 }
8601                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8602         }
8603         return NDR_ERR_SUCCESS;
8604 }
8605
8606 static enum ndr_err_code ndr_pull_lsa_GetUserName(struct ndr_pull *ndr, int flags, struct lsa_GetUserName *r)
8607 {
8608         uint32_t _ptr_system_name;
8609         uint32_t _ptr_account_name;
8610         uint32_t _ptr_authority_name;
8611         TALLOC_CTX *_mem_save_system_name_0;
8612         TALLOC_CTX *_mem_save_account_name_0;
8613         TALLOC_CTX *_mem_save_account_name_1;
8614         TALLOC_CTX *_mem_save_authority_name_0;
8615         TALLOC_CTX *_mem_save_authority_name_1;
8616         if (flags & NDR_IN) {
8617                 ZERO_STRUCT(r->out);
8618
8619                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
8620                 if (_ptr_system_name) {
8621                         NDR_PULL_ALLOC(ndr, r->in.system_name);
8622                 } else {
8623                         r->in.system_name = NULL;
8624                 }
8625                 if (r->in.system_name) {
8626                         _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8627                         NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
8628                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.system_name));
8629                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.system_name));
8630                         if (ndr_get_array_length(ndr, &r->in.system_name) > ndr_get_array_size(ndr, &r->in.system_name)) {
8631                                 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));
8632                         }
8633                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.system_name), sizeof(uint16_t)));
8634                         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));
8635                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
8636                 }
8637                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8638                         NDR_PULL_ALLOC(ndr, r->in.account_name);
8639                 }
8640                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8641                 NDR_PULL_SET_MEM_CTX(ndr, r->in.account_name, LIBNDR_FLAG_REF_ALLOC);
8642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
8643                 if (_ptr_account_name) {
8644                         NDR_PULL_ALLOC(ndr, *r->in.account_name);
8645                 } else {
8646                         *r->in.account_name = NULL;
8647                 }
8648                 if (*r->in.account_name) {
8649                         _mem_save_account_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
8650                         NDR_PULL_SET_MEM_CTX(ndr, *r->in.account_name, 0);
8651                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.account_name));
8652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_1, 0);
8653                 }
8654                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
8655                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
8656                 if (_ptr_authority_name) {
8657                         NDR_PULL_ALLOC(ndr, r->in.authority_name);
8658                 } else {
8659                         r->in.authority_name = NULL;
8660                 }
8661                 if (r->in.authority_name) {
8662                         _mem_save_authority_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8663                         NDR_PULL_SET_MEM_CTX(ndr, r->in.authority_name, 0);
8664                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
8665                         if (_ptr_authority_name) {
8666                                 NDR_PULL_ALLOC(ndr, *r->in.authority_name);
8667                         } else {
8668                                 *r->in.authority_name = NULL;
8669                         }
8670                         if (*r->in.authority_name) {
8671                                 _mem_save_authority_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
8672                                 NDR_PULL_SET_MEM_CTX(ndr, *r->in.authority_name, 0);
8673                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->in.authority_name));
8674                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_1, 0);
8675                         }
8676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_0, 0);
8677                 }
8678                 NDR_PULL_ALLOC(ndr, r->out.account_name);
8679                 *r->out.account_name = *r->in.account_name;
8680         }
8681         if (flags & NDR_OUT) {
8682                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8683                         NDR_PULL_ALLOC(ndr, r->out.account_name);
8684                 }
8685                 _mem_save_account_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8686                 NDR_PULL_SET_MEM_CTX(ndr, r->out.account_name, LIBNDR_FLAG_REF_ALLOC);
8687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_account_name));
8688                 if (_ptr_account_name) {
8689                         NDR_PULL_ALLOC(ndr, *r->out.account_name);
8690                 } else {
8691                         *r->out.account_name = NULL;
8692                 }
8693                 if (*r->out.account_name) {
8694                         _mem_save_account_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
8695                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.account_name, 0);
8696                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.account_name));
8697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_1, 0);
8698                 }
8699                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_account_name_0, LIBNDR_FLAG_REF_ALLOC);
8700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
8701                 if (_ptr_authority_name) {
8702                         NDR_PULL_ALLOC(ndr, r->out.authority_name);
8703                 } else {
8704                         r->out.authority_name = NULL;
8705                 }
8706                 if (r->out.authority_name) {
8707                         _mem_save_authority_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8708                         NDR_PULL_SET_MEM_CTX(ndr, r->out.authority_name, 0);
8709                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_authority_name));
8710                         if (_ptr_authority_name) {
8711                                 NDR_PULL_ALLOC(ndr, *r->out.authority_name);
8712                         } else {
8713                                 *r->out.authority_name = NULL;
8714                         }
8715                         if (*r->out.authority_name) {
8716                                 _mem_save_authority_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
8717                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.authority_name, 0);
8718                                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.authority_name));
8719                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_1, 0);
8720                         }
8721                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_authority_name_0, 0);
8722                 }
8723                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8724         }
8725         return NDR_ERR_SUCCESS;
8726 }
8727
8728 _PUBLIC_ void ndr_print_lsa_GetUserName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_GetUserName *r)
8729 {
8730         ndr_print_struct(ndr, name, "lsa_GetUserName");
8731         ndr->depth++;
8732         if (flags & NDR_SET_VALUES) {
8733                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8734         }
8735         if (flags & NDR_IN) {
8736                 ndr_print_struct(ndr, "in", "lsa_GetUserName");
8737                 ndr->depth++;
8738                 ndr_print_ptr(ndr, "system_name", r->in.system_name);
8739                 ndr->depth++;
8740                 if (r->in.system_name) {
8741                         ndr_print_string(ndr, "system_name", r->in.system_name);
8742                 }
8743                 ndr->depth--;
8744                 ndr_print_ptr(ndr, "account_name", r->in.account_name);
8745                 ndr->depth++;
8746                 ndr_print_ptr(ndr, "account_name", *r->in.account_name);
8747                 ndr->depth++;
8748                 if (*r->in.account_name) {
8749                         ndr_print_lsa_String(ndr, "account_name", *r->in.account_name);
8750                 }
8751                 ndr->depth--;
8752                 ndr->depth--;
8753                 ndr_print_ptr(ndr, "authority_name", r->in.authority_name);
8754                 ndr->depth++;
8755                 if (r->in.authority_name) {
8756                         ndr_print_ptr(ndr, "authority_name", *r->in.authority_name);
8757                         ndr->depth++;
8758                         if (*r->in.authority_name) {
8759                                 ndr_print_lsa_String(ndr, "authority_name", *r->in.authority_name);
8760                         }
8761                         ndr->depth--;
8762                 }
8763                 ndr->depth--;
8764                 ndr->depth--;
8765         }
8766         if (flags & NDR_OUT) {
8767                 ndr_print_struct(ndr, "out", "lsa_GetUserName");
8768                 ndr->depth++;
8769                 ndr_print_ptr(ndr, "account_name", r->out.account_name);
8770                 ndr->depth++;
8771                 ndr_print_ptr(ndr, "account_name", *r->out.account_name);
8772                 ndr->depth++;
8773                 if (*r->out.account_name) {
8774                         ndr_print_lsa_String(ndr, "account_name", *r->out.account_name);
8775                 }
8776                 ndr->depth--;
8777                 ndr->depth--;
8778                 ndr_print_ptr(ndr, "authority_name", r->out.authority_name);
8779                 ndr->depth++;
8780                 if (r->out.authority_name) {
8781                         ndr_print_ptr(ndr, "authority_name", *r->out.authority_name);
8782                         ndr->depth++;
8783                         if (*r->out.authority_name) {
8784                                 ndr_print_lsa_String(ndr, "authority_name", *r->out.authority_name);
8785                         }
8786                         ndr->depth--;
8787                 }
8788                 ndr->depth--;
8789                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8790                 ndr->depth--;
8791         }
8792         ndr->depth--;
8793 }
8794
8795 static enum ndr_err_code ndr_push_lsa_QueryInfoPolicy2(struct ndr_push *ndr, int flags, const struct lsa_QueryInfoPolicy2 *r)
8796 {
8797         if (flags & NDR_IN) {
8798                 if (r->in.handle == NULL) {
8799                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8800                 }
8801                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8802                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
8803         }
8804         if (flags & NDR_OUT) {
8805                 if (r->out.info == NULL) {
8806                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8807                 }
8808                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
8809                 if (*r->out.info) {
8810                         NDR_CHECK(ndr_push_set_switch_value(ndr, *r->out.info, r->in.level));
8811                         NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8812                 }
8813                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8814         }
8815         return NDR_ERR_SUCCESS;
8816 }
8817
8818 static enum ndr_err_code ndr_pull_lsa_QueryInfoPolicy2(struct ndr_pull *ndr, int flags, struct lsa_QueryInfoPolicy2 *r)
8819 {
8820         uint32_t _ptr_info;
8821         TALLOC_CTX *_mem_save_handle_0;
8822         TALLOC_CTX *_mem_save_info_0;
8823         TALLOC_CTX *_mem_save_info_1;
8824         if (flags & NDR_IN) {
8825                 ZERO_STRUCT(r->out);
8826
8827                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8828                         NDR_PULL_ALLOC(ndr, r->in.handle);
8829                 }
8830                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8831                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8832                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8833                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8834                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
8835                 NDR_PULL_ALLOC(ndr, r->out.info);
8836                 ZERO_STRUCTP(r->out.info);
8837         }
8838         if (flags & NDR_OUT) {
8839                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8840                         NDR_PULL_ALLOC(ndr, r->out.info);
8841                 }
8842                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8843                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
8844                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8845                 if (_ptr_info) {
8846                         NDR_PULL_ALLOC(ndr, *r->out.info);
8847                 } else {
8848                         *r->out.info = NULL;
8849                 }
8850                 if (*r->out.info) {
8851                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
8852                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
8853                         NDR_CHECK(ndr_pull_set_switch_value(ndr, *r->out.info, r->in.level));
8854                         NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
8855                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
8856                 }
8857                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8858                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8859         }
8860         return NDR_ERR_SUCCESS;
8861 }
8862
8863 _PUBLIC_ void ndr_print_lsa_QueryInfoPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryInfoPolicy2 *r)
8864 {
8865         ndr_print_struct(ndr, name, "lsa_QueryInfoPolicy2");
8866         ndr->depth++;
8867         if (flags & NDR_SET_VALUES) {
8868                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8869         }
8870         if (flags & NDR_IN) {
8871                 ndr_print_struct(ndr, "in", "lsa_QueryInfoPolicy2");
8872                 ndr->depth++;
8873                 ndr_print_ptr(ndr, "handle", r->in.handle);
8874                 ndr->depth++;
8875                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8876                 ndr->depth--;
8877                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
8878                 ndr->depth--;
8879         }
8880         if (flags & NDR_OUT) {
8881                 ndr_print_struct(ndr, "out", "lsa_QueryInfoPolicy2");
8882                 ndr->depth++;
8883                 ndr_print_ptr(ndr, "info", r->out.info);
8884                 ndr->depth++;
8885                 ndr_print_ptr(ndr, "info", *r->out.info);
8886                 ndr->depth++;
8887                 if (*r->out.info) {
8888                         ndr_print_set_switch_value(ndr, *r->out.info, r->in.level);
8889                         ndr_print_lsa_PolicyInformation(ndr, "info", *r->out.info);
8890                 }
8891                 ndr->depth--;
8892                 ndr->depth--;
8893                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8894                 ndr->depth--;
8895         }
8896         ndr->depth--;
8897 }
8898
8899 static enum ndr_err_code ndr_push_lsa_SetInfoPolicy2(struct ndr_push *ndr, int flags, const struct lsa_SetInfoPolicy2 *r)
8900 {
8901         if (flags & NDR_IN) {
8902                 if (r->in.handle == NULL) {
8903                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8904                 }
8905                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8906                 NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
8907                 if (r->in.info == NULL) {
8908                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8909                 }
8910                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
8911                 NDR_CHECK(ndr_push_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8912         }
8913         if (flags & NDR_OUT) {
8914                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8915         }
8916         return NDR_ERR_SUCCESS;
8917 }
8918
8919 static enum ndr_err_code ndr_pull_lsa_SetInfoPolicy2(struct ndr_pull *ndr, int flags, struct lsa_SetInfoPolicy2 *r)
8920 {
8921         TALLOC_CTX *_mem_save_handle_0;
8922         TALLOC_CTX *_mem_save_info_0;
8923         if (flags & NDR_IN) {
8924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8925                         NDR_PULL_ALLOC(ndr, r->in.handle);
8926                 }
8927                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8928                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8929                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8931                 NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
8932                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8933                         NDR_PULL_ALLOC(ndr, r->in.info);
8934                 }
8935                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8936                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info, LIBNDR_FLAG_REF_ALLOC);
8937                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
8938                 NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
8939                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
8940         }
8941         if (flags & NDR_OUT) {
8942                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8943         }
8944         return NDR_ERR_SUCCESS;
8945 }
8946
8947 _PUBLIC_ void ndr_print_lsa_SetInfoPolicy2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetInfoPolicy2 *r)
8948 {
8949         ndr_print_struct(ndr, name, "lsa_SetInfoPolicy2");
8950         ndr->depth++;
8951         if (flags & NDR_SET_VALUES) {
8952                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
8953         }
8954         if (flags & NDR_IN) {
8955                 ndr_print_struct(ndr, "in", "lsa_SetInfoPolicy2");
8956                 ndr->depth++;
8957                 ndr_print_ptr(ndr, "handle", r->in.handle);
8958                 ndr->depth++;
8959                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
8960                 ndr->depth--;
8961                 ndr_print_lsa_PolicyInfo(ndr, "level", r->in.level);
8962                 ndr_print_ptr(ndr, "info", r->in.info);
8963                 ndr->depth++;
8964                 ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
8965                 ndr_print_lsa_PolicyInformation(ndr, "info", r->in.info);
8966                 ndr->depth--;
8967                 ndr->depth--;
8968         }
8969         if (flags & NDR_OUT) {
8970                 ndr_print_struct(ndr, "out", "lsa_SetInfoPolicy2");
8971                 ndr->depth++;
8972                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
8973                 ndr->depth--;
8974         }
8975         ndr->depth--;
8976 }
8977
8978 static enum ndr_err_code ndr_push_lsa_QueryTrustedDomainInfoByName(struct ndr_push *ndr, int flags, const struct lsa_QueryTrustedDomainInfoByName *r)
8979 {
8980         if (flags & NDR_IN) {
8981                 if (r->in.handle == NULL) {
8982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8983                 }
8984                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
8985                 if (r->in.trusted_domain == NULL) {
8986                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8987                 }
8988                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain));
8989                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
8990         }
8991         if (flags & NDR_OUT) {
8992                 if (r->out.info == NULL) {
8993                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8994                 }
8995                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
8996                 NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
8997                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8998         }
8999         return NDR_ERR_SUCCESS;
9000 }
9001
9002 static enum ndr_err_code ndr_pull_lsa_QueryTrustedDomainInfoByName(struct ndr_pull *ndr, int flags, struct lsa_QueryTrustedDomainInfoByName *r)
9003 {
9004         TALLOC_CTX *_mem_save_handle_0;
9005         TALLOC_CTX *_mem_save_trusted_domain_0;
9006         TALLOC_CTX *_mem_save_info_0;
9007         if (flags & NDR_IN) {
9008                 ZERO_STRUCT(r->out);
9009
9010                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9011                         NDR_PULL_ALLOC(ndr, r->in.handle);
9012                 }
9013                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9014                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9015                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9016                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9017                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9018                         NDR_PULL_ALLOC(ndr, r->in.trusted_domain);
9019                 }
9020                 _mem_save_trusted_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
9021                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trusted_domain, LIBNDR_FLAG_REF_ALLOC);
9022                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain));
9023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trusted_domain_0, LIBNDR_FLAG_REF_ALLOC);
9024                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
9025                 NDR_PULL_ALLOC(ndr, r->out.info);
9026                 ZERO_STRUCTP(r->out.info);
9027         }
9028         if (flags & NDR_OUT) {
9029                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9030                         NDR_PULL_ALLOC(ndr, r->out.info);
9031                 }
9032                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9033                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
9034                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
9035                 NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9036                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
9037                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9038         }
9039         return NDR_ERR_SUCCESS;
9040 }
9041
9042 _PUBLIC_ void ndr_print_lsa_QueryTrustedDomainInfoByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryTrustedDomainInfoByName *r)
9043 {
9044         ndr_print_struct(ndr, name, "lsa_QueryTrustedDomainInfoByName");
9045         ndr->depth++;
9046         if (flags & NDR_SET_VALUES) {
9047                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9048         }
9049         if (flags & NDR_IN) {
9050                 ndr_print_struct(ndr, "in", "lsa_QueryTrustedDomainInfoByName");
9051                 ndr->depth++;
9052                 ndr_print_ptr(ndr, "handle", r->in.handle);
9053                 ndr->depth++;
9054                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9055                 ndr->depth--;
9056                 ndr_print_ptr(ndr, "trusted_domain", r->in.trusted_domain);
9057                 ndr->depth++;
9058                 ndr_print_lsa_String(ndr, "trusted_domain", r->in.trusted_domain);
9059                 ndr->depth--;
9060                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
9061                 ndr->depth--;
9062         }
9063         if (flags & NDR_OUT) {
9064                 ndr_print_struct(ndr, "out", "lsa_QueryTrustedDomainInfoByName");
9065                 ndr->depth++;
9066                 ndr_print_ptr(ndr, "info", r->out.info);
9067                 ndr->depth++;
9068                 ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
9069                 ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->out.info);
9070                 ndr->depth--;
9071                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9072                 ndr->depth--;
9073         }
9074         ndr->depth--;
9075 }
9076
9077 static enum ndr_err_code ndr_push_lsa_SetTrustedDomainInfoByName(struct ndr_push *ndr, int flags, const struct lsa_SetTrustedDomainInfoByName *r)
9078 {
9079         if (flags & NDR_IN) {
9080                 if (r->in.handle == NULL) {
9081                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9082                 }
9083                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9084                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
9085                 NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
9086                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
9087                 if (r->in.info) {
9088                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
9089                         NDR_CHECK(ndr_push_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9090                 }
9091         }
9092         if (flags & NDR_OUT) {
9093                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9094         }
9095         return NDR_ERR_SUCCESS;
9096 }
9097
9098 static enum ndr_err_code ndr_pull_lsa_SetTrustedDomainInfoByName(struct ndr_pull *ndr, int flags, struct lsa_SetTrustedDomainInfoByName *r)
9099 {
9100         uint32_t _ptr_info;
9101         TALLOC_CTX *_mem_save_handle_0;
9102         TALLOC_CTX *_mem_save_info_0;
9103         if (flags & NDR_IN) {
9104                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9105                         NDR_PULL_ALLOC(ndr, r->in.handle);
9106                 }
9107                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9108                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9109                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9110                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9111                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
9112                 NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
9113                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9114                 if (_ptr_info) {
9115                         NDR_PULL_ALLOC(ndr, r->in.info);
9116                 } else {
9117                         r->in.info = NULL;
9118                 }
9119                 if (r->in.info) {
9120                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9121                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
9122                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
9123                         NDR_CHECK(ndr_pull_lsa_TrustedDomainInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9124                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9125                 }
9126         }
9127         if (flags & NDR_OUT) {
9128                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9129         }
9130         return NDR_ERR_SUCCESS;
9131 }
9132
9133 _PUBLIC_ void ndr_print_lsa_SetTrustedDomainInfoByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetTrustedDomainInfoByName *r)
9134 {
9135         ndr_print_struct(ndr, name, "lsa_SetTrustedDomainInfoByName");
9136         ndr->depth++;
9137         if (flags & NDR_SET_VALUES) {
9138                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9139         }
9140         if (flags & NDR_IN) {
9141                 ndr_print_struct(ndr, "in", "lsa_SetTrustedDomainInfoByName");
9142                 ndr->depth++;
9143                 ndr_print_ptr(ndr, "handle", r->in.handle);
9144                 ndr->depth++;
9145                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9146                 ndr->depth--;
9147                 ndr_print_lsa_String(ndr, "trusted_domain", &r->in.trusted_domain);
9148                 ndr_print_lsa_TrustDomInfoEnum(ndr, "level", r->in.level);
9149                 ndr_print_ptr(ndr, "info", r->in.info);
9150                 ndr->depth++;
9151                 if (r->in.info) {
9152                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9153                         ndr_print_lsa_TrustedDomainInfo(ndr, "info", r->in.info);
9154                 }
9155                 ndr->depth--;
9156                 ndr->depth--;
9157         }
9158         if (flags & NDR_OUT) {
9159                 ndr_print_struct(ndr, "out", "lsa_SetTrustedDomainInfoByName");
9160                 ndr->depth++;
9161                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9162                 ndr->depth--;
9163         }
9164         ndr->depth--;
9165 }
9166
9167 static enum ndr_err_code ndr_push_lsa_EnumTrustedDomainsEx(struct ndr_push *ndr, int flags, const struct lsa_EnumTrustedDomainsEx *r)
9168 {
9169         if (flags & NDR_IN) {
9170                 if (r->in.handle == NULL) {
9171                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9172                 }
9173                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9174                 if (r->in.resume_handle == NULL) {
9175                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9176                 }
9177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
9178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_size));
9179         }
9180         if (flags & NDR_OUT) {
9181                 if (r->out.resume_handle == NULL) {
9182                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9183                 }
9184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
9185                 if (r->out.domains == NULL) {
9186                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9187                 }
9188                 NDR_CHECK(ndr_push_lsa_DomainListEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
9189                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9190         }
9191         return NDR_ERR_SUCCESS;
9192 }
9193
9194 static enum ndr_err_code ndr_pull_lsa_EnumTrustedDomainsEx(struct ndr_pull *ndr, int flags, struct lsa_EnumTrustedDomainsEx *r)
9195 {
9196         TALLOC_CTX *_mem_save_handle_0;
9197         TALLOC_CTX *_mem_save_resume_handle_0;
9198         TALLOC_CTX *_mem_save_domains_0;
9199         if (flags & NDR_IN) {
9200                 ZERO_STRUCT(r->out);
9201
9202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9203                         NDR_PULL_ALLOC(ndr, r->in.handle);
9204                 }
9205                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9206                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9207                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9209                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9210                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
9211                 }
9212                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9213                 NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, LIBNDR_FLAG_REF_ALLOC);
9214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
9215                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
9216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_size));
9217                 NDR_PULL_ALLOC(ndr, r->out.resume_handle);
9218                 *r->out.resume_handle = *r->in.resume_handle;
9219                 NDR_PULL_ALLOC(ndr, r->out.domains);
9220                 ZERO_STRUCTP(r->out.domains);
9221         }
9222         if (flags & NDR_OUT) {
9223                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9224                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
9225                 }
9226                 _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9227                 NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, LIBNDR_FLAG_REF_ALLOC);
9228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
9229                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, LIBNDR_FLAG_REF_ALLOC);
9230                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9231                         NDR_PULL_ALLOC(ndr, r->out.domains);
9232                 }
9233                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
9234                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
9235                 NDR_CHECK(ndr_pull_lsa_DomainListEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
9236                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
9237                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9238         }
9239         return NDR_ERR_SUCCESS;
9240 }
9241
9242 _PUBLIC_ void ndr_print_lsa_EnumTrustedDomainsEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_EnumTrustedDomainsEx *r)
9243 {
9244         ndr_print_struct(ndr, name, "lsa_EnumTrustedDomainsEx");
9245         ndr->depth++;
9246         if (flags & NDR_SET_VALUES) {
9247                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9248         }
9249         if (flags & NDR_IN) {
9250                 ndr_print_struct(ndr, "in", "lsa_EnumTrustedDomainsEx");
9251                 ndr->depth++;
9252                 ndr_print_ptr(ndr, "handle", r->in.handle);
9253                 ndr->depth++;
9254                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9255                 ndr->depth--;
9256                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
9257                 ndr->depth++;
9258                 ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
9259                 ndr->depth--;
9260                 ndr_print_uint32(ndr, "max_size", r->in.max_size);
9261                 ndr->depth--;
9262         }
9263         if (flags & NDR_OUT) {
9264                 ndr_print_struct(ndr, "out", "lsa_EnumTrustedDomainsEx");
9265                 ndr->depth++;
9266                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
9267                 ndr->depth++;
9268                 ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
9269                 ndr->depth--;
9270                 ndr_print_ptr(ndr, "domains", r->out.domains);
9271                 ndr->depth++;
9272                 ndr_print_lsa_DomainListEx(ndr, "domains", r->out.domains);
9273                 ndr->depth--;
9274                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9275                 ndr->depth--;
9276         }
9277         ndr->depth--;
9278 }
9279
9280 static enum ndr_err_code ndr_push_lsa_CreateTrustedDomainEx(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomainEx *r)
9281 {
9282         if (flags & NDR_IN) {
9283         }
9284         if (flags & NDR_OUT) {
9285                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9286         }
9287         return NDR_ERR_SUCCESS;
9288 }
9289
9290 static enum ndr_err_code ndr_pull_lsa_CreateTrustedDomainEx(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomainEx *r)
9291 {
9292         if (flags & NDR_IN) {
9293         }
9294         if (flags & NDR_OUT) {
9295                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9296         }
9297         return NDR_ERR_SUCCESS;
9298 }
9299
9300 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomainEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomainEx *r)
9301 {
9302         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomainEx");
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_CreateTrustedDomainEx");
9309                 ndr->depth++;
9310                 ndr->depth--;
9311         }
9312         if (flags & NDR_OUT) {
9313                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomainEx");
9314                 ndr->depth++;
9315                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9316                 ndr->depth--;
9317         }
9318         ndr->depth--;
9319 }
9320
9321 static enum ndr_err_code ndr_push_lsa_CloseTrustedDomainEx(struct ndr_push *ndr, int flags, const struct lsa_CloseTrustedDomainEx *r)
9322 {
9323         if (flags & NDR_IN) {
9324                 if (r->in.handle == NULL) {
9325                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9326                 }
9327                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9328         }
9329         if (flags & NDR_OUT) {
9330                 if (r->out.handle == NULL) {
9331                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9332                 }
9333                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
9334                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9335         }
9336         return NDR_ERR_SUCCESS;
9337 }
9338
9339 static enum ndr_err_code ndr_pull_lsa_CloseTrustedDomainEx(struct ndr_pull *ndr, int flags, struct lsa_CloseTrustedDomainEx *r)
9340 {
9341         TALLOC_CTX *_mem_save_handle_0;
9342         if (flags & NDR_IN) {
9343                 ZERO_STRUCT(r->out);
9344
9345                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9346                         NDR_PULL_ALLOC(ndr, r->in.handle);
9347                 }
9348                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9349                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9350                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9351                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9352                 NDR_PULL_ALLOC(ndr, r->out.handle);
9353                 *r->out.handle = *r->in.handle;
9354         }
9355         if (flags & NDR_OUT) {
9356                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9357                         NDR_PULL_ALLOC(ndr, r->out.handle);
9358                 }
9359                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9360                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
9361                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
9362                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9363                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9364         }
9365         return NDR_ERR_SUCCESS;
9366 }
9367
9368 _PUBLIC_ void ndr_print_lsa_CloseTrustedDomainEx(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CloseTrustedDomainEx *r)
9369 {
9370         ndr_print_struct(ndr, name, "lsa_CloseTrustedDomainEx");
9371         ndr->depth++;
9372         if (flags & NDR_SET_VALUES) {
9373                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9374         }
9375         if (flags & NDR_IN) {
9376                 ndr_print_struct(ndr, "in", "lsa_CloseTrustedDomainEx");
9377                 ndr->depth++;
9378                 ndr_print_ptr(ndr, "handle", r->in.handle);
9379                 ndr->depth++;
9380                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9381                 ndr->depth--;
9382                 ndr->depth--;
9383         }
9384         if (flags & NDR_OUT) {
9385                 ndr_print_struct(ndr, "out", "lsa_CloseTrustedDomainEx");
9386                 ndr->depth++;
9387                 ndr_print_ptr(ndr, "handle", r->out.handle);
9388                 ndr->depth++;
9389                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
9390                 ndr->depth--;
9391                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9392                 ndr->depth--;
9393         }
9394         ndr->depth--;
9395 }
9396
9397 static enum ndr_err_code ndr_push_lsa_QueryDomainInformationPolicy(struct ndr_push *ndr, int flags, const struct lsa_QueryDomainInformationPolicy *r)
9398 {
9399         if (flags & NDR_IN) {
9400                 if (r->in.handle == NULL) {
9401                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9402                 }
9403                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9404                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9405         }
9406         if (flags & NDR_OUT) {
9407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
9408                 if (r->out.info) {
9409                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, r->in.level));
9410                         NDR_CHECK(ndr_push_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9411                 }
9412                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9413         }
9414         return NDR_ERR_SUCCESS;
9415 }
9416
9417 static enum ndr_err_code ndr_pull_lsa_QueryDomainInformationPolicy(struct ndr_pull *ndr, int flags, struct lsa_QueryDomainInformationPolicy *r)
9418 {
9419         uint32_t _ptr_info;
9420         TALLOC_CTX *_mem_save_handle_0;
9421         TALLOC_CTX *_mem_save_info_0;
9422         if (flags & NDR_IN) {
9423                 ZERO_STRUCT(r->out);
9424
9425                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9426                         NDR_PULL_ALLOC(ndr, r->in.handle);
9427                 }
9428                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9429                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9430                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9431                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9432                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9433         }
9434         if (flags & NDR_OUT) {
9435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9436                 if (_ptr_info) {
9437                         NDR_PULL_ALLOC(ndr, r->out.info);
9438                 } else {
9439                         r->out.info = NULL;
9440                 }
9441                 if (r->out.info) {
9442                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9443                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9444                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, r->in.level));
9445                         NDR_CHECK(ndr_pull_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9446                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9447                 }
9448                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9449         }
9450         return NDR_ERR_SUCCESS;
9451 }
9452
9453 _PUBLIC_ void ndr_print_lsa_QueryDomainInformationPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_QueryDomainInformationPolicy *r)
9454 {
9455         ndr_print_struct(ndr, name, "lsa_QueryDomainInformationPolicy");
9456         ndr->depth++;
9457         if (flags & NDR_SET_VALUES) {
9458                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9459         }
9460         if (flags & NDR_IN) {
9461                 ndr_print_struct(ndr, "in", "lsa_QueryDomainInformationPolicy");
9462                 ndr->depth++;
9463                 ndr_print_ptr(ndr, "handle", r->in.handle);
9464                 ndr->depth++;
9465                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9466                 ndr->depth--;
9467                 ndr_print_uint16(ndr, "level", r->in.level);
9468                 ndr->depth--;
9469         }
9470         if (flags & NDR_OUT) {
9471                 ndr_print_struct(ndr, "out", "lsa_QueryDomainInformationPolicy");
9472                 ndr->depth++;
9473                 ndr_print_ptr(ndr, "info", r->out.info);
9474                 ndr->depth++;
9475                 if (r->out.info) {
9476                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
9477                         ndr_print_lsa_DomainInformationPolicy(ndr, "info", r->out.info);
9478                 }
9479                 ndr->depth--;
9480                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9481                 ndr->depth--;
9482         }
9483         ndr->depth--;
9484 }
9485
9486 static enum ndr_err_code ndr_push_lsa_SetDomainInformationPolicy(struct ndr_push *ndr, int flags, const struct lsa_SetDomainInformationPolicy *r)
9487 {
9488         if (flags & NDR_IN) {
9489                 if (r->in.handle == NULL) {
9490                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9491                 }
9492                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9493                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9494                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
9495                 if (r->in.info) {
9496                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
9497                         NDR_CHECK(ndr_push_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9498                 }
9499         }
9500         if (flags & NDR_OUT) {
9501                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9502         }
9503         return NDR_ERR_SUCCESS;
9504 }
9505
9506 static enum ndr_err_code ndr_pull_lsa_SetDomainInformationPolicy(struct ndr_pull *ndr, int flags, struct lsa_SetDomainInformationPolicy *r)
9507 {
9508         uint32_t _ptr_info;
9509         TALLOC_CTX *_mem_save_handle_0;
9510         TALLOC_CTX *_mem_save_info_0;
9511         if (flags & NDR_IN) {
9512                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9513                         NDR_PULL_ALLOC(ndr, r->in.handle);
9514                 }
9515                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9516                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9517                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9518                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9519                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9521                 if (_ptr_info) {
9522                         NDR_PULL_ALLOC(ndr, r->in.info);
9523                 } else {
9524                         r->in.info = NULL;
9525                 }
9526                 if (r->in.info) {
9527                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9528                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
9529                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
9530                         NDR_CHECK(ndr_pull_lsa_DomainInformationPolicy(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
9531                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9532                 }
9533         }
9534         if (flags & NDR_OUT) {
9535                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9536         }
9537         return NDR_ERR_SUCCESS;
9538 }
9539
9540 _PUBLIC_ void ndr_print_lsa_SetDomainInformationPolicy(struct ndr_print *ndr, const char *name, int flags, const struct lsa_SetDomainInformationPolicy *r)
9541 {
9542         ndr_print_struct(ndr, name, "lsa_SetDomainInformationPolicy");
9543         ndr->depth++;
9544         if (flags & NDR_SET_VALUES) {
9545                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9546         }
9547         if (flags & NDR_IN) {
9548                 ndr_print_struct(ndr, "in", "lsa_SetDomainInformationPolicy");
9549                 ndr->depth++;
9550                 ndr_print_ptr(ndr, "handle", r->in.handle);
9551                 ndr->depth++;
9552                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9553                 ndr->depth--;
9554                 ndr_print_uint16(ndr, "level", r->in.level);
9555                 ndr_print_ptr(ndr, "info", r->in.info);
9556                 ndr->depth++;
9557                 if (r->in.info) {
9558                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
9559                         ndr_print_lsa_DomainInformationPolicy(ndr, "info", r->in.info);
9560                 }
9561                 ndr->depth--;
9562                 ndr->depth--;
9563         }
9564         if (flags & NDR_OUT) {
9565                 ndr_print_struct(ndr, "out", "lsa_SetDomainInformationPolicy");
9566                 ndr->depth++;
9567                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9568                 ndr->depth--;
9569         }
9570         ndr->depth--;
9571 }
9572
9573 static enum ndr_err_code ndr_push_lsa_OpenTrustedDomainByName(struct ndr_push *ndr, int flags, const struct lsa_OpenTrustedDomainByName *r)
9574 {
9575         if (flags & NDR_IN) {
9576                 if (r->in.handle == NULL) {
9577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9578                 }
9579                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9580                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
9581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
9582         }
9583         if (flags & NDR_OUT) {
9584                 if (r->out.trustdom_handle == NULL) {
9585                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9586                 }
9587                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
9588                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9589         }
9590         return NDR_ERR_SUCCESS;
9591 }
9592
9593 static enum ndr_err_code ndr_pull_lsa_OpenTrustedDomainByName(struct ndr_pull *ndr, int flags, struct lsa_OpenTrustedDomainByName *r)
9594 {
9595         TALLOC_CTX *_mem_save_handle_0;
9596         TALLOC_CTX *_mem_save_trustdom_handle_0;
9597         if (flags & NDR_IN) {
9598                 ZERO_STRUCT(r->out);
9599
9600                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9601                         NDR_PULL_ALLOC(ndr, r->in.handle);
9602                 }
9603                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9604                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9605                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9606                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9607                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
9608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
9609                 NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
9610                 ZERO_STRUCTP(r->out.trustdom_handle);
9611         }
9612         if (flags & NDR_OUT) {
9613                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9614                         NDR_PULL_ALLOC(ndr, r->out.trustdom_handle);
9615                 }
9616                 _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9617                 NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
9618                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
9619                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
9620                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9621         }
9622         return NDR_ERR_SUCCESS;
9623 }
9624
9625 _PUBLIC_ void ndr_print_lsa_OpenTrustedDomainByName(struct ndr_print *ndr, const char *name, int flags, const struct lsa_OpenTrustedDomainByName *r)
9626 {
9627         ndr_print_struct(ndr, name, "lsa_OpenTrustedDomainByName");
9628         ndr->depth++;
9629         if (flags & NDR_SET_VALUES) {
9630                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9631         }
9632         if (flags & NDR_IN) {
9633                 ndr_print_struct(ndr, "in", "lsa_OpenTrustedDomainByName");
9634                 ndr->depth++;
9635                 ndr_print_ptr(ndr, "handle", r->in.handle);
9636                 ndr->depth++;
9637                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9638                 ndr->depth--;
9639                 ndr_print_lsa_String(ndr, "name", &r->in.name);
9640                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
9641                 ndr->depth--;
9642         }
9643         if (flags & NDR_OUT) {
9644                 ndr_print_struct(ndr, "out", "lsa_OpenTrustedDomainByName");
9645                 ndr->depth++;
9646                 ndr_print_ptr(ndr, "trustdom_handle", r->out.trustdom_handle);
9647                 ndr->depth++;
9648                 ndr_print_policy_handle(ndr, "trustdom_handle", r->out.trustdom_handle);
9649                 ndr->depth--;
9650                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9651                 ndr->depth--;
9652         }
9653         ndr->depth--;
9654 }
9655
9656 static enum ndr_err_code ndr_push_lsa_TestCall(struct ndr_push *ndr, int flags, const struct lsa_TestCall *r)
9657 {
9658         if (flags & NDR_IN) {
9659         }
9660         if (flags & NDR_OUT) {
9661                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9662         }
9663         return NDR_ERR_SUCCESS;
9664 }
9665
9666 static enum ndr_err_code ndr_pull_lsa_TestCall(struct ndr_pull *ndr, int flags, struct lsa_TestCall *r)
9667 {
9668         if (flags & NDR_IN) {
9669         }
9670         if (flags & NDR_OUT) {
9671                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9672         }
9673         return NDR_ERR_SUCCESS;
9674 }
9675
9676 _PUBLIC_ void ndr_print_lsa_TestCall(struct ndr_print *ndr, const char *name, int flags, const struct lsa_TestCall *r)
9677 {
9678         ndr_print_struct(ndr, name, "lsa_TestCall");
9679         ndr->depth++;
9680         if (flags & NDR_SET_VALUES) {
9681                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9682         }
9683         if (flags & NDR_IN) {
9684                 ndr_print_struct(ndr, "in", "lsa_TestCall");
9685                 ndr->depth++;
9686                 ndr->depth--;
9687         }
9688         if (flags & NDR_OUT) {
9689                 ndr_print_struct(ndr, "out", "lsa_TestCall");
9690                 ndr->depth++;
9691                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9692                 ndr->depth--;
9693         }
9694         ndr->depth--;
9695 }
9696
9697 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupSids2(struct ndr_push *ndr, int flags, const struct lsa_LookupSids2 *r)
9698 {
9699         if (flags & NDR_IN) {
9700                 if (r->in.handle == NULL) {
9701                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9702                 }
9703                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9704                 if (r->in.sids == NULL) {
9705                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9706                 }
9707                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
9708                 if (r->in.names == NULL) {
9709                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9710                 }
9711                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
9712                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9713                 if (r->in.count == NULL) {
9714                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9715                 }
9716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
9717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
9718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
9719         }
9720         if (flags & NDR_OUT) {
9721                 if (r->out.domains == NULL) {
9722                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9723                 }
9724                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
9725                 if (*r->out.domains) {
9726                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
9727                 }
9728                 if (r->out.names == NULL) {
9729                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9730                 }
9731                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
9732                 if (r->out.count == NULL) {
9733                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9734                 }
9735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
9736                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9737         }
9738         return NDR_ERR_SUCCESS;
9739 }
9740
9741 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupSids2(struct ndr_pull *ndr, int flags, struct lsa_LookupSids2 *r)
9742 {
9743         uint32_t _ptr_domains;
9744         TALLOC_CTX *_mem_save_handle_0;
9745         TALLOC_CTX *_mem_save_sids_0;
9746         TALLOC_CTX *_mem_save_domains_0;
9747         TALLOC_CTX *_mem_save_domains_1;
9748         TALLOC_CTX *_mem_save_names_0;
9749         TALLOC_CTX *_mem_save_count_0;
9750         if (flags & NDR_IN) {
9751                 ZERO_STRUCT(r->out);
9752
9753                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9754                         NDR_PULL_ALLOC(ndr, r->in.handle);
9755                 }
9756                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9757                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9758                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9759                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9760                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9761                         NDR_PULL_ALLOC(ndr, r->in.sids);
9762                 }
9763                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9764                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
9765                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
9766                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
9767                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9768                         NDR_PULL_ALLOC(ndr, r->in.names);
9769                 }
9770                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9771                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
9772                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
9773                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
9774                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9775                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9776                         NDR_PULL_ALLOC(ndr, r->in.count);
9777                 }
9778                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
9779                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
9780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
9781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
9782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
9783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
9784                 NDR_PULL_ALLOC(ndr, r->out.domains);
9785                 ZERO_STRUCTP(r->out.domains);
9786                 NDR_PULL_ALLOC(ndr, r->out.names);
9787                 *r->out.names = *r->in.names;
9788                 NDR_PULL_ALLOC(ndr, r->out.count);
9789                 *r->out.count = *r->in.count;
9790         }
9791         if (flags & NDR_OUT) {
9792                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9793                         NDR_PULL_ALLOC(ndr, r->out.domains);
9794                 }
9795                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
9796                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
9797                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
9798                 if (_ptr_domains) {
9799                         NDR_PULL_ALLOC(ndr, *r->out.domains);
9800                 } else {
9801                         *r->out.domains = NULL;
9802                 }
9803                 if (*r->out.domains) {
9804                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
9805                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
9806                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
9807                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
9808                 }
9809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
9810                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9811                         NDR_PULL_ALLOC(ndr, r->out.names);
9812                 }
9813                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9814                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
9815                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
9816                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
9817                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9818                         NDR_PULL_ALLOC(ndr, r->out.count);
9819                 }
9820                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
9821                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
9822                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
9823                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
9824                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9825         }
9826         return NDR_ERR_SUCCESS;
9827 }
9828
9829 _PUBLIC_ void ndr_print_lsa_LookupSids2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids2 *r)
9830 {
9831         ndr_print_struct(ndr, name, "lsa_LookupSids2");
9832         ndr->depth++;
9833         if (flags & NDR_SET_VALUES) {
9834                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9835         }
9836         if (flags & NDR_IN) {
9837                 ndr_print_struct(ndr, "in", "lsa_LookupSids2");
9838                 ndr->depth++;
9839                 ndr_print_ptr(ndr, "handle", r->in.handle);
9840                 ndr->depth++;
9841                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9842                 ndr->depth--;
9843                 ndr_print_ptr(ndr, "sids", r->in.sids);
9844                 ndr->depth++;
9845                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
9846                 ndr->depth--;
9847                 ndr_print_ptr(ndr, "names", r->in.names);
9848                 ndr->depth++;
9849                 ndr_print_lsa_TransNameArray2(ndr, "names", r->in.names);
9850                 ndr->depth--;
9851                 ndr_print_uint16(ndr, "level", r->in.level);
9852                 ndr_print_ptr(ndr, "count", r->in.count);
9853                 ndr->depth++;
9854                 ndr_print_uint32(ndr, "count", *r->in.count);
9855                 ndr->depth--;
9856                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
9857                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
9858                 ndr->depth--;
9859         }
9860         if (flags & NDR_OUT) {
9861                 ndr_print_struct(ndr, "out", "lsa_LookupSids2");
9862                 ndr->depth++;
9863                 ndr_print_ptr(ndr, "domains", r->out.domains);
9864                 ndr->depth++;
9865                 ndr_print_ptr(ndr, "domains", *r->out.domains);
9866                 ndr->depth++;
9867                 if (*r->out.domains) {
9868                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
9869                 }
9870                 ndr->depth--;
9871                 ndr->depth--;
9872                 ndr_print_ptr(ndr, "names", r->out.names);
9873                 ndr->depth++;
9874                 ndr_print_lsa_TransNameArray2(ndr, "names", r->out.names);
9875                 ndr->depth--;
9876                 ndr_print_ptr(ndr, "count", r->out.count);
9877                 ndr->depth++;
9878                 ndr_print_uint32(ndr, "count", *r->out.count);
9879                 ndr->depth--;
9880                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
9881                 ndr->depth--;
9882         }
9883         ndr->depth--;
9884 }
9885
9886 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupNames2(struct ndr_push *ndr, int flags, const struct lsa_LookupNames2 *r)
9887 {
9888         uint32_t cntr_names_0;
9889         if (flags & NDR_IN) {
9890                 if (r->in.handle == NULL) {
9891                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9892                 }
9893                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
9895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
9896                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
9897                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
9898                 }
9899                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
9900                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
9901                 }
9902                 if (r->in.sids == NULL) {
9903                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9904                 }
9905                 NDR_CHECK(ndr_push_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
9906                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
9907                 if (r->in.count == NULL) {
9908                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9909                 }
9910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
9911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
9912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
9913         }
9914         if (flags & NDR_OUT) {
9915                 if (r->out.domains == NULL) {
9916                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9917                 }
9918                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
9919                 if (*r->out.domains) {
9920                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
9921                 }
9922                 if (r->out.sids == NULL) {
9923                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9924                 }
9925                 NDR_CHECK(ndr_push_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
9926                 if (r->out.count == NULL) {
9927                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9928                 }
9929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
9930                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9931         }
9932         return NDR_ERR_SUCCESS;
9933 }
9934
9935 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupNames2(struct ndr_pull *ndr, int flags, struct lsa_LookupNames2 *r)
9936 {
9937         uint32_t cntr_names_0;
9938         uint32_t _ptr_domains;
9939         TALLOC_CTX *_mem_save_handle_0;
9940         TALLOC_CTX *_mem_save_names_0;
9941         TALLOC_CTX *_mem_save_domains_0;
9942         TALLOC_CTX *_mem_save_domains_1;
9943         TALLOC_CTX *_mem_save_sids_0;
9944         TALLOC_CTX *_mem_save_count_0;
9945         if (flags & NDR_IN) {
9946                 ZERO_STRUCT(r->out);
9947
9948                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9949                         NDR_PULL_ALLOC(ndr, r->in.handle);
9950                 }
9951                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9952                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9953                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
9954                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
9956                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
9957                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9958                 }
9959                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
9960                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
9961                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9962                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
9963                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
9964                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
9965                 }
9966                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
9967                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
9968                 }
9969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
9970                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9971                         NDR_PULL_ALLOC(ndr, r->in.sids);
9972                 }
9973                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
9974                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
9975                 NDR_CHECK(ndr_pull_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
9976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
9977                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
9978                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9979                         NDR_PULL_ALLOC(ndr, r->in.count);
9980                 }
9981                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
9982                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
9983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
9984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
9985                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
9986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
9987                 NDR_PULL_ALLOC(ndr, r->out.domains);
9988                 ZERO_STRUCTP(r->out.domains);
9989                 NDR_PULL_ALLOC(ndr, r->out.sids);
9990                 *r->out.sids = *r->in.sids;
9991                 NDR_PULL_ALLOC(ndr, r->out.count);
9992                 *r->out.count = *r->in.count;
9993                 if (r->in.names) {
9994                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
9995                 }
9996         }
9997         if (flags & NDR_OUT) {
9998                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9999                         NDR_PULL_ALLOC(ndr, r->out.domains);
10000                 }
10001                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
10002                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
10003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
10004                 if (_ptr_domains) {
10005                         NDR_PULL_ALLOC(ndr, *r->out.domains);
10006                 } else {
10007                         *r->out.domains = NULL;
10008                 }
10009                 if (*r->out.domains) {
10010                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
10011                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
10012                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
10014                 }
10015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
10016                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10017                         NDR_PULL_ALLOC(ndr, r->out.sids);
10018                 }
10019                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10020                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
10021                 NDR_CHECK(ndr_pull_lsa_TransSidArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
10022                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10023                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10024                         NDR_PULL_ALLOC(ndr, r->out.count);
10025                 }
10026                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10027                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
10028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
10029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10030                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10031         }
10032         return NDR_ERR_SUCCESS;
10033 }
10034
10035 _PUBLIC_ void ndr_print_lsa_LookupNames2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames2 *r)
10036 {
10037         uint32_t cntr_names_0;
10038         ndr_print_struct(ndr, name, "lsa_LookupNames2");
10039         ndr->depth++;
10040         if (flags & NDR_SET_VALUES) {
10041                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10042         }
10043         if (flags & NDR_IN) {
10044                 ndr_print_struct(ndr, "in", "lsa_LookupNames2");
10045                 ndr->depth++;
10046                 ndr_print_ptr(ndr, "handle", r->in.handle);
10047                 ndr->depth++;
10048                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10049                 ndr->depth--;
10050                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
10051                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
10052                 ndr->depth++;
10053                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
10054                         char *idx_0=NULL;
10055                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
10056                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
10057                                 free(idx_0);
10058                         }
10059                 }
10060                 ndr->depth--;
10061                 ndr_print_ptr(ndr, "sids", r->in.sids);
10062                 ndr->depth++;
10063                 ndr_print_lsa_TransSidArray2(ndr, "sids", r->in.sids);
10064                 ndr->depth--;
10065                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
10066                 ndr_print_ptr(ndr, "count", r->in.count);
10067                 ndr->depth++;
10068                 ndr_print_uint32(ndr, "count", *r->in.count);
10069                 ndr->depth--;
10070                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
10071                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
10072                 ndr->depth--;
10073         }
10074         if (flags & NDR_OUT) {
10075                 ndr_print_struct(ndr, "out", "lsa_LookupNames2");
10076                 ndr->depth++;
10077                 ndr_print_ptr(ndr, "domains", r->out.domains);
10078                 ndr->depth++;
10079                 ndr_print_ptr(ndr, "domains", *r->out.domains);
10080                 ndr->depth++;
10081                 if (*r->out.domains) {
10082                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
10083                 }
10084                 ndr->depth--;
10085                 ndr->depth--;
10086                 ndr_print_ptr(ndr, "sids", r->out.sids);
10087                 ndr->depth++;
10088                 ndr_print_lsa_TransSidArray2(ndr, "sids", r->out.sids);
10089                 ndr->depth--;
10090                 ndr_print_ptr(ndr, "count", r->out.count);
10091                 ndr->depth++;
10092                 ndr_print_uint32(ndr, "count", *r->out.count);
10093                 ndr->depth--;
10094                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10095                 ndr->depth--;
10096         }
10097         ndr->depth--;
10098 }
10099
10100 static enum ndr_err_code ndr_push_lsa_CreateTrustedDomainEx2(struct ndr_push *ndr, int flags, const struct lsa_CreateTrustedDomainEx2 *r)
10101 {
10102         if (flags & NDR_IN) {
10103         }
10104         if (flags & NDR_OUT) {
10105                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10106         }
10107         return NDR_ERR_SUCCESS;
10108 }
10109
10110 static enum ndr_err_code ndr_pull_lsa_CreateTrustedDomainEx2(struct ndr_pull *ndr, int flags, struct lsa_CreateTrustedDomainEx2 *r)
10111 {
10112         if (flags & NDR_IN) {
10113         }
10114         if (flags & NDR_OUT) {
10115                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10116         }
10117         return NDR_ERR_SUCCESS;
10118 }
10119
10120 _PUBLIC_ void ndr_print_lsa_CreateTrustedDomainEx2(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CreateTrustedDomainEx2 *r)
10121 {
10122         ndr_print_struct(ndr, name, "lsa_CreateTrustedDomainEx2");
10123         ndr->depth++;
10124         if (flags & NDR_SET_VALUES) {
10125                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10126         }
10127         if (flags & NDR_IN) {
10128                 ndr_print_struct(ndr, "in", "lsa_CreateTrustedDomainEx2");
10129                 ndr->depth++;
10130                 ndr->depth--;
10131         }
10132         if (flags & NDR_OUT) {
10133                 ndr_print_struct(ndr, "out", "lsa_CreateTrustedDomainEx2");
10134                 ndr->depth++;
10135                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10136                 ndr->depth--;
10137         }
10138         ndr->depth--;
10139 }
10140
10141 static enum ndr_err_code ndr_push_lsa_CREDRWRITE(struct ndr_push *ndr, int flags, const struct lsa_CREDRWRITE *r)
10142 {
10143         if (flags & NDR_IN) {
10144         }
10145         if (flags & NDR_OUT) {
10146                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10147         }
10148         return NDR_ERR_SUCCESS;
10149 }
10150
10151 static enum ndr_err_code ndr_pull_lsa_CREDRWRITE(struct ndr_pull *ndr, int flags, struct lsa_CREDRWRITE *r)
10152 {
10153         if (flags & NDR_IN) {
10154         }
10155         if (flags & NDR_OUT) {
10156                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10157         }
10158         return NDR_ERR_SUCCESS;
10159 }
10160
10161 _PUBLIC_ void ndr_print_lsa_CREDRWRITE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRWRITE *r)
10162 {
10163         ndr_print_struct(ndr, name, "lsa_CREDRWRITE");
10164         ndr->depth++;
10165         if (flags & NDR_SET_VALUES) {
10166                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10167         }
10168         if (flags & NDR_IN) {
10169                 ndr_print_struct(ndr, "in", "lsa_CREDRWRITE");
10170                 ndr->depth++;
10171                 ndr->depth--;
10172         }
10173         if (flags & NDR_OUT) {
10174                 ndr_print_struct(ndr, "out", "lsa_CREDRWRITE");
10175                 ndr->depth++;
10176                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10177                 ndr->depth--;
10178         }
10179         ndr->depth--;
10180 }
10181
10182 static enum ndr_err_code ndr_push_lsa_CREDRREAD(struct ndr_push *ndr, int flags, const struct lsa_CREDRREAD *r)
10183 {
10184         if (flags & NDR_IN) {
10185         }
10186         if (flags & NDR_OUT) {
10187                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10188         }
10189         return NDR_ERR_SUCCESS;
10190 }
10191
10192 static enum ndr_err_code ndr_pull_lsa_CREDRREAD(struct ndr_pull *ndr, int flags, struct lsa_CREDRREAD *r)
10193 {
10194         if (flags & NDR_IN) {
10195         }
10196         if (flags & NDR_OUT) {
10197                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10198         }
10199         return NDR_ERR_SUCCESS;
10200 }
10201
10202 _PUBLIC_ void ndr_print_lsa_CREDRREAD(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRREAD *r)
10203 {
10204         ndr_print_struct(ndr, name, "lsa_CREDRREAD");
10205         ndr->depth++;
10206         if (flags & NDR_SET_VALUES) {
10207                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10208         }
10209         if (flags & NDR_IN) {
10210                 ndr_print_struct(ndr, "in", "lsa_CREDRREAD");
10211                 ndr->depth++;
10212                 ndr->depth--;
10213         }
10214         if (flags & NDR_OUT) {
10215                 ndr_print_struct(ndr, "out", "lsa_CREDRREAD");
10216                 ndr->depth++;
10217                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10218                 ndr->depth--;
10219         }
10220         ndr->depth--;
10221 }
10222
10223 static enum ndr_err_code ndr_push_lsa_CREDRENUMERATE(struct ndr_push *ndr, int flags, const struct lsa_CREDRENUMERATE *r)
10224 {
10225         if (flags & NDR_IN) {
10226         }
10227         if (flags & NDR_OUT) {
10228                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10229         }
10230         return NDR_ERR_SUCCESS;
10231 }
10232
10233 static enum ndr_err_code ndr_pull_lsa_CREDRENUMERATE(struct ndr_pull *ndr, int flags, struct lsa_CREDRENUMERATE *r)
10234 {
10235         if (flags & NDR_IN) {
10236         }
10237         if (flags & NDR_OUT) {
10238                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10239         }
10240         return NDR_ERR_SUCCESS;
10241 }
10242
10243 _PUBLIC_ void ndr_print_lsa_CREDRENUMERATE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRENUMERATE *r)
10244 {
10245         ndr_print_struct(ndr, name, "lsa_CREDRENUMERATE");
10246         ndr->depth++;
10247         if (flags & NDR_SET_VALUES) {
10248                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10249         }
10250         if (flags & NDR_IN) {
10251                 ndr_print_struct(ndr, "in", "lsa_CREDRENUMERATE");
10252                 ndr->depth++;
10253                 ndr->depth--;
10254         }
10255         if (flags & NDR_OUT) {
10256                 ndr_print_struct(ndr, "out", "lsa_CREDRENUMERATE");
10257                 ndr->depth++;
10258                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10259                 ndr->depth--;
10260         }
10261         ndr->depth--;
10262 }
10263
10264 static enum ndr_err_code ndr_push_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_push *ndr, int flags, const struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
10265 {
10266         if (flags & NDR_IN) {
10267         }
10268         if (flags & NDR_OUT) {
10269                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10270         }
10271         return NDR_ERR_SUCCESS;
10272 }
10273
10274 static enum ndr_err_code ndr_pull_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_pull *ndr, int flags, struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
10275 {
10276         if (flags & NDR_IN) {
10277         }
10278         if (flags & NDR_OUT) {
10279                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10280         }
10281         return NDR_ERR_SUCCESS;
10282 }
10283
10284 _PUBLIC_ void ndr_print_lsa_CREDRWRITEDOMAINCREDENTIALS(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
10285 {
10286         ndr_print_struct(ndr, name, "lsa_CREDRWRITEDOMAINCREDENTIALS");
10287         ndr->depth++;
10288         if (flags & NDR_SET_VALUES) {
10289                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10290         }
10291         if (flags & NDR_IN) {
10292                 ndr_print_struct(ndr, "in", "lsa_CREDRWRITEDOMAINCREDENTIALS");
10293                 ndr->depth++;
10294                 ndr->depth--;
10295         }
10296         if (flags & NDR_OUT) {
10297                 ndr_print_struct(ndr, "out", "lsa_CREDRWRITEDOMAINCREDENTIALS");
10298                 ndr->depth++;
10299                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10300                 ndr->depth--;
10301         }
10302         ndr->depth--;
10303 }
10304
10305 static enum ndr_err_code ndr_push_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_push *ndr, int flags, const struct lsa_CREDRREADDOMAINCREDENTIALS *r)
10306 {
10307         if (flags & NDR_IN) {
10308         }
10309         if (flags & NDR_OUT) {
10310                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10311         }
10312         return NDR_ERR_SUCCESS;
10313 }
10314
10315 static enum ndr_err_code ndr_pull_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_pull *ndr, int flags, struct lsa_CREDRREADDOMAINCREDENTIALS *r)
10316 {
10317         if (flags & NDR_IN) {
10318         }
10319         if (flags & NDR_OUT) {
10320                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10321         }
10322         return NDR_ERR_SUCCESS;
10323 }
10324
10325 _PUBLIC_ void ndr_print_lsa_CREDRREADDOMAINCREDENTIALS(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRREADDOMAINCREDENTIALS *r)
10326 {
10327         ndr_print_struct(ndr, name, "lsa_CREDRREADDOMAINCREDENTIALS");
10328         ndr->depth++;
10329         if (flags & NDR_SET_VALUES) {
10330                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10331         }
10332         if (flags & NDR_IN) {
10333                 ndr_print_struct(ndr, "in", "lsa_CREDRREADDOMAINCREDENTIALS");
10334                 ndr->depth++;
10335                 ndr->depth--;
10336         }
10337         if (flags & NDR_OUT) {
10338                 ndr_print_struct(ndr, "out", "lsa_CREDRREADDOMAINCREDENTIALS");
10339                 ndr->depth++;
10340                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10341                 ndr->depth--;
10342         }
10343         ndr->depth--;
10344 }
10345
10346 static enum ndr_err_code ndr_push_lsa_CREDRDELETE(struct ndr_push *ndr, int flags, const struct lsa_CREDRDELETE *r)
10347 {
10348         if (flags & NDR_IN) {
10349         }
10350         if (flags & NDR_OUT) {
10351                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10352         }
10353         return NDR_ERR_SUCCESS;
10354 }
10355
10356 static enum ndr_err_code ndr_pull_lsa_CREDRDELETE(struct ndr_pull *ndr, int flags, struct lsa_CREDRDELETE *r)
10357 {
10358         if (flags & NDR_IN) {
10359         }
10360         if (flags & NDR_OUT) {
10361                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10362         }
10363         return NDR_ERR_SUCCESS;
10364 }
10365
10366 _PUBLIC_ void ndr_print_lsa_CREDRDELETE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRDELETE *r)
10367 {
10368         ndr_print_struct(ndr, name, "lsa_CREDRDELETE");
10369         ndr->depth++;
10370         if (flags & NDR_SET_VALUES) {
10371                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10372         }
10373         if (flags & NDR_IN) {
10374                 ndr_print_struct(ndr, "in", "lsa_CREDRDELETE");
10375                 ndr->depth++;
10376                 ndr->depth--;
10377         }
10378         if (flags & NDR_OUT) {
10379                 ndr_print_struct(ndr, "out", "lsa_CREDRDELETE");
10380                 ndr->depth++;
10381                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10382                 ndr->depth--;
10383         }
10384         ndr->depth--;
10385 }
10386
10387 static enum ndr_err_code ndr_push_lsa_CREDRGETTARGETINFO(struct ndr_push *ndr, int flags, const struct lsa_CREDRGETTARGETINFO *r)
10388 {
10389         if (flags & NDR_IN) {
10390         }
10391         if (flags & NDR_OUT) {
10392                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10393         }
10394         return NDR_ERR_SUCCESS;
10395 }
10396
10397 static enum ndr_err_code ndr_pull_lsa_CREDRGETTARGETINFO(struct ndr_pull *ndr, int flags, struct lsa_CREDRGETTARGETINFO *r)
10398 {
10399         if (flags & NDR_IN) {
10400         }
10401         if (flags & NDR_OUT) {
10402                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10403         }
10404         return NDR_ERR_SUCCESS;
10405 }
10406
10407 _PUBLIC_ void ndr_print_lsa_CREDRGETTARGETINFO(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRGETTARGETINFO *r)
10408 {
10409         ndr_print_struct(ndr, name, "lsa_CREDRGETTARGETINFO");
10410         ndr->depth++;
10411         if (flags & NDR_SET_VALUES) {
10412                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10413         }
10414         if (flags & NDR_IN) {
10415                 ndr_print_struct(ndr, "in", "lsa_CREDRGETTARGETINFO");
10416                 ndr->depth++;
10417                 ndr->depth--;
10418         }
10419         if (flags & NDR_OUT) {
10420                 ndr_print_struct(ndr, "out", "lsa_CREDRGETTARGETINFO");
10421                 ndr->depth++;
10422                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10423                 ndr->depth--;
10424         }
10425         ndr->depth--;
10426 }
10427
10428 static enum ndr_err_code ndr_push_lsa_CREDRPROFILELOADED(struct ndr_push *ndr, int flags, const struct lsa_CREDRPROFILELOADED *r)
10429 {
10430         if (flags & NDR_IN) {
10431         }
10432         if (flags & NDR_OUT) {
10433                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10434         }
10435         return NDR_ERR_SUCCESS;
10436 }
10437
10438 static enum ndr_err_code ndr_pull_lsa_CREDRPROFILELOADED(struct ndr_pull *ndr, int flags, struct lsa_CREDRPROFILELOADED *r)
10439 {
10440         if (flags & NDR_IN) {
10441         }
10442         if (flags & NDR_OUT) {
10443                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10444         }
10445         return NDR_ERR_SUCCESS;
10446 }
10447
10448 _PUBLIC_ void ndr_print_lsa_CREDRPROFILELOADED(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRPROFILELOADED *r)
10449 {
10450         ndr_print_struct(ndr, name, "lsa_CREDRPROFILELOADED");
10451         ndr->depth++;
10452         if (flags & NDR_SET_VALUES) {
10453                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10454         }
10455         if (flags & NDR_IN) {
10456                 ndr_print_struct(ndr, "in", "lsa_CREDRPROFILELOADED");
10457                 ndr->depth++;
10458                 ndr->depth--;
10459         }
10460         if (flags & NDR_OUT) {
10461                 ndr_print_struct(ndr, "out", "lsa_CREDRPROFILELOADED");
10462                 ndr->depth++;
10463                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10464                 ndr->depth--;
10465         }
10466         ndr->depth--;
10467 }
10468
10469 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupNames3(struct ndr_push *ndr, int flags, const struct lsa_LookupNames3 *r)
10470 {
10471         uint32_t cntr_names_0;
10472         if (flags & NDR_IN) {
10473                 if (r->in.handle == NULL) {
10474                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10475                 }
10476                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
10477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10479                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10480                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
10481                 }
10482                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10483                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
10484                 }
10485                 if (r->in.sids == NULL) {
10486                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10487                 }
10488                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10489                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
10490                 if (r->in.count == NULL) {
10491                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10492                 }
10493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
10494                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
10495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
10496         }
10497         if (flags & NDR_OUT) {
10498                 if (r->out.domains == NULL) {
10499                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10500                 }
10501                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
10502                 if (*r->out.domains) {
10503                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10504                 }
10505                 if (r->out.sids == NULL) {
10506                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10507                 }
10508                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
10509                 if (r->out.count == NULL) {
10510                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10511                 }
10512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
10513                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10514         }
10515         return NDR_ERR_SUCCESS;
10516 }
10517
10518 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupNames3(struct ndr_pull *ndr, int flags, struct lsa_LookupNames3 *r)
10519 {
10520         uint32_t cntr_names_0;
10521         uint32_t _ptr_domains;
10522         TALLOC_CTX *_mem_save_handle_0;
10523         TALLOC_CTX *_mem_save_names_0;
10524         TALLOC_CTX *_mem_save_domains_0;
10525         TALLOC_CTX *_mem_save_domains_1;
10526         TALLOC_CTX *_mem_save_sids_0;
10527         TALLOC_CTX *_mem_save_count_0;
10528         if (flags & NDR_IN) {
10529                 ZERO_STRUCT(r->out);
10530
10531                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10532                         NDR_PULL_ALLOC(ndr, r->in.handle);
10533                 }
10534                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10535                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10536                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
10537                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
10539                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
10540                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
10541                 }
10542                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
10543                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
10544                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10545                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
10546                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10547                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
10548                 }
10549                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10550                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
10551                 }
10552                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
10553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10554                         NDR_PULL_ALLOC(ndr, r->in.sids);
10555                 }
10556                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10557                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
10558                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
10559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10560                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
10561                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10562                         NDR_PULL_ALLOC(ndr, r->in.count);
10563                 }
10564                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10565                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
10566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
10567                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
10569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
10570                 NDR_PULL_ALLOC(ndr, r->out.domains);
10571                 ZERO_STRUCTP(r->out.domains);
10572                 NDR_PULL_ALLOC(ndr, r->out.sids);
10573                 *r->out.sids = *r->in.sids;
10574                 NDR_PULL_ALLOC(ndr, r->out.count);
10575                 *r->out.count = *r->in.count;
10576                 if (r->in.names) {
10577                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
10578                 }
10579         }
10580         if (flags & NDR_OUT) {
10581                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10582                         NDR_PULL_ALLOC(ndr, r->out.domains);
10583                 }
10584                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
10585                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
10586                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
10587                 if (_ptr_domains) {
10588                         NDR_PULL_ALLOC(ndr, *r->out.domains);
10589                 } else {
10590                         *r->out.domains = NULL;
10591                 }
10592                 if (*r->out.domains) {
10593                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
10594                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
10595                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
10596                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
10597                 }
10598                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
10599                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10600                         NDR_PULL_ALLOC(ndr, r->out.sids);
10601                 }
10602                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
10603                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
10604                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
10605                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
10606                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10607                         NDR_PULL_ALLOC(ndr, r->out.count);
10608                 }
10609                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
10610                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
10611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
10612                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
10613                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10614         }
10615         return NDR_ERR_SUCCESS;
10616 }
10617
10618 _PUBLIC_ void ndr_print_lsa_LookupNames3(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames3 *r)
10619 {
10620         uint32_t cntr_names_0;
10621         ndr_print_struct(ndr, name, "lsa_LookupNames3");
10622         ndr->depth++;
10623         if (flags & NDR_SET_VALUES) {
10624                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10625         }
10626         if (flags & NDR_IN) {
10627                 ndr_print_struct(ndr, "in", "lsa_LookupNames3");
10628                 ndr->depth++;
10629                 ndr_print_ptr(ndr, "handle", r->in.handle);
10630                 ndr->depth++;
10631                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10632                 ndr->depth--;
10633                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
10634                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
10635                 ndr->depth++;
10636                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
10637                         char *idx_0=NULL;
10638                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
10639                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
10640                                 free(idx_0);
10641                         }
10642                 }
10643                 ndr->depth--;
10644                 ndr_print_ptr(ndr, "sids", r->in.sids);
10645                 ndr->depth++;
10646                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->in.sids);
10647                 ndr->depth--;
10648                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
10649                 ndr_print_ptr(ndr, "count", r->in.count);
10650                 ndr->depth++;
10651                 ndr_print_uint32(ndr, "count", *r->in.count);
10652                 ndr->depth--;
10653                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
10654                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
10655                 ndr->depth--;
10656         }
10657         if (flags & NDR_OUT) {
10658                 ndr_print_struct(ndr, "out", "lsa_LookupNames3");
10659                 ndr->depth++;
10660                 ndr_print_ptr(ndr, "domains", r->out.domains);
10661                 ndr->depth++;
10662                 ndr_print_ptr(ndr, "domains", *r->out.domains);
10663                 ndr->depth++;
10664                 if (*r->out.domains) {
10665                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
10666                 }
10667                 ndr->depth--;
10668                 ndr->depth--;
10669                 ndr_print_ptr(ndr, "sids", r->out.sids);
10670                 ndr->depth++;
10671                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->out.sids);
10672                 ndr->depth--;
10673                 ndr_print_ptr(ndr, "count", r->out.count);
10674                 ndr->depth++;
10675                 ndr_print_uint32(ndr, "count", *r->out.count);
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_CREDRGETSESSIONTYPES(struct ndr_push *ndr, int flags, const struct lsa_CREDRGETSESSIONTYPES *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_CREDRGETSESSIONTYPES(struct ndr_pull *ndr, int flags, struct lsa_CREDRGETSESSIONTYPES *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_CREDRGETSESSIONTYPES(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRGETSESSIONTYPES *r)
10704 {
10705         ndr_print_struct(ndr, name, "lsa_CREDRGETSESSIONTYPES");
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_CREDRGETSESSIONTYPES");
10712                 ndr->depth++;
10713                 ndr->depth--;
10714         }
10715         if (flags & NDR_OUT) {
10716                 ndr_print_struct(ndr, "out", "lsa_CREDRGETSESSIONTYPES");
10717                 ndr->depth++;
10718                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10719                 ndr->depth--;
10720         }
10721         ndr->depth--;
10722 }
10723
10724 static enum ndr_err_code ndr_push_lsa_LSARREGISTERAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARREGISTERAUDITEVENT *r)
10725 {
10726         if (flags & NDR_IN) {
10727         }
10728         if (flags & NDR_OUT) {
10729                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10730         }
10731         return NDR_ERR_SUCCESS;
10732 }
10733
10734 static enum ndr_err_code ndr_pull_lsa_LSARREGISTERAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARREGISTERAUDITEVENT *r)
10735 {
10736         if (flags & NDR_IN) {
10737         }
10738         if (flags & NDR_OUT) {
10739                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10740         }
10741         return NDR_ERR_SUCCESS;
10742 }
10743
10744 _PUBLIC_ void ndr_print_lsa_LSARREGISTERAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARREGISTERAUDITEVENT *r)
10745 {
10746         ndr_print_struct(ndr, name, "lsa_LSARREGISTERAUDITEVENT");
10747         ndr->depth++;
10748         if (flags & NDR_SET_VALUES) {
10749                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10750         }
10751         if (flags & NDR_IN) {
10752                 ndr_print_struct(ndr, "in", "lsa_LSARREGISTERAUDITEVENT");
10753                 ndr->depth++;
10754                 ndr->depth--;
10755         }
10756         if (flags & NDR_OUT) {
10757                 ndr_print_struct(ndr, "out", "lsa_LSARREGISTERAUDITEVENT");
10758                 ndr->depth++;
10759                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10760                 ndr->depth--;
10761         }
10762         ndr->depth--;
10763 }
10764
10765 static enum ndr_err_code ndr_push_lsa_LSARGENAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARGENAUDITEVENT *r)
10766 {
10767         if (flags & NDR_IN) {
10768         }
10769         if (flags & NDR_OUT) {
10770                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10771         }
10772         return NDR_ERR_SUCCESS;
10773 }
10774
10775 static enum ndr_err_code ndr_pull_lsa_LSARGENAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARGENAUDITEVENT *r)
10776 {
10777         if (flags & NDR_IN) {
10778         }
10779         if (flags & NDR_OUT) {
10780                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10781         }
10782         return NDR_ERR_SUCCESS;
10783 }
10784
10785 _PUBLIC_ void ndr_print_lsa_LSARGENAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARGENAUDITEVENT *r)
10786 {
10787         ndr_print_struct(ndr, name, "lsa_LSARGENAUDITEVENT");
10788         ndr->depth++;
10789         if (flags & NDR_SET_VALUES) {
10790                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10791         }
10792         if (flags & NDR_IN) {
10793                 ndr_print_struct(ndr, "in", "lsa_LSARGENAUDITEVENT");
10794                 ndr->depth++;
10795                 ndr->depth--;
10796         }
10797         if (flags & NDR_OUT) {
10798                 ndr_print_struct(ndr, "out", "lsa_LSARGENAUDITEVENT");
10799                 ndr->depth++;
10800                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10801                 ndr->depth--;
10802         }
10803         ndr->depth--;
10804 }
10805
10806 static enum ndr_err_code ndr_push_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARUNREGISTERAUDITEVENT *r)
10807 {
10808         if (flags & NDR_IN) {
10809         }
10810         if (flags & NDR_OUT) {
10811                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10812         }
10813         return NDR_ERR_SUCCESS;
10814 }
10815
10816 static enum ndr_err_code ndr_pull_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARUNREGISTERAUDITEVENT *r)
10817 {
10818         if (flags & NDR_IN) {
10819         }
10820         if (flags & NDR_OUT) {
10821                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10822         }
10823         return NDR_ERR_SUCCESS;
10824 }
10825
10826 _PUBLIC_ void ndr_print_lsa_LSARUNREGISTERAUDITEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARUNREGISTERAUDITEVENT *r)
10827 {
10828         ndr_print_struct(ndr, name, "lsa_LSARUNREGISTERAUDITEVENT");
10829         ndr->depth++;
10830         if (flags & NDR_SET_VALUES) {
10831                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10832         }
10833         if (flags & NDR_IN) {
10834                 ndr_print_struct(ndr, "in", "lsa_LSARUNREGISTERAUDITEVENT");
10835                 ndr->depth++;
10836                 ndr->depth--;
10837         }
10838         if (flags & NDR_OUT) {
10839                 ndr_print_struct(ndr, "out", "lsa_LSARUNREGISTERAUDITEVENT");
10840                 ndr->depth++;
10841                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10842                 ndr->depth--;
10843         }
10844         ndr->depth--;
10845 }
10846
10847 static enum ndr_err_code ndr_push_lsa_lsaRQueryForestTrustInformation(struct ndr_push *ndr, int flags, const struct lsa_lsaRQueryForestTrustInformation *r)
10848 {
10849         if (flags & NDR_IN) {
10850                 if (r->in.handle == NULL) {
10851                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10852                 }
10853                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
10854                 if (r->in.trusted_domain_name == NULL) {
10855                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10856                 }
10857                 NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain_name));
10858                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.unknown));
10859         }
10860         if (flags & NDR_OUT) {
10861                 if (r->out.forest_trust_info == NULL) {
10862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10863                 }
10864                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.forest_trust_info));
10865                 if (*r->out.forest_trust_info) {
10866                         NDR_CHECK(ndr_push_lsa_ForestTrustInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.forest_trust_info));
10867                 }
10868                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10869         }
10870         return NDR_ERR_SUCCESS;
10871 }
10872
10873 static enum ndr_err_code ndr_pull_lsa_lsaRQueryForestTrustInformation(struct ndr_pull *ndr, int flags, struct lsa_lsaRQueryForestTrustInformation *r)
10874 {
10875         uint32_t _ptr_forest_trust_info;
10876         TALLOC_CTX *_mem_save_handle_0;
10877         TALLOC_CTX *_mem_save_trusted_domain_name_0;
10878         TALLOC_CTX *_mem_save_forest_trust_info_0;
10879         TALLOC_CTX *_mem_save_forest_trust_info_1;
10880         if (flags & NDR_IN) {
10881                 ZERO_STRUCT(r->out);
10882
10883                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10884                         NDR_PULL_ALLOC(ndr, r->in.handle);
10885                 }
10886                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10887                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10888                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
10889                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10890                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10891                         NDR_PULL_ALLOC(ndr, r->in.trusted_domain_name);
10892                 }
10893                 _mem_save_trusted_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10894                 NDR_PULL_SET_MEM_CTX(ndr, r->in.trusted_domain_name, LIBNDR_FLAG_REF_ALLOC);
10895                 NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trusted_domain_name));
10896                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trusted_domain_name_0, LIBNDR_FLAG_REF_ALLOC);
10897                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.unknown));
10898                 NDR_PULL_ALLOC(ndr, r->out.forest_trust_info);
10899                 ZERO_STRUCTP(r->out.forest_trust_info);
10900         }
10901         if (flags & NDR_OUT) {
10902                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10903                         NDR_PULL_ALLOC(ndr, r->out.forest_trust_info);
10904                 }
10905                 _mem_save_forest_trust_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10906                 NDR_PULL_SET_MEM_CTX(ndr, r->out.forest_trust_info, LIBNDR_FLAG_REF_ALLOC);
10907                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_forest_trust_info));
10908                 if (_ptr_forest_trust_info) {
10909                         NDR_PULL_ALLOC(ndr, *r->out.forest_trust_info);
10910                 } else {
10911                         *r->out.forest_trust_info = NULL;
10912                 }
10913                 if (*r->out.forest_trust_info) {
10914                         _mem_save_forest_trust_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
10915                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.forest_trust_info, 0);
10916                         NDR_CHECK(ndr_pull_lsa_ForestTrustInformation(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.forest_trust_info));
10917                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_forest_trust_info_1, 0);
10918                 }
10919                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_forest_trust_info_0, LIBNDR_FLAG_REF_ALLOC);
10920                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10921         }
10922         return NDR_ERR_SUCCESS;
10923 }
10924
10925 _PUBLIC_ void ndr_print_lsa_lsaRQueryForestTrustInformation(struct ndr_print *ndr, const char *name, int flags, const struct lsa_lsaRQueryForestTrustInformation *r)
10926 {
10927         ndr_print_struct(ndr, name, "lsa_lsaRQueryForestTrustInformation");
10928         ndr->depth++;
10929         if (flags & NDR_SET_VALUES) {
10930                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10931         }
10932         if (flags & NDR_IN) {
10933                 ndr_print_struct(ndr, "in", "lsa_lsaRQueryForestTrustInformation");
10934                 ndr->depth++;
10935                 ndr_print_ptr(ndr, "handle", r->in.handle);
10936                 ndr->depth++;
10937                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10938                 ndr->depth--;
10939                 ndr_print_ptr(ndr, "trusted_domain_name", r->in.trusted_domain_name);
10940                 ndr->depth++;
10941                 ndr_print_lsa_String(ndr, "trusted_domain_name", r->in.trusted_domain_name);
10942                 ndr->depth--;
10943                 ndr_print_uint16(ndr, "unknown", r->in.unknown);
10944                 ndr->depth--;
10945         }
10946         if (flags & NDR_OUT) {
10947                 ndr_print_struct(ndr, "out", "lsa_lsaRQueryForestTrustInformation");
10948                 ndr->depth++;
10949                 ndr_print_ptr(ndr, "forest_trust_info", r->out.forest_trust_info);
10950                 ndr->depth++;
10951                 ndr_print_ptr(ndr, "forest_trust_info", *r->out.forest_trust_info);
10952                 ndr->depth++;
10953                 if (*r->out.forest_trust_info) {
10954                         ndr_print_lsa_ForestTrustInformation(ndr, "forest_trust_info", *r->out.forest_trust_info);
10955                 }
10956                 ndr->depth--;
10957                 ndr->depth--;
10958                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
10959                 ndr->depth--;
10960         }
10961         ndr->depth--;
10962 }
10963
10964 static enum ndr_err_code ndr_push_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_push *ndr, int flags, const struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
10965 {
10966         if (flags & NDR_IN) {
10967         }
10968         if (flags & NDR_OUT) {
10969                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
10970         }
10971         return NDR_ERR_SUCCESS;
10972 }
10973
10974 static enum ndr_err_code ndr_pull_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_pull *ndr, int flags, struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
10975 {
10976         if (flags & NDR_IN) {
10977         }
10978         if (flags & NDR_OUT) {
10979                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
10980         }
10981         return NDR_ERR_SUCCESS;
10982 }
10983
10984 _PUBLIC_ void ndr_print_lsa_LSARSETFORESTTRUSTINFORMATION(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
10985 {
10986         ndr_print_struct(ndr, name, "lsa_LSARSETFORESTTRUSTINFORMATION");
10987         ndr->depth++;
10988         if (flags & NDR_SET_VALUES) {
10989                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10990         }
10991         if (flags & NDR_IN) {
10992                 ndr_print_struct(ndr, "in", "lsa_LSARSETFORESTTRUSTINFORMATION");
10993                 ndr->depth++;
10994                 ndr->depth--;
10995         }
10996         if (flags & NDR_OUT) {
10997                 ndr_print_struct(ndr, "out", "lsa_LSARSETFORESTTRUSTINFORMATION");
10998                 ndr->depth++;
10999                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11000                 ndr->depth--;
11001         }
11002         ndr->depth--;
11003 }
11004
11005 static enum ndr_err_code ndr_push_lsa_CREDRRENAME(struct ndr_push *ndr, int flags, const struct lsa_CREDRRENAME *r)
11006 {
11007         if (flags & NDR_IN) {
11008         }
11009         if (flags & NDR_OUT) {
11010                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11011         }
11012         return NDR_ERR_SUCCESS;
11013 }
11014
11015 static enum ndr_err_code ndr_pull_lsa_CREDRRENAME(struct ndr_pull *ndr, int flags, struct lsa_CREDRRENAME *r)
11016 {
11017         if (flags & NDR_IN) {
11018         }
11019         if (flags & NDR_OUT) {
11020                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11021         }
11022         return NDR_ERR_SUCCESS;
11023 }
11024
11025 _PUBLIC_ void ndr_print_lsa_CREDRRENAME(struct ndr_print *ndr, const char *name, int flags, const struct lsa_CREDRRENAME *r)
11026 {
11027         ndr_print_struct(ndr, name, "lsa_CREDRRENAME");
11028         ndr->depth++;
11029         if (flags & NDR_SET_VALUES) {
11030                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11031         }
11032         if (flags & NDR_IN) {
11033                 ndr_print_struct(ndr, "in", "lsa_CREDRRENAME");
11034                 ndr->depth++;
11035                 ndr->depth--;
11036         }
11037         if (flags & NDR_OUT) {
11038                 ndr_print_struct(ndr, "out", "lsa_CREDRRENAME");
11039                 ndr->depth++;
11040                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11041                 ndr->depth--;
11042         }
11043         ndr->depth--;
11044 }
11045
11046 _PUBLIC_ enum ndr_err_code ndr_push_lsa_LookupSids3(struct ndr_push *ndr, int flags, const struct lsa_LookupSids3 *r)
11047 {
11048         if (flags & NDR_IN) {
11049                 if (r->in.sids == NULL) {
11050                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11051                 }
11052                 NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11053                 if (r->in.names == NULL) {
11054                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11055                 }
11056                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
11057                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
11058                 if (r->in.count == NULL) {
11059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11060                 }
11061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
11062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
11063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
11064         }
11065         if (flags & NDR_OUT) {
11066                 if (r->out.domains == NULL) {
11067                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11068                 }
11069                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
11070                 if (*r->out.domains) {
11071                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11072                 }
11073                 if (r->out.names == NULL) {
11074                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11075                 }
11076                 NDR_CHECK(ndr_push_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
11077                 if (r->out.count == NULL) {
11078                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11079                 }
11080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
11081                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11082         }
11083         return NDR_ERR_SUCCESS;
11084 }
11085
11086 _PUBLIC_ enum ndr_err_code ndr_pull_lsa_LookupSids3(struct ndr_pull *ndr, int flags, struct lsa_LookupSids3 *r)
11087 {
11088         uint32_t _ptr_domains;
11089         TALLOC_CTX *_mem_save_sids_0;
11090         TALLOC_CTX *_mem_save_domains_0;
11091         TALLOC_CTX *_mem_save_domains_1;
11092         TALLOC_CTX *_mem_save_names_0;
11093         TALLOC_CTX *_mem_save_count_0;
11094         if (flags & NDR_IN) {
11095                 ZERO_STRUCT(r->out);
11096
11097                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11098                         NDR_PULL_ALLOC(ndr, r->in.sids);
11099                 }
11100                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11101                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
11102                 NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11103                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11104                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11105                         NDR_PULL_ALLOC(ndr, r->in.names);
11106                 }
11107                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11108                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, LIBNDR_FLAG_REF_ALLOC);
11109                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
11110                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
11111                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
11112                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11113                         NDR_PULL_ALLOC(ndr, r->in.count);
11114                 }
11115                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11116                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
11117                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
11118                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
11120                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
11121                 NDR_PULL_ALLOC(ndr, r->out.domains);
11122                 ZERO_STRUCTP(r->out.domains);
11123                 NDR_PULL_ALLOC(ndr, r->out.names);
11124                 *r->out.names = *r->in.names;
11125                 NDR_PULL_ALLOC(ndr, r->out.count);
11126                 *r->out.count = *r->in.count;
11127         }
11128         if (flags & NDR_OUT) {
11129                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11130                         NDR_PULL_ALLOC(ndr, r->out.domains);
11131                 }
11132                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
11133                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
11134                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
11135                 if (_ptr_domains) {
11136                         NDR_PULL_ALLOC(ndr, *r->out.domains);
11137                 } else {
11138                         *r->out.domains = NULL;
11139                 }
11140                 if (*r->out.domains) {
11141                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
11142                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
11143                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11144                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
11145                 }
11146                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
11147                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11148                         NDR_PULL_ALLOC(ndr, r->out.names);
11149                 }
11150                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11151                 NDR_PULL_SET_MEM_CTX(ndr, r->out.names, LIBNDR_FLAG_REF_ALLOC);
11152                 NDR_CHECK(ndr_pull_lsa_TransNameArray2(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
11153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, LIBNDR_FLAG_REF_ALLOC);
11154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11155                         NDR_PULL_ALLOC(ndr, r->out.count);
11156                 }
11157                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11158                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
11159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
11160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11161                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11162         }
11163         return NDR_ERR_SUCCESS;
11164 }
11165
11166 _PUBLIC_ void ndr_print_lsa_LookupSids3(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupSids3 *r)
11167 {
11168         ndr_print_struct(ndr, name, "lsa_LookupSids3");
11169         ndr->depth++;
11170         if (flags & NDR_SET_VALUES) {
11171                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11172         }
11173         if (flags & NDR_IN) {
11174                 ndr_print_struct(ndr, "in", "lsa_LookupSids3");
11175                 ndr->depth++;
11176                 ndr_print_ptr(ndr, "sids", r->in.sids);
11177                 ndr->depth++;
11178                 ndr_print_lsa_SidArray(ndr, "sids", r->in.sids);
11179                 ndr->depth--;
11180                 ndr_print_ptr(ndr, "names", r->in.names);
11181                 ndr->depth++;
11182                 ndr_print_lsa_TransNameArray2(ndr, "names", r->in.names);
11183                 ndr->depth--;
11184                 ndr_print_uint16(ndr, "level", r->in.level);
11185                 ndr_print_ptr(ndr, "count", r->in.count);
11186                 ndr->depth++;
11187                 ndr_print_uint32(ndr, "count", *r->in.count);
11188                 ndr->depth--;
11189                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
11190                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
11191                 ndr->depth--;
11192         }
11193         if (flags & NDR_OUT) {
11194                 ndr_print_struct(ndr, "out", "lsa_LookupSids3");
11195                 ndr->depth++;
11196                 ndr_print_ptr(ndr, "domains", r->out.domains);
11197                 ndr->depth++;
11198                 ndr_print_ptr(ndr, "domains", *r->out.domains);
11199                 ndr->depth++;
11200                 if (*r->out.domains) {
11201                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
11202                 }
11203                 ndr->depth--;
11204                 ndr->depth--;
11205                 ndr_print_ptr(ndr, "names", r->out.names);
11206                 ndr->depth++;
11207                 ndr_print_lsa_TransNameArray2(ndr, "names", r->out.names);
11208                 ndr->depth--;
11209                 ndr_print_ptr(ndr, "count", r->out.count);
11210                 ndr->depth++;
11211                 ndr_print_uint32(ndr, "count", *r->out.count);
11212                 ndr->depth--;
11213                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11214                 ndr->depth--;
11215         }
11216         ndr->depth--;
11217 }
11218
11219 static enum ndr_err_code ndr_push_lsa_LookupNames4(struct ndr_push *ndr, int flags, const struct lsa_LookupNames4 *r)
11220 {
11221         uint32_t cntr_names_0;
11222         if (flags & NDR_IN) {
11223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
11224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
11225                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11226                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
11227                 }
11228                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11229                         NDR_CHECK(ndr_push_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
11230                 }
11231                 if (r->in.sids == NULL) {
11232                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11233                 }
11234                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11235                 NDR_CHECK(ndr_push_lsa_LookupNamesLevel(ndr, NDR_SCALARS, r->in.level));
11236                 if (r->in.count == NULL) {
11237                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11238                 }
11239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.count));
11240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
11241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
11242         }
11243         if (flags & NDR_OUT) {
11244                 if (r->out.domains == NULL) {
11245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11246                 }
11247                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.domains));
11248                 if (*r->out.domains) {
11249                         NDR_CHECK(ndr_push_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11250                 }
11251                 if (r->out.sids == NULL) {
11252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11253                 }
11254                 NDR_CHECK(ndr_push_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
11255                 if (r->out.count == NULL) {
11256                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11257                 }
11258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
11259                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11260         }
11261         return NDR_ERR_SUCCESS;
11262 }
11263
11264 static enum ndr_err_code ndr_pull_lsa_LookupNames4(struct ndr_pull *ndr, int flags, struct lsa_LookupNames4 *r)
11265 {
11266         uint32_t cntr_names_0;
11267         uint32_t _ptr_domains;
11268         TALLOC_CTX *_mem_save_names_0;
11269         TALLOC_CTX *_mem_save_domains_0;
11270         TALLOC_CTX *_mem_save_domains_1;
11271         TALLOC_CTX *_mem_save_sids_0;
11272         TALLOC_CTX *_mem_save_count_0;
11273         if (flags & NDR_IN) {
11274                 ZERO_STRUCT(r->out);
11275
11276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
11277                 if (r->in.num_names < 0 || r->in.num_names > 1000) {
11278                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11279                 }
11280                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.names));
11281                 NDR_PULL_ALLOC_N(ndr, r->in.names, ndr_get_array_size(ndr, &r->in.names));
11282                 _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11283                 NDR_PULL_SET_MEM_CTX(ndr, r->in.names, 0);
11284                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11285                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS, &r->in.names[cntr_names_0]));
11286                 }
11287                 for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
11288                         NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_BUFFERS, &r->in.names[cntr_names_0]));
11289                 }
11290                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
11291                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11292                         NDR_PULL_ALLOC(ndr, r->in.sids);
11293                 }
11294                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11295                 NDR_PULL_SET_MEM_CTX(ndr, r->in.sids, LIBNDR_FLAG_REF_ALLOC);
11296                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
11297                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11298                 NDR_CHECK(ndr_pull_lsa_LookupNamesLevel(ndr, NDR_SCALARS, &r->in.level));
11299                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11300                         NDR_PULL_ALLOC(ndr, r->in.count);
11301                 }
11302                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11303                 NDR_PULL_SET_MEM_CTX(ndr, r->in.count, LIBNDR_FLAG_REF_ALLOC);
11304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.count));
11305                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
11307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
11308                 NDR_PULL_ALLOC(ndr, r->out.domains);
11309                 ZERO_STRUCTP(r->out.domains);
11310                 NDR_PULL_ALLOC(ndr, r->out.sids);
11311                 *r->out.sids = *r->in.sids;
11312                 NDR_PULL_ALLOC(ndr, r->out.count);
11313                 *r->out.count = *r->in.count;
11314                 if (r->in.names) {
11315                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.names, r->in.num_names));
11316                 }
11317         }
11318         if (flags & NDR_OUT) {
11319                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11320                         NDR_PULL_ALLOC(ndr, r->out.domains);
11321                 }
11322                 _mem_save_domains_0 = NDR_PULL_GET_MEM_CTX(ndr);
11323                 NDR_PULL_SET_MEM_CTX(ndr, r->out.domains, LIBNDR_FLAG_REF_ALLOC);
11324                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domains));
11325                 if (_ptr_domains) {
11326                         NDR_PULL_ALLOC(ndr, *r->out.domains);
11327                 } else {
11328                         *r->out.domains = NULL;
11329                 }
11330                 if (*r->out.domains) {
11331                         _mem_save_domains_1 = NDR_PULL_GET_MEM_CTX(ndr);
11332                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.domains, 0);
11333                         NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.domains));
11334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_1, 0);
11335                 }
11336                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domains_0, LIBNDR_FLAG_REF_ALLOC);
11337                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11338                         NDR_PULL_ALLOC(ndr, r->out.sids);
11339                 }
11340                 _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
11341                 NDR_PULL_SET_MEM_CTX(ndr, r->out.sids, LIBNDR_FLAG_REF_ALLOC);
11342                 NDR_CHECK(ndr_pull_lsa_TransSidArray3(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
11343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, LIBNDR_FLAG_REF_ALLOC);
11344                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11345                         NDR_PULL_ALLOC(ndr, r->out.count);
11346                 }
11347                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
11348                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
11349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
11350                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
11351                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11352         }
11353         return NDR_ERR_SUCCESS;
11354 }
11355
11356 _PUBLIC_ void ndr_print_lsa_LookupNames4(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LookupNames4 *r)
11357 {
11358         uint32_t cntr_names_0;
11359         ndr_print_struct(ndr, name, "lsa_LookupNames4");
11360         ndr->depth++;
11361         if (flags & NDR_SET_VALUES) {
11362                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11363         }
11364         if (flags & NDR_IN) {
11365                 ndr_print_struct(ndr, "in", "lsa_LookupNames4");
11366                 ndr->depth++;
11367                 ndr_print_uint32(ndr, "num_names", r->in.num_names);
11368                 ndr->print(ndr, "%s: ARRAY(%d)", "names", r->in.num_names);
11369                 ndr->depth++;
11370                 for (cntr_names_0=0;cntr_names_0<r->in.num_names;cntr_names_0++) {
11371                         char *idx_0=NULL;
11372                         if (asprintf(&idx_0, "[%d]", cntr_names_0) != -1) {
11373                                 ndr_print_lsa_String(ndr, "names", &r->in.names[cntr_names_0]);
11374                                 free(idx_0);
11375                         }
11376                 }
11377                 ndr->depth--;
11378                 ndr_print_ptr(ndr, "sids", r->in.sids);
11379                 ndr->depth++;
11380                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->in.sids);
11381                 ndr->depth--;
11382                 ndr_print_lsa_LookupNamesLevel(ndr, "level", r->in.level);
11383                 ndr_print_ptr(ndr, "count", r->in.count);
11384                 ndr->depth++;
11385                 ndr_print_uint32(ndr, "count", *r->in.count);
11386                 ndr->depth--;
11387                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
11388                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
11389                 ndr->depth--;
11390         }
11391         if (flags & NDR_OUT) {
11392                 ndr_print_struct(ndr, "out", "lsa_LookupNames4");
11393                 ndr->depth++;
11394                 ndr_print_ptr(ndr, "domains", r->out.domains);
11395                 ndr->depth++;
11396                 ndr_print_ptr(ndr, "domains", *r->out.domains);
11397                 ndr->depth++;
11398                 if (*r->out.domains) {
11399                         ndr_print_lsa_RefDomainList(ndr, "domains", *r->out.domains);
11400                 }
11401                 ndr->depth--;
11402                 ndr->depth--;
11403                 ndr_print_ptr(ndr, "sids", r->out.sids);
11404                 ndr->depth++;
11405                 ndr_print_lsa_TransSidArray3(ndr, "sids", r->out.sids);
11406                 ndr->depth--;
11407                 ndr_print_ptr(ndr, "count", r->out.count);
11408                 ndr->depth++;
11409                 ndr_print_uint32(ndr, "count", *r->out.count);
11410                 ndr->depth--;
11411                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11412                 ndr->depth--;
11413         }
11414         ndr->depth--;
11415 }
11416
11417 static enum ndr_err_code ndr_push_lsa_LSAROPENPOLICYSCE(struct ndr_push *ndr, int flags, const struct lsa_LSAROPENPOLICYSCE *r)
11418 {
11419         if (flags & NDR_IN) {
11420         }
11421         if (flags & NDR_OUT) {
11422                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11423         }
11424         return NDR_ERR_SUCCESS;
11425 }
11426
11427 static enum ndr_err_code ndr_pull_lsa_LSAROPENPOLICYSCE(struct ndr_pull *ndr, int flags, struct lsa_LSAROPENPOLICYSCE *r)
11428 {
11429         if (flags & NDR_IN) {
11430         }
11431         if (flags & NDR_OUT) {
11432                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11433         }
11434         return NDR_ERR_SUCCESS;
11435 }
11436
11437 _PUBLIC_ void ndr_print_lsa_LSAROPENPOLICYSCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSAROPENPOLICYSCE *r)
11438 {
11439         ndr_print_struct(ndr, name, "lsa_LSAROPENPOLICYSCE");
11440         ndr->depth++;
11441         if (flags & NDR_SET_VALUES) {
11442                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11443         }
11444         if (flags & NDR_IN) {
11445                 ndr_print_struct(ndr, "in", "lsa_LSAROPENPOLICYSCE");
11446                 ndr->depth++;
11447                 ndr->depth--;
11448         }
11449         if (flags & NDR_OUT) {
11450                 ndr_print_struct(ndr, "out", "lsa_LSAROPENPOLICYSCE");
11451                 ndr->depth++;
11452                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11453                 ndr->depth--;
11454         }
11455         ndr->depth--;
11456 }
11457
11458 static enum ndr_err_code ndr_push_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_push *ndr, int flags, const struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
11459 {
11460         if (flags & NDR_IN) {
11461         }
11462         if (flags & NDR_OUT) {
11463                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11464         }
11465         return NDR_ERR_SUCCESS;
11466 }
11467
11468 static enum ndr_err_code ndr_pull_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_pull *ndr, int flags, struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
11469 {
11470         if (flags & NDR_IN) {
11471         }
11472         if (flags & NDR_OUT) {
11473                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11474         }
11475         return NDR_ERR_SUCCESS;
11476 }
11477
11478 _PUBLIC_ void ndr_print_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
11479 {
11480         ndr_print_struct(ndr, name, "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
11481         ndr->depth++;
11482         if (flags & NDR_SET_VALUES) {
11483                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11484         }
11485         if (flags & NDR_IN) {
11486                 ndr_print_struct(ndr, "in", "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
11487                 ndr->depth++;
11488                 ndr->depth--;
11489         }
11490         if (flags & NDR_OUT) {
11491                 ndr_print_struct(ndr, "out", "lsa_LSARADTREGISTERSECURITYEVENTSOURCE");
11492                 ndr->depth++;
11493                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11494                 ndr->depth--;
11495         }
11496         ndr->depth--;
11497 }
11498
11499 static enum ndr_err_code ndr_push_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_push *ndr, int flags, const struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
11500 {
11501         if (flags & NDR_IN) {
11502         }
11503         if (flags & NDR_OUT) {
11504                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11505         }
11506         return NDR_ERR_SUCCESS;
11507 }
11508
11509 static enum ndr_err_code ndr_pull_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_pull *ndr, int flags, struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
11510 {
11511         if (flags & NDR_IN) {
11512         }
11513         if (flags & NDR_OUT) {
11514                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11515         }
11516         return NDR_ERR_SUCCESS;
11517 }
11518
11519 _PUBLIC_ void ndr_print_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
11520 {
11521         ndr_print_struct(ndr, name, "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
11522         ndr->depth++;
11523         if (flags & NDR_SET_VALUES) {
11524                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11525         }
11526         if (flags & NDR_IN) {
11527                 ndr_print_struct(ndr, "in", "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
11528                 ndr->depth++;
11529                 ndr->depth--;
11530         }
11531         if (flags & NDR_OUT) {
11532                 ndr_print_struct(ndr, "out", "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE");
11533                 ndr->depth++;
11534                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11535                 ndr->depth--;
11536         }
11537         ndr->depth--;
11538 }
11539
11540 static enum ndr_err_code ndr_push_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_push *ndr, int flags, const struct lsa_LSARADTREPORTSECURITYEVENT *r)
11541 {
11542         if (flags & NDR_IN) {
11543         }
11544         if (flags & NDR_OUT) {
11545                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
11546         }
11547         return NDR_ERR_SUCCESS;
11548 }
11549
11550 static enum ndr_err_code ndr_pull_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_pull *ndr, int flags, struct lsa_LSARADTREPORTSECURITYEVENT *r)
11551 {
11552         if (flags & NDR_IN) {
11553         }
11554         if (flags & NDR_OUT) {
11555                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
11556         }
11557         return NDR_ERR_SUCCESS;
11558 }
11559
11560 _PUBLIC_ void ndr_print_lsa_LSARADTREPORTSECURITYEVENT(struct ndr_print *ndr, const char *name, int flags, const struct lsa_LSARADTREPORTSECURITYEVENT *r)
11561 {
11562         ndr_print_struct(ndr, name, "lsa_LSARADTREPORTSECURITYEVENT");
11563         ndr->depth++;
11564         if (flags & NDR_SET_VALUES) {
11565                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11566         }
11567         if (flags & NDR_IN) {
11568                 ndr_print_struct(ndr, "in", "lsa_LSARADTREPORTSECURITYEVENT");
11569                 ndr->depth++;
11570                 ndr->depth--;
11571         }
11572         if (flags & NDR_OUT) {
11573                 ndr_print_struct(ndr, "out", "lsa_LSARADTREPORTSECURITYEVENT");
11574                 ndr->depth++;
11575                 ndr_print_NTSTATUS(ndr, "result", r->out.result);
11576                 ndr->depth--;
11577         }
11578         ndr->depth--;
11579 }
11580
11581 static const struct ndr_interface_call lsarpc_calls[] = {
11582         {
11583                 "lsa_Close",
11584                 sizeof(struct lsa_Close),
11585                 (ndr_push_flags_fn_t) ndr_push_lsa_Close,
11586                 (ndr_pull_flags_fn_t) ndr_pull_lsa_Close,
11587                 (ndr_print_function_t) ndr_print_lsa_Close,
11588                 false,
11589         },
11590         {
11591                 "lsa_Delete",
11592                 sizeof(struct lsa_Delete),
11593                 (ndr_push_flags_fn_t) ndr_push_lsa_Delete,
11594                 (ndr_pull_flags_fn_t) ndr_pull_lsa_Delete,
11595                 (ndr_print_function_t) ndr_print_lsa_Delete,
11596                 false,
11597         },
11598         {
11599                 "lsa_EnumPrivs",
11600                 sizeof(struct lsa_EnumPrivs),
11601                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumPrivs,
11602                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumPrivs,
11603                 (ndr_print_function_t) ndr_print_lsa_EnumPrivs,
11604                 false,
11605         },
11606         {
11607                 "lsa_QuerySecurity",
11608                 sizeof(struct lsa_QuerySecurity),
11609                 (ndr_push_flags_fn_t) ndr_push_lsa_QuerySecurity,
11610                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QuerySecurity,
11611                 (ndr_print_function_t) ndr_print_lsa_QuerySecurity,
11612                 false,
11613         },
11614         {
11615                 "lsa_SetSecObj",
11616                 sizeof(struct lsa_SetSecObj),
11617                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSecObj,
11618                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSecObj,
11619                 (ndr_print_function_t) ndr_print_lsa_SetSecObj,
11620                 false,
11621         },
11622         {
11623                 "lsa_ChangePassword",
11624                 sizeof(struct lsa_ChangePassword),
11625                 (ndr_push_flags_fn_t) ndr_push_lsa_ChangePassword,
11626                 (ndr_pull_flags_fn_t) ndr_pull_lsa_ChangePassword,
11627                 (ndr_print_function_t) ndr_print_lsa_ChangePassword,
11628                 false,
11629         },
11630         {
11631                 "lsa_OpenPolicy",
11632                 sizeof(struct lsa_OpenPolicy),
11633                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenPolicy,
11634                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenPolicy,
11635                 (ndr_print_function_t) ndr_print_lsa_OpenPolicy,
11636                 false,
11637         },
11638         {
11639                 "lsa_QueryInfoPolicy",
11640                 sizeof(struct lsa_QueryInfoPolicy),
11641                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryInfoPolicy,
11642                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryInfoPolicy,
11643                 (ndr_print_function_t) ndr_print_lsa_QueryInfoPolicy,
11644                 false,
11645         },
11646         {
11647                 "lsa_SetInfoPolicy",
11648                 sizeof(struct lsa_SetInfoPolicy),
11649                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInfoPolicy,
11650                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInfoPolicy,
11651                 (ndr_print_function_t) ndr_print_lsa_SetInfoPolicy,
11652                 false,
11653         },
11654         {
11655                 "lsa_ClearAuditLog",
11656                 sizeof(struct lsa_ClearAuditLog),
11657                 (ndr_push_flags_fn_t) ndr_push_lsa_ClearAuditLog,
11658                 (ndr_pull_flags_fn_t) ndr_pull_lsa_ClearAuditLog,
11659                 (ndr_print_function_t) ndr_print_lsa_ClearAuditLog,
11660                 false,
11661         },
11662         {
11663                 "lsa_CreateAccount",
11664                 sizeof(struct lsa_CreateAccount),
11665                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateAccount,
11666                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateAccount,
11667                 (ndr_print_function_t) ndr_print_lsa_CreateAccount,
11668                 false,
11669         },
11670         {
11671                 "lsa_EnumAccounts",
11672                 sizeof(struct lsa_EnumAccounts),
11673                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccounts,
11674                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccounts,
11675                 (ndr_print_function_t) ndr_print_lsa_EnumAccounts,
11676                 false,
11677         },
11678         {
11679                 "lsa_CreateTrustedDomain",
11680                 sizeof(struct lsa_CreateTrustedDomain),
11681                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomain,
11682                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomain,
11683                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomain,
11684                 false,
11685         },
11686         {
11687                 "lsa_EnumTrustDom",
11688                 sizeof(struct lsa_EnumTrustDom),
11689                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumTrustDom,
11690                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumTrustDom,
11691                 (ndr_print_function_t) ndr_print_lsa_EnumTrustDom,
11692                 false,
11693         },
11694         {
11695                 "lsa_LookupNames",
11696                 sizeof(struct lsa_LookupNames),
11697                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames,
11698                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames,
11699                 (ndr_print_function_t) ndr_print_lsa_LookupNames,
11700                 false,
11701         },
11702         {
11703                 "lsa_LookupSids",
11704                 sizeof(struct lsa_LookupSids),
11705                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids,
11706                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids,
11707                 (ndr_print_function_t) ndr_print_lsa_LookupSids,
11708                 false,
11709         },
11710         {
11711                 "lsa_CreateSecret",
11712                 sizeof(struct lsa_CreateSecret),
11713                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateSecret,
11714                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateSecret,
11715                 (ndr_print_function_t) ndr_print_lsa_CreateSecret,
11716                 false,
11717         },
11718         {
11719                 "lsa_OpenAccount",
11720                 sizeof(struct lsa_OpenAccount),
11721                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenAccount,
11722                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenAccount,
11723                 (ndr_print_function_t) ndr_print_lsa_OpenAccount,
11724                 false,
11725         },
11726         {
11727                 "lsa_EnumPrivsAccount",
11728                 sizeof(struct lsa_EnumPrivsAccount),
11729                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumPrivsAccount,
11730                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumPrivsAccount,
11731                 (ndr_print_function_t) ndr_print_lsa_EnumPrivsAccount,
11732                 false,
11733         },
11734         {
11735                 "lsa_AddPrivilegesToAccount",
11736                 sizeof(struct lsa_AddPrivilegesToAccount),
11737                 (ndr_push_flags_fn_t) ndr_push_lsa_AddPrivilegesToAccount,
11738                 (ndr_pull_flags_fn_t) ndr_pull_lsa_AddPrivilegesToAccount,
11739                 (ndr_print_function_t) ndr_print_lsa_AddPrivilegesToAccount,
11740                 false,
11741         },
11742         {
11743                 "lsa_RemovePrivilegesFromAccount",
11744                 sizeof(struct lsa_RemovePrivilegesFromAccount),
11745                 (ndr_push_flags_fn_t) ndr_push_lsa_RemovePrivilegesFromAccount,
11746                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RemovePrivilegesFromAccount,
11747                 (ndr_print_function_t) ndr_print_lsa_RemovePrivilegesFromAccount,
11748                 false,
11749         },
11750         {
11751                 "lsa_GetQuotasForAccount",
11752                 sizeof(struct lsa_GetQuotasForAccount),
11753                 (ndr_push_flags_fn_t) ndr_push_lsa_GetQuotasForAccount,
11754                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetQuotasForAccount,
11755                 (ndr_print_function_t) ndr_print_lsa_GetQuotasForAccount,
11756                 false,
11757         },
11758         {
11759                 "lsa_SetQuotasForAccount",
11760                 sizeof(struct lsa_SetQuotasForAccount),
11761                 (ndr_push_flags_fn_t) ndr_push_lsa_SetQuotasForAccount,
11762                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetQuotasForAccount,
11763                 (ndr_print_function_t) ndr_print_lsa_SetQuotasForAccount,
11764                 false,
11765         },
11766         {
11767                 "lsa_GetSystemAccessAccount",
11768                 sizeof(struct lsa_GetSystemAccessAccount),
11769                 (ndr_push_flags_fn_t) ndr_push_lsa_GetSystemAccessAccount,
11770                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetSystemAccessAccount,
11771                 (ndr_print_function_t) ndr_print_lsa_GetSystemAccessAccount,
11772                 false,
11773         },
11774         {
11775                 "lsa_SetSystemAccessAccount",
11776                 sizeof(struct lsa_SetSystemAccessAccount),
11777                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSystemAccessAccount,
11778                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSystemAccessAccount,
11779                 (ndr_print_function_t) ndr_print_lsa_SetSystemAccessAccount,
11780                 false,
11781         },
11782         {
11783                 "lsa_OpenTrustedDomain",
11784                 sizeof(struct lsa_OpenTrustedDomain),
11785                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenTrustedDomain,
11786                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenTrustedDomain,
11787                 (ndr_print_function_t) ndr_print_lsa_OpenTrustedDomain,
11788                 false,
11789         },
11790         {
11791                 "lsa_QueryTrustedDomainInfo",
11792                 sizeof(struct lsa_QueryTrustedDomainInfo),
11793                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfo,
11794                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfo,
11795                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfo,
11796                 false,
11797         },
11798         {
11799                 "lsa_SetInformationTrustedDomain",
11800                 sizeof(struct lsa_SetInformationTrustedDomain),
11801                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInformationTrustedDomain,
11802                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInformationTrustedDomain,
11803                 (ndr_print_function_t) ndr_print_lsa_SetInformationTrustedDomain,
11804                 false,
11805         },
11806         {
11807                 "lsa_OpenSecret",
11808                 sizeof(struct lsa_OpenSecret),
11809                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenSecret,
11810                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenSecret,
11811                 (ndr_print_function_t) ndr_print_lsa_OpenSecret,
11812                 false,
11813         },
11814         {
11815                 "lsa_SetSecret",
11816                 sizeof(struct lsa_SetSecret),
11817                 (ndr_push_flags_fn_t) ndr_push_lsa_SetSecret,
11818                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetSecret,
11819                 (ndr_print_function_t) ndr_print_lsa_SetSecret,
11820                 false,
11821         },
11822         {
11823                 "lsa_QuerySecret",
11824                 sizeof(struct lsa_QuerySecret),
11825                 (ndr_push_flags_fn_t) ndr_push_lsa_QuerySecret,
11826                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QuerySecret,
11827                 (ndr_print_function_t) ndr_print_lsa_QuerySecret,
11828                 false,
11829         },
11830         {
11831                 "lsa_LookupPrivValue",
11832                 sizeof(struct lsa_LookupPrivValue),
11833                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivValue,
11834                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivValue,
11835                 (ndr_print_function_t) ndr_print_lsa_LookupPrivValue,
11836                 false,
11837         },
11838         {
11839                 "lsa_LookupPrivName",
11840                 sizeof(struct lsa_LookupPrivName),
11841                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivName,
11842                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivName,
11843                 (ndr_print_function_t) ndr_print_lsa_LookupPrivName,
11844                 false,
11845         },
11846         {
11847                 "lsa_LookupPrivDisplayName",
11848                 sizeof(struct lsa_LookupPrivDisplayName),
11849                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupPrivDisplayName,
11850                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupPrivDisplayName,
11851                 (ndr_print_function_t) ndr_print_lsa_LookupPrivDisplayName,
11852                 false,
11853         },
11854         {
11855                 "lsa_DeleteObject",
11856                 sizeof(struct lsa_DeleteObject),
11857                 (ndr_push_flags_fn_t) ndr_push_lsa_DeleteObject,
11858                 (ndr_pull_flags_fn_t) ndr_pull_lsa_DeleteObject,
11859                 (ndr_print_function_t) ndr_print_lsa_DeleteObject,
11860                 false,
11861         },
11862         {
11863                 "lsa_EnumAccountsWithUserRight",
11864                 sizeof(struct lsa_EnumAccountsWithUserRight),
11865                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccountsWithUserRight,
11866                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccountsWithUserRight,
11867                 (ndr_print_function_t) ndr_print_lsa_EnumAccountsWithUserRight,
11868                 false,
11869         },
11870         {
11871                 "lsa_EnumAccountRights",
11872                 sizeof(struct lsa_EnumAccountRights),
11873                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumAccountRights,
11874                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumAccountRights,
11875                 (ndr_print_function_t) ndr_print_lsa_EnumAccountRights,
11876                 false,
11877         },
11878         {
11879                 "lsa_AddAccountRights",
11880                 sizeof(struct lsa_AddAccountRights),
11881                 (ndr_push_flags_fn_t) ndr_push_lsa_AddAccountRights,
11882                 (ndr_pull_flags_fn_t) ndr_pull_lsa_AddAccountRights,
11883                 (ndr_print_function_t) ndr_print_lsa_AddAccountRights,
11884                 false,
11885         },
11886         {
11887                 "lsa_RemoveAccountRights",
11888                 sizeof(struct lsa_RemoveAccountRights),
11889                 (ndr_push_flags_fn_t) ndr_push_lsa_RemoveAccountRights,
11890                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RemoveAccountRights,
11891                 (ndr_print_function_t) ndr_print_lsa_RemoveAccountRights,
11892                 false,
11893         },
11894         {
11895                 "lsa_QueryTrustedDomainInfoBySid",
11896                 sizeof(struct lsa_QueryTrustedDomainInfoBySid),
11897                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfoBySid,
11898                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfoBySid,
11899                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfoBySid,
11900                 false,
11901         },
11902         {
11903                 "lsa_SetTrustedDomainInfo",
11904                 sizeof(struct lsa_SetTrustedDomainInfo),
11905                 (ndr_push_flags_fn_t) ndr_push_lsa_SetTrustedDomainInfo,
11906                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetTrustedDomainInfo,
11907                 (ndr_print_function_t) ndr_print_lsa_SetTrustedDomainInfo,
11908                 false,
11909         },
11910         {
11911                 "lsa_DeleteTrustedDomain",
11912                 sizeof(struct lsa_DeleteTrustedDomain),
11913                 (ndr_push_flags_fn_t) ndr_push_lsa_DeleteTrustedDomain,
11914                 (ndr_pull_flags_fn_t) ndr_pull_lsa_DeleteTrustedDomain,
11915                 (ndr_print_function_t) ndr_print_lsa_DeleteTrustedDomain,
11916                 false,
11917         },
11918         {
11919                 "lsa_StorePrivateData",
11920                 sizeof(struct lsa_StorePrivateData),
11921                 (ndr_push_flags_fn_t) ndr_push_lsa_StorePrivateData,
11922                 (ndr_pull_flags_fn_t) ndr_pull_lsa_StorePrivateData,
11923                 (ndr_print_function_t) ndr_print_lsa_StorePrivateData,
11924                 false,
11925         },
11926         {
11927                 "lsa_RetrievePrivateData",
11928                 sizeof(struct lsa_RetrievePrivateData),
11929                 (ndr_push_flags_fn_t) ndr_push_lsa_RetrievePrivateData,
11930                 (ndr_pull_flags_fn_t) ndr_pull_lsa_RetrievePrivateData,
11931                 (ndr_print_function_t) ndr_print_lsa_RetrievePrivateData,
11932                 false,
11933         },
11934         {
11935                 "lsa_OpenPolicy2",
11936                 sizeof(struct lsa_OpenPolicy2),
11937                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenPolicy2,
11938                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenPolicy2,
11939                 (ndr_print_function_t) ndr_print_lsa_OpenPolicy2,
11940                 false,
11941         },
11942         {
11943                 "lsa_GetUserName",
11944                 sizeof(struct lsa_GetUserName),
11945                 (ndr_push_flags_fn_t) ndr_push_lsa_GetUserName,
11946                 (ndr_pull_flags_fn_t) ndr_pull_lsa_GetUserName,
11947                 (ndr_print_function_t) ndr_print_lsa_GetUserName,
11948                 false,
11949         },
11950         {
11951                 "lsa_QueryInfoPolicy2",
11952                 sizeof(struct lsa_QueryInfoPolicy2),
11953                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryInfoPolicy2,
11954                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryInfoPolicy2,
11955                 (ndr_print_function_t) ndr_print_lsa_QueryInfoPolicy2,
11956                 false,
11957         },
11958         {
11959                 "lsa_SetInfoPolicy2",
11960                 sizeof(struct lsa_SetInfoPolicy2),
11961                 (ndr_push_flags_fn_t) ndr_push_lsa_SetInfoPolicy2,
11962                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetInfoPolicy2,
11963                 (ndr_print_function_t) ndr_print_lsa_SetInfoPolicy2,
11964                 false,
11965         },
11966         {
11967                 "lsa_QueryTrustedDomainInfoByName",
11968                 sizeof(struct lsa_QueryTrustedDomainInfoByName),
11969                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryTrustedDomainInfoByName,
11970                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryTrustedDomainInfoByName,
11971                 (ndr_print_function_t) ndr_print_lsa_QueryTrustedDomainInfoByName,
11972                 false,
11973         },
11974         {
11975                 "lsa_SetTrustedDomainInfoByName",
11976                 sizeof(struct lsa_SetTrustedDomainInfoByName),
11977                 (ndr_push_flags_fn_t) ndr_push_lsa_SetTrustedDomainInfoByName,
11978                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetTrustedDomainInfoByName,
11979                 (ndr_print_function_t) ndr_print_lsa_SetTrustedDomainInfoByName,
11980                 false,
11981         },
11982         {
11983                 "lsa_EnumTrustedDomainsEx",
11984                 sizeof(struct lsa_EnumTrustedDomainsEx),
11985                 (ndr_push_flags_fn_t) ndr_push_lsa_EnumTrustedDomainsEx,
11986                 (ndr_pull_flags_fn_t) ndr_pull_lsa_EnumTrustedDomainsEx,
11987                 (ndr_print_function_t) ndr_print_lsa_EnumTrustedDomainsEx,
11988                 false,
11989         },
11990         {
11991                 "lsa_CreateTrustedDomainEx",
11992                 sizeof(struct lsa_CreateTrustedDomainEx),
11993                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomainEx,
11994                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomainEx,
11995                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomainEx,
11996                 false,
11997         },
11998         {
11999                 "lsa_CloseTrustedDomainEx",
12000                 sizeof(struct lsa_CloseTrustedDomainEx),
12001                 (ndr_push_flags_fn_t) ndr_push_lsa_CloseTrustedDomainEx,
12002                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CloseTrustedDomainEx,
12003                 (ndr_print_function_t) ndr_print_lsa_CloseTrustedDomainEx,
12004                 false,
12005         },
12006         {
12007                 "lsa_QueryDomainInformationPolicy",
12008                 sizeof(struct lsa_QueryDomainInformationPolicy),
12009                 (ndr_push_flags_fn_t) ndr_push_lsa_QueryDomainInformationPolicy,
12010                 (ndr_pull_flags_fn_t) ndr_pull_lsa_QueryDomainInformationPolicy,
12011                 (ndr_print_function_t) ndr_print_lsa_QueryDomainInformationPolicy,
12012                 false,
12013         },
12014         {
12015                 "lsa_SetDomainInformationPolicy",
12016                 sizeof(struct lsa_SetDomainInformationPolicy),
12017                 (ndr_push_flags_fn_t) ndr_push_lsa_SetDomainInformationPolicy,
12018                 (ndr_pull_flags_fn_t) ndr_pull_lsa_SetDomainInformationPolicy,
12019                 (ndr_print_function_t) ndr_print_lsa_SetDomainInformationPolicy,
12020                 false,
12021         },
12022         {
12023                 "lsa_OpenTrustedDomainByName",
12024                 sizeof(struct lsa_OpenTrustedDomainByName),
12025                 (ndr_push_flags_fn_t) ndr_push_lsa_OpenTrustedDomainByName,
12026                 (ndr_pull_flags_fn_t) ndr_pull_lsa_OpenTrustedDomainByName,
12027                 (ndr_print_function_t) ndr_print_lsa_OpenTrustedDomainByName,
12028                 false,
12029         },
12030         {
12031                 "lsa_TestCall",
12032                 sizeof(struct lsa_TestCall),
12033                 (ndr_push_flags_fn_t) ndr_push_lsa_TestCall,
12034                 (ndr_pull_flags_fn_t) ndr_pull_lsa_TestCall,
12035                 (ndr_print_function_t) ndr_print_lsa_TestCall,
12036                 false,
12037         },
12038         {
12039                 "lsa_LookupSids2",
12040                 sizeof(struct lsa_LookupSids2),
12041                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids2,
12042                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids2,
12043                 (ndr_print_function_t) ndr_print_lsa_LookupSids2,
12044                 false,
12045         },
12046         {
12047                 "lsa_LookupNames2",
12048                 sizeof(struct lsa_LookupNames2),
12049                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames2,
12050                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames2,
12051                 (ndr_print_function_t) ndr_print_lsa_LookupNames2,
12052                 false,
12053         },
12054         {
12055                 "lsa_CreateTrustedDomainEx2",
12056                 sizeof(struct lsa_CreateTrustedDomainEx2),
12057                 (ndr_push_flags_fn_t) ndr_push_lsa_CreateTrustedDomainEx2,
12058                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CreateTrustedDomainEx2,
12059                 (ndr_print_function_t) ndr_print_lsa_CreateTrustedDomainEx2,
12060                 false,
12061         },
12062         {
12063                 "lsa_CREDRWRITE",
12064                 sizeof(struct lsa_CREDRWRITE),
12065                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRWRITE,
12066                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRWRITE,
12067                 (ndr_print_function_t) ndr_print_lsa_CREDRWRITE,
12068                 false,
12069         },
12070         {
12071                 "lsa_CREDRREAD",
12072                 sizeof(struct lsa_CREDRREAD),
12073                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRREAD,
12074                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRREAD,
12075                 (ndr_print_function_t) ndr_print_lsa_CREDRREAD,
12076                 false,
12077         },
12078         {
12079                 "lsa_CREDRENUMERATE",
12080                 sizeof(struct lsa_CREDRENUMERATE),
12081                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRENUMERATE,
12082                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRENUMERATE,
12083                 (ndr_print_function_t) ndr_print_lsa_CREDRENUMERATE,
12084                 false,
12085         },
12086         {
12087                 "lsa_CREDRWRITEDOMAINCREDENTIALS",
12088                 sizeof(struct lsa_CREDRWRITEDOMAINCREDENTIALS),
12089                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRWRITEDOMAINCREDENTIALS,
12090                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRWRITEDOMAINCREDENTIALS,
12091                 (ndr_print_function_t) ndr_print_lsa_CREDRWRITEDOMAINCREDENTIALS,
12092                 false,
12093         },
12094         {
12095                 "lsa_CREDRREADDOMAINCREDENTIALS",
12096                 sizeof(struct lsa_CREDRREADDOMAINCREDENTIALS),
12097                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRREADDOMAINCREDENTIALS,
12098                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRREADDOMAINCREDENTIALS,
12099                 (ndr_print_function_t) ndr_print_lsa_CREDRREADDOMAINCREDENTIALS,
12100                 false,
12101         },
12102         {
12103                 "lsa_CREDRDELETE",
12104                 sizeof(struct lsa_CREDRDELETE),
12105                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRDELETE,
12106                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRDELETE,
12107                 (ndr_print_function_t) ndr_print_lsa_CREDRDELETE,
12108                 false,
12109         },
12110         {
12111                 "lsa_CREDRGETTARGETINFO",
12112                 sizeof(struct lsa_CREDRGETTARGETINFO),
12113                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRGETTARGETINFO,
12114                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRGETTARGETINFO,
12115                 (ndr_print_function_t) ndr_print_lsa_CREDRGETTARGETINFO,
12116                 false,
12117         },
12118         {
12119                 "lsa_CREDRPROFILELOADED",
12120                 sizeof(struct lsa_CREDRPROFILELOADED),
12121                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRPROFILELOADED,
12122                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRPROFILELOADED,
12123                 (ndr_print_function_t) ndr_print_lsa_CREDRPROFILELOADED,
12124                 false,
12125         },
12126         {
12127                 "lsa_LookupNames3",
12128                 sizeof(struct lsa_LookupNames3),
12129                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames3,
12130                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames3,
12131                 (ndr_print_function_t) ndr_print_lsa_LookupNames3,
12132                 false,
12133         },
12134         {
12135                 "lsa_CREDRGETSESSIONTYPES",
12136                 sizeof(struct lsa_CREDRGETSESSIONTYPES),
12137                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRGETSESSIONTYPES,
12138                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRGETSESSIONTYPES,
12139                 (ndr_print_function_t) ndr_print_lsa_CREDRGETSESSIONTYPES,
12140                 false,
12141         },
12142         {
12143                 "lsa_LSARREGISTERAUDITEVENT",
12144                 sizeof(struct lsa_LSARREGISTERAUDITEVENT),
12145                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARREGISTERAUDITEVENT,
12146                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARREGISTERAUDITEVENT,
12147                 (ndr_print_function_t) ndr_print_lsa_LSARREGISTERAUDITEVENT,
12148                 false,
12149         },
12150         {
12151                 "lsa_LSARGENAUDITEVENT",
12152                 sizeof(struct lsa_LSARGENAUDITEVENT),
12153                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARGENAUDITEVENT,
12154                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARGENAUDITEVENT,
12155                 (ndr_print_function_t) ndr_print_lsa_LSARGENAUDITEVENT,
12156                 false,
12157         },
12158         {
12159                 "lsa_LSARUNREGISTERAUDITEVENT",
12160                 sizeof(struct lsa_LSARUNREGISTERAUDITEVENT),
12161                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARUNREGISTERAUDITEVENT,
12162                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARUNREGISTERAUDITEVENT,
12163                 (ndr_print_function_t) ndr_print_lsa_LSARUNREGISTERAUDITEVENT,
12164                 false,
12165         },
12166         {
12167                 "lsa_lsaRQueryForestTrustInformation",
12168                 sizeof(struct lsa_lsaRQueryForestTrustInformation),
12169                 (ndr_push_flags_fn_t) ndr_push_lsa_lsaRQueryForestTrustInformation,
12170                 (ndr_pull_flags_fn_t) ndr_pull_lsa_lsaRQueryForestTrustInformation,
12171                 (ndr_print_function_t) ndr_print_lsa_lsaRQueryForestTrustInformation,
12172                 false,
12173         },
12174         {
12175                 "lsa_LSARSETFORESTTRUSTINFORMATION",
12176                 sizeof(struct lsa_LSARSETFORESTTRUSTINFORMATION),
12177                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARSETFORESTTRUSTINFORMATION,
12178                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARSETFORESTTRUSTINFORMATION,
12179                 (ndr_print_function_t) ndr_print_lsa_LSARSETFORESTTRUSTINFORMATION,
12180                 false,
12181         },
12182         {
12183                 "lsa_CREDRRENAME",
12184                 sizeof(struct lsa_CREDRRENAME),
12185                 (ndr_push_flags_fn_t) ndr_push_lsa_CREDRRENAME,
12186                 (ndr_pull_flags_fn_t) ndr_pull_lsa_CREDRRENAME,
12187                 (ndr_print_function_t) ndr_print_lsa_CREDRRENAME,
12188                 false,
12189         },
12190         {
12191                 "lsa_LookupSids3",
12192                 sizeof(struct lsa_LookupSids3),
12193                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupSids3,
12194                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupSids3,
12195                 (ndr_print_function_t) ndr_print_lsa_LookupSids3,
12196                 false,
12197         },
12198         {
12199                 "lsa_LookupNames4",
12200                 sizeof(struct lsa_LookupNames4),
12201                 (ndr_push_flags_fn_t) ndr_push_lsa_LookupNames4,
12202                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LookupNames4,
12203                 (ndr_print_function_t) ndr_print_lsa_LookupNames4,
12204                 false,
12205         },
12206         {
12207                 "lsa_LSAROPENPOLICYSCE",
12208                 sizeof(struct lsa_LSAROPENPOLICYSCE),
12209                 (ndr_push_flags_fn_t) ndr_push_lsa_LSAROPENPOLICYSCE,
12210                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSAROPENPOLICYSCE,
12211                 (ndr_print_function_t) ndr_print_lsa_LSAROPENPOLICYSCE,
12212                 false,
12213         },
12214         {
12215                 "lsa_LSARADTREGISTERSECURITYEVENTSOURCE",
12216                 sizeof(struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE),
12217                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
12218                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
12219                 (ndr_print_function_t) ndr_print_lsa_LSARADTREGISTERSECURITYEVENTSOURCE,
12220                 false,
12221         },
12222         {
12223                 "lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE",
12224                 sizeof(struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE),
12225                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
12226                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
12227                 (ndr_print_function_t) ndr_print_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE,
12228                 false,
12229         },
12230         {
12231                 "lsa_LSARADTREPORTSECURITYEVENT",
12232                 sizeof(struct lsa_LSARADTREPORTSECURITYEVENT),
12233                 (ndr_push_flags_fn_t) ndr_push_lsa_LSARADTREPORTSECURITYEVENT,
12234                 (ndr_pull_flags_fn_t) ndr_pull_lsa_LSARADTREPORTSECURITYEVENT,
12235                 (ndr_print_function_t) ndr_print_lsa_LSARADTREPORTSECURITYEVENT,
12236                 false,
12237         },
12238         { NULL, 0, NULL, NULL, NULL, false }
12239 };
12240
12241 static const char * const lsarpc_endpoint_strings[] = {
12242         "ncacn_np:[\\pipe\\lsarpc]",
12243         "ncacn_np:[\\pipe\\netlogon]",
12244         "ncacn_np:[\\pipe\\lsass]",
12245         "ncacn_ip_tcp:",
12246         "ncalrpc:",
12247 };
12248
12249 static const struct ndr_interface_string_array lsarpc_endpoints = {
12250         .count  = 5,
12251         .names  = lsarpc_endpoint_strings
12252 };
12253
12254 static const char * const lsarpc_authservice_strings[] = {
12255         "host",
12256 };
12257
12258 static const struct ndr_interface_string_array lsarpc_authservices = {
12259         .count  = 5,
12260         .names  = lsarpc_authservice_strings
12261 };
12262
12263
12264 const struct ndr_interface_table ndr_table_lsarpc = {
12265         .name           = "lsarpc",
12266         .syntax_id      = {
12267                 {0x12345778,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
12268                 NDR_LSARPC_VERSION
12269         },
12270         .helpstring     = NDR_LSARPC_HELPSTRING,
12271         .num_calls      = 82,
12272         .calls          = lsarpc_calls,
12273         .endpoints      = &lsarpc_endpoints,
12274         .authservices   = &lsarpc_authservices
12275 };
12276