← Back to branch summary

~ubuntu-branches/ubuntu/maverick/samba/maverick-security

« back to all changes in this revision

Viewing changes to source/librpc/gen_ndr/ndr_lsa.c

  • Committer: Bazaar Package Importer
  • Author(s): Steve Langasek
  • Date: 2009-03-03 22:02:23 UTC
  • mfrom: (0.28.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090303220223-3bdlm2d9fwx1p1ye
Tags: 2:3.3.1-1ubuntu1
https://launchpad.net/bugs/337094
* Merge from Debian unstable (LP: #337094), remaining changes:
  + debian/patches/VERSION.patch:
    - setup SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access. 
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/mksambapasswd.awk:
    - Do not add user with UID less than 1000 to smbpasswd.
  + debian/control:
    - Make libwbclient0 replace/conflict with hardy's likewise-open.
    - Don't build against ctdb.
  + debian/rules:
    - enable "native" PIE hardening.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
* Dropped changes, merged in Debian:
  + debian/libpam-smbpass.pam-config, debian/libpam-smbpass.postinst,
    debian/libpam-smbpass.prerm, debian/libpam-smbpass.files,
    debian/rules:
    - Make libpam-smbpasswd depend on libpam-runtime to allow 
      libpam-smbpasswd for auto-configuration.
  + debian/control:
    - Provide a config block for the new PAM framework to auto-configure
      itself
  + debian/samba.postinst:
    - When populating the new sambashare group, it is not an error
      if the user simply does not exist; test for this case and let
      the install continue instead of aborting.
  + debian/winbind.files:
    - include additional files

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/librpc/gen_ndr/ndr_lsa.c
1305
1305
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1306
1306
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain));
1307
1307
                NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_forest));
1308
 
                NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->domain_guid));
1309
1308
                if (r->sid) {
1310
1309
                        NDR_CHECK(ndr_push_dom_sid2(ndr, NDR_SCALARS|NDR_BUFFERS, r->sid));
1311
1310
                }
1334
1333
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->name));
1335
1334
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_domain));
1336
1335
                NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_BUFFERS, &r->dns_forest));
1337
 
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->domain_guid));
1338
1336
                if (r->sid) {
1339
1337
                        _mem_save_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1340
1338
                        NDR_PULL_SET_MEM_CTX(ndr, r->sid, 0);
4645
4643
                if (r->in.handle == NULL) {
4646
4644
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4647
4645
                }
4648
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
4646
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4649
4647
        }
4650
4648
        if (flags & NDR_OUT) {
4651
4649
                if (r->out.handle == NULL) {
4652
4650
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4653
4651
                }
4654
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 
4652
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4655
4653
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4656
4654
        }
4657
4655
        return NDR_ERR_SUCCESS;
4668
4666
                }
4669
4667
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4670
4668
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4671
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
4669
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4672
4670
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4673
4671
                NDR_PULL_ALLOC(ndr, r->out.handle);
4674
4672
                *r->out.handle = *r->in.handle;
4679
4677
                }
4680
4678
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4681
4679
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
4682
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 
4680
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4683
4681
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4684
4682
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
4685
4683
        }
4721
4719
                if (r->in.handle == NULL) {
4722
4720
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4723
4721
                }
4724
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
4722
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4725
4723
        }
4726
4724
        if (flags & NDR_OUT) {
4727
4725
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
4738
4736
                }
4739
4737
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4740
4738
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4741
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
4739
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4742
4740
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4743
4741
        }
4744
4742
        if (flags & NDR_OUT) {
4778
4776
                if (r->in.handle == NULL) {
4779
4777
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4780
4778
                }
4781
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
4779
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4782
4780
                if (r->in.resume_handle == NULL) {
4783
4781
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4784
4782
                }
4812
4810
                }
4813
4811
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4814
4812
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4815
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
4813
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4816
4814
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4817
4815
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4818
4816
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
4891
4889
                if (r->in.handle == NULL) {
4892
4890
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4893
4891
                }
4894
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
4892
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4895
4893
                NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
4896
4894
        }
