← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/drsblobs.h

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
librpc/gen_ndr/drsblobs.h
 
1
/* header auto-generated by pidl */
 
2
 
 
3
#include <stdint.h>
 
4
 
 
5
#include "libcli/util/ntstatus.h"
 
6
 
 
7
#include "librpc/gen_ndr/drsuapi.h"
 
8
#include "librpc/gen_ndr/misc.h"
 
9
#include "librpc/gen_ndr/samr.h"
 
10
#include "librpc/gen_ndr/lsa.h"
 
11
#ifndef _HEADER_drsblobs
 
12
#define _HEADER_drsblobs
 
13
 
 
14
#define SUPPLEMENTAL_CREDENTIALS_PREFIX ( "                                                " )
 
15
struct replPropertyMetaData1 {
 
16
        enum drsuapi_DsAttributeId attid;
 
17
        uint32_t version;
 
18
        NTTIME originating_change_time;
 
19
        struct GUID originating_invocation_id;
 
20
        uint64_t originating_usn;
 
21
        uint64_t local_usn;
 
22
};
 
23
 
 
24
struct replPropertyMetaDataCtr1 {
 
25
        uint32_t count;
 
26
        uint32_t reserved;
 
27
        struct replPropertyMetaData1 *array;
 
28
};
 
29
 
 
30
union replPropertyMetaDataCtr {
 
31
        struct replPropertyMetaDataCtr1 ctr1;/* [case] */
 
32
}/* [nodiscriminant] */;
 
33
 
 
34
struct replPropertyMetaDataBlob {
 
35
        uint32_t version;
 
36
        uint32_t reserved;
 
37
        union replPropertyMetaDataCtr ctr;/* [switch_is(version)] */
 
38
}/* [public] */;
 
39
 
 
40
struct replUpToDateVectorCtr1 {
 
41
        uint32_t count;
 
42
        uint32_t reserved;
 
43
        struct drsuapi_DsReplicaCursor *cursors;
 
44
};
 
45
 
 
46
struct replUpToDateVectorCtr2 {
 
47
        uint32_t count;
 
48
        uint32_t reserved;
 
49
        struct drsuapi_DsReplicaCursor2 *cursors;
 
50
};
 
51
 
 
52
union replUpToDateVectorCtr {
 
53
        struct replUpToDateVectorCtr1 ctr1;/* [case] */
 
54
        struct replUpToDateVectorCtr2 ctr2;/* [case(2)] */
 
55
}/* [nodiscriminant] */;
 
56
 
 
57
struct replUpToDateVectorBlob {
 
58
        uint32_t version;
 
59
        uint32_t reserved;
 
60
        union replUpToDateVectorCtr ctr;/* [switch_is(version)] */
 
61
}/* [public] */;
 
62
 
 
63
struct repsFromTo1OtherInfo {
 
64
        uint32_t __dns_name_size;/* [value(strlen(dns_name)+1)] */
 
65
        const char *dns_name;/* [charset(DOS)] */
 
66
}/* [gensize,public] */;
 
67
 
 
68
struct repsFromTo1 {
 
69
        uint32_t blobsize;/* [value(ndr_size_repsFromTo1(this,ndr->iconv_convenience,ndr->flags)+8)] */
 
70
        uint32_t consecutive_sync_failures;
 
71
        NTTIME last_success;
 
72
        NTTIME last_attempt;
 
73
        WERROR result_last_attempt;
 
74
        struct repsFromTo1OtherInfo *other_info;/* [relative] */
 
75
        uint32_t other_info_length;/* [value(ndr_size_repsFromTo1OtherInfo(other_info,ndr->iconv_convenience,ndr->flags))] */
 
76
        uint32_t replica_flags;
 
77
        uint8_t schedule[84];
 
78
        uint32_t reserved;
 
79
        struct drsuapi_DsReplicaHighWaterMark highwatermark;
 
80
        struct GUID source_dsa_obj_guid;
 
81
        struct GUID source_dsa_invocation_id;
 
82
        struct GUID transport_guid;
 
83
}/* [gensize,public,flag(LIBNDR_PRINT_ARRAY_HEX)] */;
 
