~ubuntu-branches/ubuntu/oneiric/samba/oneiric-security
» Revision
148
: librpc/gen_ndr/ndr_drsuapi.c
« back to all changes in this revision
Viewing changes to librpc/gen_ndr/ndr_drsuapi.c
- browse files at revision 148
- compare with another revision
- download diff
- download tarball
- view history from revision 148
- Committer: Package Import Robot
- Author(s): Tyler Hicks
- Date: 2012-04-12 05:28:44 UTC
- mfrom: (147.1.1 oneiric-proposed)
- Revision ID: package-import@ubuntu.com-20120412052844-348q6l4dcb303sdu
Tags: 2:3.5.11~dfsg-1ubuntu2.2
* SECURITY UPDATE: Unauthenticated remote code execution via
RPC calls (LP: #978458)
- debian/patches/CVE-2012-1182-1.patch: Fix PIDL compiler to generate code
that uses the same value for array allocation and array length checks.
Based on upstream patch.
- debian/patches/CVE-2012-1182-2.patch: Regenerate PIDL generated files with
the patched PIDL compiler
- CVE-2012-1182
RPC calls (LP: #978458)
- debian/patches/CVE-2012-1182-1.patch: Fix PIDL compiler to generate code
that uses the same value for array allocation and array length checks.
Based on upstream patch.
- debian/patches/CVE-2012-1182-2.patch: Regenerate PIDL generated files with
the patched PIDL compiler
- CVE-2012-1182
- files added:
- .pc/CVE-2012-1182-1.patch
- .pc/CVE-2012-1182-1.patch/pidl
- .pc/CVE-2012-1182-1.patch/pidl/lib
- .pc/CVE-2012-1182-1.patch/pidl/lib/Parse
- .pc/CVE-2012-1182-1.patch/pidl/lib/Parse/Pidl
- .pc/CVE-2012-1182-1.patch/pidl/lib/Parse/Pidl/Samba4
- .pc/CVE-2012-1182-1.patch/pidl/lib/Parse/Pidl/Samba4/NDR
- .pc/CVE-2012-1182-2.patch
- .pc/CVE-2012-1182-2.patch/librpc
- .pc/CVE-2012-1182-2.patch/librpc/gen_ndr
- .pc/CVE-2012-1182-2.patch/source3
- .pc/CVE-2012-1182-2.patch/source3/librpc
- .pc/CVE-2012-1182-2.patch/source3/librpc/gen_ndr
- .pc/initialize_password_db-null-deref
- .pc/initialize_password_db-null-deref/source3
- .pc/initialize_password_db-null-deref/source3/passdb
- files modified:
- .pc/applied-patches
added
removed
librpc/gen_ndr/ndr_drsuapi.c
468
468
469
469
_PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier *r)
470
470
{
471
uint32_t size_dn_0 = 0;
471
472
if (ndr_flags & NDR_SCALARS) {
472
473
NDR_CHECK(ndr_pull_array_size(ndr, &r->dn));
473
474
NDR_CHECK(ndr_pull_align(ndr, 4));
476
477
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
477
478
NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
478
479
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
479
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, ndr_get_array_size(ndr, &r->dn), sizeof(uint16_t), CH_UTF16));
480
size_dn_0 = ndr_get_array_size(ndr, &r->dn);
481
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, size_dn_0, sizeof(uint16_t), CH_UTF16));
480
482
if (r->dn) {
481
483
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dn, r->__ndr_size_dn + 1));
482
484
}
826
828
827
829
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtrEx *r)
828
830
{
831
uint32_t size_cursors_0 = 0;
829
832
uint32_t cntr_cursors_0;
830
833
TALLOC_CTX *_mem_save_cursors_0;
831
834
if (ndr_flags & NDR_SCALARS) {
838
841
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
839
842
}
840
843
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
841
NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
844
size_cursors_0 = ndr_get_array_size(ndr, &r->cursors);
845
NDR_PULL_ALLOC_N(ndr, r->cursors, size_cursors_0);
842
846
_mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
843
847
NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
844
for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
848
for (cntr_cursors_0 = 0; cntr_cursors_0 < size_cursors_0; cntr_cursors_0++) {
845
849
NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
846
850
}
847
851
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
1193
1197
_PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1194
1198
{
1195
1199
uint32_t _ptr_mappings;
1200
uint32_t size_mappings_1 = 0;
1196
1201
uint32_t cntr_mappings_1;
1197
1202
TALLOC_CTX *_mem_save_mappings_0;
1198
1203
TALLOC_CTX *_mem_save_mappings_1;
1215
1220
_mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1216
1221
NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1217
1222
NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1218
NDR_PULL_ALLOC_N(ndr, r->mappings, ndr_get_array_size(ndr, &r->mappings));
1223
size_mappings_1 = ndr_get_array_size(ndr, &r->mappings);
1224
NDR_PULL_ALLOC_N(ndr, r->mappings, size_mappings_1);
1219
1225
_mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1220
1226
NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1221
for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1227
for (cntr_mappings_1 = 0; cntr_mappings_1 < size_mappings_1; cntr_mappings_1++) {
1222
1228
NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1223
1229
}
1224
for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1230
for (cntr_mappings_1 = 0; cntr_mappings_1 < size_mappings_1; cntr_mappings_1++) {
1225
1231
NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1226
1232
}
1227
1233
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1386
1392
1387
1393
static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1388
1394
{
1395
uint32_t size_attids_0 = 0;
1389
1396
uint32_t cntr_attids_0;
1390
1397
TALLOC_CTX *_mem_save_attids_0;
1391
1398
if (ndr_flags & NDR_SCALARS) {
1397
1404
if (r->num_attids < 1 || r->num_attids > 0x100000) {
1398
1405
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1399
1406
}
1400
NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1407
size_attids_0 = ndr_get_array_size(ndr, &r->attids);
1408
NDR_PULL_ALLOC_N(ndr, r->attids, size_attids_0);
1401
1409
_mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1402
1410
NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1403
for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1411
for (cntr_attids_0 = 0; cntr_attids_0 < size_attids_0; cntr_attids_0++) {
1404
1412
NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1405
1413
}
1406
1414
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1917
1925
1918
1926
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1919
1927
{
1928
uint32_t size_cursors_0 = 0;
1920
1929
uint32_t cntr_cursors_0;
1921
1930
TALLOC_CTX *_mem_save_cursors_0;
1922
1931
if (ndr_flags & NDR_SCALARS) {
1929
1938
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1930
1939
}
1931
1940
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1932
NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
1941
size_cursors_0 = ndr_get_array_size(ndr, &r->cursors);
1942
NDR_PULL_ALLOC_N(ndr, r->cursors, size_cursors_0);
1933
1943
_mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1934
1944
NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1935
for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1945
for (cntr_cursors_0 = 0; cntr_cursors_0 < size_cursors_0; cntr_cursors_0++) {
1936
1946
NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1937
1947
}
1938
1948
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
2053
2063
static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2054
2064
{
2055
2065
uint32_t _ptr_values;
2066
uint32_t size_values_1 = 0;
2056
2067
uint32_t cntr_values_1;
2057
2068
TALLOC_CTX *_mem_save_values_0;
2058
2069
TALLOC_CTX *_mem_save_values_1;
2075
2086
_mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2076
2087
NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2077
2088
NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2078
NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2089
size_values_1 = ndr_get_array_size(ndr, &r->values);
2090
NDR_PULL_ALLOC_N(ndr, r->values, size_values_1);
2079
2091
_mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2080
2092
NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2081
for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2093
for (cntr_values_1 = 0; cntr_values_1 < size_values_1; cntr_values_1++) {
2082
2094
NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2083
2095
}
2084
for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2096
for (cntr_values_1 = 0; cntr_values_1 < size_values_1; cntr_values_1++) {
2085
2097
NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2086
2098
}
2087
2099
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2138
2150
2139
2151
_PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2140
2152
{
2153
uint32_t size_dn_0 = 0;
2141
2154
if (ndr_flags & NDR_SCALARS) {
2142
2155
NDR_CHECK(ndr_pull_align(ndr, 4));
2143
2156
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2145
2158
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2146
2159
NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2147
2160
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2148
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2161
size_dn_0 = r->__ndr_size_dn + 1;
2162
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, size_dn_0, sizeof(uint16_t), CH_UTF16));
2149
2163
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2150
2164
}
2151
2165
if (ndr_flags & NDR_BUFFERS) {
2199
2213
2200
2214
_PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2201
2215
{
2216
uint32_t size_dn_0 = 0;
2202
2217
if (ndr_flags & NDR_SCALARS) {
2203
2218
NDR_CHECK(ndr_pull_align(ndr, 4));
2204
2219
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2206
2221
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2207
2222
NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2208
2223
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2209
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2224
size_dn_0 = r->__ndr_size_dn + 1;
2225
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, size_dn_0, sizeof(uint16_t), CH_UTF16));
2210
2226
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2211
2227
{
2212
2228
uint32_t _flags_save_DATA_BLOB = ndr->flags;
2300
2316
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2301
2317
{
2302
2318
uint32_t _ptr_attributes;
2319
uint32_t size_attributes_1 = 0;
2303
2320
uint32_t cntr_attributes_1;
2304
2321
TALLOC_CTX *_mem_save_attributes_0;
2305
2322
TALLOC_CTX *_mem_save_attributes_1;
2322
2339
_mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2323
2340
NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2324
2341
NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2325
NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2342
size_attributes_1 = ndr_get_array_size(ndr, &r->attributes);
2343
NDR_PULL_ALLOC_N(ndr, r->attributes, size_attributes_1);
2326
2344
_mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2327
2345
NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2328
for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2346
for (cntr_attributes_1 = 0; cntr_attributes_1 < size_attributes_1; cntr_attributes_1++) {
2329
2347
NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2330
2348
}
2331
for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2349
for (cntr_attributes_1 = 0; cntr_attributes_1 < size_attributes_1; cntr_attributes_1++) {
2332
2350
NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2333
2351
}
2334
2352
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2510
2528
2511
2529
_PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2512
2530
{
2531
uint32_t size_meta_data_0 = 0;
2513
2532
uint32_t cntr_meta_data_0;
2514
2533
TALLOC_CTX *_mem_save_meta_data_0;
2515
2534
if (ndr_flags & NDR_SCALARS) {
2519
2538
if (r->count > 1048576) {
2520
2539
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2521
2540
}
2522
NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2541
size_meta_data_0 = ndr_get_array_size(ndr, &r->meta_data);
2542
NDR_PULL_ALLOC_N(ndr, r->meta_data, size_meta_data_0);
2523
2543
_mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2524
2544
NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2525
for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2545
for (cntr_meta_data_0 = 0; cntr_meta_data_0 < size_meta_data_0; cntr_meta_data_0++) {
2526
2546
NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2527
2547
}
2528
2548
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2921
2941
uint32_t _ptr_first_object;
2922
2942
TALLOC_CTX *_mem_save_first_object_0;
2923
2943
uint32_t _ptr_linked_attributes;
2944
uint32_t size_linked_attributes_1 = 0;
2924
2945
uint32_t cntr_linked_attributes_1;
2925
2946
TALLOC_CTX *_mem_save_linked_attributes_0;
2926
2947
TALLOC_CTX *_mem_save_linked_attributes_1;
2992
3013
_mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2993
3014
NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
2994
3015
NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
2995
NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
3016
size_linked_attributes_1 = ndr_get_array_size(ndr, &r->linked_attributes);
3017
NDR_PULL_ALLOC_N(ndr, r->linked_attributes, size_linked_attributes_1);
2996
3018
_mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2997
3019
NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
2998
for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3020
for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < size_linked_attributes_1; cntr_linked_attributes_1++) {
2999
3021
NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3000
3022
}
3001
for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3023
for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < size_linked_attributes_1; cntr_linked_attributes_1++) {
3002
3024
NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3003
3025
}
3004
3026
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
3810
3832
uint32_t _ptr_naming_context;
3811
3833
TALLOC_CTX *_mem_save_naming_context_0;
3812
3834
uint32_t _ptr_dest_dsa_dns_name;
3835
uint32_t size_dest_dsa_dns_name_1 = 0;
3836
uint32_t length_dest_dsa_dns_name_1 = 0;
3813
3837
if (ndr_flags & NDR_SCALARS) {
3814
3838
NDR_CHECK(ndr_pull_align(ndr, 5));
3815
3839
NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3835
3859
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3836
3860
NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3837
3861
NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3838
if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3839
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dest_dsa_dns_name), ndr_get_array_length(ndr, &r->dest_dsa_dns_name));
3862
size_dest_dsa_dns_name_1 = ndr_get_array_size(ndr, &r->dest_dsa_dns_name);
3863
length_dest_dsa_dns_name_1 = ndr_get_array_length(ndr, &r->dest_dsa_dns_name);
3864
if (length_dest_dsa_dns_name_1 > size_dest_dsa_dns_name_1) {
3865
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dest_dsa_dns_name_1, length_dest_dsa_dns_name_1);
3840
3866
}
3841
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3842
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dest_dsa_dns_name, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t), CH_DOS));
3867
NDR_CHECK(ndr_check_string_terminator(ndr, length_dest_dsa_dns_name_1, sizeof(uint8_t)));
3868
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dest_dsa_dns_name, length_dest_dsa_dns_name_1, sizeof(uint8_t), CH_DOS));
3843
3869
}
3844
3870
return NDR_ERR_SUCCESS;
3845
3871
}
3991
4017
uint32_t _ptr_naming_context;
3992
4018
TALLOC_CTX *_mem_save_naming_context_0;
3993
4019
uint32_t _ptr_source_dsa_address;
4020
uint32_t size_source_dsa_address_1 = 0;
4021
uint32_t length_source_dsa_address_1 = 0;
3994
4022
TALLOC_CTX *_mem_save_source_dsa_address_0;
4023
uint32_t size_schedule_0 = 0;
3995
4024
if (ndr_flags & NDR_SCALARS) {
3996
4025
NDR_CHECK(ndr_pull_align(ndr, 5));
3997
4026
NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4006
4035
} else {
4007
4036
r->source_dsa_address = NULL;
4008
4037
}
4009
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4038
size_schedule_0 = 84;
4039
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, size_schedule_0));
4010
4040
NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
4011
4041
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4012
4042
}
4020
4050
NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4021
4051
NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4022
4052
NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4023
if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4024
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
4053
size_source_dsa_address_1 = ndr_get_array_size(ndr, &r->source_dsa_address);
4054
length_source_dsa_address_1 = ndr_get_array_length(ndr, &r->source_dsa_address);
4055
if (length_source_dsa_address_1 > size_source_dsa_address_1) {
4056
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_source_dsa_address_1, length_source_dsa_address_1);
4025
4057
}
4026
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4027
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16));
4058
NDR_CHECK(ndr_check_string_terminator(ndr, length_source_dsa_address_1, sizeof(uint16_t)));
4059
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, length_source_dsa_address_1, sizeof(uint16_t), CH_UTF16));
4028
4060
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4029
4061
}
4030
4062
}
4092
4124
uint32_t _ptr_transport_dn;
4093
4125
TALLOC_CTX *_mem_save_transport_dn_0;
4094
4126
uint32_t _ptr_source_dsa_address;
4127
uint32_t size_source_dsa_address_1 = 0;
4128
uint32_t length_source_dsa_address_1 = 0;
4095
4129
TALLOC_CTX *_mem_save_source_dsa_address_0;
4130
uint32_t size_schedule_0 = 0;
4096
4131
if (ndr_flags & NDR_SCALARS) {
4097
4132
NDR_CHECK(ndr_pull_align(ndr, 5));
4098
4133
NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4119
4154
} else {
4120
4155
r->source_dsa_address = NULL;
4121
4156
}
4122
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4157
size_schedule_0 = 84;
4158
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, size_schedule_0));
4123
4159
NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
4124
4160
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4125
4161
}
4145
4181
NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4146
4182
NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4147
4183
NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4148
if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4149
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
4184
size_source_dsa_address_1 = ndr_get_array_size(ndr, &r->source_dsa_address);
4185
length_source_dsa_address_1 = ndr_get_array_length(ndr, &r->source_dsa_address);
4186
if (length_source_dsa_address_1 > size_source_dsa_address_1) {
4187
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_source_dsa_address_1, length_source_dsa_address_1);
4150
4188
}
4151
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4152
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16));
4189
NDR_CHECK(ndr_check_string_terminator(ndr, length_source_dsa_address_1, sizeof(uint16_t)));
4190
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, length_source_dsa_address_1, sizeof(uint16_t), CH_UTF16));
4153
4191
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4154
4192
}
4155
4193
}
4336
4374
uint32_t _ptr_naming_context;
4337
4375
TALLOC_CTX *_mem_save_naming_context_0;
4338
4376
uint32_t _ptr_source_dsa_address;
4377
uint32_t size_source_dsa_address_1 = 0;
4378
uint32_t length_source_dsa_address_1 = 0;
4339
4379
TALLOC_CTX *_mem_save_source_dsa_address_0;
4340
4380
if (ndr_flags & NDR_SCALARS) {
4341
4381
NDR_CHECK(ndr_pull_align(ndr, 5));
4364
4404
NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4365
4405
NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4366
4406
NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4367
if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4368
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
4407
size_source_dsa_address_1 = ndr_get_array_size(ndr, &r->source_dsa_address);
4408
length_source_dsa_address_1 = ndr_get_array_length(ndr, &r->source_dsa_address);
4409
if (length_source_dsa_address_1 > size_source_dsa_address_1) {
4410
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_source_dsa_address_1, length_source_dsa_address_1);
4369
4411
}
4370
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4371
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16));
4412
NDR_CHECK(ndr_check_string_terminator(ndr, length_source_dsa_address_1, sizeof(uint16_t)));
4413
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, length_source_dsa_address_1, sizeof(uint16_t), CH_UTF16));
4372
4414
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4373
4415
}
4374
4416
}
4526
4568
uint32_t _ptr_naming_context;
4527
4569
TALLOC_CTX *_mem_save_naming_context_0;
4528
4570
uint32_t _ptr_source_dra_address;
4571
uint32_t size_source_dra_address_1 = 0;
4572
uint32_t length_source_dra_address_1 = 0;
4529
4573
TALLOC_CTX *_mem_save_source_dra_address_0;
4574
uint32_t size_schedule_0 = 0;
4530
4575
if (ndr_flags & NDR_SCALARS) {
4531
4576
NDR_CHECK(ndr_pull_align(ndr, 5));
4532
4577
NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4542
4587
} else {
4543
4588
r->source_dra_address = NULL;
4544
4589
}
4545
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4590
size_schedule_0 = 84;
4591
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, size_schedule_0));
4546
4592
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4547
4593
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4548
4594
NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->options));
4558
4604
NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4559
4605
NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4560
4606
NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4561
if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4562
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dra_address), ndr_get_array_length(ndr, &r->source_dra_address));
4607
size_source_dra_address_1 = ndr_get_array_size(ndr, &r->source_dra_address);
4608
length_source_dra_address_1 = ndr_get_array_length(ndr, &r->source_dra_address);
4609
if (length_source_dra_address_1 > size_source_dra_address_1) {
4610
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_source_dra_address_1, length_source_dra_address_1);
4563
4611
}
4564
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4565
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dra_address, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t), CH_UTF16));
4612
NDR_CHECK(ndr_check_string_terminator(ndr, length_source_dra_address_1, sizeof(uint16_t)));
4613
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dra_address, length_source_dra_address_1, sizeof(uint16_t), CH_UTF16));
4566
4614
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4567
4615
}
4568
4616
}
4749
4797
static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4750
4798
{
4751
4799
uint32_t _ptr_info_array;
4800
uint32_t size_info_array_1 = 0;
4752
4801
uint32_t cntr_info_array_1;
4753
4802
TALLOC_CTX *_mem_save_info_array_0;
4754
4803
TALLOC_CTX *_mem_save_info_array_1;
4755
4804
TALLOC_CTX *_mem_save_info_array_2;
4756
4805
uint32_t _ptr_group_attrs;
4806
uint32_t size_group_attrs_1 = 0;
4757
4807
uint32_t cntr_group_attrs_1;
4758
4808
TALLOC_CTX *_mem_save_group_attrs_0;
4759
4809
TALLOC_CTX *_mem_save_group_attrs_1;
4760
4810
uint32_t _ptr_sids;
4811
uint32_t size_sids_1 = 0;
4761
4812
uint32_t cntr_sids_1;
4762
4813
TALLOC_CTX *_mem_save_sids_0;
4763
4814
TALLOC_CTX *_mem_save_sids_1;
4798
4849
_mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4799
4850
NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4800
4851
NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4801
NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4852
size_info_array_1 = ndr_get_array_size(ndr, &r->info_array);
4853
NDR_PULL_ALLOC_N(ndr, r->info_array, size_info_array_1);
4802
4854
_mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4803
4855
NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4804
for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4856
for (cntr_info_array_1 = 0; cntr_info_array_1 < size_info_array_1; cntr_info_array_1++) {
4805
4857
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4806
4858
if (_ptr_info_array) {
4807
4859
NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4809
4861
r->info_array[cntr_info_array_1] = NULL;
4810
4862
}
4811
4863
}
4812
for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4864
for (cntr_info_array_1 = 0; cntr_info_array_1 < size_info_array_1; cntr_info_array_1++) {
4813
4865
if (r->info_array[cntr_info_array_1]) {
4814
4866
_mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4815
4867
NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4824
4876
_mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4825
4877
NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4826
4878
NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4827
NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4879
size_group_attrs_1 = ndr_get_array_size(ndr, &r->group_attrs);
4880
NDR_PULL_ALLOC_N(ndr, r->group_attrs, size_group_attrs_1);
4828
4881
_mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4829
4882
NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4830
for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4883
for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < size_group_attrs_1; cntr_group_attrs_1++) {
4831
4884
NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4832
4885
}
4833
4886
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4837
4890
_mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4838
4891
NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4839
4892
NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4840
NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4893
size_sids_1 = ndr_get_array_size(ndr, &r->sids);
4894
NDR_PULL_ALLOC_N(ndr, r->sids, size_sids_1);
4841
4895
_mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4842
4896
NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4843
for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4897
for (cntr_sids_1 = 0; cntr_sids_1 < size_sids_1; cntr_sids_1++) {
4844
4898
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4845
4899
if (_ptr_sids) {
4846
4900
NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4848
4902
r->sids[cntr_sids_1] = NULL;
4849
4903
}
4850
4904
}
4851
for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4905
for (cntr_sids_1 = 0; cntr_sids_1 < size_sids_1; cntr_sids_1++) {
4852
4906
if (r->sids[cntr_sids_1]) {
4853
4907
_mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4854
4908
NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
5051
5105
static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
5052
5106
{
5053
5107
uint32_t _ptr_info_array;
5108
uint32_t size_info_array_1 = 0;
5054
5109
uint32_t cntr_info_array_1;
5055
5110
TALLOC_CTX *_mem_save_info_array_0;
5056
5111
TALLOC_CTX *_mem_save_info_array_1;
5084
5139
_mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5085
5140
NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5086
5141
NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
5087
NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
5142
size_info_array_1 = ndr_get_array_size(ndr, &r->info_array);
5143
NDR_PULL_ALLOC_N(ndr, r->info_array, size_info_array_1);
5088
5144
_mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5089
5145
NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5090
for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5146
for (cntr_info_array_1 = 0; cntr_info_array_1 < size_info_array_1; cntr_info_array_1++) {
5091
5147
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5092
5148
if (_ptr_info_array) {
5093
5149
NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
5095
5151
r->info_array[cntr_info_array_1] = NULL;
5096
5152
}
5097
5153
}
5098
for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5154
for (cntr_info_array_1 = 0; cntr_info_array_1 < size_info_array_1; cntr_info_array_1++) {
5099
5155
if (r->info_array[cntr_info_array_1]) {
5100
5156
_mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
5101
5157
NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
5255
5311
static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5256
5312
{
5257
5313
uint32_t _ptr_data;
5314
uint32_t size_data_1 = 0;
5258
5315
TALLOC_CTX *_mem_save_data_0;
5259
5316
if (ndr_flags & NDR_SCALARS) {
5260
5317
NDR_CHECK(ndr_pull_align(ndr, 5));
5277
5334
_mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5278
5335
NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5279
5336
NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5280
NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5281
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5337
size_data_1 = ndr_get_array_size(ndr, &r->data);
5338
NDR_PULL_ALLOC_N(ndr, r->data, size_data_1);
5339
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_1));
5282
5340
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5283
5341
}
5284
5342
if (r->data) {
5414
5472
static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5415
5473
{
5416
5474
uint32_t _ptr_data1;
5475
uint32_t size_data1_1 = 0;
5417
5476
TALLOC_CTX *_mem_save_data1_0;
5418
5477
uint32_t _ptr_data2;
5478
uint32_t size_data2_1 = 0;
5419
5479
TALLOC_CTX *_mem_save_data2_0;
5420
5480
if (ndr_flags & NDR_SCALARS) {
5421
5481
NDR_CHECK(ndr_pull_align(ndr, 8));
5453
5513
_mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5454
5514
NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5455
5515
NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5456
NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5457
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5516
size_data1_1 = ndr_get_array_size(ndr, &r->data1);
5517
NDR_PULL_ALLOC_N(ndr, r->data1, size_data1_1);
5518
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, size_data1_1));
5458
5519
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5459
5520
}
5460
5521
if (r->data2) {
5461
5522
_mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5462
5523
NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5463
5524
NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5464
NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5465
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5525
size_data2_1 = ndr_get_array_size(ndr, &r->data2);
5526
NDR_PULL_ALLOC_N(ndr, r->data2, size_data2_1);
5527
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, size_data2_1));
5466
5528
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5467
5529
}
5468
5530
if (r->data1) {
5694
5756
static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5695
5757
{
5696
5758
uint32_t _ptr_str;
5759
uint32_t size_str_1 = 0;
5760
uint32_t length_str_1 = 0;
5697
5761
TALLOC_CTX *_mem_save_str_0;
5698
5762
if (ndr_flags & NDR_SCALARS) {
5699
5763
NDR_CHECK(ndr_pull_align(ndr, 5));
5711
5775
NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5712
5776
NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5713
5777
NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5714
if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5715
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->str), ndr_get_array_length(ndr, &r->str));
5778
size_str_1 = ndr_get_array_size(ndr, &r->str);
5779
length_str_1 = ndr_get_array_length(ndr, &r->str);
5780
if (length_str_1 > size_str_1) {
5781
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_str_1, length_str_1);
5716
5782
}
5717
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5718
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5783
NDR_CHECK(ndr_check_string_terminator(ndr, length_str_1, sizeof(uint16_t)));
5784
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, length_str_1, sizeof(uint16_t), CH_UTF16));
5719
5785
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5720
5786
}
5721
5787
}
5766
5832
static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5767
5833
{
5768
5834
uint32_t _ptr_names;
5835
uint32_t size_names_1 = 0;
5769
5836
uint32_t cntr_names_1;
5770
5837
TALLOC_CTX *_mem_save_names_0;
5771
5838
TALLOC_CTX *_mem_save_names_1;
5793
5860
_mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5794
5861
NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5795
5862
NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5796
NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5863
size_names_1 = ndr_get_array_size(ndr, &r->names);
5864
NDR_PULL_ALLOC_N(ndr, r->names, size_names_1);
5797
5865
_mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5798
5866
NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5799
for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5867
for (cntr_names_1 = 0; cntr_names_1 < size_names_1; cntr_names_1++) {
5800
5868
NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5801
5869
}
5802
for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5870
for (cntr_names_1 = 0; cntr_names_1 < size_names_1; cntr_names_1++) {
5803
5871
NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5804
5872
}
5805
5873
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5947
6015
static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5948
6016
{
5949
6017
uint32_t _ptr_dns_domain_name;
6018
uint32_t size_dns_domain_name_1 = 0;
6019
uint32_t length_dns_domain_name_1 = 0;
5950
6020
TALLOC_CTX *_mem_save_dns_domain_name_0;
5951
6021
uint32_t _ptr_result_name;
6022
uint32_t size_result_name_1 = 0;
6023
uint32_t length_result_name_1 = 0;
5952
6024
TALLOC_CTX *_mem_save_result_name_0;
5953
6025
if (ndr_flags & NDR_SCALARS) {
5954
6026
NDR_CHECK(ndr_pull_align(ndr, 5));
5973
6045
NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5974
6046
NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5975
6047
NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5976
if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5977
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dns_domain_name), ndr_get_array_length(ndr, &r->dns_domain_name));
6048
size_dns_domain_name_1 = ndr_get_array_size(ndr, &r->dns_domain_name);
6049
length_dns_domain_name_1 = ndr_get_array_length(ndr, &r->dns_domain_name);
6050
if (length_dns_domain_name_1 > size_dns_domain_name_1) {
6051
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dns_domain_name_1, length_dns_domain_name_1);
5978
6052
}
5979
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5980
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_domain_name, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t), CH_UTF16));
6053
NDR_CHECK(ndr_check_string_terminator(ndr, length_dns_domain_name_1, sizeof(uint16_t)));
6054
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_domain_name, length_dns_domain_name_1, sizeof(uint16_t), CH_UTF16));
5981
6055
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5982
6056
}
5983
6057
if (r->result_name) {
5985
6059
NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5986
6060
NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5987
6061
NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5988
if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5989
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->result_name), ndr_get_array_length(ndr, &r->result_name));
6062
size_result_name_1 = ndr_get_array_size(ndr, &r->result_name);
6063
length_result_name_1 = ndr_get_array_length(ndr, &r->result_name);
6064
if (length_result_name_1 > size_result_name_1) {
6065
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_result_name_1, length_result_name_1);
5990
6066
}
5991
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5992
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
6067
NDR_CHECK(ndr_check_string_terminator(ndr, length_result_name_1, sizeof(uint16_t)));
6068
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, length_result_name_1, sizeof(uint16_t), CH_UTF16));
5993
6069
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5994
6070
}
5995
6071
}
6042
6118
static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
6043
6119
{
6044
6120
uint32_t _ptr_array;
6121
uint32_t size_array_1 = 0;
6045
6122
uint32_t cntr_array_1;
6046
6123
TALLOC_CTX *_mem_save_array_0;
6047
6124
TALLOC_CTX *_mem_save_array_1;
6061
6138
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6062
6139
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6063
6140
NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6064
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6141
size_array_1 = ndr_get_array_size(ndr, &r->array);
6142
NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
6065
6143
_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6066
6144
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6067
for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6145
for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
6068
6146
NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6069
6147
}
6070
for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6148
for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
6071
6149
NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6072
6150
}
6073
6151
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6140
6218
int level;
6141
6219
int32_t _level;
6142
6220
TALLOC_CTX *_mem_save_ctr1_0;
6221
uint32_t _ptr_ctr1;
6143
6222
level = ndr_pull_get_switch_value(ndr, r);
6144
6223
if (ndr_flags & NDR_SCALARS) {
6145
6224
NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6149
6228
NDR_CHECK(ndr_pull_union_align(ndr, 5));
6150
6229
switch (level) {
6151
6230
case 1: {
6152
uint32_t _ptr_ctr1;
6153
6231
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6154
6232
if (_ptr_ctr1) {
6155
6233
NDR_PULL_ALLOC(ndr, r->ctr1);
6261
6339
static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6262
6340
{
6263
6341
uint32_t _ptr_object_dn;
6342
uint32_t size_object_dn_1 = 0;
6343
uint32_t length_object_dn_1 = 0;
6264
6344
TALLOC_CTX *_mem_save_object_dn_0;
6265
6345
uint32_t _ptr_spn_names;
6346
uint32_t size_spn_names_1 = 0;
6266
6347
uint32_t cntr_spn_names_1;
6267
6348
TALLOC_CTX *_mem_save_spn_names_0;
6268
6349
TALLOC_CTX *_mem_save_spn_names_1;
6294
6375
NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6295
6376
NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6296
6377
NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6297
if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6298
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
6378
size_object_dn_1 = ndr_get_array_size(ndr, &r->object_dn);
6379
length_object_dn_1 = ndr_get_array_length(ndr, &r->object_dn);
6380
if (length_object_dn_1 > size_object_dn_1) {
6381
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_object_dn_1, length_object_dn_1);
6299
6382
}
6300
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6301
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6383
NDR_CHECK(ndr_check_string_terminator(ndr, length_object_dn_1, sizeof(uint16_t)));
6384
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, length_object_dn_1, sizeof(uint16_t), CH_UTF16));
6302
6385
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6303
6386
}
6304
6387
if (r->spn_names) {
6305
6388
_mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6306
6389
NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6307
6390
NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6308
NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6391
size_spn_names_1 = ndr_get_array_size(ndr, &r->spn_names);
6392
NDR_PULL_ALLOC_N(ndr, r->spn_names, size_spn_names_1);
6309
6393
_mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6310
6394
NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6311
for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6395
for (cntr_spn_names_1 = 0; cntr_spn_names_1 < size_spn_names_1; cntr_spn_names_1++) {
6312
6396
NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6313
6397
}
6314
for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6398
for (cntr_spn_names_1 = 0; cntr_spn_names_1 < size_spn_names_1; cntr_spn_names_1++) {
6315
6399
NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6316
6400
}
6317
6401
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6569
6653
static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6570
6654
{
6571
6655
uint32_t _ptr_server_dn;
6656
uint32_t size_server_dn_1 = 0;
6657
uint32_t length_server_dn_1 = 0;
6572
6658
TALLOC_CTX *_mem_save_server_dn_0;
6573
6659
uint32_t _ptr_domain_dn;
6660
uint32_t size_domain_dn_1 = 0;
6661
uint32_t length_domain_dn_1 = 0;
6574
6662
TALLOC_CTX *_mem_save_domain_dn_0;
6575
6663
if (ndr_flags & NDR_SCALARS) {
6576
6664
NDR_CHECK(ndr_pull_align(ndr, 5));
6595
6683
NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6596
6684
NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6597
6685
NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6598
if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6599
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_dn), ndr_get_array_length(ndr, &r->server_dn));
6686
size_server_dn_1 = ndr_get_array_size(ndr, &r->server_dn);
6687
length_server_dn_1 = ndr_get_array_length(ndr, &r->server_dn);
6688
if (length_server_dn_1 > size_server_dn_1) {
6689
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_dn_1, length_server_dn_1);
6600
6690
}
6601
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6602
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6691
NDR_CHECK(ndr_check_string_terminator(ndr, length_server_dn_1, sizeof(uint16_t)));
6692
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, length_server_dn_1, sizeof(uint16_t), CH_UTF16));
6603
6693
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6604
6694
}
6605
6695
if (r->domain_dn) {
6607
6697
NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6608
6698
NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6609
6699
NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6610
if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6611
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_dn), ndr_get_array_length(ndr, &r->domain_dn));
6700
size_domain_dn_1 = ndr_get_array_size(ndr, &r->domain_dn);
6701
length_domain_dn_1 = ndr_get_array_length(ndr, &r->domain_dn);
6702
if (length_domain_dn_1 > size_domain_dn_1) {
6703
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_domain_dn_1, length_domain_dn_1);
6612
6704
}
6613
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6614
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6705
NDR_CHECK(ndr_check_string_terminator(ndr, length_domain_dn_1, sizeof(uint16_t)));
6706
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, length_domain_dn_1, sizeof(uint16_t), CH_UTF16));
6615
6707
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6616
6708
}
6617
6709
}
6844
6936
static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6845
6937
{
6846
6938
uint32_t _ptr_domain_name;
6939
uint32_t size_domain_name_1 = 0;
6940
uint32_t length_domain_name_1 = 0;
6847
6941
TALLOC_CTX *_mem_save_domain_name_0;
6848
6942
if (ndr_flags & NDR_SCALARS) {
6849
6943
NDR_CHECK(ndr_pull_align(ndr, 5));
6862
6956
NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6863
6957
NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6864
6958
NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6865
if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6866
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->domain_name), ndr_get_array_length(ndr, &r->domain_name));
6959
size_domain_name_1 = ndr_get_array_size(ndr, &r->domain_name);
6960
length_domain_name_1 = ndr_get_array_length(ndr, &r->domain_name);
6961
if (length_domain_name_1 > size_domain_name_1) {
6962
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_domain_name_1, length_domain_name_1);
6867
6963
}
6868
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6869
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6964
NDR_CHECK(ndr_check_string_terminator(ndr, length_domain_name_1, sizeof(uint16_t)));
6965
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, length_domain_name_1, sizeof(uint16_t), CH_UTF16));
6870
6966
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6871
6967
}
6872
6968
}
7015
7111
static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
7016
7112
{
7017
7113
uint32_t _ptr_netbios_name;
7114
uint32_t size_netbios_name_1 = 0;
7115
uint32_t length_netbios_name_1 = 0;
7018
7116
TALLOC_CTX *_mem_save_netbios_name_0;
7019
7117
uint32_t _ptr_dns_name;
7118
uint32_t size_dns_name_1 = 0;
7119
uint32_t length_dns_name_1 = 0;
7020
7120
TALLOC_CTX *_mem_save_dns_name_0;
7021
7121
uint32_t _ptr_site_name;
7122
uint32_t size_site_name_1 = 0;
7123
uint32_t length_site_name_1 = 0;
7022
7124
TALLOC_CTX *_mem_save_site_name_0;
7023
7125
uint32_t _ptr_computer_dn;
7126
uint32_t size_computer_dn_1 = 0;
7127
uint32_t length_computer_dn_1 = 0;
7024
7128
TALLOC_CTX *_mem_save_computer_dn_0;
7025
7129
uint32_t _ptr_server_dn;
7130
uint32_t size_server_dn_1 = 0;
7131
uint32_t length_server_dn_1 = 0;
7026
7132
TALLOC_CTX *_mem_save_server_dn_0;
7027
7133
if (ndr_flags & NDR_SCALARS) {
7028
7134
NDR_CHECK(ndr_pull_align(ndr, 5));
7066
7172
NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7067
7173
NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7068
7174
NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7069
if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7070
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->netbios_name), ndr_get_array_length(ndr, &r->netbios_name));
7175
size_netbios_name_1 = ndr_get_array_size(ndr, &r->netbios_name);
7176
length_netbios_name_1 = ndr_get_array_length(ndr, &r->netbios_name);
7177
if (length_netbios_name_1 > size_netbios_name_1) {
7178
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_netbios_name_1, length_netbios_name_1);
7071
7179
}
7072
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7073
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7180
NDR_CHECK(ndr_check_string_terminator(ndr, length_netbios_name_1, sizeof(uint16_t)));
7181
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, length_netbios_name_1, sizeof(uint16_t), CH_UTF16));
7074
7182
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7075
7183
}
7076
7184
if (r->dns_name) {
7078
7186
NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7079
7187
NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7080
7188
NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7081
if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7082
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dns_name), ndr_get_array_length(ndr, &r->dns_name));
7189
size_dns_name_1 = ndr_get_array_size(ndr, &r->dns_name);
7190
length_dns_name_1 = ndr_get_array_length(ndr, &r->dns_name);
7191
if (length_dns_name_1 > size_dns_name_1) {
7192
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dns_name_1, length_dns_name_1);
7083
7193
}
7084
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7085
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7194
NDR_CHECK(ndr_check_string_terminator(ndr, length_dns_name_1, sizeof(uint16_t)));
7195
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, length_dns_name_1, sizeof(uint16_t), CH_UTF16));
7086
7196
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7087
7197
}
7088
7198
if (r->site_name) {
7090
7200
NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7091
7201
NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7092
7202
NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7093
if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7094
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_name), ndr_get_array_length(ndr, &r->site_name));
7203
size_site_name_1 = ndr_get_array_size(ndr, &r->site_name);
7204
length_site_name_1 = ndr_get_array_length(ndr, &r->site_name);
7205
if (length_site_name_1 > size_site_name_1) {
7206
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_name_1, length_site_name_1);
7095
7207
}
7096
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7097
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7208
NDR_CHECK(ndr_check_string_terminator(ndr, length_site_name_1, sizeof(uint16_t)));
7209
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, length_site_name_1, sizeof(uint16_t), CH_UTF16));
7098
7210
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7099
7211
}
7100
7212
if (r->computer_dn) {
7102
7214
NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7103
7215
NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7104
7216
NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7105
if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7106
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->computer_dn), ndr_get_array_length(ndr, &r->computer_dn));
7217
size_computer_dn_1 = ndr_get_array_size(ndr, &r->computer_dn);
7218
length_computer_dn_1 = ndr_get_array_length(ndr, &r->computer_dn);
7219
if (length_computer_dn_1 > size_computer_dn_1) {
7220
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_computer_dn_1, length_computer_dn_1);
7107
7221
}
7108
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7109
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7222
NDR_CHECK(ndr_check_string_terminator(ndr, length_computer_dn_1, sizeof(uint16_t)));
7223
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, length_computer_dn_1, sizeof(uint16_t), CH_UTF16));
7110
7224
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7111
7225
}
7112
7226
if (r->server_dn) {
7114
7228
NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7115
7229
NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7116
7230
NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7117
if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7118
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_dn), ndr_get_array_length(ndr, &r->server_dn));
7231
size_server_dn_1 = ndr_get_array_size(ndr, &r->server_dn);
7232
length_server_dn_1 = ndr_get_array_length(ndr, &r->server_dn);
7233
if (length_server_dn_1 > size_server_dn_1) {
7234
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_dn_1, length_server_dn_1);
7119
7235
}
7120
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7121
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7236
NDR_CHECK(ndr_check_string_terminator(ndr, length_server_dn_1, sizeof(uint16_t)));
7237
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, length_server_dn_1, sizeof(uint16_t), CH_UTF16));
7122
7238
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7123
7239
}
7124
7240
}
7190
7306
static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7191
7307
{
7192
7308
uint32_t _ptr_array;
7309
uint32_t size_array_1 = 0;
7193
7310
uint32_t cntr_array_1;
7194
7311
TALLOC_CTX *_mem_save_array_0;
7195
7312
TALLOC_CTX *_mem_save_array_1;
7212
7329
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7213
7330
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7214
7331
NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7215
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7332
size_array_1 = ndr_get_array_size(ndr, &r->array);
7333
NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
7216
7334
_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7217
7335
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7218
for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7336
for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
7219
7337
NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7220
7338
}
7221
for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7339
for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
7222
7340
NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7223
7341
}
7224
7342
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7325
7443
static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7326
7444
{
7327
7445
uint32_t _ptr_netbios_name;
7446
uint32_t size_netbios_name_1 = 0;
7447
uint32_t length_netbios_name_1 = 0;
7328
7448
TALLOC_CTX *_mem_save_netbios_name_0;
7329
7449
uint32_t _ptr_dns_name;
7450
uint32_t size_dns_name_1 = 0;
7451
uint32_t length_dns_name_1 = 0;
7330
7452
TALLOC_CTX *_mem_save_dns_name_0;
7331
7453
uint32_t _ptr_site_name;
7454
uint32_t size_site_name_1 = 0;
7455
uint32_t length_site_name_1 = 0;
7332
7456
TALLOC_CTX *_mem_save_site_name_0;
7333
7457
uint32_t _ptr_site_dn;
7458
uint32_t size_site_dn_1 = 0;
7459
uint32_t length_site_dn_1 = 0;
7334
7460
TALLOC_CTX *_mem_save_site_dn_0;
7335
7461
uint32_t _ptr_computer_dn;
7462
uint32_t size_computer_dn_1 = 0;
7463
uint32_t length_computer_dn_1 = 0;
7336
7464
TALLOC_CTX *_mem_save_computer_dn_0;
7337
7465
uint32_t _ptr_server_dn;
7466
uint32_t size_server_dn_1 = 0;
7467
uint32_t length_server_dn_1 = 0;
7338
7468
TALLOC_CTX *_mem_save_server_dn_0;
7339
7469
uint32_t _ptr_ntds_dn;
7470
uint32_t size_ntds_dn_1 = 0;
7471
uint32_t length_ntds_dn_1 = 0;
7340
7472
TALLOC_CTX *_mem_save_ntds_dn_0;
7341
7473
if (ndr_flags & NDR_SCALARS) {
7342
7474
NDR_CHECK(ndr_pull_align(ndr, 5));
7397
7529
NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7398
7530
NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7399
7531
NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7400
if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7401
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->netbios_name), ndr_get_array_length(ndr, &r->netbios_name));
7532
size_netbios_name_1 = ndr_get_array_size(ndr, &r->netbios_name);
7533
length_netbios_name_1 = ndr_get_array_length(ndr, &r->netbios_name);
7534
if (length_netbios_name_1 > size_netbios_name_1) {
7535
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_netbios_name_1, length_netbios_name_1);
7402
7536
}
7403
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7404
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7537
NDR_CHECK(ndr_check_string_terminator(ndr, length_netbios_name_1, sizeof(uint16_t)));
7538
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, length_netbios_name_1, sizeof(uint16_t), CH_UTF16));
7405
7539
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7406
7540
}
7407
7541
if (r->dns_name) {
7409
7543
NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7410
7544
NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7411
7545
NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7412
if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7413
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dns_name), ndr_get_array_length(ndr, &r->dns_name));
7546
size_dns_name_1 = ndr_get_array_size(ndr, &r->dns_name);
7547
length_dns_name_1 = ndr_get_array_length(ndr, &r->dns_name);
7548
if (length_dns_name_1 > size_dns_name_1) {
7549
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dns_name_1, length_dns_name_1);
7414
7550
}
7415
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7416
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7551
NDR_CHECK(ndr_check_string_terminator(ndr, length_dns_name_1, sizeof(uint16_t)));
7552
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, length_dns_name_1, sizeof(uint16_t), CH_UTF16));
7417
7553
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7418
7554
}
7419
7555
if (r->site_name) {
7421
7557
NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7422
7558
NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7423
7559
NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7424
if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7425
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_name), ndr_get_array_length(ndr, &r->site_name));
7560
size_site_name_1 = ndr_get_array_size(ndr, &r->site_name);
7561
length_site_name_1 = ndr_get_array_length(ndr, &r->site_name);
7562
if (length_site_name_1 > size_site_name_1) {
7563
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_name_1, length_site_name_1);
7426
7564
}
7427
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7428
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7565
NDR_CHECK(ndr_check_string_terminator(ndr, length_site_name_1, sizeof(uint16_t)));
7566
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, length_site_name_1, sizeof(uint16_t), CH_UTF16));
7429
7567
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7430
7568
}
7431
7569
if (r->site_dn) {
7433
7571
NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7434
7572
NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7435
7573
NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7436
if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7437
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_dn), ndr_get_array_length(ndr, &r->site_dn));
7574
size_site_dn_1 = ndr_get_array_size(ndr, &r->site_dn);
7575
length_site_dn_1 = ndr_get_array_length(ndr, &r->site_dn);
7576
if (length_site_dn_1 > size_site_dn_1) {
7577
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_dn_1, length_site_dn_1);
7438
7578
}
7439
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7440
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7579
NDR_CHECK(ndr_check_string_terminator(ndr, length_site_dn_1, sizeof(uint16_t)));
7580
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, length_site_dn_1, sizeof(uint16_t), CH_UTF16));
7441
7581
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7442
7582
}
7443
7583
if (r->computer_dn) {
7445
7585
NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7446
7586
NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7447
7587
NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7448
if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7449
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->computer_dn), ndr_get_array_length(ndr, &r->computer_dn));
7588
size_computer_dn_1 = ndr_get_array_size(ndr, &r->computer_dn);
7589
length_computer_dn_1 = ndr_get_array_length(ndr, &r->computer_dn);
7590
if (length_computer_dn_1 > size_computer_dn_1) {
7591
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_computer_dn_1, length_computer_dn_1);
7450
7592
}
7451
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7452
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7593
NDR_CHECK(ndr_check_string_terminator(ndr, length_computer_dn_1, sizeof(uint16_t)));
7594
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, length_computer_dn_1, sizeof(uint16_t), CH_UTF16));
7453
7595
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7454
7596
}
7455
7597
if (r->server_dn) {
7457
7599
NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7458
7600
NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7459
7601
NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7460
if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7461
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_dn), ndr_get_array_length(ndr, &r->server_dn));
7602
size_server_dn_1 = ndr_get_array_size(ndr, &r->server_dn);
7603
length_server_dn_1 = ndr_get_array_length(ndr, &r->server_dn);
7604
if (length_server_dn_1 > size_server_dn_1) {
7605
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_dn_1, length_server_dn_1);
7462
7606
}
7463
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7464
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7607
NDR_CHECK(ndr_check_string_terminator(ndr, length_server_dn_1, sizeof(uint16_t)));
7608
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, length_server_dn_1, sizeof(uint16_t), CH_UTF16));
7465
7609
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7466
7610
}
7467
7611
if (r->ntds_dn) {
7469
7613
NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7470
7614
NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7471
7615
NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7472
if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7473
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->ntds_dn), ndr_get_array_length(ndr, &r->ntds_dn));
7616
size_ntds_dn_1 = ndr_get_array_size(ndr, &r->ntds_dn);
7617
length_ntds_dn_1 = ndr_get_array_length(ndr, &r->ntds_dn);
7618
if (length_ntds_dn_1 > size_ntds_dn_1) {
7619
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ntds_dn_1, length_ntds_dn_1);
7474
7620
}
7475
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7476
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7621
NDR_CHECK(ndr_check_string_terminator(ndr, length_ntds_dn_1, sizeof(uint16_t)));
7622
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, length_ntds_dn_1, sizeof(uint16_t), CH_UTF16));
7477
7623
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7478
7624
}
7479
7625
}
7562
7708
static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7563
7709
{
7564
7710
uint32_t _ptr_array;
7711
uint32_t size_array_1 = 0;
7565
7712
uint32_t cntr_array_1;
7566
7713
TALLOC_CTX *_mem_save_array_0;
7567
7714
TALLOC_CTX *_mem_save_array_1;
7584
7731
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7585
7732
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7586
7733
NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7587
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7734
size_array_1 = ndr_get_array_size(ndr, &r->array);
7735
NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
7588
7736
_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7589
7737
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7590
for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7738
for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
7591
7739
NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7592
7740
}
7593
for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7741
for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
7594
7742
NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7595
7743
}
7596
7744
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7698
7846
static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7699
7847
{
7700
7848
uint32_t _ptr_netbios_name;
7849
uint32_t size_netbios_name_1 = 0;
7850
uint32_t length_netbios_name_1 = 0;
7701
7851
TALLOC_CTX *_mem_save_netbios_name_0;
7702
7852
uint32_t _ptr_dns_name;
7853
uint32_t size_dns_name_1 = 0;
7854
uint32_t length_dns_name_1 = 0;
7703
7855
TALLOC_CTX *_mem_save_dns_name_0;
7704
7856
uint32_t _ptr_site_name;
7857
uint32_t size_site_name_1 = 0;
7858
uint32_t length_site_name_1 = 0;
7705
7859
TALLOC_CTX *_mem_save_site_name_0;
7706
7860
uint32_t _ptr_site_dn;
7861
uint32_t size_site_dn_1 = 0;
7862
uint32_t length_site_dn_1 = 0;
7707
7863
TALLOC_CTX *_mem_save_site_dn_0;
7708
7864
uint32_t _ptr_computer_dn;
7865
uint32_t size_computer_dn_1 = 0;
7866
uint32_t length_computer_dn_1 = 0;
7709
7867
TALLOC_CTX *_mem_save_computer_dn_0;
7710
7868
uint32_t _ptr_server_dn;
7869
uint32_t size_server_dn_1 = 0;
7870
uint32_t length_server_dn_1 = 0;
7711
7871
TALLOC_CTX *_mem_save_server_dn_0;
7712
7872
uint32_t _ptr_ntds_dn;
7873
uint32_t size_ntds_dn_1 = 0;
7874
uint32_t length_ntds_dn_1 = 0;
7713
7875
TALLOC_CTX *_mem_save_ntds_dn_0;
7714
7876
if (ndr_flags & NDR_SCALARS) {
7715
7877
NDR_CHECK(ndr_pull_align(ndr, 5));
7771
7933
NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7772
7934
NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7773
7935
NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7774
if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7775
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->netbios_name), ndr_get_array_length(ndr, &r->netbios_name));
7936
size_netbios_name_1 = ndr_get_array_size(ndr, &r->netbios_name);
7937
length_netbios_name_1 = ndr_get_array_length(ndr, &r->netbios_name);
7938
if (length_netbios_name_1 > size_netbios_name_1) {
7939
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_netbios_name_1, length_netbios_name_1);
7776
7940
}
7777
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7778
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7941
NDR_CHECK(ndr_check_string_terminator(ndr, length_netbios_name_1, sizeof(uint16_t)));
7942
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, length_netbios_name_1, sizeof(uint16_t), CH_UTF16));
7779
7943
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7780
7944
}
7781
7945
if (r->dns_name) {
7783
7947
NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7784
7948
NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7785
7949
NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7786
if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7787
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dns_name), ndr_get_array_length(ndr, &r->dns_name));
7950
size_dns_name_1 = ndr_get_array_size(ndr, &r->dns_name);
7951
length_dns_name_1 = ndr_get_array_length(ndr, &r->dns_name);
7952
if (length_dns_name_1 > size_dns_name_1) {
7953
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dns_name_1, length_dns_name_1);
7788
7954
}
7789
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7790
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7955
NDR_CHECK(ndr_check_string_terminator(ndr, length_dns_name_1, sizeof(uint16_t)));
7956
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, length_dns_name_1, sizeof(uint16_t), CH_UTF16));
7791
7957
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7792
7958
}
7793
7959
if (r->site_name) {
7795
7961
NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7796
7962
NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7797
7963
NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7798
if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7799
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_name), ndr_get_array_length(ndr, &r->site_name));
7964
size_site_name_1 = ndr_get_array_size(ndr, &r->site_name);
7965
length_site_name_1 = ndr_get_array_length(ndr, &r->site_name);
7966
if (length_site_name_1 > size_site_name_1) {
7967
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_name_1, length_site_name_1);
7800
7968
}
7801
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7802
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7969
NDR_CHECK(ndr_check_string_terminator(ndr, length_site_name_1, sizeof(uint16_t)));
7970
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, length_site_name_1, sizeof(uint16_t), CH_UTF16));
7803
7971
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7804
7972
}
7805
7973
if (r->site_dn) {
7807
7975
NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7808
7976
NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7809
7977
NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7810
if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7811
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_dn), ndr_get_array_length(ndr, &r->site_dn));
7978
size_site_dn_1 = ndr_get_array_size(ndr, &r->site_dn);
7979
length_site_dn_1 = ndr_get_array_length(ndr, &r->site_dn);
7980
if (length_site_dn_1 > size_site_dn_1) {
7981
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_dn_1, length_site_dn_1);
7812
7982
}
7813
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7814
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7983
NDR_CHECK(ndr_check_string_terminator(ndr, length_site_dn_1, sizeof(uint16_t)));
7984
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, length_site_dn_1, sizeof(uint16_t), CH_UTF16));
7815
7985
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7816
7986
}
7817
7987
if (r->computer_dn) {
7819
7989
NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7820
7990
NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7821
7991
NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7822
if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7823
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->computer_dn), ndr_get_array_length(ndr, &r->computer_dn));
7992
size_computer_dn_1 = ndr_get_array_size(ndr, &r->computer_dn);
7993
length_computer_dn_1 = ndr_get_array_length(ndr, &r->computer_dn);
7994
if (length_computer_dn_1 > size_computer_dn_1) {
7995
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_computer_dn_1, length_computer_dn_1);
7824
7996
}
7825
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7826
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7997
NDR_CHECK(ndr_check_string_terminator(ndr, length_computer_dn_1, sizeof(uint16_t)));
7998
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, length_computer_dn_1, sizeof(uint16_t), CH_UTF16));
7827
7999
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7828
8000
}
7829
8001
if (r->server_dn) {
7831
8003
NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7832
8004
NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7833
8005
NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7834
if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7835
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_dn), ndr_get_array_length(ndr, &r->server_dn));
8006
size_server_dn_1 = ndr_get_array_size(ndr, &r->server_dn);
8007
length_server_dn_1 = ndr_get_array_length(ndr, &r->server_dn);
8008
if (length_server_dn_1 > size_server_dn_1) {
8009
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_server_dn_1, length_server_dn_1);
7836
8010
}
7837
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7838
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
8011
NDR_CHECK(ndr_check_string_terminator(ndr, length_server_dn_1, sizeof(uint16_t)));
8012
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, length_server_dn_1, sizeof(uint16_t), CH_UTF16));
7839
8013
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7840
8014
}
7841
8015
if (r->ntds_dn) {
7843
8017
NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7844
8018
NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7845
8019
NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7846
if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7847
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->ntds_dn), ndr_get_array_length(ndr, &r->ntds_dn));
8020
size_ntds_dn_1 = ndr_get_array_size(ndr, &r->ntds_dn);
8021
length_ntds_dn_1 = ndr_get_array_length(ndr, &r->ntds_dn);
8022
if (length_ntds_dn_1 > size_ntds_dn_1) {
8023
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ntds_dn_1, length_ntds_dn_1);
7848
8024
}
7849
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7850
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
8025
NDR_CHECK(ndr_check_string_terminator(ndr, length_ntds_dn_1, sizeof(uint16_t)));
8026
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, length_ntds_dn_1, sizeof(uint16_t), CH_UTF16));
7851
8027
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7852
8028
}
7853
8029
}
7937
8113
static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7938
8114
{
7939
8115
uint32_t _ptr_array;
8116
uint32_t size_array_1 = 0;
7940
8117
uint32_t cntr_array_1;
7941
8118
TALLOC_CTX *_mem_save_array_0;
7942
8119
TALLOC_CTX *_mem_save_array_1;
7959
8136
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7960
8137
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7961
8138
NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7962
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8139
size_array_1 = ndr_get_array_size(ndr, &r->array);
8140
NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
7963
8141
_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7964
8142
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7965
for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8143
for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
7966
8144
NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7967
8145
}
7968
for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8146
for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
7969
8147
NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7970
8148
}
7971
8149
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8034
8212
static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
8035
8213
{
8036
8214
uint32_t _ptr_client_account;
8215
uint32_t size_client_account_1 = 0;
8216
uint32_t length_client_account_1 = 0;
8037
8217
TALLOC_CTX *_mem_save_client_account_0;
8038
8218
if (ndr_flags & NDR_SCALARS) {
8039
8219
NDR_CHECK(ndr_pull_align(ndr, 5));
8062
8242
NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
8063
8243
NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
8064
8244
NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
8065
if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
8066
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client_account), ndr_get_array_length(ndr, &r->client_account));
8245
size_client_account_1 = ndr_get_array_size(ndr, &r->client_account);
8246
length_client_account_1 = ndr_get_array_length(ndr, &r->client_account);
8247
if (length_client_account_1 > size_client_account_1) {
8248
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_client_account_1, length_client_account_1);
8067
8249
}
8068
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
8069
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
8250
NDR_CHECK(ndr_check_string_terminator(ndr, length_client_account_1, sizeof(uint16_t)));
8251
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, length_client_account_1, sizeof(uint16_t), CH_UTF16));
8070
8252
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
8071
8253
}
8072
8254
}
8118
8300
static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8119
8301
{
8120
8302
uint32_t _ptr_array;
8303
uint32_t size_array_1 = 0;
8121
8304
uint32_t cntr_array_1;
8122
8305
TALLOC_CTX *_mem_save_array_0;
8123
8306
TALLOC_CTX *_mem_save_array_1;
8140
8323
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8141
8324
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8142
8325
NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8143
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8326
size_array_1 = ndr_get_array_size(ndr, &r->array);
8327
NDR_PULL_ALLOC_N(ndr, r->array, size_array_1);
8144
8328
_mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8145
8329
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8146
for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8330
for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
8147
8331
NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8148
8332
}
8149
for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8333
for (cntr_array_1 = 0; cntr_array_1 < size_array_1; cntr_array_1++) {
8150
8334
NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8151
8335
}
8152
8336
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8536
8720
static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8537
8721
{
8538
8722
uint32_t _ptr_data;
8723
uint32_t size_data_1 = 0;
8539
8724
TALLOC_CTX *_mem_save_data_0;
8540
8725
if (ndr_flags & NDR_SCALARS) {
8541
8726
NDR_CHECK(ndr_pull_align(ndr, 5));
8556
8741
_mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8557
8742
NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8558
8743
NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8559
NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8560
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8744
size_data_1 = ndr_get_array_size(ndr, &r->data);
8745
NDR_PULL_ALLOC_N(ndr, r->data, size_data_1);
8746
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, size_data_1));
8561
8747
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8562
8748
}
8563
8749
if (r->data) {
9102
9288
uint32_t _ptr_id;
9103
9289
TALLOC_CTX *_mem_save_id_0;
9104
9290
uint32_t _ptr_objects;
9291
uint32_t size_objects_1 = 0;
9105
9292
uint32_t cntr_objects_1;
9106
9293
TALLOC_CTX *_mem_save_objects_0;
9107
9294
TALLOC_CTX *_mem_save_objects_1;
9138
9325
_mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9139
9326
NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9140
9327
NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9141
NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9328
size_objects_1 = ndr_get_array_size(ndr, &r->objects);
9329
NDR_PULL_ALLOC_N(ndr, r->objects, size_objects_1);
9142
9330
_mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9143
9331
NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9144
for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9332
for (cntr_objects_1 = 0; cntr_objects_1 < size_objects_1; cntr_objects_1++) {
9145
9333
NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9146
9334
}
9147
for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9335
for (cntr_objects_1 = 0; cntr_objects_1 < size_objects_1; cntr_objects_1++) {
9148
9336
NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9149
9337
}
9150
9338
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9229
9417
uint32_t _ptr_error;
9230
9418
TALLOC_CTX *_mem_save_error_0;
9231
9419
uint32_t _ptr_objects;
9420
uint32_t size_objects_1 = 0;
9232
9421
uint32_t cntr_objects_1;
9233
9422
TALLOC_CTX *_mem_save_objects_0;
9234
9423
TALLOC_CTX *_mem_save_objects_1;
9277
9466
_mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9278
9467
NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9279
9468
NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9280
NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9469
size_objects_1 = ndr_get_array_size(ndr, &r->objects);
9470
NDR_PULL_ALLOC_N(ndr, r->objects, size_objects_1);
9281
9471
_mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9282
9472
NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9283
for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9473
for (cntr_objects_1 = 0; cntr_objects_1 < size_objects_1; cntr_objects_1++) {
9284
9474
NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9285
9475
}
9286
for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9476
for (cntr_objects_1 = 0; cntr_objects_1 < size_objects_1; cntr_objects_1++) {
9287
9477
NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9288
9478
}
9289
9479
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9650
9840
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9651
9841
{
9652
9842
uint32_t _ptr_object_dn;
9843
uint32_t size_object_dn_1 = 0;
9844
uint32_t length_object_dn_1 = 0;
9653
9845
TALLOC_CTX *_mem_save_object_dn_0;
9654
9846
if (ndr_flags & NDR_SCALARS) {
9655
9847
NDR_CHECK(ndr_pull_align(ndr, 5));
9669
9861
NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9670
9862
NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9671
9863
NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9672
if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9673
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
9864
size_object_dn_1 = ndr_get_array_size(ndr, &r->object_dn);
9865
length_object_dn_1 = ndr_get_array_length(ndr, &r->object_dn);
9866
if (length_object_dn_1 > size_object_dn_1) {
9867
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_object_dn_1, length_object_dn_1);
9674
9868
}
9675
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9676
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9869
NDR_CHECK(ndr_check_string_terminator(ndr, length_object_dn_1, sizeof(uint16_t)));
9870
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, length_object_dn_1, sizeof(uint16_t), CH_UTF16));
9677
9871
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9678
9872
}
9679
9873
}
9734
9928
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9735
9929
{
9736
9930
uint32_t _ptr_object_dn;
9931
uint32_t size_object_dn_1 = 0;
9932
uint32_t length_object_dn_1 = 0;
9737
9933
TALLOC_CTX *_mem_save_object_dn_0;
9738
9934
uint32_t _ptr_string1;
9935
uint32_t size_string1_1 = 0;
9936
uint32_t length_string1_1 = 0;
9739
9937
TALLOC_CTX *_mem_save_string1_0;
9740
9938
uint32_t _ptr_string2;
9939
uint32_t size_string2_1 = 0;
9940
uint32_t length_string2_1 = 0;
9741
9941
TALLOC_CTX *_mem_save_string2_0;
9742
9942
if (ndr_flags & NDR_SCALARS) {
9743
9943
NDR_CHECK(ndr_pull_align(ndr, 5));
9771
9971
NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9772
9972
NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9773
9973
NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9774
if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9775
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
9974
size_object_dn_1 = ndr_get_array_size(ndr, &r->object_dn);
9975
length_object_dn_1 = ndr_get_array_length(ndr, &r->object_dn);
9976
if (length_object_dn_1 > size_object_dn_1) {
9977
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_object_dn_1, length_object_dn_1);
9776
9978
}
9777
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9778
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9979
NDR_CHECK(ndr_check_string_terminator(ndr, length_object_dn_1, sizeof(uint16_t)));
9980
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, length_object_dn_1, sizeof(uint16_t), CH_UTF16));
9779
9981
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9780
9982
}
9781
9983
if (r->string1) {
9783
9985
NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9784
9986
NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9785
9987
NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9786
if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9787
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string1), ndr_get_array_length(ndr, &r->string1));
9988
size_string1_1 = ndr_get_array_size(ndr, &r->string1);
9989
length_string1_1 = ndr_get_array_length(ndr, &r->string1);
9990
if (length_string1_1 > size_string1_1) {
9991
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_string1_1, length_string1_1);
9788
9992
}
9789
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9790
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9993
NDR_CHECK(ndr_check_string_terminator(ndr, length_string1_1, sizeof(uint16_t)));
9994
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, length_string1_1, sizeof(uint16_t), CH_UTF16));
9791
9995
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9792
9996
}
9793
9997
if (r->string2) {
9795
9999
NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9796
10000
NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9797
10001
NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9798
if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9799
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string2), ndr_get_array_length(ndr, &r->string2));
10002
size_string2_1 = ndr_get_array_size(ndr, &r->string2);
10003
length_string2_1 = ndr_get_array_length(ndr, &r->string2);
10004
if (length_string2_1 > size_string2_1) {
10005
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_string2_1, length_string2_1);
9800
10006
}
9801
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9802
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
10007
NDR_CHECK(ndr_check_string_terminator(ndr, length_string2_1, sizeof(uint16_t)));
10008
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, length_string2_1, sizeof(uint16_t), CH_UTF16));
9803
10009
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9804
10010
}
9805
10011
}
9986
10192
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9987
10193
{
9988
10194
uint32_t _ptr_naming_context_dn;
10195
uint32_t size_naming_context_dn_1 = 0;
10196
uint32_t length_naming_context_dn_1 = 0;
9989
10197
TALLOC_CTX *_mem_save_naming_context_dn_0;
9990
10198
uint32_t _ptr_source_dsa_obj_dn;
10199
uint32_t size_source_dsa_obj_dn_1 = 0;
10200
uint32_t length_source_dsa_obj_dn_1 = 0;
9991
10201
TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9992
10202
uint32_t _ptr_source_dsa_address;
10203
uint32_t size_source_dsa_address_1 = 0;
10204
uint32_t length_source_dsa_address_1 = 0;
9993
10205
TALLOC_CTX *_mem_save_source_dsa_address_0;
9994
10206
uint32_t _ptr_transport_obj_dn;
10207
uint32_t size_transport_obj_dn_1 = 0;
10208
uint32_t length_transport_obj_dn_1 = 0;
9995
10209
TALLOC_CTX *_mem_save_transport_obj_dn_0;
9996
10210
if (ndr_flags & NDR_SCALARS) {
9997
10211
NDR_CHECK(ndr_pull_align(ndr, 8));
10039
10253
NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
10040
10254
NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
10041
10255
NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
10042
if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
10043
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->naming_context_dn), ndr_get_array_length(ndr, &r->naming_context_dn));
10256
size_naming_context_dn_1 = ndr_get_array_size(ndr, &r->naming_context_dn);
10257
length_naming_context_dn_1 = ndr_get_array_length(ndr, &r->naming_context_dn);
10258
if (length_naming_context_dn_1 > size_naming_context_dn_1) {
10259
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_naming_context_dn_1, length_naming_context_dn_1);
10044
10260
}
10045
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
10046
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->naming_context_dn, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t), CH_UTF16));
10261
NDR_CHECK(ndr_check_string_terminator(ndr, length_naming_context_dn_1, sizeof(uint16_t)));
10262
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->naming_context_dn, length_naming_context_dn_1, sizeof(uint16_t), CH_UTF16));
10047
10263
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
10048
10264
}
10049
10265
if (r->source_dsa_obj_dn) {
10051
10267
NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10052
10268
NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10053
10269
NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10054
if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10055
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_obj_dn), ndr_get_array_length(ndr, &r->source_dsa_obj_dn));
10270
size_source_dsa_obj_dn_1 = ndr_get_array_size(ndr, &r->source_dsa_obj_dn);
10271
length_source_dsa_obj_dn_1 = ndr_get_array_length(ndr, &r->source_dsa_obj_dn);
10272
if (length_source_dsa_obj_dn_1 > size_source_dsa_obj_dn_1) {
10273
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_source_dsa_obj_dn_1, length_source_dsa_obj_dn_1);
10056
10274
}
10057
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10058
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_obj_dn, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t), CH_UTF16));
10275
NDR_CHECK(ndr_check_string_terminator(ndr, length_source_dsa_obj_dn_1, sizeof(uint16_t)));
10276
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_obj_dn, length_source_dsa_obj_dn_1, sizeof(uint16_t), CH_UTF16));
10059
10277
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10060
10278
}
10061
10279
if (r->source_dsa_address) {
10063
10281
NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
10064
10282
NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
10065
10283
NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
10066
if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
10067
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address));
10284
size_source_dsa_address_1 = ndr_get_array_size(ndr, &r->source_dsa_address);
10285
length_source_dsa_address_1 = ndr_get_array_length(ndr, &r->source_dsa_address);
10286
if (length_source_dsa_address_1 > size_source_dsa_address_1) {
10287
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_source_dsa_address_1, length_source_dsa_address_1);
10068
10288
}
10069
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
10070
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16));
10289
NDR_CHECK(ndr_check_string_terminator(ndr, length_source_dsa_address_1, sizeof(uint16_t)));
10290
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, length_source_dsa_address_1, sizeof(uint16_t), CH_UTF16));
10071
10291
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
10072
10292
}
10073
10293
if (r->transport_obj_dn) {
10075
10295
NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
10076
10296
NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
10077
10297
NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
10078
if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
10079
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->transport_obj_dn), ndr_get_array_length(ndr, &r->transport_obj_dn));
10298
size_transport_obj_dn_1 = ndr_get_array_size(ndr, &r->transport_obj_dn);
10299
length_transport_obj_dn_1 = ndr_get_array_length(ndr, &r->transport_obj_dn);
10300
if (length_transport_obj_dn_1 > size_transport_obj_dn_1) {
10301
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_transport_obj_dn_1, length_transport_obj_dn_1);
10080
10302
}
10081
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10082
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->transport_obj_dn, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t), CH_UTF16));
10303
NDR_CHECK(ndr_check_string_terminator(ndr, length_transport_obj_dn_1, sizeof(uint16_t)));
10304
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->transport_obj_dn, length_transport_obj_dn_1, sizeof(uint16_t), CH_UTF16));
10083
10305
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10084
10306
}
10085
10307
}
10152
10374
10153
10375
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10154
10376
{
10377
uint32_t size_array_0 = 0;
10155
10378
uint32_t cntr_array_0;
10156
10379
TALLOC_CTX *_mem_save_array_0;
10157
10380
if (ndr_flags & NDR_SCALARS) {
10159
10382
NDR_CHECK(ndr_pull_align(ndr, 8));
10160
10383
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10161
10384
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10162
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10385
size_array_0 = ndr_get_array_size(ndr, &r->array);
10386
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
10163
10387
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10164
10388
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10165
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10389
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10166
10390
NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10167
10391
}
10168
10392
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10172
10396
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10173
10397
}
10174
10398
if (ndr_flags & NDR_BUFFERS) {
10399
size_array_0 = ndr_get_array_size(ndr, &r->array);
10175
10400
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10176
10401
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10177
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10402
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10178
10403
NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10179
10404
}
10180
10405
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10222
10447
10223
10448
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10224
10449
{
10450
uint32_t size_array_0 = 0;
10225
10451
uint32_t cntr_array_0;
10226
10452
TALLOC_CTX *_mem_save_array_0;
10227
10453
if (ndr_flags & NDR_SCALARS) {
10229
10455
NDR_CHECK(ndr_pull_align(ndr, 8));
10230
10456
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10231
10457
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10232
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10458
size_array_0 = ndr_get_array_size(ndr, &r->array);
10459
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
10233
10460
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10234
10461
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10235
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10462
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10236
10463
NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10237
10464
}
10238
10465
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10292
10519
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10293
10520
{
10294
10521
uint32_t _ptr_attribute_name;
10522
uint32_t size_attribute_name_1 = 0;
10523
uint32_t length_attribute_name_1 = 0;
10295
10524
TALLOC_CTX *_mem_save_attribute_name_0;
10296
10525
if (ndr_flags & NDR_SCALARS) {
10297
10526
NDR_CHECK(ndr_pull_align(ndr, 8));
10314
10543
NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10315
10544
NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10316
10545
NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10317
if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10318
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->attribute_name), ndr_get_array_length(ndr, &r->attribute_name));
10546
size_attribute_name_1 = ndr_get_array_size(ndr, &r->attribute_name);
10547
length_attribute_name_1 = ndr_get_array_length(ndr, &r->attribute_name);
10548
if (length_attribute_name_1 > size_attribute_name_1) {
10549
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_attribute_name_1, length_attribute_name_1);
10319
10550
}
10320
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10321
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10551
NDR_CHECK(ndr_check_string_terminator(ndr, length_attribute_name_1, sizeof(uint16_t)));
10552
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, length_attribute_name_1, sizeof(uint16_t), CH_UTF16));
10322
10553
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10323
10554
}
10324
10555
}
10366
10597
10367
10598
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10368
10599
{
10600
uint32_t size_array_0 = 0;
10369
10601
uint32_t cntr_array_0;
10370
10602
TALLOC_CTX *_mem_save_array_0;
10371
10603
if (ndr_flags & NDR_SCALARS) {
10373
10605
NDR_CHECK(ndr_pull_align(ndr, 8));
10374
10606
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10375
10607
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10376
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10608
size_array_0 = ndr_get_array_size(ndr, &r->array);
10609
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
10377
10610
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10378
10611
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10379
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10612
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10380
10613
NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10381
10614
}
10382
10615
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10386
10619
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10387
10620
}
10388
10621
if (ndr_flags & NDR_BUFFERS) {
10622
size_array_0 = ndr_get_array_size(ndr, &r->array);
10389
10623
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10390
10624
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10391
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10625
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10392
10626
NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10393
10627
}
10394
10628
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10441
10675
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10442
10676
{
10443
10677
uint32_t _ptr_dsa_obj_dn;
10678
uint32_t size_dsa_obj_dn_1 = 0;
10679
uint32_t length_dsa_obj_dn_1 = 0;
10444
10680
TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10445
10681
if (ndr_flags & NDR_SCALARS) {
10446
10682
NDR_CHECK(ndr_pull_align(ndr, 5));
10462
10698
NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10463
10699
NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10464
10700
NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10465
if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10466
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dsa_obj_dn), ndr_get_array_length(ndr, &r->dsa_obj_dn));
10701
size_dsa_obj_dn_1 = ndr_get_array_size(ndr, &r->dsa_obj_dn);
10702
length_dsa_obj_dn_1 = ndr_get_array_length(ndr, &r->dsa_obj_dn);
10703
if (length_dsa_obj_dn_1 > size_dsa_obj_dn_1) {
10704
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dsa_obj_dn_1, length_dsa_obj_dn_1);
10467
10705
}
10468
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10469
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dsa_obj_dn, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t), CH_UTF16));
10706
NDR_CHECK(ndr_check_string_terminator(ndr, length_dsa_obj_dn_1, sizeof(uint16_t)));
10707
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dsa_obj_dn, length_dsa_obj_dn_1, sizeof(uint16_t), CH_UTF16));
10470
10708
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10471
10709
}
10472
10710
}
10513
10751
10514
10752
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10515
10753
{
10754
uint32_t size_array_0 = 0;
10516
10755
uint32_t cntr_array_0;
10517
10756
TALLOC_CTX *_mem_save_array_0;
10518
10757
if (ndr_flags & NDR_SCALARS) {
10520
10759
NDR_CHECK(ndr_pull_align(ndr, 5));
10521
10760
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10522
10761
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10523
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10762
size_array_0 = ndr_get_array_size(ndr, &r->array);
10763
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
10524
10764
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10525
10765
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10526
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10766
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10527
10767
NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10528
10768
}
10529
10769
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10533
10773
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10534
10774
}
10535
10775
if (ndr_flags & NDR_BUFFERS) {
10776
size_array_0 = ndr_get_array_size(ndr, &r->array);
10536
10777
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10537
10778
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10538
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10779
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10539
10780
NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10540
10781
}
10541
10782
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10789
11030
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10790
11031
{
10791
11032
uint32_t _ptr_nc_dn;
11033
uint32_t size_nc_dn_1 = 0;
11034
uint32_t length_nc_dn_1 = 0;
10792
11035
TALLOC_CTX *_mem_save_nc_dn_0;
10793
11036
uint32_t _ptr_remote_dsa_obj_dn;
11037
uint32_t size_remote_dsa_obj_dn_1 = 0;
11038
uint32_t length_remote_dsa_obj_dn_1 = 0;
10794
11039
TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10795
11040
uint32_t _ptr_remote_dsa_address;
11041
uint32_t size_remote_dsa_address_1 = 0;
11042
uint32_t length_remote_dsa_address_1 = 0;
10796
11043
TALLOC_CTX *_mem_save_remote_dsa_address_0;
10797
11044
if (ndr_flags & NDR_SCALARS) {
10798
11045
NDR_CHECK(ndr_pull_align(ndr, 5));
10830
11077
NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10831
11078
NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10832
11079
NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10833
if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10834
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->nc_dn), ndr_get_array_length(ndr, &r->nc_dn));
11080
size_nc_dn_1 = ndr_get_array_size(ndr, &r->nc_dn);
11081
length_nc_dn_1 = ndr_get_array_length(ndr, &r->nc_dn);
11082
if (length_nc_dn_1 > size_nc_dn_1) {
11083
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_nc_dn_1, length_nc_dn_1);
10835
11084
}
10836
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10837
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
11085
NDR_CHECK(ndr_check_string_terminator(ndr, length_nc_dn_1, sizeof(uint16_t)));
11086
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, length_nc_dn_1, sizeof(uint16_t), CH_UTF16));
10838
11087
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10839
11088
}
10840
11089
if (r->remote_dsa_obj_dn) {
10842
11091
NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10843
11092
NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10844
11093
NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10845
if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10846
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote_dsa_obj_dn), ndr_get_array_length(ndr, &r->remote_dsa_obj_dn));
11094
size_remote_dsa_obj_dn_1 = ndr_get_array_size(ndr, &r->remote_dsa_obj_dn);
11095
length_remote_dsa_obj_dn_1 = ndr_get_array_length(ndr, &r->remote_dsa_obj_dn);
11096
if (length_remote_dsa_obj_dn_1 > size_remote_dsa_obj_dn_1) {
11097
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_remote_dsa_obj_dn_1, length_remote_dsa_obj_dn_1);
10847
11098
}
10848
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10849
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote_dsa_obj_dn, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t), CH_UTF16));
11099
NDR_CHECK(ndr_check_string_terminator(ndr, length_remote_dsa_obj_dn_1, sizeof(uint16_t)));
11100
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote_dsa_obj_dn, length_remote_dsa_obj_dn_1, sizeof(uint16_t), CH_UTF16));
10850
11101
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10851
11102
}
10852
11103
if (r->remote_dsa_address) {
10854
11105
NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10855
11106
NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10856
11107
NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10857
if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10858
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->remote_dsa_address), ndr_get_array_length(ndr, &r->remote_dsa_address));
11108
size_remote_dsa_address_1 = ndr_get_array_size(ndr, &r->remote_dsa_address);
11109
length_remote_dsa_address_1 = ndr_get_array_length(ndr, &r->remote_dsa_address);
11110
if (length_remote_dsa_address_1 > size_remote_dsa_address_1) {
11111
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_remote_dsa_address_1, length_remote_dsa_address_1);
10859
11112
}
10860
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10861
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote_dsa_address, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t), CH_UTF16));
11113
NDR_CHECK(ndr_check_string_terminator(ndr, length_remote_dsa_address_1, sizeof(uint16_t)));
11114
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->remote_dsa_address, length_remote_dsa_address_1, sizeof(uint16_t), CH_UTF16));
10862
11115
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10863
11116
}
10864
11117
}
10921
11174
10922
11175
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10923
11176
{
11177
uint32_t size_array_0 = 0;
10924
11178
uint32_t cntr_array_0;
10925
11179
TALLOC_CTX *_mem_save_array_0;
10926
11180
if (ndr_flags & NDR_SCALARS) {
10928
11182
NDR_CHECK(ndr_pull_align(ndr, 5));
10929
11183
NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10930
11184
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10931
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11185
size_array_0 = ndr_get_array_size(ndr, &r->array);
11186
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
10932
11187
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10933
11188
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10934
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11189
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10935
11190
NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10936
11191
}
10937
11192
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10941
11196
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10942
11197
}
10943
11198
if (ndr_flags & NDR_BUFFERS) {
11199
size_array_0 = ndr_get_array_size(ndr, &r->array);
10944
11200
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10945
11201
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10946
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11202
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
10947
11203
NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10948
11204
}
10949
11205
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11011
11267
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
11012
11268
{
11013
11269
uint32_t _ptr_attribute_name;
11270
uint32_t size_attribute_name_1 = 0;
11271
uint32_t length_attribute_name_1 = 0;
11014
11272
TALLOC_CTX *_mem_save_attribute_name_0;
11015
11273
uint32_t _ptr_object_dn;
11274
uint32_t size_object_dn_1 = 0;
11275
uint32_t length_object_dn_1 = 0;
11016
11276
TALLOC_CTX *_mem_save_object_dn_0;
11017
11277
uint32_t _ptr_binary;
11018
11278
TALLOC_CTX *_mem_save_binary_0;
11052
11312
NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11053
11313
NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11054
11314
NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11055
if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11056
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->attribute_name), ndr_get_array_length(ndr, &r->attribute_name));
11315
size_attribute_name_1 = ndr_get_array_size(ndr, &r->attribute_name);
11316
length_attribute_name_1 = ndr_get_array_length(ndr, &r->attribute_name);
11317
if (length_attribute_name_1 > size_attribute_name_1) {
11318
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_attribute_name_1, length_attribute_name_1);
11057
11319
}
11058
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11059
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11320
NDR_CHECK(ndr_check_string_terminator(ndr, length_attribute_name_1, sizeof(uint16_t)));
11321
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, length_attribute_name_1, sizeof(uint16_t), CH_UTF16));
11060
11322
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11061
11323
}
11062
11324
if (r->object_dn) {
11064
11326
NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11065
11327
NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11066
11328
NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11067
if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11068
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
11329
size_object_dn_1 = ndr_get_array_size(ndr, &r->object_dn);
11330
length_object_dn_1 = ndr_get_array_length(ndr, &r->object_dn);
11331
if (length_object_dn_1 > size_object_dn_1) {
11332
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_object_dn_1, length_object_dn_1);
11069
11333
}
11070
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11071
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11334
NDR_CHECK(ndr_check_string_terminator(ndr, length_object_dn_1, sizeof(uint16_t)));
11335
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, length_object_dn_1, sizeof(uint16_t), CH_UTF16));
11072
11336
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11073
11337
}
11074
11338
if (r->binary) {
11137
11401
11138
11402
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11139
11403
{
11404
uint32_t size_array_0 = 0;
11140
11405
uint32_t cntr_array_0;
11141
11406
TALLOC_CTX *_mem_save_array_0;
11142
11407
if (ndr_flags & NDR_SCALARS) {
11144
11409
NDR_CHECK(ndr_pull_align(ndr, 8));
11145
11410
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11146
11411
NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11147
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11412
size_array_0 = ndr_get_array_size(ndr, &r->array);
11413
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
11148
11414
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11149
11415
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11150
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11416
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11151
11417
NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11152
11418
}
11153
11419
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11157
11423
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11158
11424
}
11159
11425
if (ndr_flags & NDR_BUFFERS) {
11426
size_array_0 = ndr_get_array_size(ndr, &r->array);
11160
11427
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11161
11428
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11162
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11429
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11163
11430
NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11164
11431
}
11165
11432
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11207
11474
11208
11475
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
11209
11476
{
11477
uint32_t size_array_0 = 0;
11210
11478
uint32_t cntr_array_0;
11211
11479
TALLOC_CTX *_mem_save_array_0;
11212
11480
if (ndr_flags & NDR_SCALARS) {
11214
11482
NDR_CHECK(ndr_pull_align(ndr, 8));
11215
11483
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11216
11484
NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11217
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11485
size_array_0 = ndr_get_array_size(ndr, &r->array);
11486
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
11218
11487
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11219
11488
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11220
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11489
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11221
11490
NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11222
11491
}
11223
11492
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11275
11544
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11276
11545
{
11277
11546
uint32_t _ptr_source_dsa_obj_dn;
11547
uint32_t size_source_dsa_obj_dn_1 = 0;
11548
uint32_t length_source_dsa_obj_dn_1 = 0;
11278
11549
TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11279
11550
if (ndr_flags & NDR_SCALARS) {
11280
11551
NDR_CHECK(ndr_pull_align(ndr, 8));
11295
11566
NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11296
11567
NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11297
11568
NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11298
if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11299
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_obj_dn), ndr_get_array_length(ndr, &r->source_dsa_obj_dn));
11569
size_source_dsa_obj_dn_1 = ndr_get_array_size(ndr, &r->source_dsa_obj_dn);
11570
length_source_dsa_obj_dn_1 = ndr_get_array_length(ndr, &r->source_dsa_obj_dn);
11571
if (length_source_dsa_obj_dn_1 > size_source_dsa_obj_dn_1) {
11572
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_source_dsa_obj_dn_1, length_source_dsa_obj_dn_1);
11300
11573
}
11301
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11302
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_obj_dn, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t), CH_UTF16));
11574
NDR_CHECK(ndr_check_string_terminator(ndr, length_source_dsa_obj_dn_1, sizeof(uint16_t)));
11575
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_obj_dn, length_source_dsa_obj_dn_1, sizeof(uint16_t), CH_UTF16));
11303
11576
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11304
11577
}
11305
11578
}
11345
11618
11346
11619
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11347
11620
{
11621
uint32_t size_array_0 = 0;
11348
11622
uint32_t cntr_array_0;
11349
11623
TALLOC_CTX *_mem_save_array_0;
11350
11624
if (ndr_flags & NDR_SCALARS) {
11352
11626
NDR_CHECK(ndr_pull_align(ndr, 8));
11353
11627
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11354
11628
NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11355
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11629
size_array_0 = ndr_get_array_size(ndr, &r->array);
11630
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
11356
11631
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11357
11632
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11358
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11633
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11359
11634
NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11360
11635
}
11361
11636
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11365
11640
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11366
11641
}
11367
11642
if (ndr_flags & NDR_BUFFERS) {
11643
size_array_0 = ndr_get_array_size(ndr, &r->array);
11368
11644
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11369
11645
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11370
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11646
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11371
11647
NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11372
11648
}
11373
11649
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11428
11704
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11429
11705
{
11430
11706
uint32_t _ptr_attribute_name;
11707
uint32_t size_attribute_name_1 = 0;
11708
uint32_t length_attribute_name_1 = 0;
11431
11709
TALLOC_CTX *_mem_save_attribute_name_0;
11432
11710
uint32_t _ptr_originating_dsa_dn;
11711
uint32_t size_originating_dsa_dn_1 = 0;
11712
uint32_t length_originating_dsa_dn_1 = 0;
11433
11713
TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11434
11714
if (ndr_flags & NDR_SCALARS) {
11435
11715
NDR_CHECK(ndr_pull_align(ndr, 8));
11458
11738
NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11459
11739
NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11460
11740
NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11461
if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11462
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->attribute_name), ndr_get_array_length(ndr, &r->attribute_name));
11741
size_attribute_name_1 = ndr_get_array_size(ndr, &r->attribute_name);
11742
length_attribute_name_1 = ndr_get_array_length(ndr, &r->attribute_name);
11743
if (length_attribute_name_1 > size_attribute_name_1) {
11744
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_attribute_name_1, length_attribute_name_1);
11463
11745
}
11464
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11465
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11746
NDR_CHECK(ndr_check_string_terminator(ndr, length_attribute_name_1, sizeof(uint16_t)));
11747
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, length_attribute_name_1, sizeof(uint16_t), CH_UTF16));
11466
11748
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11467
11749
}
11468
11750
if (r->originating_dsa_dn) {
11470
11752
NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11471
11753
NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11472
11754
NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11473
if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11474
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->originating_dsa_dn), ndr_get_array_length(ndr, &r->originating_dsa_dn));
11755
size_originating_dsa_dn_1 = ndr_get_array_size(ndr, &r->originating_dsa_dn);
11756
length_originating_dsa_dn_1 = ndr_get_array_length(ndr, &r->originating_dsa_dn);
11757
if (length_originating_dsa_dn_1 > size_originating_dsa_dn_1) {
11758
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_originating_dsa_dn_1, length_originating_dsa_dn_1);
11475
11759
}
11476
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11477
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->originating_dsa_dn, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t), CH_UTF16));
11760
NDR_CHECK(ndr_check_string_terminator(ndr, length_originating_dsa_dn_1, sizeof(uint16_t)));
11761
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->originating_dsa_dn, length_originating_dsa_dn_1, sizeof(uint16_t), CH_UTF16));
11478
11762
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11479
11763
}
11480
11764
}
11528
11812
11529
11813
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11530
11814
{
11815
uint32_t size_array_0 = 0;
11531
11816
uint32_t cntr_array_0;
11532
11817
TALLOC_CTX *_mem_save_array_0;
11533
11818
if (ndr_flags & NDR_SCALARS) {
11535
11820
NDR_CHECK(ndr_pull_align(ndr, 8));
11536
11821
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11537
11822
NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11538
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11823
size_array_0 = ndr_get_array_size(ndr, &r->array);
11824
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
11539
11825
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11540
11826
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11541
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11827
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11542
11828
NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11543
11829
}
11544
11830
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11548
11834
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11549
11835
}
11550
11836
if (ndr_flags & NDR_BUFFERS) {
11837
size_array_0 = ndr_get_array_size(ndr, &r->array);
11551
11838
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11552
11839
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11553
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11840
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11554
11841
NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11555
11842
}
11556
11843
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11625
11912
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11626
11913
{
11627
11914
uint32_t _ptr_attribute_name;
11915
uint32_t size_attribute_name_1 = 0;
11916
uint32_t length_attribute_name_1 = 0;
11628
11917
TALLOC_CTX *_mem_save_attribute_name_0;
11629
11918
uint32_t _ptr_object_dn;
11919
uint32_t size_object_dn_1 = 0;
11920
uint32_t length_object_dn_1 = 0;
11630
11921
TALLOC_CTX *_mem_save_object_dn_0;
11631
11922
uint32_t _ptr_binary;
11632
11923
TALLOC_CTX *_mem_save_binary_0;
11633
11924
uint32_t _ptr_originating_dsa_dn;
11925
uint32_t size_originating_dsa_dn_1 = 0;
11926
uint32_t length_originating_dsa_dn_1 = 0;
11634
11927
TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11635
11928
if (ndr_flags & NDR_SCALARS) {
11636
11929
NDR_CHECK(ndr_pull_align(ndr, 8));
11674
11967
NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11675
11968
NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11676
11969
NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11677
if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11678
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->attribute_name), ndr_get_array_length(ndr, &r->attribute_name));
11970
size_attribute_name_1 = ndr_get_array_size(ndr, &r->attribute_name);
11971
length_attribute_name_1 = ndr_get_array_length(ndr, &r->attribute_name);
11972
if (length_attribute_name_1 > size_attribute_name_1) {
11973
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_attribute_name_1, length_attribute_name_1);
11679
11974
}
11680
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11681
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11975
NDR_CHECK(ndr_check_string_terminator(ndr, length_attribute_name_1, sizeof(uint16_t)));
11976
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, length_attribute_name_1, sizeof(uint16_t), CH_UTF16));
11682
11977
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11683
11978
}
11684
11979
if (r->object_dn) {
11686
11981
NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11687
11982
NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11688
11983
NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11689
if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11690
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
11984
size_object_dn_1 = ndr_get_array_size(ndr, &r->object_dn);
11985
length_object_dn_1 = ndr_get_array_length(ndr, &r->object_dn);
11986
if (length_object_dn_1 > size_object_dn_1) {
11987
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_object_dn_1, length_object_dn_1);
11691
11988
}
11692
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11693
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11989
NDR_CHECK(ndr_check_string_terminator(ndr, length_object_dn_1, sizeof(uint16_t)));
11990
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, length_object_dn_1, sizeof(uint16_t), CH_UTF16));
11694
11991
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11695
11992
}
11696
11993
if (r->binary) {
11704
12001
NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11705
12002
NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11706
12003
NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11707
if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11708
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->originating_dsa_dn), ndr_get_array_length(ndr, &r->originating_dsa_dn));
12004
size_originating_dsa_dn_1 = ndr_get_array_size(ndr, &r->originating_dsa_dn);
12005
length_originating_dsa_dn_1 = ndr_get_array_length(ndr, &r->originating_dsa_dn);
12006
if (length_originating_dsa_dn_1 > size_originating_dsa_dn_1) {
12007
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_originating_dsa_dn_1, length_originating_dsa_dn_1);
11709
12008
}
11710
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11711
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->originating_dsa_dn, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t), CH_UTF16));
12009
NDR_CHECK(ndr_check_string_terminator(ndr, length_originating_dsa_dn_1, sizeof(uint16_t)));
12010
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->originating_dsa_dn, length_originating_dsa_dn_1, sizeof(uint16_t), CH_UTF16));
11712
12011
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11713
12012
}
11714
12013
}
11777
12076
11778
12077
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11779
12078
{
12079
uint32_t size_array_0 = 0;
11780
12080
uint32_t cntr_array_0;
11781
12081
TALLOC_CTX *_mem_save_array_0;
11782
12082
if (ndr_flags & NDR_SCALARS) {
11784
12084
NDR_CHECK(ndr_pull_align(ndr, 8));
11785
12085
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11786
12086
NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11787
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12087
size_array_0 = ndr_get_array_size(ndr, &r->array);
12088
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
11788
12089
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11789
12090
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11790
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12091
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11791
12092
NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11792
12093
}
11793
12094
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11797
12098
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11798
12099
}
11799
12100
if (ndr_flags & NDR_BUFFERS) {
12101
size_array_0 = ndr_get_array_size(ndr, &r->array);
11800
12102
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11801
12103
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11802
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12104
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11803
12105
NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11804
12106
}
11805
12107
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11907
12209
11908
12210
static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11909
12211
{
12212
uint32_t size_array_0 = 0;
11910
12213
uint32_t cntr_array_0;
11911
12214
TALLOC_CTX *_mem_save_array_0;
11912
12215
if (ndr_flags & NDR_SCALARS) {
11917
12220
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11918
12221
}
11919
12222
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11920
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12223
size_array_0 = ndr_get_array_size(ndr, &r->array);
12224
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
11921
12225
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11922
12226
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11923
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12227
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
11924
12228
NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11925
12229
}
11926
12230
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11982
12286
static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11983
12287
{
11984
12288
uint32_t _ptr_str1;
12289
uint32_t size_str1_1 = 0;
12290
uint32_t length_str1_1 = 0;
11985
12291
TALLOC_CTX *_mem_save_str1_0;
11986
12292
if (ndr_flags & NDR_SCALARS) {
11987
12293
NDR_CHECK(ndr_pull_align(ndr, 8));
12006
12312
NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
12007
12313
NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
12008
12314
NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
12009
if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
12010
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->str1), ndr_get_array_length(ndr, &r->str1));
12315
size_str1_1 = ndr_get_array_size(ndr, &r->str1);
12316
length_str1_1 = ndr_get_array_length(ndr, &r->str1);
12317
if (length_str1_1 > size_str1_1) {
12318
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_str1_1, length_str1_1);
12011
12319
}
12012
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
12013
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
12320
NDR_CHECK(ndr_check_string_terminator(ndr, length_str1_1, sizeof(uint16_t)));
12321
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, length_str1_1, sizeof(uint16_t), CH_UTF16));
12014
12322
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
12015
12323
}
12016
12324
}
12060
12368
12061
12369
static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
12062
12370
{
12371
uint32_t size_array_0 = 0;
12063
12372
uint32_t cntr_array_0;
12064
12373
TALLOC_CTX *_mem_save_array_0;
12065
12374
if (ndr_flags & NDR_SCALARS) {
12070
12379
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12071
12380
}
12072
12381
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12073
NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12382
size_array_0 = ndr_get_array_size(ndr, &r->array);
12383
NDR_PULL_ALLOC_N(ndr, r->array, size_array_0);
12074
12384
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12075
12385
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12076
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12386
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
12077
12387
NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
12078
12388
}
12079
12389
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12083
12393
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12084
12394
}
12085
12395
if (ndr_flags & NDR_BUFFERS) {
12396
size_array_0 = ndr_get_array_size(ndr, &r->array);
12086
12397
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12087
12398
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12088
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12399
for (cntr_array_0 = 0; cntr_array_0 < size_array_0; cntr_array_0++) {
12089
12400
NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
12090
12401
}
12091
12402
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12289
12600
int level;
12290
12601
uint32_t _level;
12291
12602
TALLOC_CTX *_mem_save_neighbours_0;
12603
uint32_t _ptr_neighbours;
12292
12604
TALLOC_CTX *_mem_save_cursors_0;
12605
uint32_t _ptr_cursors;
12293
12606
TALLOC_CTX *_mem_save_objmetadata_0;
12607
uint32_t _ptr_objmetadata;
12294
12608
TALLOC_CTX *_mem_save_connectfailures_0;
12609
uint32_t _ptr_connectfailures;
12295
12610
TALLOC_CTX *_mem_save_linkfailures_0;
12611
uint32_t _ptr_linkfailures;
12296
12612
TALLOC_CTX *_mem_save_pendingops_0;
12613
uint32_t _ptr_pendingops;
12297
12614
TALLOC_CTX *_mem_save_attrvalmetadata_0;
12615
uint32_t _ptr_attrvalmetadata;
12298
12616
TALLOC_CTX *_mem_save_cursors2_0;
12617
uint32_t _ptr_cursors2;
12299
12618
TALLOC_CTX *_mem_save_cursors3_0;
12619
uint32_t _ptr_cursors3;
12300
12620
TALLOC_CTX *_mem_save_objmetadata2_0;
12621
uint32_t _ptr_objmetadata2;
12301
12622
TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12623
uint32_t _ptr_attrvalmetadata2;
12302
12624
TALLOC_CTX *_mem_save_neighbours02_0;
12625
uint32_t _ptr_neighbours02;
12303
12626
TALLOC_CTX *_mem_save_connections04_0;
12627
uint32_t _ptr_connections04;
12304
12628
TALLOC_CTX *_mem_save_cursors05_0;
12629
uint32_t _ptr_cursors05;
12305
12630
TALLOC_CTX *_mem_save_i06_0;
12631
uint32_t _ptr_i06;
12306
12632
level = ndr_pull_get_switch_value(ndr, r);
12307
12633
if (ndr_flags & NDR_SCALARS) {
12308
12634
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12312
12638
NDR_CHECK(ndr_pull_union_align(ndr, 5));
12313
12639
switch (level) {
12314
12640
case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12315
uint32_t _ptr_neighbours;
12316
12641
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12317
12642
if (_ptr_neighbours) {
12318
12643
NDR_PULL_ALLOC(ndr, r->neighbours);
12322
12647
break; }
12323
12648
12324
12649
case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12325
uint32_t _ptr_cursors;
12326
12650
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12327
12651
if (_ptr_cursors) {
12328
12652
NDR_PULL_ALLOC(ndr, r->cursors);
12332
12656
break; }
12333
12657
12334
12658
case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12335
uint32_t _ptr_objmetadata;
12336
12659
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12337
12660
if (_ptr_objmetadata) {
12338
12661
NDR_PULL_ALLOC(ndr, r->objmetadata);
12342
12665
break; }
12343
12666
12344
12667
case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12345
uint32_t _ptr_connectfailures;
12346
12668
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12347
12669
if (_ptr_connectfailures) {
12348
12670
NDR_PULL_ALLOC(ndr, r->connectfailures);
12352
12674
break; }
12353
12675
12354
12676
case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12355
uint32_t _ptr_linkfailures;
12356
12677
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12357
12678
if (_ptr_linkfailures) {
12358
12679
NDR_PULL_ALLOC(ndr, r->linkfailures);
12362
12683
break; }
12363
12684
12364
12685
case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12365
uint32_t _ptr_pendingops;
12366
12686
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12367
12687
if (_ptr_pendingops) {
12368
12688
NDR_PULL_ALLOC(ndr, r->pendingops);
12372
12692
break; }
12373
12693
12374
12694
case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12375
uint32_t _ptr_attrvalmetadata;
12376
12695
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12377
12696
if (_ptr_attrvalmetadata) {
12378
12697
NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12382
12701
break; }
12383
12702
12384
12703
case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12385
uint32_t _ptr_cursors2;
12386
12704
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12387
12705
if (_ptr_cursors2) {
12388
12706
NDR_PULL_ALLOC(ndr, r->cursors2);
12392
12710
break; }
12393
12711
12394
12712
case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12395
uint32_t _ptr_cursors3;
12396
12713
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12397
12714
if (_ptr_cursors3) {
12398
12715
NDR_PULL_ALLOC(ndr, r->cursors3);
12402
12719
break; }
12403
12720
12404
12721
case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12405
uint32_t _ptr_objmetadata2;
12406
12722
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12407
12723
if (_ptr_objmetadata2) {
12408
12724
NDR_PULL_ALLOC(ndr, r->objmetadata2);
12412
12728
break; }
12413
12729
12414
12730
case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12415
uint32_t _ptr_attrvalmetadata2;
12416
12731
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12417
12732
if (_ptr_attrvalmetadata2) {
12418
12733
NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12422
12737
break; }
12423
12738
12424
12739
case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12425
uint32_t _ptr_neighbours02;
12426
12740
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
12427
12741
if (_ptr_neighbours02) {
12428
12742
NDR_PULL_ALLOC(ndr, r->neighbours02);
12432
12746
break; }
12433
12747
12434
12748
case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12435
uint32_t _ptr_connections04;
12436
12749
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
12437
12750
if (_ptr_connections04) {
12438
12751
NDR_PULL_ALLOC(ndr, r->connections04);
12442
12755
break; }
12443
12756
12444
12757
case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12445
uint32_t _ptr_cursors05;
12446
12758
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
12447
12759
if (_ptr_cursors05) {
12448
12760
NDR_PULL_ALLOC(ndr, r->cursors05);
12452
12764
break; }
12453
12765
12454
12766
case DRSUAPI_DS_REPLICA_INFO_06: {
12455
uint32_t _ptr_i06;
12456
12767
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
12457
12768
if (_ptr_i06) {
12458
12769
NDR_PULL_ALLOC(ndr, r->i06);
12860
13171
static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12861
13172
{
12862
13173
uint32_t _ptr_req_array;
13174
uint32_t size_req_array_1 = 0;
12863
13175
uint32_t cntr_req_array_1;
12864
13176
TALLOC_CTX *_mem_save_req_array_0;
12865
13177
TALLOC_CTX *_mem_save_req_array_1;
12883
13195
_mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12884
13196
NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12885
13197
NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12886
NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
13198
size_req_array_1 = ndr_get_array_size(ndr, &r->req_array);
13199
NDR_PULL_ALLOC_N(ndr, r->req_array, size_req_array_1);
12887
13200
_mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12888
13201
NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12889
for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
13202
for (cntr_req_array_1 = 0; cntr_req_array_1 < size_req_array_1; cntr_req_array_1++) {
12890
13203
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12891
13204
if (_ptr_req_array) {
12892
13205
NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12894
13207
r->req_array[cntr_req_array_1] = NULL;
12895
13208
}
12896
13209
}
12897
for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
13210
for (cntr_req_array_1 = 0; cntr_req_array_1 < size_req_array_1; cntr_req_array_1++) {
12898
13211
if (r->req_array[cntr_req_array_1]) {
12899
13212
_mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12900
13213
NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
13077
13390
static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
13078
13391
{
13079
13392
uint32_t _ptr_info;
13393
uint32_t size_info_1 = 0;
13080
13394
uint32_t cntr_info_1;
13081
13395
TALLOC_CTX *_mem_save_info_0;
13082
13396
TALLOC_CTX *_mem_save_info_1;
13100
13414
_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13101
13415
NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
13102
13416
NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
13103
NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
13417
size_info_1 = ndr_get_array_size(ndr, &r->info);
13418
NDR_PULL_ALLOC_N(ndr, r->info, size_info_1);
13104
13419
_mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
13105
13420
NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
13106
for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
13421
for (cntr_info_1 = 0; cntr_info_1 < size_info_1; cntr_info_1++) {
13107
13422
NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
13108
13423
}
13109
13424
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
13257
13572
static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13258
13573
{
13259
13574
uint32_t _ptr_site_from;
13575
uint32_t size_site_from_1 = 0;
13576
uint32_t length_site_from_1 = 0;
13260
13577
TALLOC_CTX *_mem_save_site_from_0;
13261
13578
uint32_t _ptr_site_to;
13579
uint32_t size_site_to_1 = 0;
13262
13580
uint32_t cntr_site_to_1;
13581
uint32_t size_site_to_3 = 0;
13582
uint32_t length_site_to_3 = 0;
13263
13583
TALLOC_CTX *_mem_save_site_to_0;
13264
13584
TALLOC_CTX *_mem_save_site_to_1;
13265
13585
TALLOC_CTX *_mem_save_site_to_2;
13290
13610
NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13291
13611
NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13292
13612
NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13293
if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13294
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_from), ndr_get_array_length(ndr, &r->site_from));
13613
size_site_from_1 = ndr_get_array_size(ndr, &r->site_from);
13614
length_site_from_1 = ndr_get_array_length(ndr, &r->site_from);
13615
if (length_site_from_1 > size_site_from_1) {
13616
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_from_1, length_site_from_1);
13295
13617
}
13296
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13297
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13618
NDR_CHECK(ndr_check_string_terminator(ndr, length_site_from_1, sizeof(uint16_t)));
13619
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, length_site_from_1, sizeof(uint16_t), CH_UTF16));
13298
13620
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13299
13621
}
13300
13622
if (r->site_to) {
13301
13623
_mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13302
13624
NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13303
13625
NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13304
NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13626
size_site_to_1 = ndr_get_array_size(ndr, &r->site_to);
13627
NDR_PULL_ALLOC_N(ndr, r->site_to, size_site_to_1);
13305
13628
_mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13306
13629
NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13307
for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13630
for (cntr_site_to_1 = 0; cntr_site_to_1 < size_site_to_1; cntr_site_to_1++) {
13308
13631
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13309
13632
if (_ptr_site_to) {
13310
13633
NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13312
13635
r->site_to[cntr_site_to_1] = NULL;
13313
13636
}
13314
13637
}
13315
for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13638
for (cntr_site_to_1 = 0; cntr_site_to_1 < size_site_to_1; cntr_site_to_1++) {
13316
13639
if (r->site_to[cntr_site_to_1]) {
13317
13640
_mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13318
13641
NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13319
13642
NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13320
13643
NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13321
if (ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]) > ndr_get_array_size(ndr, &r->site_to[cntr_site_to_1])) {
13322
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->site_to[cntr_site_to_1]), ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]));
13644
size_site_to_3 = ndr_get_array_size(ndr, &r->site_to[cntr_site_to_1]);
13645
length_site_to_3 = ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]);
13646
if (length_site_to_3 > size_site_to_3) {
13647
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_site_to_3, length_site_to_3);
13323
13648
}
13324
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13325
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_to[cntr_site_to_1], ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t), CH_UTF16));
13649
NDR_CHECK(ndr_check_string_terminator(ndr, length_site_to_3, sizeof(uint16_t)));
13650
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_to[cntr_site_to_1], length_site_to_3, sizeof(uint16_t), CH_UTF16));
13326
13651
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13327
13652
}
13328
13653
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1