4897
4895
        if (flags & NDR_OUT) {
4921
4919
                }
4922
4920
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4923
4921
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4924
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
4922
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4925
4923
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4926
4924
                NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
4927
4925
                NDR_PULL_ALLOC(ndr, r->out.sdbuf);
4992
4990
                if (r->in.handle == NULL) {
4993
4991
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4994
4992
                }
4995
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
4993
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4996
4994
                NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
4997
4995
                if (r->in.sdbuf == NULL) {
4998
4996
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5015
5013
                }
5016
5014
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5017
5015
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5018
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5016
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5019
5017
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5020
5018
                NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
5021
5019
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5120
5118
                if (r->out.handle == NULL) {
5121
5119
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5122
5120
                }
5123
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 
5121
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5124
5122
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5125
5123
        }
5126
5124
        return NDR_ERR_SUCCESS;
5164
5162
                }
5165
5163
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5166
5164
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5167
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 
5165
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5168
5166
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5169
5167
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5170
5168
        }
5213
5211
                if (r->in.handle == NULL) {
5214
5212
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5215
5213
                }
5216
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5214
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5217
5215
                NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
5218
5216
        }
5219
5217
        if (flags & NDR_OUT) {
5244
5242
                }
5245
5243
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5246
5244
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5247
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5245
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5248
5246
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5249
5247
                NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
5250
5248
                NDR_PULL_ALLOC(ndr, r->out.info);
5317
5315
                if (r->in.handle == NULL) {
5318
5316
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5319
5317
                }
5320
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5318
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5321
5319
                NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
5322
5320
                if (r->in.info == NULL) {
5323
5321
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5341
5339
                }
5342
5340
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5343
5341
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5344
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5342
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5345
5343
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5346
5344
                NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
5347
5345
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5437
5435
                if (r->in.handle == NULL) {
5438
5436
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5439
5437
                }
5440
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5438
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5441
5439
                if (r->in.sid == NULL) {
5442
5440
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5443
5441
                }
5448
5446
                if (r->out.acct_handle == NULL) {
5449
5447
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5450
5448
                }
5451
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
 
5449
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.acct_handle));
5452
5450
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5453
5451
        }
5454
5452
        return NDR_ERR_SUCCESS;
5467
5465
                }
5468
5466
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5469
5467
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5470
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5468
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5471
5469
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5472
5470
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5473
5471
                        NDR_PULL_ALLOC(ndr, r->in.sid);
5486
5484
                }
5487
5485
                _mem_save_acct_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5488
5486
                NDR_PULL_SET_MEM_CTX(ndr, r->out.acct_handle, LIBNDR_FLAG_REF_ALLOC);
5489
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
 
5487
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.acct_handle));
5490
5488
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_handle_0, LIBNDR_FLAG_REF_ALLOC);
5491
5489
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5492
5490
        }
5533
5531
                if (r->in.handle == NULL) {
5534
5532
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5535
5533
                }
5536
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5534
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5537
5535
                if (r->in.resume_handle == NULL) {
5538
5536
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5539
5537
                }
5567
5565
                }
5568
5566
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5569
5567
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5570
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5568
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5571
5569
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5572
5570
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5573
5571
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5649
5647
                if (r->in.handle == NULL) {
5650
5648
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5651
5649
                }
5652
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5650
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5653
5651
                if (r->in.info == NULL) {
5654
5652
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5655
5653
                }
5660
5658
                if (r->out.trustdom_handle == NULL) {
5661
5659
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5662
5660
                }
5663
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
 
5661
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
5664
5662
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
5665
5663
        }
5666
5664
        return NDR_ERR_SUCCESS;
5679
5677
                }
5680
5678
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5681
5679
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5682
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5680
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5683
5681
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5684
5682
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5685
5683
                        NDR_PULL_ALLOC(ndr, r->in.info);
5698
5696
                }
5699
5697
                _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5700
5698
                NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
5701
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
 
5699
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
5702
5700
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
5703
5701
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
5704
5702
        }
5745
5743
                if (r->in.handle == NULL) {
5746
5744
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5747
5745
                }