84
 
 
85
union repsFromTo {
 
86
        struct repsFromTo1 ctr1;/* [case] */
 
87
}/* [nodiscriminant] */;
 
88
 
 
89
struct repsFromToBlob {
 
90
        uint32_t version;
 
91
        uint32_t reserved;
 
92
        union repsFromTo ctr;/* [switch_is(version)] */
 
93
}/* [public] */;
 
94
 
 
95
struct partialAttributeSetCtr1 {
 
96
        uint32_t count;
 
97
        enum drsuapi_DsAttributeId *array;
 
98
};
 
99
 
 
100
union partialAttributeSetCtr {
 
101
        struct partialAttributeSetCtr1 ctr1;/* [case] */
 
102
}/* [nodiscriminant] */;
 
103
 
 
104
struct partialAttributeSetBlob {
 
105
        uint32_t version;
 
106
        uint32_t reserved;
 
107
        union partialAttributeSetCtr ctr;/* [switch_is(version)] */
 
108
}/* [public] */;
 
109
 
 
110
enum prefixMapVersion
 
111
#ifndef USE_UINT_ENUMS
 
112
 {
 
113
        PREFIX_MAP_VERSION_DSDB=0x44534442
 
114
}
 
115
#else
 
116
 { __donnot_use_enum_prefixMapVersion=0x7FFFFFFF}
 
117
#define PREFIX_MAP_VERSION_DSDB ( 0x44534442 )
 
118
#endif
 
119
;
 
120
 
 
121
union prefixMapCtr {
 
122
        struct drsuapi_DsReplicaOIDMapping_Ctr dsdb;/* [case(PREFIX_MAP_VERSION_DSDB)] */
 
123
}/* [nodiscriminant] */;
 
124
 
 
125
struct prefixMapBlob {
 
126
        enum prefixMapVersion version;
 
127
        uint32_t reserved;
 
128
        union prefixMapCtr ctr;/* [switch_is(version)] */
 
129
}/* [public] */;
 
130
 
 
131
union ldapControlDirSyncExtra {
 
132
        struct replUpToDateVectorBlob uptodateness_vector;/* [default] */
 
133
}/* [gensize,nodiscriminant] */;
 
134
 
 
135
struct ldapControlDirSyncBlob {
 
136
        uint32_t u1;/* [value(3)] */
 
137
        NTTIME time;
 
138
        uint32_t u2;
 
139
        uint32_t u3;
 
140
        uint32_t extra_length;/* [value(ndr_size_ldapControlDirSyncExtra(&extra,extra.uptodateness_vector.version,ndr->iconv_convenience,0))] */
 
141
        struct drsuapi_DsReplicaHighWaterMark highwatermark;
 
142
        struct GUID guid1;
 
143
        union ldapControlDirSyncExtra extra;/* [switch_is(extra_length)] */
 
144
};
 
145
 
 
146
struct ldapControlDirSyncCookie {
 
147
        const char *msds;/* [value("MSDS"),charset(DOS)] */
 
148
        struct ldapControlDirSyncBlob blob;/* [subcontext(0)] */
 
149
}/* [relative_base,public] */;
 
150
 
 
151
struct supplementalCredentialsPackage {
 
152
        uint16_t name_len;/* [value(2*strlen_m(name))] */
 
153
        uint16_t data_len;/* [value(strlen(data))] */
 
154
        uint16_t reserved;
 
155
        const char *name;/* [charset(UTF16)] */
 
156
        const char *data;/* [charset(DOS)] */
 
157
};
 
158
 
 
159
enum supplementalCredentialsSignature
 
160
#ifndef USE_UINT_ENUMS
 
161
 {
 
162
        SUPPLEMENTAL_CREDENTIALS_SIGNATURE=0x0050
 
163
}
 
164
#else
 
165
 { __donnot_use_enum_supplementalCredentialsSignature=0x7FFFFFFF}
 
166
#define SUPPLEMENTAL_CREDENTIALS_SIGNATURE ( 0x0050 )
 
167
#endif
 
168
;
 
