source/librpc/ndr/ndr_lsa.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4
   5 NTSTATUS ndr_push_lsa_Close(struct ndr_push *ndr, struct lsa_Close *r)
   6 {
   7         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
   8
   9         return NT_STATUS_OK;
  10 }
  11
  12 NTSTATUS ndr_pull_lsa_Close(struct ndr_pull *ndr, struct lsa_Close *r)
  13 {
  14         NDR_CHECK(ndr_pull_policy_handle(ndr, r->out.handle));
  15         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
  16
  17         return NT_STATUS_OK;
  18 }
  19
  20 NTSTATUS ndr_push_lsa_Delete(struct ndr_push *ndr, struct lsa_Delete *r)
  21 {
  22         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
  23
  24         return NT_STATUS_OK;
  25 }
  26
  27 NTSTATUS ndr_pull_lsa_Delete(struct ndr_pull *ndr, struct lsa_Delete *r)
  28 {
  29         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
  30
  31         return NT_STATUS_OK;
  32 }
  33
  34 static NTSTATUS ndr_push_lsa_Name(struct ndr_push *ndr, int ndr_flags, struct lsa_Name *r)
  35 {
  36         NDR_CHECK(ndr_push_align(ndr, 4));
  37         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
  38         NDR_CHECK(ndr_push_uint16(ndr, r->name_len));
  39         NDR_CHECK(ndr_push_uint16(ndr, r->name_size));
  40         NDR_CHECK(ndr_push_ptr(ndr, r->name));
  41 buffers:
  42         if (!(ndr_flags & NDR_BUFFERS)) goto done;
  43         if (r->name) {
  44                 NDR_CHECK(ndr_push_unistr_noterm(ndr, r->name));
  45         }
  46 done:
  47         return NT_STATUS_OK;
  48 }
  49
  50 static NTSTATUS ndr_pull_lsa_Name(struct ndr_pull *ndr, int ndr_flags, struct lsa_Name *r)
  51 {
  52         uint32 _ptr_name;
  53         NDR_CHECK(ndr_pull_align(ndr, 4));
  54         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
  55         NDR_CHECK(ndr_pull_uint16(ndr, &r->name_len));
  56         NDR_CHECK(ndr_pull_uint16(ndr, &r->name_size));
  57         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_name));
  58         if (_ptr_name) {
  59                 NDR_ALLOC(ndr, r->name);
  60         } else {
  61                 r->name = NULL;
  62         }
  63 buffers:
  64         if (!(ndr_flags & NDR_BUFFERS)) goto done;
  65         if (r->name) {
  66                 NDR_CHECK(ndr_pull_unistr_noterm(ndr, &r->name));
  67         }
  68 done:
  69         return NT_STATUS_OK;
  70 }
  71
  72 void ndr_print_lsa_Name(struct ndr_print *ndr, const char *name, struct lsa_Name *r)
  73 {
  74         ndr_print_struct(ndr, name, "lsa_Name");
  75         ndr->depth++;
  76         ndr_print_uint16(ndr, "name_len", r->name_len);
  77         ndr_print_uint16(ndr, "name_size", r->name_size);
  78         ndr_print_ptr(ndr, "name", r->name);
  79         ndr->depth++;
  80         if (r->name) {
  81                 ndr_print_unistr_noterm(ndr, "name", r->name);
  82         }
  83         ndr->depth--;
  84         ndr->depth--;
  85 }
  86
  87 static NTSTATUS ndr_pull_lsa_PrivEntry(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivEntry *r)
  88 {
  89         NDR_CHECK(ndr_pull_align(ndr, 4));
  90         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
  91         NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS, &r->name));
  92         NDR_CHECK(ndr_pull_uint32(ndr, &r->luid_low));
  93         NDR_CHECK(ndr_pull_uint32(ndr, &r->luid_high));
  94 buffers:
  95         if (!(ndr_flags & NDR_BUFFERS)) goto done;
  96                 NDR_CHECK(ndr_pull_lsa_Name(ndr, ndr_flags, &r->name));
  97 done:
  98         return NT_STATUS_OK;
  99 }
 100
 101 void ndr_print_lsa_PrivEntry(struct ndr_print *ndr, const char *name, struct lsa_PrivEntry *r)
 102 {
 103         ndr_print_struct(ndr, name, "lsa_PrivEntry");
 104         ndr->depth++;
 105         ndr_print_lsa_Name(ndr, "name", &r->name);
 106         ndr_print_uint32(ndr, "luid_low", r->luid_low);
 107         ndr_print_uint32(ndr, "luid_high", r->luid_high);
 108         ndr->depth--;
 109 }
 110
 111 static NTSTATUS ndr_pull_lsa_PrivArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivArray *r)
 112 {
 113         uint32 _ptr_privs;
 114         NDR_CHECK(ndr_pull_align(ndr, 4));
 115         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 116         NDR_CHECK(ndr_pull_uint32(ndr, &r->count));
 117         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_privs));
 118         if (_ptr_privs) {
 119                 NDR_ALLOC(ndr, r->privs);
 120         } else {
 121                 r->privs = NULL;
 122         }
 123 buffers:
 124         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 125         if (r->privs) {
 126         {
 127                 uint32 _array_size;
 128                 NDR_CHECK(ndr_pull_uint32(ndr, &_array_size));
 129                 if (r->count > _array_size) {
 130                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should be %u", _array_size, r->count);
 131                 }
 132         }
 133                 NDR_ALLOC_N_SIZE(ndr, r->privs, r->count, sizeof(r->privs[0]));
 134                 NDR_CHECK(ndr_pull_array(ndr, ndr_flags, (void **)r->privs, sizeof(r->privs[0]), r->count, (ndr_pull_flags_fn_t)ndr_pull_lsa_PrivEntry));
 135         }
 136 done:
 137         return NT_STATUS_OK;
 138 }
 139
 140 void ndr_print_lsa_PrivArray(struct ndr_print *ndr, const char *name, struct lsa_PrivArray *r)
 141 {
 142         ndr_print_struct(ndr, name, "lsa_PrivArray");
 143         ndr->depth++;
 144         ndr_print_uint32(ndr, "count", r->count);
 145         ndr_print_ptr(ndr, "privs", r->privs);
 146         ndr->depth++;
 147         if (r->privs) {
 148                 ndr_print_array(ndr, "privs", r->privs, sizeof(r->privs[0]), r->count, (ndr_print_fn_t)ndr_print_lsa_PrivEntry);
 149         }
 150         ndr->depth--;
 151         ndr->depth--;
 152 }
 153
 154 NTSTATUS ndr_push_lsa_EnumPrivs(struct ndr_push *ndr, struct lsa_EnumPrivs *r)
 155 {
 156         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
 157         NDR_CHECK(ndr_push_uint32(ndr, *r->in.resume_handle));
 158         NDR_CHECK(ndr_push_uint32(ndr, r->in.max_count));
 159
 160         return NT_STATUS_OK;
 161 }
 162
 163 NTSTATUS ndr_pull_lsa_EnumPrivs(struct ndr_pull *ndr, struct lsa_EnumPrivs *r)
 164 {
 165         NDR_CHECK(ndr_pull_uint32(ndr, r->out.resume_handle));
 166         NDR_CHECK(ndr_pull_lsa_PrivArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.privs));
 167         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
 168
 169         return NT_STATUS_OK;
 170 }
 171
 172 NTSTATUS ndr_push_lsa_QuerySecObj(struct ndr_push *ndr, struct lsa_QuerySecObj *r)
 173 {
 174
 175         return NT_STATUS_OK;
 176 }
 177
 178 NTSTATUS ndr_pull_lsa_QuerySecObj(struct ndr_pull *ndr, struct lsa_QuerySecObj *r)
 179 {
 180         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
 181
 182         return NT_STATUS_OK;
 183 }
 184
 185 NTSTATUS ndr_push_lsa_SetSecObj(struct ndr_push *ndr, struct lsa_SetSecObj *r)
 186 {
 187
 188         return NT_STATUS_OK;
 189 }
 190
 191 NTSTATUS ndr_pull_lsa_SetSecObj(struct ndr_pull *ndr, struct lsa_SetSecObj *r)
 192 {
 193         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
 194
 195         return NT_STATUS_OK;
 196 }
 197
 198 NTSTATUS ndr_push_lsa_ChangePassword(struct ndr_push *ndr, struct lsa_ChangePassword *r)
 199 {
 200
 201         return NT_STATUS_OK;
 202 }
 203
 204 NTSTATUS ndr_pull_lsa_ChangePassword(struct ndr_pull *ndr, struct lsa_ChangePassword *r)
 205 {
 206         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
 207
 208         return NT_STATUS_OK;
 209 }
 210
 211 static NTSTATUS ndr_push_lsa_QosInfo(struct ndr_push *ndr, int ndr_flags, struct lsa_QosInfo *r)
 212 {
 213         struct ndr_push_save _save1, _save2, _save3;
 214         ndr_push_save(ndr, &_save1);
 215         NDR_CHECK(ndr_push_align(ndr, 4));
 216         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 217         NDR_CHECK(ndr_push_align(ndr, sizeof(uint32)));
 218         ndr_push_save(ndr, &_save2);
 219         NDR_CHECK(ndr_push_uint32(ndr, 0));
 220         NDR_CHECK(ndr_push_uint16(ndr, r->impersonation_level));
 221         NDR_CHECK(ndr_push_uint8(ndr, r->context_mode));
 222         NDR_CHECK(ndr_push_uint8(ndr, r->effective_only));
 223 buffers:
 224         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 225         ndr_push_save(ndr, &_save3);
 226         ndr_push_restore(ndr, &_save2);
 227         NDR_CHECK(ndr_push_uint32(ndr, _save3.offset - _save1.offset));
 228         ndr_push_restore(ndr, &_save3);
 229 done:
 230         return NT_STATUS_OK;
 231 }
 232
 233 void ndr_print_lsa_QosInfo(struct ndr_print *ndr, const char *name, struct lsa_QosInfo *r)
 234 {
 235         ndr_print_struct(ndr, name, "lsa_QosInfo");
 236         ndr->depth++;
 237         ndr_print_uint16(ndr, "impersonation_level", r->impersonation_level);
 238         ndr_print_uint8(ndr, "context_mode", r->context_mode);
 239         ndr_print_uint8(ndr, "effective_only", r->effective_only);
 240         ndr->depth--;
 241 }
 242
 243 static NTSTATUS ndr_push_lsa_ObjectAttribute(struct ndr_push *ndr, int ndr_flags, struct lsa_ObjectAttribute *r)
 244 {
 245         struct ndr_push_save _save1, _save2, _save3;
 246         ndr_push_save(ndr, &_save1);
 247         NDR_CHECK(ndr_push_align(ndr, 4));
 248         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 249         NDR_CHECK(ndr_push_align(ndr, sizeof(uint32)));
 250         ndr_push_save(ndr, &_save2);
 251         NDR_CHECK(ndr_push_uint32(ndr, 0));
 252         NDR_CHECK(ndr_push_ptr(ndr, r->root_dir));
 253         NDR_CHECK(ndr_push_ptr(ndr, r->object_name));
 254         NDR_CHECK(ndr_push_uint32(ndr, r->attributes));
 255         NDR_CHECK(ndr_push_ptr(ndr, r->sec_desc));
 256         NDR_CHECK(ndr_push_ptr(ndr, r->sec_qos));
 257 buffers:
 258         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 259         if (r->root_dir) {
 260                 NDR_CHECK(ndr_push_uint8(ndr, *r->root_dir));
 261         }
 262         if (r->object_name) {
 263                 NDR_CHECK(ndr_push_unistr(ndr, r->object_name));
 264         }
 265         if (r->sec_desc) {
 266                 NDR_CHECK(ndr_push_security_descriptor(ndr, r->sec_desc));
 267         }
 268         if (r->sec_qos) {
 269                 NDR_CHECK(ndr_push_lsa_QosInfo(ndr, ndr_flags, r->sec_qos));
 270         }
 271         ndr_push_save(ndr, &_save3);
 272         ndr_push_restore(ndr, &_save2);
 273         NDR_CHECK(ndr_push_uint32(ndr, _save3.offset - _save1.offset));
 274         ndr_push_restore(ndr, &_save3);
 275 done:
 276         return NT_STATUS_OK;
 277 }
 278
 279 void ndr_print_lsa_ObjectAttribute(struct ndr_print *ndr, const char *name, struct lsa_ObjectAttribute *r)
 280 {
 281         ndr_print_struct(ndr, name, "lsa_ObjectAttribute");
 282         ndr->depth++;
 283         ndr_print_ptr(ndr, "root_dir", r->root_dir);
 284         ndr->depth++;
 285         if (r->root_dir) {
 286                 ndr_print_uint8(ndr, "root_dir", *r->root_dir);
 287         }
 288         ndr->depth--;
 289         ndr_print_ptr(ndr, "object_name", r->object_name);
 290         ndr->depth++;
 291         if (r->object_name) {
 292                 ndr_print_unistr(ndr, "object_name", r->object_name);
 293         }
 294         ndr->depth--;
 295         ndr_print_uint32(ndr, "attributes", r->attributes);
 296         ndr_print_ptr(ndr, "sec_desc", r->sec_desc);
 297         ndr->depth++;
 298         if (r->sec_desc) {
 299                 ndr_print_security_descriptor(ndr, "sec_desc", r->sec_desc);
 300         }
 301         ndr->depth--;
 302         ndr_print_ptr(ndr, "sec_qos", r->sec_qos);
 303         ndr->depth++;
 304         if (r->sec_qos) {
 305                 ndr_print_lsa_QosInfo(ndr, "sec_qos", r->sec_qos);
 306         }
 307         ndr->depth--;
 308         ndr->depth--;
 309 }
 310
 311 NTSTATUS ndr_push_lsa_OpenPolicy(struct ndr_push *ndr, struct lsa_OpenPolicy *r)
 312 {
 313         NDR_CHECK(ndr_push_ptr(ndr, r->in.system_name));
 314         if (r->in.system_name) {
 315                 NDR_CHECK(ndr_push_uint16(ndr, *r->in.system_name));
 316         }
 317         NDR_CHECK(ndr_push_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
 318         NDR_CHECK(ndr_push_uint32(ndr, r->in.desired_access));
 319
 320         return NT_STATUS_OK;
 321 }
 322
 323 NTSTATUS ndr_pull_lsa_OpenPolicy(struct ndr_pull *ndr, struct lsa_OpenPolicy *r)
 324 {
 325         NDR_CHECK(ndr_pull_policy_handle(ndr, r->out.handle));
 326         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
 327
 328         return NT_STATUS_OK;
 329 }
 330
 331 static NTSTATUS ndr_pull_lsa_AuditLogInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditLogInfo *r)
 332 {
 333         NDR_CHECK(ndr_pull_align(ndr, 4));
 334         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 335         NDR_CHECK(ndr_pull_uint32(ndr, &r->percent_full));
 336         NDR_CHECK(ndr_pull_uint32(ndr, &r->log_size));
 337         NDR_CHECK(ndr_pull_NTTIME(ndr, &r->retention_time));
 338         NDR_CHECK(ndr_pull_uint8(ndr, &r->shutdown_in_progress));
 339         NDR_CHECK(ndr_pull_NTTIME(ndr, &r->time_to_shutdown));
 340         NDR_CHECK(ndr_pull_uint32(ndr, &r->next_audit_record));
 341         NDR_CHECK(ndr_pull_uint32(ndr, &r->unknown));
 342 buffers:
 343         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 344 done:
 345         return NT_STATUS_OK;
 346 }
 347
 348 void ndr_print_lsa_AuditLogInfo(struct ndr_print *ndr, const char *name, struct lsa_AuditLogInfo *r)
 349 {
 350         ndr_print_struct(ndr, name, "lsa_AuditLogInfo");
 351         ndr->depth++;
 352         ndr_print_uint32(ndr, "percent_full", r->percent_full);
 353         ndr_print_uint32(ndr, "log_size", r->log_size);
 354         ndr_print_NTTIME(ndr, "retention_time", r->retention_time);
 355         ndr_print_uint8(ndr, "shutdown_in_progress", r->shutdown_in_progress);
 356         ndr_print_NTTIME(ndr, "time_to_shutdown", r->time_to_shutdown);
 357         ndr_print_uint32(ndr, "next_audit_record", r->next_audit_record);
 358         ndr_print_uint32(ndr, "unknown", r->unknown);
 359         ndr->depth--;
 360 }
 361
 362 static NTSTATUS ndr_pull_lsa_AuditSettings(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditSettings *r)
 363 {
 364         uint32 _conformant_size;
 365         NDR_CHECK(ndr_pull_uint32(ndr, &_conformant_size));
 366         NDR_CHECK(ndr_pull_align(ndr, 4));
 367         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 368         NDR_CHECK(ndr_pull_uint32(ndr, &r->count));
 369 buffers:
 370         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 371         if (r->count > _conformant_size) {
 372                 return ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, "Bad conformant size %u should be %u", _conformant_size, r->count);
 373         }
 374                 NDR_ALLOC_N_SIZE(ndr, r->settings, _conformant_size, sizeof(r->settings[0]));
 375                 NDR_CHECK(ndr_pull_array_uint32(ndr, r->settings, r->count));
 376 done:
 377         return NT_STATUS_OK;
 378 }
 379
 380 void ndr_print_lsa_AuditSettings(struct ndr_print *ndr, const char *name, struct lsa_AuditSettings *r)
 381 {
 382         ndr_print_struct(ndr, name, "lsa_AuditSettings");
 383         ndr->depth++;
 384         ndr_print_uint32(ndr, "count", r->count);
 385         ndr_print_ptr(ndr, "settings", r->settings);
 386         ndr->depth++;
 387                 ndr_print_array_uint32(ndr, "settings", r->settings, r->count);
 388         ndr->depth--;
 389         ndr->depth--;
 390 }
 391
 392 static NTSTATUS ndr_pull_lsa_AuditEventsInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditEventsInfo *r)
 393 {
 394         uint32 _ptr_settings;
 395         NDR_CHECK(ndr_pull_align(ndr, 4));
 396         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 397         NDR_CHECK(ndr_pull_uint32(ndr, &r->auditing_mode));
 398         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_settings));
 399         if (_ptr_settings) {
 400                 NDR_ALLOC(ndr, r->settings);
 401         } else {
 402                 r->settings = NULL;
 403         }
 404 buffers:
 405         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 406         if (r->settings) {
 407                 NDR_CHECK(ndr_pull_lsa_AuditSettings(ndr, NDR_SCALARS|NDR_BUFFERS, r->settings));
 408         }
 409 done:
 410         return NT_STATUS_OK;
 411 }
 412
 413 void ndr_print_lsa_AuditEventsInfo(struct ndr_print *ndr, const char *name, struct lsa_AuditEventsInfo *r)
 414 {
 415         ndr_print_struct(ndr, name, "lsa_AuditEventsInfo");
 416         ndr->depth++;
 417         ndr_print_uint32(ndr, "auditing_mode", r->auditing_mode);
 418         ndr_print_ptr(ndr, "settings", r->settings);
 419         ndr->depth++;
 420         if (r->settings) {
 421                 ndr_print_lsa_AuditSettings(ndr, "settings", r->settings);
 422         }
 423         ndr->depth--;
 424         ndr->depth--;
 425 }
 426
 427 static NTSTATUS ndr_pull_lsa_DomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInfo *r)
 428 {
 429         uint32 _ptr_sid;
 430         NDR_CHECK(ndr_pull_align(ndr, 4));
 431         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 432         NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS, &r->name));
 433         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_sid));
 434         if (_ptr_sid) {
 435                 NDR_ALLOC(ndr, r->sid);
 436         } else {
 437                 r->sid = NULL;
 438         }
 439 buffers:
 440         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 441                 NDR_CHECK(ndr_pull_lsa_Name(ndr, ndr_flags, &r->name));
 442         if (r->sid) {
 443                 NDR_CHECK(ndr_pull_dom_sid2(ndr, r->sid));
 444         }
 445 done:
 446         return NT_STATUS_OK;
 447 }
 448
 449 void ndr_print_lsa_DomainInfo(struct ndr_print *ndr, const char *name, struct lsa_DomainInfo *r)
 450 {
 451         ndr_print_struct(ndr, name, "lsa_DomainInfo");
 452         ndr->depth++;
 453         ndr_print_lsa_Name(ndr, "name", &r->name);
 454         ndr_print_ptr(ndr, "sid", r->sid);
 455         ndr->depth++;
 456         if (r->sid) {
 457                 ndr_print_dom_sid2(ndr, "sid", r->sid);
 458         }
 459         ndr->depth--;
 460         ndr->depth--;
 461 }
 462
 463 static NTSTATUS ndr_pull_lsa_PDAccountInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_PDAccountInfo *r)
 464 {
 465         NDR_CHECK(ndr_pull_align(ndr, 4));
 466         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 467         NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS, &r->name));
 468 buffers:
 469         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 470                 NDR_CHECK(ndr_pull_lsa_Name(ndr, ndr_flags, &r->name));
 471 done:
 472         return NT_STATUS_OK;
 473 }
 474
 475 void ndr_print_lsa_PDAccountInfo(struct ndr_print *ndr, const char *name, struct lsa_PDAccountInfo *r)
 476 {
 477         ndr_print_struct(ndr, name, "lsa_PDAccountInfo");
 478         ndr->depth++;
 479         ndr_print_lsa_Name(ndr, "name", &r->name);
 480         ndr->depth--;
 481 }
 482
 483 static NTSTATUS ndr_pull_lsa_ServerRole(struct ndr_pull *ndr, int ndr_flags, struct lsa_ServerRole *r)
 484 {
 485         NDR_CHECK(ndr_pull_align(ndr, 4));
 486         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 487         NDR_CHECK(ndr_pull_uint16(ndr, &r->role));
 488 buffers:
 489         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 490 done:
 491         return NT_STATUS_OK;
 492 }
 493
 494 void ndr_print_lsa_ServerRole(struct ndr_print *ndr, const char *name, struct lsa_ServerRole *r)
 495 {
 496         ndr_print_struct(ndr, name, "lsa_ServerRole");
 497         ndr->depth++;
 498         ndr_print_uint16(ndr, "role", r->role);
 499         ndr->depth--;
 500 }
 501
 502 static NTSTATUS ndr_pull_lsa_ReplicaSourceInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ReplicaSourceInfo *r)
 503 {
 504         NDR_CHECK(ndr_pull_align(ndr, 4));
 505         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 506         NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS, &r->source));
 507         NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS, &r->account));
 508 buffers:
 509         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 510                 NDR_CHECK(ndr_pull_lsa_Name(ndr, ndr_flags, &r->source));
 511                 NDR_CHECK(ndr_pull_lsa_Name(ndr, ndr_flags, &r->account));
 512 done:
 513         return NT_STATUS_OK;
 514 }
 515
 516 void ndr_print_lsa_ReplicaSourceInfo(struct ndr_print *ndr, const char *name, struct lsa_ReplicaSourceInfo *r)
 517 {
 518         ndr_print_struct(ndr, name, "lsa_ReplicaSourceInfo");
 519         ndr->depth++;
 520         ndr_print_lsa_Name(ndr, "source", &r->source);
 521         ndr_print_lsa_Name(ndr, "account", &r->account);
 522         ndr->depth--;
 523 }
 524
 525 static NTSTATUS ndr_pull_lsa_DefaultQuotaInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DefaultQuotaInfo *r)
 526 {
 527         NDR_CHECK(ndr_pull_align(ndr, 8));
 528         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 529         NDR_CHECK(ndr_pull_uint32(ndr, &r->paged_pool));
 530         NDR_CHECK(ndr_pull_uint32(ndr, &r->non_paged_pool));
 531         NDR_CHECK(ndr_pull_uint32(ndr, &r->min_wss));
 532         NDR_CHECK(ndr_pull_uint32(ndr, &r->max_wss));
 533         NDR_CHECK(ndr_pull_uint32(ndr, &r->pagefile));
 534         NDR_CHECK(ndr_pull_HYPER_T(ndr, &r->unknown));
 535 buffers:
 536         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 537 done:
 538         return NT_STATUS_OK;
 539 }
 540
 541 void ndr_print_lsa_DefaultQuotaInfo(struct ndr_print *ndr, const char *name, struct lsa_DefaultQuotaInfo *r)
 542 {
 543         ndr_print_struct(ndr, name, "lsa_DefaultQuotaInfo");
 544         ndr->depth++;
 545         ndr_print_uint32(ndr, "paged_pool", r->paged_pool);
 546         ndr_print_uint32(ndr, "non_paged_pool", r->non_paged_pool);
 547         ndr_print_uint32(ndr, "min_wss", r->min_wss);
 548         ndr_print_uint32(ndr, "max_wss", r->max_wss);
 549         ndr_print_uint32(ndr, "pagefile", r->pagefile);
 550         ndr_print_HYPER_T(ndr, "unknown", r->unknown);
 551         ndr->depth--;
 552 }
 553
 554 static NTSTATUS ndr_pull_lsa_ModificationInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_ModificationInfo *r)
 555 {
 556         NDR_CHECK(ndr_pull_align(ndr, 8));
 557         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 558         NDR_CHECK(ndr_pull_HYPER_T(ndr, &r->modified_id));
 559         NDR_CHECK(ndr_pull_NTTIME(ndr, &r->db_create_time));
 560 buffers:
 561         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 562 done:
 563         return NT_STATUS_OK;
 564 }
 565
 566 void ndr_print_lsa_ModificationInfo(struct ndr_print *ndr, const char *name, struct lsa_ModificationInfo *r)
 567 {
 568         ndr_print_struct(ndr, name, "lsa_ModificationInfo");
 569         ndr->depth++;
 570         ndr_print_HYPER_T(ndr, "modified_id", r->modified_id);
 571         ndr_print_NTTIME(ndr, "db_create_time", r->db_create_time);
 572         ndr->depth--;
 573 }
 574
 575 static NTSTATUS ndr_pull_lsa_AuditFullSetInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditFullSetInfo *r)
 576 {
 577         NDR_CHECK(ndr_pull_align(ndr, 4));
 578         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 579         NDR_CHECK(ndr_pull_uint32(ndr, &r->shutdown_on_full));
 580 buffers:
 581         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 582 done:
 583         return NT_STATUS_OK;
 584 }
 585
 586 void ndr_print_lsa_AuditFullSetInfo(struct ndr_print *ndr, const char *name, struct lsa_AuditFullSetInfo *r)
 587 {
 588         ndr_print_struct(ndr, name, "lsa_AuditFullSetInfo");
 589         ndr->depth++;
 590         ndr_print_uint32(ndr, "shutdown_on_full", r->shutdown_on_full);
 591         ndr->depth--;
 592 }
 593
 594 static NTSTATUS ndr_pull_lsa_AuditFullQueryInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_AuditFullQueryInfo *r)
 595 {
 596         NDR_CHECK(ndr_pull_align(ndr, 4));
 597         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 598         NDR_CHECK(ndr_pull_uint32(ndr, &r->shutdown_on_full));
 599         NDR_CHECK(ndr_pull_uint32(ndr, &r->log_is_full));
 600 buffers:
 601         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 602 done:
 603         return NT_STATUS_OK;
 604 }
 605
 606 void ndr_print_lsa_AuditFullQueryInfo(struct ndr_print *ndr, const char *name, struct lsa_AuditFullQueryInfo *r)
 607 {
 608         ndr_print_struct(ndr, name, "lsa_AuditFullQueryInfo");
 609         ndr->depth++;
 610         ndr_print_uint32(ndr, "shutdown_on_full", r->shutdown_on_full);
 611         ndr_print_uint32(ndr, "log_is_full", r->log_is_full);
 612         ndr->depth--;
 613 }
 614
 615 static NTSTATUS ndr_pull_lsa_DnsDomainInfo(struct ndr_pull *ndr, int ndr_flags, struct lsa_DnsDomainInfo *r)
 616 {
 617         uint32 _ptr_sid;
 618         NDR_CHECK(ndr_pull_align(ndr, 4));
 619         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 620         NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS, &r->name));
 621         NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS, &r->dns_domain));
 622         NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS, &r->dns_forest));
 623         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_guid));
 624         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_sid));
 625         if (_ptr_sid) {
 626                 NDR_ALLOC(ndr, r->sid);
 627         } else {
 628                 r->sid = NULL;
 629         }
 630 buffers:
 631         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 632                 NDR_CHECK(ndr_pull_lsa_Name(ndr, ndr_flags, &r->name));
 633                 NDR_CHECK(ndr_pull_lsa_Name(ndr, ndr_flags, &r->dns_domain));
 634                 NDR_CHECK(ndr_pull_lsa_Name(ndr, ndr_flags, &r->dns_forest));
 635                 NDR_CHECK(ndr_pull_GUID(ndr, ndr_flags, &r->domain_guid));
 636         if (r->sid) {
 637                 NDR_CHECK(ndr_pull_dom_sid2(ndr, r->sid));
 638         }
 639 done:
 640         return NT_STATUS_OK;
 641 }
 642
 643 void ndr_print_lsa_DnsDomainInfo(struct ndr_print *ndr, const char *name, struct lsa_DnsDomainInfo *r)
 644 {
 645         ndr_print_struct(ndr, name, "lsa_DnsDomainInfo");
 646         ndr->depth++;
 647         ndr_print_lsa_Name(ndr, "name", &r->name);
 648         ndr_print_lsa_Name(ndr, "dns_domain", &r->dns_domain);
 649         ndr_print_lsa_Name(ndr, "dns_forest", &r->dns_forest);
 650         ndr_print_GUID(ndr, "domain_guid", &r->domain_guid);
 651         ndr_print_ptr(ndr, "sid", r->sid);
 652         ndr->depth++;
 653         if (r->sid) {
 654                 ndr_print_dom_sid2(ndr, "sid", r->sid);
 655         }
 656         ndr->depth--;
 657         ndr->depth--;
 658 }
 659
 660 static NTSTATUS ndr_pull_lsa_PolicyInformation(struct ndr_pull *ndr, int ndr_flags, uint16 *level, union lsa_PolicyInformation *r)
 661 {
 662         NDR_CHECK(ndr_pull_uint16(ndr, level));
 663         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 664         switch (*level) {
 665         case 1:
 666         NDR_CHECK(ndr_pull_lsa_AuditLogInfo(ndr, NDR_SCALARS, &r->audit_log));
 667         break;
 668
 669         case 2:
 670         NDR_CHECK(ndr_pull_lsa_AuditEventsInfo(ndr, NDR_SCALARS, &r->audit_events));
 671         break;
 672
 673         case 3:
 674         NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->domain));
 675         break;
 676
 677         case 4:
 678         NDR_CHECK(ndr_pull_lsa_PDAccountInfo(ndr, NDR_SCALARS, &r->pd));
 679         break;
 680
 681         case 5:
 682         NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_SCALARS, &r->account_domain));
 683         break;
 684
 685         case 6:
 686         NDR_CHECK(ndr_pull_lsa_ServerRole(ndr, NDR_SCALARS, &r->role));
 687         break;
 688
 689         case 7:
 690         NDR_CHECK(ndr_pull_lsa_ReplicaSourceInfo(ndr, NDR_SCALARS, &r->replica));
 691         break;
 692
 693         case 8:
 694         NDR_CHECK(ndr_pull_lsa_DefaultQuotaInfo(ndr, NDR_SCALARS, &r->quota));
 695         break;
 696
 697         case 9:
 698         NDR_CHECK(ndr_pull_lsa_ModificationInfo(ndr, NDR_SCALARS, &r->db));
 699         break;
 700
 701         case 10:
 702         NDR_CHECK(ndr_pull_lsa_AuditFullSetInfo(ndr, NDR_SCALARS, &r->auditfullset));
 703         break;
 704
 705         case 11:
 706         NDR_CHECK(ndr_pull_lsa_AuditFullQueryInfo(ndr, NDR_SCALARS, &r->auditfullquery));
 707         break;
 708
 709         case 12:
 710         NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_SCALARS, &r->dns));
 711         break;
 712
 713         default:
 714                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u in ", *level);
 715         }
 716 buffers:
 717         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 718         switch (*level) {
 719         case 1:
 720                 NDR_CHECK(ndr_pull_lsa_AuditLogInfo(ndr, NDR_BUFFERS, &r->audit_log));
 721         break;
 722
 723         case 2:
 724                 NDR_CHECK(ndr_pull_lsa_AuditEventsInfo(ndr, NDR_BUFFERS, &r->audit_events));
 725         break;
 726
 727         case 3:
 728                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->domain));
 729         break;
 730
 731         case 4:
 732                 NDR_CHECK(ndr_pull_lsa_PDAccountInfo(ndr, NDR_BUFFERS, &r->pd));
 733         break;
 734
 735         case 5:
 736                 NDR_CHECK(ndr_pull_lsa_DomainInfo(ndr, NDR_BUFFERS, &r->account_domain));
 737         break;
 738
 739         case 6:
 740                 NDR_CHECK(ndr_pull_lsa_ServerRole(ndr, NDR_BUFFERS, &r->role));
 741         break;
 742
 743         case 7:
 744                 NDR_CHECK(ndr_pull_lsa_ReplicaSourceInfo(ndr, NDR_BUFFERS, &r->replica));
 745         break;
 746
 747         case 8:
 748                 NDR_CHECK(ndr_pull_lsa_DefaultQuotaInfo(ndr, NDR_BUFFERS, &r->quota));
 749         break;
 750
 751         case 9:
 752                 NDR_CHECK(ndr_pull_lsa_ModificationInfo(ndr, NDR_BUFFERS, &r->db));
 753         break;
 754
 755         case 10:
 756                 NDR_CHECK(ndr_pull_lsa_AuditFullSetInfo(ndr, NDR_BUFFERS, &r->auditfullset));
 757         break;
 758
 759         case 11:
 760                 NDR_CHECK(ndr_pull_lsa_AuditFullQueryInfo(ndr, NDR_BUFFERS, &r->auditfullquery));
 761         break;
 762
 763         case 12:
 764                 NDR_CHECK(ndr_pull_lsa_DnsDomainInfo(ndr, NDR_BUFFERS, &r->dns));
 765         break;
 766
 767         default:
 768                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u in ", *level);
 769         }
 770 done:
 771         return NT_STATUS_OK;
 772 }
 773
 774 void ndr_print_lsa_PolicyInformation(struct ndr_print *ndr, const char *name, uint16 level, union lsa_PolicyInformation *r)
 775 {
 776         ndr_print_union(ndr, name, level, "lsa_PolicyInformation");
 777         switch (level) {
 778         case 1:
 779         ndr_print_lsa_AuditLogInfo(ndr, "audit_log", &r->audit_log);
 780         break;
 781
 782         case 2:
 783         ndr_print_lsa_AuditEventsInfo(ndr, "audit_events", &r->audit_events);
 784         break;
 785
 786         case 3:
 787         ndr_print_lsa_DomainInfo(ndr, "domain", &r->domain);
 788         break;
 789
 790         case 4:
 791         ndr_print_lsa_PDAccountInfo(ndr, "pd", &r->pd);
 792         break;
 793
 794         case 5:
 795         ndr_print_lsa_DomainInfo(ndr, "account_domain", &r->account_domain);
 796         break;
 797
 798         case 6:
 799         ndr_print_lsa_ServerRole(ndr, "role", &r->role);
 800         break;
 801
 802         case 7:
 803         ndr_print_lsa_ReplicaSourceInfo(ndr, "replica", &r->replica);
 804         break;
 805
 806         case 8:
 807         ndr_print_lsa_DefaultQuotaInfo(ndr, "quota", &r->quota);
 808         break;
 809
 810         case 9:
 811         ndr_print_lsa_ModificationInfo(ndr, "db", &r->db);
 812         break;
 813
 814         case 10:
 815         ndr_print_lsa_AuditFullSetInfo(ndr, "auditfullset", &r->auditfullset);
 816         break;
 817
 818         case 11:
 819         ndr_print_lsa_AuditFullQueryInfo(ndr, "auditfullquery", &r->auditfullquery);
 820         break;
 821
 822         case 12:
 823         ndr_print_lsa_DnsDomainInfo(ndr, "dns", &r->dns);
 824         break;
 825
 826         default:
 827                 ndr_print_bad_level(ndr, name, level);
 828         }
 829 }
 830
 831 NTSTATUS ndr_push_lsa_QueryInfoPolicy(struct ndr_push *ndr, struct lsa_QueryInfoPolicy *r)
 832 {
 833         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
 834         NDR_CHECK(ndr_push_uint16(ndr, r->in.level));
 835
 836         return NT_STATUS_OK;
 837 }
 838
 839 NTSTATUS ndr_pull_lsa_QueryInfoPolicy(struct ndr_pull *ndr, struct lsa_QueryInfoPolicy *r)
 840 {
 841         uint32 _ptr_info;
 842         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_info));
 843         if (_ptr_info) {
 844                 NDR_ALLOC(ndr, r->out.info);
 845         } else {
 846                 r->out.info = NULL;
 847         }
 848         if (r->out.info) {
 849         { uint16 _level;
 850         NDR_CHECK(ndr_pull_lsa_PolicyInformation(ndr, NDR_SCALARS|NDR_BUFFERS, &_level, r->out.info));
 851         if (_level != r->in.level) return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u in info");
 852         }
 853         }
 854         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
 855
 856         return NT_STATUS_OK;
 857 }
 858
 859 NTSTATUS ndr_push_lsa_SetInfoPolicy(struct ndr_push *ndr, struct lsa_SetInfoPolicy *r)
 860 {
 861
 862         return NT_STATUS_OK;
 863 }
 864
 865 NTSTATUS ndr_pull_lsa_SetInfoPolicy(struct ndr_pull *ndr, struct lsa_SetInfoPolicy *r)
 866 {
 867         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
 868
 869         return NT_STATUS_OK;
 870 }
 871
 872 NTSTATUS ndr_push_lsa_ClearAuditLog(struct ndr_push *ndr, struct lsa_ClearAuditLog *r)
 873 {
 874
 875         return NT_STATUS_OK;
 876 }
 877
 878 NTSTATUS ndr_pull_lsa_ClearAuditLog(struct ndr_pull *ndr, struct lsa_ClearAuditLog *r)
 879 {
 880         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
 881
 882         return NT_STATUS_OK;
 883 }
 884
 885 NTSTATUS ndr_push_lsa_CreateAccount(struct ndr_push *ndr, struct lsa_CreateAccount *r)
 886 {
 887
 888         return NT_STATUS_OK;
 889 }
 890
 891 NTSTATUS ndr_pull_lsa_CreateAccount(struct ndr_pull *ndr, struct lsa_CreateAccount *r)
 892 {
 893         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
 894
 895         return NT_STATUS_OK;
 896 }
 897
 898 static NTSTATUS ndr_push_lsa_SidPtr(struct ndr_push *ndr, int ndr_flags, struct lsa_SidPtr *r)
 899 {
 900         NDR_CHECK(ndr_push_align(ndr, 4));
 901         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 902         NDR_CHECK(ndr_push_ptr(ndr, r->sid));
 903 buffers:
 904         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 905         if (r->sid) {
 906                 NDR_CHECK(ndr_push_dom_sid2(ndr, r->sid));
 907         }
 908 done:
 909         return NT_STATUS_OK;
 910 }
 911
 912 static NTSTATUS ndr_pull_lsa_SidPtr(struct ndr_pull *ndr, int ndr_flags, struct lsa_SidPtr *r)
 913 {
 914         uint32 _ptr_sid;
 915         NDR_CHECK(ndr_pull_align(ndr, 4));
 916         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 917         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_sid));
 918         if (_ptr_sid) {
 919                 NDR_ALLOC(ndr, r->sid);
 920         } else {
 921                 r->sid = NULL;
 922         }
 923 buffers:
 924         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 925         if (r->sid) {
 926                 NDR_CHECK(ndr_pull_dom_sid2(ndr, r->sid));
 927         }
 928 done:
 929         return NT_STATUS_OK;
 930 }
 931
 932 void ndr_print_lsa_SidPtr(struct ndr_print *ndr, const char *name, struct lsa_SidPtr *r)
 933 {
 934         ndr_print_struct(ndr, name, "lsa_SidPtr");
 935         ndr->depth++;
 936         ndr_print_ptr(ndr, "sid", r->sid);
 937         ndr->depth++;
 938         if (r->sid) {
 939                 ndr_print_dom_sid2(ndr, "sid", r->sid);
 940         }
 941         ndr->depth--;
 942         ndr->depth--;
 943 }
 944
 945 static NTSTATUS ndr_push_lsa_SidArray(struct ndr_push *ndr, int ndr_flags, struct lsa_SidArray *r)
 946 {
 947         NDR_CHECK(ndr_push_align(ndr, 4));
 948         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 949         NDR_CHECK(ndr_push_uint32(ndr, r->num_sids));
 950         NDR_CHECK(ndr_push_ptr(ndr, r->sids));
 951 buffers:
 952         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 953         if (r->sids) {
 954                 NDR_CHECK(ndr_push_uint32(ndr, r->num_sids));
 955                 NDR_CHECK(ndr_push_array(ndr, ndr_flags, r->sids, sizeof(r->sids[0]), r->num_sids, (ndr_push_flags_fn_t)ndr_push_lsa_SidPtr));
 956         }
 957 done:
 958         return NT_STATUS_OK;
 959 }
 960
 961 static NTSTATUS ndr_pull_lsa_SidArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_SidArray *r)
 962 {
 963         uint32 _ptr_sids;
 964         NDR_CHECK(ndr_pull_align(ndr, 4));
 965         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
 966         NDR_CHECK(ndr_pull_uint32(ndr, &r->num_sids));
 967         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_sids));
 968         if (_ptr_sids) {
 969                 NDR_ALLOC(ndr, r->sids);
 970         } else {
 971                 r->sids = NULL;
 972         }
 973 buffers:
 974         if (!(ndr_flags & NDR_BUFFERS)) goto done;
 975         if (r->sids) {
 976         {
 977                 uint32 _array_size;
 978                 NDR_CHECK(ndr_pull_uint32(ndr, &_array_size));
 979                 if (r->num_sids > _array_size) {
 980                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should be %u", _array_size, r->num_sids);
 981                 }
 982         }
 983                 NDR_ALLOC_N_SIZE(ndr, r->sids, r->num_sids, sizeof(r->sids[0]));
 984                 NDR_CHECK(ndr_pull_array(ndr, ndr_flags, (void **)r->sids, sizeof(r->sids[0]), r->num_sids, (ndr_pull_flags_fn_t)ndr_pull_lsa_SidPtr));
 985         }
 986 done:
 987         return NT_STATUS_OK;
 988 }
 989
 990 void ndr_print_lsa_SidArray(struct ndr_print *ndr, const char *name, struct lsa_SidArray *r)
 991 {
 992         ndr_print_struct(ndr, name, "lsa_SidArray");
 993         ndr->depth++;
 994         ndr_print_uint32(ndr, "num_sids", r->num_sids);
 995         ndr_print_ptr(ndr, "sids", r->sids);
 996         ndr->depth++;
 997         if (r->sids) {
 998                 ndr_print_array(ndr, "sids", r->sids, sizeof(r->sids[0]), r->num_sids, (ndr_print_fn_t)ndr_print_lsa_SidPtr);
 999         }
1000         ndr->depth--;
1001         ndr->depth--;
1002 }
1003
1004 NTSTATUS ndr_push_lsa_EnumAccounts(struct ndr_push *ndr, struct lsa_EnumAccounts *r)
1005 {
1006         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
1007         NDR_CHECK(ndr_push_uint32(ndr, *r->in.resume_handle));
1008         NDR_CHECK(ndr_push_uint32(ndr, r->in.num_entries));
1009
1010         return NT_STATUS_OK;
1011 }
1012
1013 NTSTATUS ndr_pull_lsa_EnumAccounts(struct ndr_pull *ndr, struct lsa_EnumAccounts *r)
1014 {
1015         NDR_CHECK(ndr_pull_uint32(ndr, r->out.resume_handle));
1016         NDR_CHECK(ndr_pull_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
1017         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1018
1019         return NT_STATUS_OK;
1020 }
1021
1022 NTSTATUS ndr_push_lsa_CreateTrustDom(struct ndr_push *ndr, struct lsa_CreateTrustDom *r)
1023 {
1024
1025         return NT_STATUS_OK;
1026 }
1027
1028 NTSTATUS ndr_pull_lsa_CreateTrustDom(struct ndr_pull *ndr, struct lsa_CreateTrustDom *r)
1029 {
1030         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1031
1032         return NT_STATUS_OK;
1033 }
1034
1035 static NTSTATUS ndr_pull_lsa_DomainInformation(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainInformation *r)
1036 {
1037         uint32 _ptr_sid;
1038         NDR_CHECK(ndr_pull_align(ndr, 4));
1039         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1040         NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS, &r->name));
1041         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_sid));
1042         if (_ptr_sid) {
1043                 NDR_ALLOC(ndr, r->sid);
1044         } else {
1045                 r->sid = NULL;
1046         }
1047 buffers:
1048         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1049                 NDR_CHECK(ndr_pull_lsa_Name(ndr, ndr_flags, &r->name));
1050         if (r->sid) {
1051                 NDR_CHECK(ndr_pull_dom_sid2(ndr, r->sid));
1052         }
1053 done:
1054         return NT_STATUS_OK;
1055 }
1056
1057 void ndr_print_lsa_DomainInformation(struct ndr_print *ndr, const char *name, struct lsa_DomainInformation *r)
1058 {
1059         ndr_print_struct(ndr, name, "lsa_DomainInformation");
1060         ndr->depth++;
1061         ndr_print_lsa_Name(ndr, "name", &r->name);
1062         ndr_print_ptr(ndr, "sid", r->sid);
1063         ndr->depth++;
1064         if (r->sid) {
1065                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1066         }
1067         ndr->depth--;
1068         ndr->depth--;
1069 }
1070
1071 static NTSTATUS ndr_pull_lsa_DomainList(struct ndr_pull *ndr, int ndr_flags, struct lsa_DomainList *r)
1072 {
1073         uint32 _ptr_domains;
1074         NDR_CHECK(ndr_pull_align(ndr, 4));
1075         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1076         NDR_CHECK(ndr_pull_uint32(ndr, &r->count));
1077         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_domains));
1078         if (_ptr_domains) {
1079                 NDR_ALLOC(ndr, r->domains);
1080         } else {
1081                 r->domains = NULL;
1082         }
1083 buffers:
1084         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1085         if (r->domains) {
1086         {
1087                 uint32 _array_size;
1088                 NDR_CHECK(ndr_pull_uint32(ndr, &_array_size));
1089                 if (r->count > _array_size) {
1090                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should be %u", _array_size, r->count);
1091                 }
1092         }
1093                 NDR_ALLOC_N_SIZE(ndr, r->domains, r->count, sizeof(r->domains[0]));
1094                 NDR_CHECK(ndr_pull_array(ndr, ndr_flags, (void **)r->domains, sizeof(r->domains[0]), r->count, (ndr_pull_flags_fn_t)ndr_pull_lsa_DomainInformation));
1095         }
1096 done:
1097         return NT_STATUS_OK;
1098 }
1099
1100 void ndr_print_lsa_DomainList(struct ndr_print *ndr, const char *name, struct lsa_DomainList *r)
1101 {
1102         ndr_print_struct(ndr, name, "lsa_DomainList");
1103         ndr->depth++;
1104         ndr_print_uint32(ndr, "count", r->count);
1105         ndr_print_ptr(ndr, "domains", r->domains);
1106         ndr->depth++;
1107         if (r->domains) {
1108                 ndr_print_array(ndr, "domains", r->domains, sizeof(r->domains[0]), r->count, (ndr_print_fn_t)ndr_print_lsa_DomainInformation);
1109         }
1110         ndr->depth--;
1111         ndr->depth--;
1112 }
1113
1114 NTSTATUS ndr_push_lsa_EnumTrustDom(struct ndr_push *ndr, struct lsa_EnumTrustDom *r)
1115 {
1116         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
1117         NDR_CHECK(ndr_push_uint32(ndr, *r->in.resume_handle));
1118         NDR_CHECK(ndr_push_uint32(ndr, r->in.num_entries));
1119
1120         return NT_STATUS_OK;
1121 }
1122
1123 NTSTATUS ndr_pull_lsa_EnumTrustDom(struct ndr_pull *ndr, struct lsa_EnumTrustDom *r)
1124 {
1125         NDR_CHECK(ndr_pull_uint32(ndr, r->out.resume_handle));
1126         NDR_CHECK(ndr_pull_lsa_DomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
1127         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1128
1129         return NT_STATUS_OK;
1130 }
1131
1132 static NTSTATUS ndr_push_lsa_TranslatedSid(struct ndr_push *ndr, int ndr_flags, struct lsa_TranslatedSid *r)
1133 {
1134         NDR_CHECK(ndr_push_align(ndr, 4));
1135         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1136         NDR_CHECK(ndr_push_uint16(ndr, r->sid_type));
1137         NDR_CHECK(ndr_push_uint32(ndr, r->rid));
1138         NDR_CHECK(ndr_push_uint32(ndr, r->sid_index));
1139 buffers:
1140         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1141 done:
1142         return NT_STATUS_OK;
1143 }
1144
1145 static NTSTATUS ndr_pull_lsa_TranslatedSid(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedSid *r)
1146 {
1147         NDR_CHECK(ndr_pull_align(ndr, 4));
1148         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1149         NDR_CHECK(ndr_pull_uint16(ndr, &r->sid_type));
1150         NDR_CHECK(ndr_pull_uint32(ndr, &r->rid));
1151         NDR_CHECK(ndr_pull_uint32(ndr, &r->sid_index));
1152 buffers:
1153         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1154 done:
1155         return NT_STATUS_OK;
1156 }
1157
1158 void ndr_print_lsa_TranslatedSid(struct ndr_print *ndr, const char *name, struct lsa_TranslatedSid *r)
1159 {
1160         ndr_print_struct(ndr, name, "lsa_TranslatedSid");
1161         ndr->depth++;
1162         ndr_print_uint16(ndr, "sid_type", r->sid_type);
1163         ndr_print_uint32(ndr, "rid", r->rid);
1164         ndr_print_uint32(ndr, "sid_index", r->sid_index);
1165         ndr->depth--;
1166 }
1167
1168 static NTSTATUS ndr_push_lsa_TransSidArray(struct ndr_push *ndr, int ndr_flags, struct lsa_TransSidArray *r)
1169 {
1170         NDR_CHECK(ndr_push_align(ndr, 4));
1171         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1172         NDR_CHECK(ndr_push_uint32(ndr, r->count));
1173         NDR_CHECK(ndr_push_ptr(ndr, r->sids));
1174 buffers:
1175         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1176         if (r->sids) {
1177                 NDR_CHECK(ndr_push_uint32(ndr, r->count));
1178                 NDR_CHECK(ndr_push_array(ndr, ndr_flags, r->sids, sizeof(r->sids[0]), r->count, (ndr_push_flags_fn_t)ndr_push_lsa_TranslatedSid));
1179         }
1180 done:
1181         return NT_STATUS_OK;
1182 }
1183
1184 static NTSTATUS ndr_pull_lsa_TransSidArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransSidArray *r)
1185 {
1186         uint32 _ptr_sids;
1187         NDR_CHECK(ndr_pull_align(ndr, 4));
1188         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1189         NDR_CHECK(ndr_pull_uint32(ndr, &r->count));
1190         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_sids));
1191         if (_ptr_sids) {
1192                 NDR_ALLOC(ndr, r->sids);
1193         } else {
1194                 r->sids = NULL;
1195         }
1196 buffers:
1197         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1198         if (r->sids) {
1199         {
1200                 uint32 _array_size;
1201                 NDR_CHECK(ndr_pull_uint32(ndr, &_array_size));
1202                 if (r->count > _array_size) {
1203                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should be %u", _array_size, r->count);
1204                 }
1205         }
1206                 NDR_ALLOC_N_SIZE(ndr, r->sids, r->count, sizeof(r->sids[0]));
1207                 NDR_CHECK(ndr_pull_array(ndr, ndr_flags, (void **)r->sids, sizeof(r->sids[0]), r->count, (ndr_pull_flags_fn_t)ndr_pull_lsa_TranslatedSid));
1208         }
1209 done:
1210         return NT_STATUS_OK;
1211 }
1212
1213 void ndr_print_lsa_TransSidArray(struct ndr_print *ndr, const char *name, struct lsa_TransSidArray *r)
1214 {
1215         ndr_print_struct(ndr, name, "lsa_TransSidArray");
1216         ndr->depth++;
1217         ndr_print_uint32(ndr, "count", r->count);
1218         ndr_print_ptr(ndr, "sids", r->sids);
1219         ndr->depth++;
1220         if (r->sids) {
1221                 ndr_print_array(ndr, "sids", r->sids, sizeof(r->sids[0]), r->count, (ndr_print_fn_t)ndr_print_lsa_TranslatedSid);
1222         }
1223         ndr->depth--;
1224         ndr->depth--;
1225 }
1226
1227 static NTSTATUS ndr_pull_lsa_TrustInformation(struct ndr_pull *ndr, int ndr_flags, struct lsa_TrustInformation *r)
1228 {
1229         uint32 _ptr_sid;
1230         NDR_CHECK(ndr_pull_align(ndr, 4));
1231         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1232         NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS, &r->name));
1233         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_sid));
1234         if (_ptr_sid) {
1235                 NDR_ALLOC(ndr, r->sid);
1236         } else {
1237                 r->sid = NULL;
1238         }
1239 buffers:
1240         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1241                 NDR_CHECK(ndr_pull_lsa_Name(ndr, ndr_flags, &r->name));
1242         if (r->sid) {
1243                 NDR_CHECK(ndr_pull_dom_sid2(ndr, r->sid));
1244         }
1245 done:
1246         return NT_STATUS_OK;
1247 }
1248
1249 void ndr_print_lsa_TrustInformation(struct ndr_print *ndr, const char *name, struct lsa_TrustInformation *r)
1250 {
1251         ndr_print_struct(ndr, name, "lsa_TrustInformation");
1252         ndr->depth++;
1253         ndr_print_lsa_Name(ndr, "name", &r->name);
1254         ndr_print_ptr(ndr, "sid", r->sid);
1255         ndr->depth++;
1256         if (r->sid) {
1257                 ndr_print_dom_sid2(ndr, "sid", r->sid);
1258         }
1259         ndr->depth--;
1260         ndr->depth--;
1261 }
1262
1263 static NTSTATUS ndr_pull_lsa_RefDomainList(struct ndr_pull *ndr, int ndr_flags, struct lsa_RefDomainList *r)
1264 {
1265         uint32 _ptr_domains;
1266         NDR_CHECK(ndr_pull_align(ndr, 4));
1267         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1268         NDR_CHECK(ndr_pull_uint32(ndr, &r->count));
1269         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_domains));
1270         if (_ptr_domains) {
1271                 NDR_ALLOC(ndr, r->domains);
1272         } else {
1273                 r->domains = NULL;
1274         }
1275         NDR_CHECK(ndr_pull_uint32(ndr, &r->max_count));
1276 buffers:
1277         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1278         if (r->domains) {
1279         {
1280                 uint32 _array_size;
1281                 NDR_CHECK(ndr_pull_uint32(ndr, &_array_size));
1282                 if (r->count > _array_size) {
1283                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should be %u", _array_size, r->count);
1284                 }
1285         }
1286                 NDR_ALLOC_N_SIZE(ndr, r->domains, r->count, sizeof(r->domains[0]));
1287                 NDR_CHECK(ndr_pull_array(ndr, ndr_flags, (void **)r->domains, sizeof(r->domains[0]), r->count, (ndr_pull_flags_fn_t)ndr_pull_lsa_TrustInformation));
1288         }
1289 done:
1290         return NT_STATUS_OK;
1291 }
1292
1293 void ndr_print_lsa_RefDomainList(struct ndr_print *ndr, const char *name, struct lsa_RefDomainList *r)
1294 {
1295         ndr_print_struct(ndr, name, "lsa_RefDomainList");
1296         ndr->depth++;
1297         ndr_print_uint32(ndr, "count", r->count);
1298         ndr_print_ptr(ndr, "domains", r->domains);
1299         ndr->depth++;
1300         if (r->domains) {
1301                 ndr_print_array(ndr, "domains", r->domains, sizeof(r->domains[0]), r->count, (ndr_print_fn_t)ndr_print_lsa_TrustInformation);
1302         }
1303         ndr->depth--;
1304         ndr_print_uint32(ndr, "max_count", r->max_count);
1305         ndr->depth--;
1306 }
1307
1308 NTSTATUS ndr_push_lsa_LookupNames(struct ndr_push *ndr, struct lsa_LookupNames *r)
1309 {
1310         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
1311         NDR_CHECK(ndr_push_uint32(ndr, r->in.num_names));
1312         if (r->in.names) {
1313                 int ndr_flags = NDR_SCALARS|NDR_BUFFERS;
1314                 NDR_CHECK(ndr_push_uint32(ndr, r->in.num_names));
1315                 NDR_CHECK(ndr_push_array(ndr, ndr_flags, r->in.names, sizeof(r->in.names[0]), r->in.num_names, (ndr_push_flags_fn_t)ndr_push_lsa_Name));
1316         }
1317         NDR_CHECK(ndr_push_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
1318         NDR_CHECK(ndr_push_uint16(ndr, r->in.level));
1319         NDR_CHECK(ndr_push_uint32(ndr, *r->in.count));
1320
1321         return NT_STATUS_OK;
1322 }
1323
1324 NTSTATUS ndr_pull_lsa_LookupNames(struct ndr_pull *ndr, struct lsa_LookupNames *r)
1325 {
1326         uint32 _ptr_domains;
1327         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_domains));
1328         if (_ptr_domains) {
1329                 NDR_ALLOC(ndr, r->out.domains);
1330         } else {
1331                 r->out.domains = NULL;
1332         }
1333         if (r->out.domains) {
1334                 NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
1335         }
1336         NDR_CHECK(ndr_pull_lsa_TransSidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sids));
1337         NDR_CHECK(ndr_pull_uint32(ndr, r->out.count));
1338         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1339
1340         return NT_STATUS_OK;
1341 }
1342
1343 static NTSTATUS ndr_push_lsa_TranslatedName(struct ndr_push *ndr, int ndr_flags, struct lsa_TranslatedName *r)
1344 {
1345         NDR_CHECK(ndr_push_align(ndr, 4));
1346         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1347         NDR_CHECK(ndr_push_uint16(ndr, r->sid_type));
1348         NDR_CHECK(ndr_push_lsa_Name(ndr, NDR_SCALARS, &r->name));
1349         NDR_CHECK(ndr_push_uint32(ndr, r->sid_index));
1350 buffers:
1351         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1352                 NDR_CHECK(ndr_push_lsa_Name(ndr, ndr_flags, &r->name));
1353 done:
1354         return NT_STATUS_OK;
1355 }
1356
1357 static NTSTATUS ndr_pull_lsa_TranslatedName(struct ndr_pull *ndr, int ndr_flags, struct lsa_TranslatedName *r)
1358 {
1359         NDR_CHECK(ndr_pull_align(ndr, 4));
1360         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1361         NDR_CHECK(ndr_pull_uint16(ndr, &r->sid_type));
1362         NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS, &r->name));
1363         NDR_CHECK(ndr_pull_uint32(ndr, &r->sid_index));
1364 buffers:
1365         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1366                 NDR_CHECK(ndr_pull_lsa_Name(ndr, ndr_flags, &r->name));
1367 done:
1368         return NT_STATUS_OK;
1369 }
1370
1371 void ndr_print_lsa_TranslatedName(struct ndr_print *ndr, const char *name, struct lsa_TranslatedName *r)
1372 {
1373         ndr_print_struct(ndr, name, "lsa_TranslatedName");
1374         ndr->depth++;
1375         ndr_print_uint16(ndr, "sid_type", r->sid_type);
1376         ndr_print_lsa_Name(ndr, "name", &r->name);
1377         ndr_print_uint32(ndr, "sid_index", r->sid_index);
1378         ndr->depth--;
1379 }
1380
1381 static NTSTATUS ndr_push_lsa_TransNameArray(struct ndr_push *ndr, int ndr_flags, struct lsa_TransNameArray *r)
1382 {
1383         NDR_CHECK(ndr_push_align(ndr, 4));
1384         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1385         NDR_CHECK(ndr_push_uint32(ndr, r->count));
1386         NDR_CHECK(ndr_push_ptr(ndr, r->names));
1387 buffers:
1388         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1389         if (r->names) {
1390                 NDR_CHECK(ndr_push_uint32(ndr, r->count));
1391                 NDR_CHECK(ndr_push_array(ndr, ndr_flags, r->names, sizeof(r->names[0]), r->count, (ndr_push_flags_fn_t)ndr_push_lsa_TranslatedName));
1392         }
1393 done:
1394         return NT_STATUS_OK;
1395 }
1396
1397 static NTSTATUS ndr_pull_lsa_TransNameArray(struct ndr_pull *ndr, int ndr_flags, struct lsa_TransNameArray *r)
1398 {
1399         uint32 _ptr_names;
1400         NDR_CHECK(ndr_pull_align(ndr, 4));
1401         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1402         NDR_CHECK(ndr_pull_uint32(ndr, &r->count));
1403         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_names));
1404         if (_ptr_names) {
1405                 NDR_ALLOC(ndr, r->names);
1406         } else {
1407                 r->names = NULL;
1408         }
1409 buffers:
1410         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1411         if (r->names) {
1412         {
1413                 uint32 _array_size;
1414                 NDR_CHECK(ndr_pull_uint32(ndr, &_array_size));
1415                 if (r->count > _array_size) {
1416                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should be %u", _array_size, r->count);
1417                 }
1418         }
1419                 NDR_ALLOC_N_SIZE(ndr, r->names, r->count, sizeof(r->names[0]));
1420                 NDR_CHECK(ndr_pull_array(ndr, ndr_flags, (void **)r->names, sizeof(r->names[0]), r->count, (ndr_pull_flags_fn_t)ndr_pull_lsa_TranslatedName));
1421         }
1422 done:
1423         return NT_STATUS_OK;
1424 }
1425
1426 void ndr_print_lsa_TransNameArray(struct ndr_print *ndr, const char *name, struct lsa_TransNameArray *r)
1427 {
1428         ndr_print_struct(ndr, name, "lsa_TransNameArray");
1429         ndr->depth++;
1430         ndr_print_uint32(ndr, "count", r->count);
1431         ndr_print_ptr(ndr, "names", r->names);
1432         ndr->depth++;
1433         if (r->names) {
1434                 ndr_print_array(ndr, "names", r->names, sizeof(r->names[0]), r->count, (ndr_print_fn_t)ndr_print_lsa_TranslatedName);
1435         }
1436         ndr->depth--;
1437         ndr->depth--;
1438 }
1439
1440 NTSTATUS ndr_push_lsa_LookupSids(struct ndr_push *ndr, struct lsa_LookupSids *r)
1441 {
1442         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
1443         NDR_CHECK(ndr_push_lsa_SidArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
1444         NDR_CHECK(ndr_push_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.names));
1445         NDR_CHECK(ndr_push_uint16(ndr, r->in.level));
1446         NDR_CHECK(ndr_push_uint32(ndr, *r->in.count));
1447
1448         return NT_STATUS_OK;
1449 }
1450
1451 NTSTATUS ndr_pull_lsa_LookupSids(struct ndr_pull *ndr, struct lsa_LookupSids *r)
1452 {
1453         uint32 _ptr_domains;
1454         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_domains));
1455         if (_ptr_domains) {
1456                 NDR_ALLOC(ndr, r->out.domains);
1457         } else {
1458                 r->out.domains = NULL;
1459         }
1460         if (r->out.domains) {
1461                 NDR_CHECK(ndr_pull_lsa_RefDomainList(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.domains));
1462         }
1463         NDR_CHECK(ndr_pull_lsa_TransNameArray(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.names));
1464         NDR_CHECK(ndr_pull_uint32(ndr, r->out.count));
1465         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1466
1467         return NT_STATUS_OK;
1468 }
1469
1470 NTSTATUS ndr_push_CREATESECRET(struct ndr_push *ndr, struct CREATESECRET *r)
1471 {
1472
1473         return NT_STATUS_OK;
1474 }
1475
1476 NTSTATUS ndr_pull_CREATESECRET(struct ndr_pull *ndr, struct CREATESECRET *r)
1477 {
1478         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1479
1480         return NT_STATUS_OK;
1481 }
1482
1483 NTSTATUS ndr_push_lsa_OpenAccount(struct ndr_push *ndr, struct lsa_OpenAccount *r)
1484 {
1485         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
1486         NDR_CHECK(ndr_push_dom_sid2(ndr, r->in.sid));
1487         NDR_CHECK(ndr_push_uint32(ndr, r->in.desired_access));
1488
1489         return NT_STATUS_OK;
1490 }
1491
1492 NTSTATUS ndr_pull_lsa_OpenAccount(struct ndr_pull *ndr, struct lsa_OpenAccount *r)
1493 {
1494         NDR_CHECK(ndr_pull_policy_handle(ndr, r->out.acct_handle));
1495         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1496
1497         return NT_STATUS_OK;
1498 }
1499
1500 static NTSTATUS ndr_pull_lsa_LUID(struct ndr_pull *ndr, int ndr_flags, struct lsa_LUID *r)
1501 {
1502         NDR_CHECK(ndr_pull_align(ndr, 4));
1503         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1504         NDR_CHECK(ndr_pull_uint32(ndr, &r->low));
1505         NDR_CHECK(ndr_pull_uint32(ndr, &r->high));
1506 buffers:
1507         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1508 done:
1509         return NT_STATUS_OK;
1510 }
1511
1512 void ndr_print_lsa_LUID(struct ndr_print *ndr, const char *name, struct lsa_LUID *r)
1513 {
1514         ndr_print_struct(ndr, name, "lsa_LUID");
1515         ndr->depth++;
1516         ndr_print_uint32(ndr, "low", r->low);
1517         ndr_print_uint32(ndr, "high", r->high);
1518         ndr->depth--;
1519 }
1520
1521 static NTSTATUS ndr_pull_lsa_LUIDAttribute(struct ndr_pull *ndr, int ndr_flags, struct lsa_LUIDAttribute *r)
1522 {
1523         NDR_CHECK(ndr_pull_align(ndr, 4));
1524         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1525         NDR_CHECK(ndr_pull_lsa_LUID(ndr, NDR_SCALARS, &r->luid));
1526         NDR_CHECK(ndr_pull_uint32(ndr, &r->attribute));
1527 buffers:
1528         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1529                 NDR_CHECK(ndr_pull_lsa_LUID(ndr, ndr_flags, &r->luid));
1530 done:
1531         return NT_STATUS_OK;
1532 }
1533
1534 void ndr_print_lsa_LUIDAttribute(struct ndr_print *ndr, const char *name, struct lsa_LUIDAttribute *r)
1535 {
1536         ndr_print_struct(ndr, name, "lsa_LUIDAttribute");
1537         ndr->depth++;
1538         ndr_print_lsa_LUID(ndr, "luid", &r->luid);
1539         ndr_print_uint32(ndr, "attribute", r->attribute);
1540         ndr->depth--;
1541 }
1542
1543 static NTSTATUS ndr_pull_lsa_PrivilegeSet(struct ndr_pull *ndr, int ndr_flags, struct lsa_PrivilegeSet *r)
1544 {
1545         uint32 _conformant_size;
1546         NDR_CHECK(ndr_pull_uint32(ndr, &_conformant_size));
1547         NDR_CHECK(ndr_pull_align(ndr, 4));
1548         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1549         NDR_CHECK(ndr_pull_uint32(ndr, &r->count));
1550         NDR_CHECK(ndr_pull_uint32(ndr, &r->unknown));
1551 buffers:
1552         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1553         if (r->count > _conformant_size) {
1554                 return ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, "Bad conformant size %u should be %u", _conformant_size, r->count);
1555         }
1556                 NDR_ALLOC_N_SIZE(ndr, r->set, _conformant_size, sizeof(r->set[0]));
1557                 NDR_CHECK(ndr_pull_array(ndr, ndr_flags, (void **)r->set, sizeof(r->set[0]), r->count, (ndr_pull_flags_fn_t)ndr_pull_lsa_LUIDAttribute));
1558 done:
1559         return NT_STATUS_OK;
1560 }
1561
1562 void ndr_print_lsa_PrivilegeSet(struct ndr_print *ndr, const char *name, struct lsa_PrivilegeSet *r)
1563 {
1564         ndr_print_struct(ndr, name, "lsa_PrivilegeSet");
1565         ndr->depth++;
1566         ndr_print_uint32(ndr, "count", r->count);
1567         ndr_print_uint32(ndr, "unknown", r->unknown);
1568         ndr_print_ptr(ndr, "set", r->set);
1569         ndr->depth++;
1570                 ndr_print_array(ndr, "set", r->set, sizeof(r->set[0]), r->count, (ndr_print_fn_t)ndr_print_lsa_LUIDAttribute);
1571         ndr->depth--;
1572         ndr->depth--;
1573 }
1574
1575 NTSTATUS ndr_push_lsa_EnumPrivsAccount(struct ndr_push *ndr, struct lsa_EnumPrivsAccount *r)
1576 {
1577         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
1578
1579         return NT_STATUS_OK;
1580 }
1581
1582 NTSTATUS ndr_pull_lsa_EnumPrivsAccount(struct ndr_pull *ndr, struct lsa_EnumPrivsAccount *r)
1583 {
1584         uint32 _ptr_privs;
1585         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_privs));
1586         if (_ptr_privs) {
1587                 NDR_ALLOC(ndr, r->out.privs);
1588         } else {
1589                 r->out.privs = NULL;
1590         }
1591         if (r->out.privs) {
1592                 NDR_CHECK(ndr_pull_lsa_PrivilegeSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.privs));
1593         }
1594         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1595
1596         return NT_STATUS_OK;
1597 }
1598
1599 NTSTATUS ndr_push_ADDPRIVS(struct ndr_push *ndr, struct ADDPRIVS *r)
1600 {
1601
1602         return NT_STATUS_OK;
1603 }
1604
1605 NTSTATUS ndr_pull_ADDPRIVS(struct ndr_pull *ndr, struct ADDPRIVS *r)
1606 {
1607         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1608
1609         return NT_STATUS_OK;
1610 }
1611
1612 NTSTATUS ndr_push_REMOVEPRIVS(struct ndr_push *ndr, struct REMOVEPRIVS *r)
1613 {
1614
1615         return NT_STATUS_OK;
1616 }
1617
1618 NTSTATUS ndr_pull_REMOVEPRIVS(struct ndr_pull *ndr, struct REMOVEPRIVS *r)
1619 {
1620         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1621
1622         return NT_STATUS_OK;
1623 }
1624
1625 NTSTATUS ndr_push_GETQUOTAS(struct ndr_push *ndr, struct GETQUOTAS *r)
1626 {
1627
1628         return NT_STATUS_OK;
1629 }
1630
1631 NTSTATUS ndr_pull_GETQUOTAS(struct ndr_pull *ndr, struct GETQUOTAS *r)
1632 {
1633         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1634
1635         return NT_STATUS_OK;
1636 }
1637
1638 NTSTATUS ndr_push_SETQUOTAS(struct ndr_push *ndr, struct SETQUOTAS *r)
1639 {
1640
1641         return NT_STATUS_OK;
1642 }
1643
1644 NTSTATUS ndr_pull_SETQUOTAS(struct ndr_pull *ndr, struct SETQUOTAS *r)
1645 {
1646         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1647
1648         return NT_STATUS_OK;
1649 }
1650
1651 NTSTATUS ndr_push_GETSYSTEMACCOUNT(struct ndr_push *ndr, struct GETSYSTEMACCOUNT *r)
1652 {
1653
1654         return NT_STATUS_OK;
1655 }
1656
1657 NTSTATUS ndr_pull_GETSYSTEMACCOUNT(struct ndr_pull *ndr, struct GETSYSTEMACCOUNT *r)
1658 {
1659         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1660
1661         return NT_STATUS_OK;
1662 }
1663
1664 NTSTATUS ndr_push_SETSYSTEMACCOUNT(struct ndr_push *ndr, struct SETSYSTEMACCOUNT *r)
1665 {
1666
1667         return NT_STATUS_OK;
1668 }
1669
1670 NTSTATUS ndr_pull_SETSYSTEMACCOUNT(struct ndr_pull *ndr, struct SETSYSTEMACCOUNT *r)
1671 {
1672         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1673
1674         return NT_STATUS_OK;
1675 }
1676
1677 NTSTATUS ndr_push_OPENTRUSTDOM(struct ndr_push *ndr, struct OPENTRUSTDOM *r)
1678 {
1679
1680         return NT_STATUS_OK;
1681 }
1682
1683 NTSTATUS ndr_pull_OPENTRUSTDOM(struct ndr_pull *ndr, struct OPENTRUSTDOM *r)
1684 {
1685         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1686
1687         return NT_STATUS_OK;
1688 }
1689
1690 NTSTATUS ndr_push_QUERYTRUSTDOM(struct ndr_push *ndr, struct QUERYTRUSTDOM *r)
1691 {
1692
1693         return NT_STATUS_OK;
1694 }
1695
1696 NTSTATUS ndr_pull_QUERYTRUSTDOM(struct ndr_pull *ndr, struct QUERYTRUSTDOM *r)
1697 {
1698         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1699
1700         return NT_STATUS_OK;
1701 }
1702
1703 NTSTATUS ndr_push_SETINFOTRUSTDOM(struct ndr_push *ndr, struct SETINFOTRUSTDOM *r)
1704 {
1705
1706         return NT_STATUS_OK;
1707 }
1708
1709 NTSTATUS ndr_pull_SETINFOTRUSTDOM(struct ndr_pull *ndr, struct SETINFOTRUSTDOM *r)
1710 {
1711         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1712
1713         return NT_STATUS_OK;
1714 }
1715
1716 NTSTATUS ndr_push_OPENSECRET(struct ndr_push *ndr, struct OPENSECRET *r)
1717 {
1718
1719         return NT_STATUS_OK;
1720 }
1721
1722 NTSTATUS ndr_pull_OPENSECRET(struct ndr_pull *ndr, struct OPENSECRET *r)
1723 {
1724         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1725
1726         return NT_STATUS_OK;
1727 }
1728
1729 NTSTATUS ndr_push_SETSECRET(struct ndr_push *ndr, struct SETSECRET *r)
1730 {
1731
1732         return NT_STATUS_OK;
1733 }
1734
1735 NTSTATUS ndr_pull_SETSECRET(struct ndr_pull *ndr, struct SETSECRET *r)
1736 {
1737         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1738
1739         return NT_STATUS_OK;
1740 }
1741
1742 NTSTATUS ndr_push_QUERYSECRET(struct ndr_push *ndr, struct QUERYSECRET *r)
1743 {
1744
1745         return NT_STATUS_OK;
1746 }
1747
1748 NTSTATUS ndr_pull_QUERYSECRET(struct ndr_pull *ndr, struct QUERYSECRET *r)
1749 {
1750         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1751
1752         return NT_STATUS_OK;
1753 }
1754
1755 NTSTATUS ndr_push_LOOKUPPRIVVALUE(struct ndr_push *ndr, struct LOOKUPPRIVVALUE *r)
1756 {
1757
1758         return NT_STATUS_OK;
1759 }
1760
1761 NTSTATUS ndr_pull_LOOKUPPRIVVALUE(struct ndr_pull *ndr, struct LOOKUPPRIVVALUE *r)
1762 {
1763         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1764
1765         return NT_STATUS_OK;
1766 }
1767
1768 NTSTATUS ndr_push_lsa_LookupPrivName(struct ndr_push *ndr, struct lsa_LookupPrivName *r)
1769 {
1770         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
1771         NDR_CHECK(ndr_push_uint32(ndr, r->in.luid_high));
1772         NDR_CHECK(ndr_push_uint32(ndr, r->in.luid_low));
1773
1774         return NT_STATUS_OK;
1775 }
1776
1777 NTSTATUS ndr_pull_lsa_LookupPrivName(struct ndr_pull *ndr, struct lsa_LookupPrivName *r)
1778 {
1779         uint32 _ptr_name;
1780         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_name));
1781         if (_ptr_name) {
1782                 NDR_ALLOC(ndr, r->out.name);
1783         } else {
1784                 r->out.name = NULL;
1785         }
1786         if (r->out.name) {
1787                 NDR_CHECK(ndr_pull_lsa_Name(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1788         }
1789         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1790
1791         return NT_STATUS_OK;
1792 }
1793
1794 NTSTATUS ndr_push_PRIV_GET_DISPNAME(struct ndr_push *ndr, struct PRIV_GET_DISPNAME *r)
1795 {
1796
1797         return NT_STATUS_OK;
1798 }
1799
1800 NTSTATUS ndr_pull_PRIV_GET_DISPNAME(struct ndr_pull *ndr, struct PRIV_GET_DISPNAME *r)
1801 {
1802         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1803
1804         return NT_STATUS_OK;
1805 }
1806
1807 NTSTATUS ndr_push_DELETEOBJECT(struct ndr_push *ndr, struct DELETEOBJECT *r)
1808 {
1809
1810         return NT_STATUS_OK;
1811 }
1812
1813 NTSTATUS ndr_pull_DELETEOBJECT(struct ndr_pull *ndr, struct DELETEOBJECT *r)
1814 {
1815         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1816
1817         return NT_STATUS_OK;
1818 }
1819
1820 NTSTATUS ndr_push_ENUMACCTWITHRIGHT(struct ndr_push *ndr, struct ENUMACCTWITHRIGHT *r)
1821 {
1822
1823         return NT_STATUS_OK;
1824 }
1825
1826 NTSTATUS ndr_pull_ENUMACCTWITHRIGHT(struct ndr_pull *ndr, struct ENUMACCTWITHRIGHT *r)
1827 {
1828         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1829
1830         return NT_STATUS_OK;
1831 }
1832
1833 void ndr_print_lsa_RightAttribute(struct ndr_print *ndr, const char *name, struct lsa_RightAttribute *r)
1834 {
1835         ndr_print_struct(ndr, name, "lsa_RightAttribute");
1836         ndr->depth++;
1837         ndr_print_ptr(ndr, "name", r->name);
1838         ndr->depth++;
1839         if (r->name) {
1840                 ndr_print_unistr(ndr, "name", r->name);
1841         }
1842         ndr->depth--;
1843         ndr->depth--;
1844 }
1845
1846 static NTSTATUS ndr_pull_lsa_RightSet(struct ndr_pull *ndr, int ndr_flags, struct lsa_RightSet *r)
1847 {
1848         uint32 _ptr_names;
1849         NDR_CHECK(ndr_pull_align(ndr, 4));
1850         if (!(ndr_flags & NDR_SCALARS)) goto buffers;
1851         NDR_CHECK(ndr_pull_uint32(ndr, &r->count));
1852         NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_names));
1853         if (_ptr_names) {
1854                 NDR_ALLOC(ndr, r->names);
1855         } else {
1856                 r->names = NULL;
1857         }
1858 buffers:
1859         if (!(ndr_flags & NDR_BUFFERS)) goto done;
1860         if (r->names) {
1861         {
1862                 uint32 _array_size;
1863                 NDR_CHECK(ndr_pull_uint32(ndr, &_array_size));
1864                 if (r->count > _array_size) {
1865                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should be %u", _array_size, r->count);
1866                 }
1867         }
1868                 NDR_ALLOC_N_SIZE(ndr, r->names, r->count, sizeof(r->names[0]));
1869                 NDR_CHECK(ndr_pull_array(ndr, ndr_flags, (void **)r->names, sizeof(r->names[0]), r->count, (ndr_pull_flags_fn_t)ndr_pull_lsa_Name));
1870         }
1871 done:
1872         return NT_STATUS_OK;
1873 }
1874
1875 void ndr_print_lsa_RightSet(struct ndr_print *ndr, const char *name, struct lsa_RightSet *r)
1876 {
1877         ndr_print_struct(ndr, name, "lsa_RightSet");
1878         ndr->depth++;
1879         ndr_print_uint32(ndr, "count", r->count);
1880         ndr_print_ptr(ndr, "names", r->names);
1881         ndr->depth++;
1882         if (r->names) {
1883                 ndr_print_array(ndr, "names", r->names, sizeof(r->names[0]), r->count, (ndr_print_fn_t)ndr_print_lsa_Name);
1884         }
1885         ndr->depth--;
1886         ndr->depth--;
1887 }
1888
1889 NTSTATUS ndr_push_lsa_EnumAccountRights(struct ndr_push *ndr, struct lsa_EnumAccountRights *r)
1890 {
1891         NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
1892         NDR_CHECK(ndr_push_dom_sid2(ndr, r->in.sid));
1893
1894         return NT_STATUS_OK;
1895 }
1896
1897 NTSTATUS ndr_pull_lsa_EnumAccountRights(struct ndr_pull *ndr, struct lsa_EnumAccountRights *r)
1898 {
1899         NDR_CHECK(ndr_pull_lsa_RightSet(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rights));
1900         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1901
1902         return NT_STATUS_OK;
1903 }
1904
1905 NTSTATUS ndr_push_ADDACCTRIGHTS(struct ndr_push *ndr, struct ADDACCTRIGHTS *r)
1906 {
1907
1908         return NT_STATUS_OK;
1909 }
1910
1911 NTSTATUS ndr_pull_ADDACCTRIGHTS(struct ndr_pull *ndr, struct ADDACCTRIGHTS *r)
1912 {
1913         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1914
1915         return NT_STATUS_OK;
1916 }
1917
1918 NTSTATUS ndr_push_REMOVEACCTRIGHTS(struct ndr_push *ndr, struct REMOVEACCTRIGHTS *r)
1919 {
1920
1921         return NT_STATUS_OK;
1922 }
1923
1924 NTSTATUS ndr_pull_REMOVEACCTRIGHTS(struct ndr_pull *ndr, struct REMOVEACCTRIGHTS *r)
1925 {
1926         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1927
1928         return NT_STATUS_OK;
1929 }
1930
1931 NTSTATUS ndr_push_QUERYTRUSTDOMINFO(struct ndr_push *ndr, struct QUERYTRUSTDOMINFO *r)
1932 {
1933
1934         return NT_STATUS_OK;
1935 }
1936
1937 NTSTATUS ndr_pull_QUERYTRUSTDOMINFO(struct ndr_pull *ndr, struct QUERYTRUSTDOMINFO *r)
1938 {
1939         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1940
1941         return NT_STATUS_OK;
1942 }
1943
1944 NTSTATUS ndr_push_SETTRUSTDOMINFO(struct ndr_push *ndr, struct SETTRUSTDOMINFO *r)
1945 {
1946
1947         return NT_STATUS_OK;
1948 }
1949
1950 NTSTATUS ndr_pull_SETTRUSTDOMINFO(struct ndr_pull *ndr, struct SETTRUSTDOMINFO *r)
1951 {
1952         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1953
1954         return NT_STATUS_OK;
1955 }
1956
1957 NTSTATUS ndr_push_DELETETRUSTDOM(struct ndr_push *ndr, struct DELETETRUSTDOM *r)
1958 {
1959
1960         return NT_STATUS_OK;
1961 }
1962
1963 NTSTATUS ndr_pull_DELETETRUSTDOM(struct ndr_pull *ndr, struct DELETETRUSTDOM *r)
1964 {
1965         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1966
1967         return NT_STATUS_OK;
1968 }
1969
1970 NTSTATUS ndr_push_STOREPRIVDATA(struct ndr_push *ndr, struct STOREPRIVDATA *r)
1971 {
1972
1973         return NT_STATUS_OK;
1974 }
1975
1976 NTSTATUS ndr_pull_STOREPRIVDATA(struct ndr_pull *ndr, struct STOREPRIVDATA *r)
1977 {
1978         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1979
1980         return NT_STATUS_OK;
1981 }
1982
1983 NTSTATUS ndr_push_RETRPRIVDATA(struct ndr_push *ndr, struct RETRPRIVDATA *r)
1984 {
1985
1986         return NT_STATUS_OK;
1987 }
1988
1989 NTSTATUS ndr_pull_RETRPRIVDATA(struct ndr_pull *ndr, struct RETRPRIVDATA *r)
1990 {
1991         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
1992
1993         return NT_STATUS_OK;
1994 }
1995
1996 NTSTATUS ndr_push_lsa_OpenPolicy2(struct ndr_push *ndr, struct lsa_OpenPolicy2 *r)
1997 {
1998         NDR_CHECK(ndr_push_ptr(ndr, r->in.system_name));
1999         if (r->in.system_name) {
2000                 NDR_CHECK(ndr_push_unistr(ndr, r->in.system_name));
2001         }
2002         NDR_CHECK(ndr_push_lsa_ObjectAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.attr));
2003         NDR_CHECK(ndr_push_uint32(ndr, r->in.desired_access));
2004
2005         return NT_STATUS_OK;
2006 }
2007
2008 NTSTATUS ndr_pull_lsa_OpenPolicy2(struct ndr_pull *ndr, struct lsa_OpenPolicy2 *r)
2009 {
2010         NDR_CHECK(ndr_pull_policy_handle(ndr, r->out.handle));
2011         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
2012
2013         return NT_STATUS_OK;
2014 }
2015
2016 NTSTATUS ndr_push_UNK_GET_CONNUSER(struct ndr_push *ndr, struct UNK_GET_CONNUSER *r)
2017 {
2018
2019         return NT_STATUS_OK;
2020 }
2021
2022 NTSTATUS ndr_pull_UNK_GET_CONNUSER(struct ndr_pull *ndr, struct UNK_GET_CONNUSER *r)
2023 {
2024         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
2025
2026         return NT_STATUS_OK;
2027 }
2028
2029 NTSTATUS ndr_push_QUERYINFO2(struct ndr_push *ndr, struct QUERYINFO2 *r)
2030 {
2031
2032         return NT_STATUS_OK;
2033 }
2034
2035 NTSTATUS ndr_pull_QUERYINFO2(struct ndr_pull *ndr, struct QUERYINFO2 *r)
2036 {
2037         NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
2038
2039         return NT_STATUS_OK;
2040 }
2041