5748
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5746
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5749
5747
                if (r->in.resume_handle == NULL) {
5750
5748
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5751
5749
                }
5779
5777
                }
5780
5778
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5781
5779
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5782
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5780
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5783
5781
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5784
5782
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5785
5783
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5859
5857
                if (r->in.handle == NULL) {
5860
5858
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5861
5859
                }
5862
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5860
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5863
5861
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
5864
5862
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
5865
5863
                for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
5917
5915
                }
5918
5916
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5919
5917
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5920
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
5918
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5921
5919
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5922
5920
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
5923
5921
                if (r->in.num_names < 0 || r->in.num_names > 1000) {
6066
6064
                if (r->in.handle == NULL) {
6067
6065
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6068
6066
                }
6069
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6067
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6070
6068
                if (r->in.sids == NULL) {
6071
6069
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6072
6070
                }
6119
6117
                }
6120
6118
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6121
6119
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6122
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6120
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6123
6121
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6124
6122
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6125
6123
                        NDR_PULL_ALLOC(ndr, r->in.sids);
6249
6247
                if (r->in.handle == NULL) {
6250
6248
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6251
6249
                }
6252
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6250
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6253
6251
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6254
6252
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6255
6253
        }
6257
6255
                if (r->out.sec_handle == NULL) {
6258
6256
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6259
6257
                }
6260
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
 
6258
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.sec_handle));
6261
6259
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6262
6260
        }
6263
6261
        return NDR_ERR_SUCCESS;
6275
6273
                }
6276
6274
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6277
6275
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6278
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6276
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6279
6277
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6280
6278
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
6281
6279
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6288
6286
                }
6289
6287
                _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6290
6288
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sec_handle, LIBNDR_FLAG_REF_ALLOC);
6291
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
 
6289
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.sec_handle));
6292
6290
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
6293
6291
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6294
6292
        }
6332
6330
                if (r->in.handle == NULL) {
6333
6331
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6334
6332
                }
6335
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6333
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6336
6334
                if (r->in.sid == NULL) {
6337
6335
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6338
6336
                }
6343
6341
                if (r->out.acct_handle == NULL) {
6344
6342
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6345
6343
                }
6346
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
 
6344
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.acct_handle));
6347
6345
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6348
6346
        }
6349
6347
        return NDR_ERR_SUCCESS;
6362
6360
                }
6363
6361
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6364
6362
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6365
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6363
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6366
6364
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6367
6365
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6368
6366
                        NDR_PULL_ALLOC(ndr, r->in.sid);
6381
6379
                }
6382
6380
                _mem_save_acct_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6383
6381
                NDR_PULL_SET_MEM_CTX(ndr, r->out.acct_handle, LIBNDR_FLAG_REF_ALLOC);
6384
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.acct_handle));
 
6382
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.acct_handle));
6385
6383
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_acct_handle_0, LIBNDR_FLAG_REF_ALLOC);
6386
6384
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6387
6385
        }
6428
6426
                if (r->in.handle == NULL) {
6429
6427
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6430
6428
                }
6431
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6429
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6432
6430
        }
6433
6431
        if (flags & NDR_OUT) {
6434
6432
                if (r->out.privs == NULL) {
6457
6455
                }
6458
6456
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6459
6457
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6460
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6458
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6461
6459
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6462
6460
                NDR_PULL_ALLOC(ndr, r->out.privs);
6463
6461
                ZERO_STRUCTP(r->out.privs);
6526
6524
                if (r->in.handle == NULL) {
6527
6525
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6528
6526
                }
6529
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6527
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6530
6528
                if (r->in.privs == NULL) {
6531
6529
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6532
6530
                }
6548
6546
                }
6549
6547
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6550
6548
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6551
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6549
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6552
6550
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6553
6551
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6554
6552
                        NDR_PULL_ALLOC(ndr, r->in.privs);
6599
6597
                if (r->in.handle == NULL) {
6600
6598
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6601
6599
                }
6602
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6600
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6603
6601
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.remove_all));
6604
6602
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.privs));
6605
6603
                if (r->in.privs) {
6623
6621
                }