169
 
 
170
struct supplementalCredentialsSubBlob {
 
171
        const char *prefix;/* [value(SUPPLEMENTAL_CREDENTIALS_PREFIX),charset(UTF16)] */
 
172
        enum supplementalCredentialsSignature signature;/* [value(SUPPLEMENTAL_CREDENTIALS_SIGNATURE)] */
 
173
        uint16_t num_packages;
 
174
        struct supplementalCredentialsPackage *packages;
 
175
}/* [gensize] */;
 
176
 
 
177
struct supplementalCredentialsBlob {
 
178
        uint32_t unknown1;/* [value(0)] */
 
179
        uint32_t __ndr_size;/* [value(ndr_size_supplementalCredentialsSubBlob(&sub,ndr->iconv_convenience,ndr->flags))] */
 
180
        uint32_t unknown2;/* [value(0)] */
 
181
        struct supplementalCredentialsSubBlob sub;/* [subcontext_size(__ndr_size),subcontext(0)] */
 
182
        uint8_t unknown3;/* [value(0)] */
 
183
}/* [public] */;
 
184
 
 
185
struct package_PackagesBlob {
 
186
        const char ** names;/* [flag(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING)] */
 
187
}/* [public] */;
 
188
 
 
189
struct package_PrimaryKerberosString {
 
190
        uint16_t length;/* [value(2*strlen_m(string))] */
 
191
        uint16_t size;/* [value(2*strlen_m(string))] */
 
192
        const char * string;/* [relative,subcontext_size(size),subcontext(0),flag(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING)] */
 
193
};
 
194
 
 
195
struct package_PrimaryKerberosKey3 {
 
196
        uint16_t reserved1;/* [value(0)] */
 
197
        uint16_t reserved2;/* [value(0)] */
 
198
        uint32_t reserved3;/* [value(0)] */
 
199
        uint32_t keytype;
 
200
        uint32_t value_len;/* [value((value?value->length:0))] */
 
201
        DATA_BLOB *value;/* [relative,subcontext_size(value_len),subcontext(0),flag(LIBNDR_FLAG_REMAINING)] */
 
202
};
 
203
 
 
204
struct package_PrimaryKerberosCtr3 {
 
205
        uint16_t num_keys;
 
206
        uint16_t num_old_keys;
 
207
        struct package_PrimaryKerberosString salt;
 
208
        struct package_PrimaryKerberosKey3 *keys;
 
209
        struct package_PrimaryKerberosKey3 *old_keys;
 
210
        uint32_t padding1;/* [value(0)] */
 
211
        uint32_t padding2;/* [value(0)] */
 
212
        uint32_t padding3;/* [value(0)] */
 
213
        uint32_t padding4;/* [value(0)] */
 
214
        uint32_t padding5;/* [value(0)] */
 
215
};
 
216
 
 
217
struct package_PrimaryKerberosKey4 {
 
218
        uint16_t reserved1;/* [value(0)] */
 
219
        uint16_t reserved2;/* [value(0)] */
 
220
        uint32_t reserved3;/* [value(0)] */
 
221
        uint32_t iteration_count;
 
222
        uint32_t keytype;
 
223
        uint32_t value_len;/* [value((value?value->length:0))] */
 
224
        DATA_BLOB *value;/* [relative,subcontext_size(value_len),subcontext(0),flag(LIBNDR_FLAG_REMAINING)] */
 
225
};
 
226
 
 
227
struct package_PrimaryKerberosCtr4 {
 
228
        uint16_t num_keys;
 
229
        uint16_t num_service_keys;/* [value(0)] */
 
230
        uint16_t num_old_keys;
 
231
        uint16_t num_older_keys;
 
232
        struct package_PrimaryKerberosString salt;
 
233
        uint32_t default_iteration_count;
 
234
        struct package_PrimaryKerberosKey4 *keys;
 
235
        struct package_PrimaryKerberosKey4 *service_keys;
 
236
        struct package_PrimaryKerberosKey4 *old_keys;
 
237
        struct package_PrimaryKerberosKey4 *older_keys;
 
238
};
 