6624
6622
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6625
6623
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6626
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6624
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6627
6625
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6628
6626
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.remove_all));
6629
6627
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_privs));
6765
6763
                if (r->in.handle == NULL) {
6766
6764
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6767
6765
                }
6768
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6766
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6769
6767
        }
6770
6768
        if (flags & NDR_OUT) {
6771
6769
                if (r->out.access_mask == NULL) {
6789
6787
                }
6790
6788
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6791
6789
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6792
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6790
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6793
6791
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6794
6792
                NDR_PULL_ALLOC(ndr, r->out.access_mask);
6795
6793
                ZERO_STRUCTP(r->out.access_mask);
6842
6840
                if (r->in.handle == NULL) {
6843
6841
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6844
6842
                }
6845
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6843
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6846
6844
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
6847
6845
        }
6848
6846
        if (flags & NDR_OUT) {
6860
6858
                }
6861
6859
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6862
6860
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6863
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6861
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6864
6862
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6865
6863
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
6866
6864
        }
6902
6900
                if (r->in.handle == NULL) {
6903
6901
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6904
6902
                }
6905
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6903
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6906
6904
                if (r->in.sid == NULL) {
6907
6905
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6908
6906
                }
6913
6911
                if (r->out.trustdom_handle == NULL) {
6914
6912
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6915
6913
                }
6916
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
 
6914
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
6917
6915
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
6918
6916
        }
6919
6917
        return NDR_ERR_SUCCESS;
6932
6930
                }
6933
6931
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6934
6932
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6935
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
6933
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6936
6934
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6937
6935
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6938
6936
                        NDR_PULL_ALLOC(ndr, r->in.sid);
6951
6949
                }
6952
6950
                _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6953
6951
                NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
6954
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
 
6952
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
6955
6953
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
6956
6954
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
6957
6955
        }
6998
6996
                if (r->in.trustdom_handle == NULL) {
6999
6997
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7000
6998
                }
7001
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trustdom_handle));
 
6999
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.trustdom_handle));
7002
7000
                NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
7003
7001
        }
7004
7002
        if (flags & NDR_OUT) {
7029
7027
                }
7030
7028
                _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7031
7029
                NDR_PULL_SET_MEM_CTX(ndr, r->in.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
7032
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.trustdom_handle));
 
7030
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.trustdom_handle));
7033
7031
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
7034
7032
                NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
7035
7033
                NDR_PULL_ALLOC(ndr, r->out.info);
7143
7141
                if (r->in.handle == NULL) {
7144
7142
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7145
7143
                }
7146
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
7144
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7147
7145
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
7148
7146
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
7149
7147
        }
7151
7149
                if (r->out.sec_handle == NULL) {
7152
7150
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7153
7151
                }
7154
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
 
7152
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.sec_handle));
7155
7153
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7156
7154
        }
7157
7155
        return NDR_ERR_SUCCESS;
7169
7167
                }
7170
7168
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7171
7169
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7172
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
7170
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7173
7171
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7174
7172
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
7175
7173
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
7182
7180
                }
7183
7181
                _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7184
7182
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sec_handle, LIBNDR_FLAG_REF_ALLOC);
7185
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sec_handle));
 
7183
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.sec_handle));
7186
7184
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
7187
7185
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7188
7186
        }
7226
7224
                if (r->in.sec_handle == NULL) {
7227
7225
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7228
7226
                }
7229
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
 
7227
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.sec_handle));
7230
7228
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_val));
7231
7229
                if (r->in.new_val) {
7232
7230
                        NDR_CHECK(ndr_push_lsa_DATA_BUF(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7255
7253
                }
7256
7254
                _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7257
7255
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_handle, LIBNDR_FLAG_REF_ALLOC);
7258
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
 
7256
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.sec_handle));
7259
7257
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
7260
7258
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
7261
7259
                if (_ptr_new_val) {
7331
7329
                if (r->in.sec_handle == NULL) {
7332
7330
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7333
7331
                }
7334
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
 
7332
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.sec_handle));
7335
7333
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.new_val));
7336
7334
                if (r->in.new_val) {
7337
7335
                        NDR_CHECK(ndr_push_lsa_DATA_BUF_PTR(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.new_val));
7390
7388
                }
7391
7389
                _mem_save_sec_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7392
7390
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_handle, LIBNDR_FLAG_REF_ALLOC);
7393
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_handle));
 
7391
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.sec_handle));
7394
7392
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_handle_0, LIBNDR_FLAG_REF_ALLOC);
7395
7393
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_new_val));
7396
7394
                if (_ptr_new_val) {
7574
7572
                if (r->in.handle == NULL) {
7575
7573
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7576
7574
                }
7577
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
7575
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7578
7576
                if (r->in.name == NULL) {
7579
7577
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7580
7578
                }
7603
7601
                }
7604
7602
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7605
7603
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7606
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
7604
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7607
7605
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7608
7606
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7609
7607
                        NDR_PULL_ALLOC(ndr, r->in.name);
7667
7665
                if (r->in.handle == NULL) {
7668
7666
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7669
7667
                }
7670
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
7668
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7671
7669
                if (r->in.luid == NULL) {
7672
7670
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7673
7671
                }
7701
7699
                }
7702
7700
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7703
7701
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7704
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
7702
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7705
7703
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7706
7704
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7707
7705
                        NDR_PULL_ALLOC(ndr, r->in.luid);
7781
7779
                if (r->in.handle == NULL) {
7782
7780
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7783
7781
                }
7784
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
7782
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7785
7783
                if (r->in.name == NULL) {
7786
7784
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7787
7785
                }
7822
7820
                }
7823
7821
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7824
7822
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7825
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
7823
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7826
7824
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7827
7825
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7828
7826
                        NDR_PULL_ALLOC(ndr, r->in.name);
7919
7917
                if (r->in.handle == NULL) {
7920
7918
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7921
7919
                }
7922
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
7920
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7923
7921
        }
7924
7922
        if (flags & NDR_OUT) {
7925
7923
                if (r->out.handle == NULL) {
7926
7924
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7927
7925
                }
7928
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 
7926
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
7929
7927
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
7930
7928
        }
7931
7929
        return NDR_ERR_SUCCESS;
7942
7940
                }
7943
7941
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7944
7942
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
7945
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
7943
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7946
7944
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7947
7945
                NDR_PULL_ALLOC(ndr, r->out.handle);
7948
7946
                *r->out.handle = *r->in.handle;
7953
7951
                }
7954
7952
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7955
7953
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
7956
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 
7954
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
7957
7955
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
7958
7956
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
7959
7957
        }
7995
7993
                if (r->in.handle == NULL) {
7996
7994
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
7997
7995
                }
7998
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
7996
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
7999
7997
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.name));
8000
7998
                if (r->in.name) {
8001
7999
                        NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
8025
8023
                }
8026
8024
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8027
8025
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8028
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
8026
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8029
8027
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8030
8028
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
8031
8029
                if (_ptr_name) {
8096
8094
                if (r->in.handle == NULL) {
8097
8095
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8098
8096
                }
8099
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
8097
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8100
8098
                if (r->in.sid == NULL) {
8101
8099
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8102
8100
                }
8125
8123
                }
8126
8124
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8127
8125
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8128
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
8126
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8129
8127
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8130
8128
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8131
8129
                        NDR_PULL_ALLOC(ndr, r->in.sid);
8189
8187
                if (r->in.handle == NULL) {
8190
8188
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8191
8189
                }
8192
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
8190
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8193
8191
                if (r->in.sid == NULL) {
8194
8192
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8195
8193
                }
8216
8214
                }
8217
8215
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8218
8216
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8219
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
8217
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8220
8218
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8221
8219
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8222
8220
                        NDR_PULL_ALLOC(ndr, r->in.sid);
8278
8276
                if (r->in.handle == NULL) {
8279
8277
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8280
8278
                }
8281
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
8279
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8282
8280
                if (r->in.sid == NULL) {
8283
8281
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8284
8282
                }