239
 
 
240
union package_PrimaryKerberosCtr {
 
241
        struct package_PrimaryKerberosCtr3 ctr3;/* [case(3)] */
 
242
        struct package_PrimaryKerberosCtr4 ctr4;/* [case(4)] */
 
243
}/* [nodiscriminant] */;
 
244
 
 
245
struct package_PrimaryKerberosBlob {
 
246
        uint16_t version;
 
247
        uint16_t flags;/* [value(0)] */
 
248
        union package_PrimaryKerberosCtr ctr;/* [switch_is(version)] */
 
249
}/* [public] */;
 
250
 
 
251
struct package_PrimaryCLEARTEXTBlob {
 
252
        DATA_BLOB cleartext;/* [flag(LIBNDR_FLAG_REMAINING)] */
 
253
}/* [public] */;
 
254
 
 
255
struct package_PrimaryWDigestHash {
 
256
        uint8_t hash[16];
 
257
}/* [flag(LIBNDR_PRINT_ARRAY_HEX)] */;
 
258
 
 
259
struct package_PrimaryWDigestBlob {
 
260
        uint16_t unknown1;/* [value(0x31)] */
 
261
        uint8_t unknown2;/* [value(0x01)] */
 
262
        uint8_t num_hashes;
 
263
        uint32_t unknown3;/* [value(0)] */
 
264
        uint64_t uuknown4;/* [value(0)] */
 
265
        struct package_PrimaryWDigestHash *hashes;
 
266
}/* [public] */;
 
267
 
 
268
struct AuthInfoNone {
 
269
        uint32_t size;/* [value(0)] */
 
270
};
 
271
 
 
272
struct AuthInfoNT4Owf {
 
273
        uint32_t size;/* [value(16)] */
 
274
        struct samr_Password password;
 
275
};
 
276
 
 
277
struct AuthInfoClear {
 
278
        uint32_t size;
 
279
        uint8_t *password;
 
280
};
 
281
 
 
282
struct AuthInfoVersion {
 
283
        uint32_t size;/* [value(4)] */
 
284
        uint32_t version;
 
285
};
 
286
 
 
287
union AuthInfo {
 
288
        struct AuthInfoNone none;/* [case(TRUST_AUTH_TYPE_NONE)] */
 
289
        struct AuthInfoNT4Owf nt4owf;/* [case(TRUST_AUTH_TYPE_NT4OWF)] */
 
290
        struct AuthInfoClear clear;/* [case(TRUST_AUTH_TYPE_CLEAR)] */
 
291
        struct AuthInfoVersion version;/* [case(TRUST_AUTH_TYPE_VERSION)] */
 
292
}/* [nodiscriminant] */;
 
293
 
 
294
struct AuthenticationInformation {
 
295
        NTTIME LastUpdateTime;
 
296
        enum lsa_TrustAuthType AuthType;
 
297
        union AuthInfo AuthInfo;/* [switch_is(AuthType)] */
 
298
        DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN4)] */
 
299
}/* [public] */;
 
300
 
 
301
struct AuthenticationInformationArray {
 
302
        struct AuthenticationInformation *array;/* [size_is] */
 
303
}/* [noprint,nopush,nopull] */;
 
304
 
 
305
struct trustAuthInOutBlob {
 
306
        uint32_t count;
 
307
        struct AuthenticationInformationArray *current;/* [relative] */
 
308
        struct AuthenticationInformationArray *previous;/* [relative] */
 
309
}/* [noprint,gensize,nopull,public,nopush] */;
 
310
 
 
311
struct trustCurrentPasswords {
 
312
        uint32_t count;
 
313
        struct AuthenticationInformation **current;/* [relative] */
 
314
}/* [gensize,public] */;
 
315
 
 
316
struct trustDomainPasswords {
 
317
        uint8_t confounder[512];
 
318
        struct trustCurrentPasswords outgoing;/* [subcontext_size(outgoing_size),subcontext(0)] */
 
319
        struct trustCurrentPasswords incoming;/* [subcontext_size(incoming_size),subcontext(0)] */
 
320
        uint32_t outgoing_size;/* [value(ndr_size_trustCurrentPasswords(&outgoing,ndr->iconv_convenience,ndr->flags))] */
 
321
        uint32_t incoming_size;/* [value(ndr_size_trustCurrentPasswords(&incoming,ndr->iconv_convenience,ndr->flags))] */
 
322
}/* [public,nopull] */;
 
323
 
 
324
struct DsCompressedChunk {
 
325
        uint32_t marker;
 
326
        DATA_BLOB data;
 
327
}/* [public] */;
 
328
 
 
329
struct ExtendedErrorAString {
 
330
        uint16_t __size;
 
331
        const char *string;/* [unique,charset(DOS),size_is(__size)] */
 
332
};
 
333
 
 
334
struct ExtendedErrorUString {
 
335
        uint16_t __size;
 
336
        const char *string;/* [unique,charset(UTF16),size_is(__size)] */
 
337
};
 
338
 
 
339
struct ExtendedErrorBlob {
 
340
        uint16_t length;
 
341
        uint8_t *data;/* [unique,size_is(length)] */
 
342
};
 
343
 
 
344
enum ExtendedErrorComputerNamePresent
 
345
#ifndef USE_UINT_ENUMS
 
346
 {
 
347
        EXTENDED_ERROR_COMPUTER_NAME_PRESENT=1,
 
348
        EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT=2
 
349
}
 
350
#else
 
351
 { __donnot_use_enum_ExtendedErrorComputerNamePresent=0x7FFFFFFF}
 
352
#define EXTENDED_ERROR_COMPUTER_NAME_PRESENT ( 1 )
 
353
#define EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT ( 2 )
 
354
#endif
 
355
;
 
356
 
 
357
union ExtendedErrorComputerNameU {
 
358
        struct ExtendedErrorUString name;/* [case(EXTENDED_ERROR_COMPUTER_NAME_PRESENT)] */
 
359
}/* [switch_type(ExtendedErrorComputerNamePresent)] */;
 
360
 
 
361
struct ExtendedErrorComputerName {
 
362
        enum ExtendedErrorComputerNamePresent present;
 
363
        union ExtendedErrorComputerNameU n;/* [switch_is(present)] */
 
364
};
 
365
 
 
366
enum ExtendedErrorParamType
 
367
#ifndef USE_UINT_ENUMS
 
368
 {
 
369
        EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING=1,
 
370
        EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING=2,
 
371
        EXTENDED_ERROR_PARAM_TYPE_UINT32=3,
 
372
        EXTENDED_ERROR_PARAM_TYPE_UINT16=4,
 
373
        EXTENDED_ERROR_PARAM_TYPE_UINT64=5,
 
374
        EXTENDED_ERROR_PARAM_TYPE_NONE=6,
 
375
        EXTENDED_ERROR_PARAM_TYPE_BLOB=7
 
376
}
 
377
#else
 
378
 { __donnot_use_enum_ExtendedErrorParamType=0x7FFFFFFF}
 
379
#define EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING ( 1 )
 
380
#define EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING ( 2 )
 
381
#define EXTENDED_ERROR_PARAM_TYPE_UINT32 ( 3 )
 
382
#define EXTENDED_ERROR_PARAM_TYPE_UINT16 ( 4 )
 
383
#define EXTENDED_ERROR_PARAM_TYPE_UINT64 ( 5 )
 
384
#define EXTENDED_ERROR_PARAM_TYPE_NONE ( 6 )
 
385
#define EXTENDED_ERROR_PARAM_TYPE_BLOB ( 7 )
 
386
#endif
 
387
;
 
388
 
 
389
union ExtendedErrorParamU {
 
390
        struct ExtendedErrorAString a_string;/* [case(EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING)] */
 
391
        struct ExtendedErrorUString u_string;/* [case(EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING)] */
 
392
        uint32_t uint32;/* [case(EXTENDED_ERROR_PARAM_TYPE_UINT32)] */
 
393
        uint16_t uint16;/* [case(EXTENDED_ERROR_PARAM_TYPE_UINT16)] */
 
394
        uint64_t uint64;/* [case(EXTENDED_ERROR_PARAM_TYPE_UINT64)] */
 
395
        struct ExtendedErrorBlob blob;/* [case(EXTENDED_ERROR_PARAM_TYPE_BLOB)] */
 
396
}/* [switch_type(ExtendedErrorParamType)] */;
 