8306
8304
                }
8307
8305
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8308
8306
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8309
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
8307
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8310
8308
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8311
8309
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8312
8310
                        NDR_PULL_ALLOC(ndr, r->in.sid);
8370
8368
                if (r->in.handle == NULL) {
8371
8369
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8372
8370
                }
8373
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
8371
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8374
8372
                if (r->in.dom_sid == NULL) {
8375
8373
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8376
8374
                }
8406
8404
                }
8407
8405
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8408
8406
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8409
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
8407
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8410
8408
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8411
8409
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8412
8410
                        NDR_PULL_ALLOC(ndr, r->in.dom_sid);
8531
8529
                if (r->in.handle == NULL) {
8532
8530
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8533
8531
                }
8534
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
8532
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8535
8533
                if (r->in.dom_sid == NULL) {
8536
8534
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8537
8535
                }
8553
8551
                }
8554
8552
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8555
8553
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
8556
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
8554
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
8557
8555
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8558
8556
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
8559
8557
                        NDR_PULL_ALLOC(ndr, r->in.dom_sid);
8700
8698
                if (r->out.handle == NULL) {
8701
8699
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
8702
8700
                }
8703
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 
8701
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
8704
8702
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
8705
8703
        }
8706
8704
        return NDR_ERR_SUCCESS;
8750
8748
                }
8751
8749
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
8752
8750
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
8753
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 
8751
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
8754
8752
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
8755
8753
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
8756
8754
        }
9033
9031
                if (r->in.handle == NULL) {
9034
9032
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9035
9033
                }
9036
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9034
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9037
9035
                NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
9038
9036
        }
9039
9037
        if (flags & NDR_OUT) {
9064
9062
                }
9065
9063
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9066
9064
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9067
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9065
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9068
9066
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9069
9067
                NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
9070
9068
                NDR_PULL_ALLOC(ndr, r->out.info);
9137
9135
                if (r->in.handle == NULL) {
9138
9136
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9139
9137
                }
9140
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9138
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9141
9139
                NDR_CHECK(ndr_push_lsa_PolicyInfo(ndr, NDR_SCALARS, r->in.level));
9142
9140
                if (r->in.info == NULL) {
9143
9141
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9161
9159
                }
9162
9160
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9163
9161
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9164
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9162
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9165
9163
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9166
9164
                NDR_CHECK(ndr_pull_lsa_PolicyInfo(ndr, NDR_SCALARS, &r->in.level));
9167
9165
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9216
9214
                if (r->in.handle == NULL) {
9217
9215
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9218
9216
                }
9219
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9217
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9220
9218
                if (r->in.trusted_domain == NULL) {
9221
9219
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9222
9220
                }
9252
9250
                }
9253
9251
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9254
9252
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9255
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9253
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9256
9254
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9257
9255
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9258
9256
                        NDR_PULL_ALLOC(ndr, r->in.trusted_domain);
9336
9334
                if (r->in.handle == NULL) {
9337
9335
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9338
9336
                }
9339
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9337
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9340
9338
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
9341
9339
                NDR_CHECK(ndr_push_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, r->in.level));
9342
9340
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
9362
9360
                }
9363
9361
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9364
9362
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9365
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9363
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9366
9364
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9367
9365
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.trusted_domain));
9368
9366
                NDR_CHECK(ndr_pull_lsa_TrustDomInfoEnum(ndr, NDR_SCALARS, &r->in.level));
9426
9424
                if (r->in.handle == NULL) {
9427
9425
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9428
9426
                }
9429
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9427
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9430
9428
                if (r->in.resume_handle == NULL) {
9431
9429
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9432
9430
                }
9460
9458
                }
9461
9459
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9462
9460
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9463
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9461
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9464
9462
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9465
9463
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9466
9464
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
9580
9578
                if (r->in.handle == NULL) {
9581
9579
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9582
9580
                }
9583
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9581
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9584
9582
        }
9585
9583
        if (flags & NDR_OUT) {
9586
9584
                if (r->out.handle == NULL) {
9587
9585
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9588
9586
                }
9589
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 
9587
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
9590
9588
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9591
9589
        }
9592
9590
        return NDR_ERR_SUCCESS;
9603
9601
                }
9604
9602
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9605
9603
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9606
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9604
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9607
9605
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9608
9606
                NDR_PULL_ALLOC(ndr, r->out.handle);
9609
9607
                *r->out.handle = *r->in.handle;
9614
9612
                }
9615
9613
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9616
9614
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
9617
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 
9615
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
9618
9616
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9619
9617
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9620
9618
        }
9656
9654
                if (r->in.handle == NULL) {
9657
9655
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9658
9656
                }
9659
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9657
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9660
9658
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9661
9659
        }
9662
9660
        if (flags & NDR_OUT) {
9687
9685
                }
9688
9686
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9689
9687
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9690
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9688
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9691
9689
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9692
9690
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9693
9691
                NDR_PULL_ALLOC(ndr, r->out.info);
9760
9758
                if (r->in.handle == NULL) {
9761
9759
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9762
9760
                }
9763
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9761
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9764
9762
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.level));
9765
9763
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
9766
9764
                if (r->in.info) {
9785
9783
                }
9786
9784
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9787
9785
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9788
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9786
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9789
9787
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9790
9788
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.level));
9791
9789
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9847
9845
                if (r->in.handle == NULL) {
9848
9846
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9849
9847
                }
9850
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9848
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9851
9849
                NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
9852
9850
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
9853
9851
        }
9855
9853
                if (r->out.trustdom_handle == NULL) {
9856
9854
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9857
9855
                }
9858
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
 
9856
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
9859
9857
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
9860
9858
        }
9861
9859
        return NDR_ERR_SUCCESS;
9873
9871
                }
9874
9872
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9875
9873
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9876
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9874
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9877
9875
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9878
9876
                NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
9879
9877
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
9886
9884
                }
9887
9885
                _mem_save_trustdom_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9888
9886
                NDR_PULL_SET_MEM_CTX(ndr, r->out.trustdom_handle, LIBNDR_FLAG_REF_ALLOC);
9889
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.trustdom_handle));
 
9887
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.trustdom_handle));
9890
9888
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_trustdom_handle_0, LIBNDR_FLAG_REF_ALLOC);
9891
9889
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
9892
9890
        }
9971
9969
                if (r->in.handle == NULL) {
9972
9970
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9973
9971
                }
9974
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
9972
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9975
9973
                if (r->in.sids == NULL) {
9976
9974
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9977
9975
                }
10026
10024
                }
10027
10025
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10028
10026
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10029
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
10027
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10030
10028
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10031
10029
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10032
10030
                        NDR_PULL_ALLOC(ndr, r->in.sids);
10161
10159
                if (r->in.handle == NULL) {
10162
10160
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10163
10161
                }
10164
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
10162
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10165
10163
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10166
10164
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10167
10165
                for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10221
10219
                }
10222
10220
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10223
10221
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10224
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
10222
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10225
10223
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10226
10224
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
10227
10225
                if (r->in.num_names < 0 || r->in.num_names > 1000) {
10744
10742
                if (r->in.handle == NULL) {
10745
10743
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10746
10744
                }
10747
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
10745
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10748
10746
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10749
10747
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_names));
10750
10748
                for (cntr_names_0 = 0; cntr_names_0 < r->in.num_names; cntr_names_0++) {
10804
10802
                }
10805
10803
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10806
10804
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10807
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
10805
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10808
10806
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10809
10807
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_names));
10810
10808
                if (r->in.num_names < 0 || r->in.num_names > 1000) {
11121
11119
                if (r->in.handle == NULL) {
11122
11120
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11123
11121
                }
11124
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
11122
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11125
11123
                if (r->in.trusted_domain_name == NULL) {
11126
11124
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11127
11125
                }
11156
11154
                }
11157
11155
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11158
11156
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11159
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 
11157
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11160
11158
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11161
11159
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11162
11160
                        NDR_PULL_ALLOC(ndr, r->in.trusted_domain_name);