397
 
 
398
struct ExtendedErrorParam {
 
399
        enum ExtendedErrorParamType type;
 
400
        union ExtendedErrorParamU p;/* [switch_is(type)] */
 
401
};
 
402
 
 
403
struct ExtendedErrorInfo {
 
404
        struct ExtendedErrorInfo *next;/* [unique] */
 
405
        struct ExtendedErrorComputerName computer_name;
 
406
        uint64_t pid;
 
407
        NTTIME time;
 
408
        uint32_t generating_component;
 
409
        WERROR status;
 
410
        uint16_t detection_location;
 
411
        uint16_t flags;
 
412
        uint16_t num_params;
 
413
        struct ExtendedErrorParam *params;/* [size_is(num_params)] */
 
414
}/* [public] */;
 
415
 
 
416
struct ExtendedErrorInfoPtr {
 
417
        struct ExtendedErrorInfo *info;/* [unique] */
 
418
};
 
419
 
 
420
 
 
421
struct decode_replPropertyMetaData {
 
422
        struct {
 
423
                struct replPropertyMetaDataBlob blob;
 
424
        } in;
 
425
 
 
426
};
 
427
 
 
428
 
 
429
struct decode_replUpToDateVector {
 
430
        struct {
 
431
                struct replUpToDateVectorBlob blob;
 
432
        } in;
 
433
 
 
434
};
 
435
 
 
436
 
 
437
struct decode_repsFromTo {
 
438
        struct {
 
439
                struct repsFromToBlob blob;
 
440
        } in;
 
441
 
 
442
};
 
443
 
 
444
 
 
445
struct decode_partialAttributeSet {
 
446
        struct {
 
447
                struct partialAttributeSetBlob blob;
 
448
        } in;
 
449
 
 
450
};
 
451
 
 
452
 
 
453
struct decode_prefixMap {
 
454
        struct {
 
455
                struct prefixMapBlob blob;
 
456
        } in;
 
457
 
 
458
};
 
459
 
 
460
 
 
461
struct decode_ldapControlDirSync {
 
462
        struct {
 
463
                struct ldapControlDirSyncCookie cookie;
 
464
        } in;
 
465
 
 
466
};
 
467
 
 
468
 
 
469
struct decode_supplementalCredentials {
 
470
        struct {
 
471
                struct supplementalCredentialsBlob blob;
 
472
        } in;
 
473
 
 
474
};
 
475
 
 
476
 
 
477
struct decode_Packages {
 
478
        struct {
 
479
                struct package_PackagesBlob blob;
 
480
        } in;
 
481
 
 
482
};
 
483
 
 
484
 
 
485
struct decode_PrimaryKerberos {
 
486
        struct {
 
487
                struct package_PrimaryKerberosBlob blob;
 
488
        } in;
 
489
 
 
490
};
 
491
 
 
492
 
 
493
struct decode_PrimaryCLEARTEXT {
 
494
        struct {
 
495
                struct package_PrimaryCLEARTEXTBlob blob;
 
496
        } in;
 
497
 
 
498
};
 
499
 
 
500
 
 
501
struct decode_PrimaryWDigest {
 
502
        struct {
 
503
                struct package_PrimaryWDigestBlob blob;
 
504
        } in;
 
505
 
 
506
};
 
507
 
 
508
 
 
509
struct decode_trustAuthInOut {
 
510
        struct {
 
511
                struct trustAuthInOutBlob blob;
 
512
        } in;
 
513
 
 
514
};
 
515
 
 
516
 
 
517
struct decode_trustDomainPasswords {
 
518
        struct {
 
519
                struct trustDomainPasswords blob;
 
520
        } in;
 
521
 
 
522
};
 
523
 
 
524
 
 
525
struct decode_ExtendedErrorInfo {
 
526
        struct {
 
527
                struct ExtendedErrorInfoPtr ptr;/* [subcontext(0xFFFFFC01)] */
 
528
        } in;
 
529
 
 
530
};
 
531
 
 
532
#endif /* _HEADER_drsblobs */