← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/samba/oneiric-security

« back to all changes in this revision

Viewing changes to .pc/fix-windows7-print-connection.patch/librpc/gen_ndr/ndr_misc.c

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2011-03-02 16:05:41 UTC
  • Revision ID: james.westby@ubuntu.com-20110302160541-oi1y7yhqn9qe2phs
Tags: 2:3.5.6~dfsg-5ubuntu3
https://launchpad.net/bugs/674216
https://launchpad.net/bugs/652065
* debian/patches/fix-windows7-print-connection.patch: Fix
  error "0x000003e6" when trying to connect a Windows 7 printer
  to a domain. (LP: #674216)
* debian/samba-common.dhcp: Take in account of the upstart script.
  (LP: #652065)

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/fix-windows7-print-connection.patch/librpc/gen_ndr/ndr_misc.c
 
1
/* parser auto-generated by pidl */
 
2
 
 
3
#include "includes.h"
 
4
#include "../librpc/gen_ndr/ndr_misc.h"
 
5
 
 
6
_PUBLIC_ enum ndr_err_code ndr_push_GUID(struct ndr_push *ndr, int ndr_flags, const struct GUID *r)
 
7
{
 
8
        if (ndr_flags & NDR_SCALARS) {
 
9
                NDR_CHECK(ndr_push_align(ndr, 4));
 
10
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time_low));
 
11
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->time_mid));
 
12
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->time_hi_and_version));
 
13
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->clock_seq, 2));
 
14
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->node, 6));
 
15
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
16
        }
 
17
        if (ndr_flags & NDR_BUFFERS) {
 
18
        }
 
19
        return NDR_ERR_SUCCESS;
 
20
}
 
21
 
 
22
_PUBLIC_ enum ndr_err_code ndr_pull_GUID(struct ndr_pull *ndr, int ndr_flags, struct GUID *r)
 
23
{
 
24
        if (ndr_flags & NDR_SCALARS) {
 
25
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
26
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time_low));
 
27
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->time_mid));
 
28
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->time_hi_and_version));
 
29
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->clock_seq, 2));
 
30
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->node, 6));
 
31
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
32
        }
 
33
        if (ndr_flags & NDR_BUFFERS) {
 
34
        }
 
35
        return NDR_ERR_SUCCESS;
 
36
}
 
37
 
 
38
_PUBLIC_ size_t ndr_size_GUID(const struct GUID *r, struct smb_iconv_convenience *ic, int flags)
 
39
{
 
40
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_GUID, ic);
 
41
}
 
42
 
 
43
_PUBLIC_ enum ndr_err_code ndr_push_ndr_syntax_id(struct ndr_push *ndr, int ndr_flags, const struct ndr_syntax_id *r)
 
44
{
 
45
        if (ndr_flags & NDR_SCALARS) {
 
46
                NDR_CHECK(ndr_push_align(ndr, 4));
 
47
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
 
48
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->if_version));
 
49
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
50
        }
 
51
        if (ndr_flags & NDR_BUFFERS) {
 
52
        }
 
53
        return NDR_ERR_SUCCESS;
 
54
}
 
55
 
 
56
_PUBLIC_ enum ndr_err_code ndr_pull_ndr_syntax_id(struct ndr_pull *ndr, int ndr_flags, struct ndr_syntax_id *r)
 
57
{
 
58
        if (ndr_flags & NDR_SCALARS) {
 
59
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
60
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
 
61
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->if_version));
 
62
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
63
        }
 
64
        if (ndr_flags & NDR_BUFFERS) {
 
65
        }
 
66
        return NDR_ERR_SUCCESS;
 
67
}
 
68
 
 
69
_PUBLIC_ void ndr_print_ndr_syntax_id(struct ndr_print *ndr, const char *name, const struct ndr_syntax_id *r)
 
70
{
 
71
        ndr_print_struct(ndr, name, "ndr_syntax_id");
 
72
        ndr->depth++;
 
73
        ndr_print_GUID(ndr, "uuid", &r->uuid);
 
74
        ndr_print_uint32(ndr, "if_version", r->if_version);
 
75
        ndr->depth--;
 
76
}
 
77
 
 
78
_PUBLIC_ enum ndr_err_code ndr_push_policy_handle(struct ndr_push *ndr, int ndr_flags, const struct policy_handle *r)
 
79
{
 
80
        if (ndr_flags & NDR_SCALARS) {
 
81
                NDR_CHECK(ndr_push_align(ndr, 4));
 
82
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->handle_type));
 
83
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
 
84
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
85
        }
 
86
        if (ndr_flags & NDR_BUFFERS) {
 
87
        }
 
88
        return NDR_ERR_SUCCESS;
 
89
}
 
90
 
 
91
_PUBLIC_ enum ndr_err_code ndr_pull_policy_handle(struct ndr_pull *ndr, int ndr_flags, struct policy_handle *r)
 
92
{
 
93
        if (ndr_flags & NDR_SCALARS) {
 
94
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
95
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->handle_type));
 
96
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
 
97
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
98
        }
 
99
        if (ndr_flags & NDR_BUFFERS) {
 
100
        }
 
101
        return NDR_ERR_SUCCESS;
 
102
}
 
103
 
 
104
_PUBLIC_ void ndr_print_policy_handle(struct ndr_print *ndr, const char *name, const struct policy_handle *r)
 
105
{
 
106
        ndr_print_struct(ndr, name, "policy_handle");
 
107
        ndr->depth++;
 
108
        ndr_print_uint32(ndr, "handle_type", r->handle_type);
 
109
        ndr_print_GUID(ndr, "uuid", &r->uuid);
 
110
        ndr->depth--;
 
111
}
 
112
 
 
113
_PUBLIC_ enum ndr_err_code ndr_push_netr_SchannelType(struct ndr_push *ndr, int ndr_flags, enum netr_SchannelType r)
 
114
{
 
115
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
116
        return NDR_ERR_SUCCESS;
 
117
}
 
118
 
 
119
_PUBLIC_ enum ndr_err_code ndr_pull_netr_SchannelType(struct ndr_pull *ndr, int ndr_flags, enum netr_SchannelType *r)
 
120
{
 
121
        uint16_t v;
 
122
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
123
        *r = v;
 
124
        return NDR_ERR_SUCCESS;
 
125
}
 
126
 
 
127
_PUBLIC_ void ndr_print_netr_SchannelType(struct ndr_print *ndr, const char *name, enum netr_SchannelType r)
 
128
{
 
129
        const char *val = NULL;
 
130
 
 
131
        switch (r) {
 
132
                case SEC_CHAN_NULL: val = "SEC_CHAN_NULL"; break;
 
133
                case SEC_CHAN_WKSTA: val = "SEC_CHAN_WKSTA"; break;
 
134
                case SEC_CHAN_DNS_DOMAIN: val = "SEC_CHAN_DNS_DOMAIN"; break;
 
135
                case SEC_CHAN_DOMAIN: val = "SEC_CHAN_DOMAIN"; break;
 
136
                case SEC_CHAN_BDC: val = "SEC_CHAN_BDC"; break;
 
137
        }
 
138
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
139
}
 
140
 
 
141
_PUBLIC_ enum ndr_err_code ndr_push_KRB5_EDATA_NTSTATUS(struct ndr_push *ndr, int ndr_flags, const struct KRB5_EDATA_NTSTATUS *r)
 
142
{
 
143
        if (ndr_flags & NDR_SCALARS) {
 
144
                NDR_CHECK(ndr_push_align(ndr, 4));
 
145
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->ntstatus));
 
146
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
 
147
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
 
148
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
149
        }
 
150
        if (ndr_flags & NDR_BUFFERS) {
 
151
        }
 
152
        return NDR_ERR_SUCCESS;
 
153
}
 
154
 
 
155
_PUBLIC_ enum ndr_err_code ndr_pull_KRB5_EDATA_NTSTATUS(struct ndr_pull *ndr, int ndr_flags, struct KRB5_EDATA_NTSTATUS *r)
 
156
{
 
157
        if (ndr_flags & NDR_SCALARS) {
 
158
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
159
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->ntstatus));
 
160
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
 
161
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
 
162
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
163
        }
 
164
        if (ndr_flags & NDR_BUFFERS) {
 
165
        }
 
166
        return NDR_ERR_SUCCESS;
 
167
}
 
168
 
 
169
_PUBLIC_ void ndr_print_KRB5_EDATA_NTSTATUS(struct ndr_print *ndr, const char *name, const struct KRB5_EDATA_NTSTATUS *r)
 
170
{
 
171
        ndr_print_struct(ndr, name, "KRB5_EDATA_NTSTATUS");
 
172
        ndr->depth++;
 
173
        ndr_print_NTSTATUS(ndr, "ntstatus", r->ntstatus);
 
174
        ndr_print_uint32(ndr, "unknown1", r->unknown1);
 
175
        ndr_print_uint32(ndr, "unknown2", r->unknown2);
 
176
        ndr->depth--;
 
177
}
 
178
 
 
179
_PUBLIC_ enum ndr_err_code ndr_push_winreg_Type(struct ndr_push *ndr, int ndr_flags, enum winreg_Type r)
 
180
{
 
181
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 
182
        return NDR_ERR_SUCCESS;
 
183
}
 
184
 
 
185
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_Type(struct ndr_pull *ndr, int ndr_flags, enum winreg_Type *r)
 
186
{
 
187
        uint32_t v;
 
188
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 
189
        *r = v;
 
190
        return NDR_ERR_SUCCESS;
 
191
}
 
192
 
 
193
_PUBLIC_ void ndr_print_winreg_Type(struct ndr_print *ndr, const char *name, enum winreg_Type r)
 
194
{
 
195
        const char *val = NULL;
 
196
 
 
197
        switch (r) {
 
198
                case REG_NONE: val = "REG_NONE"; break;
 
199
                case REG_SZ: val = "REG_SZ"; break;
 
200
                case REG_EXPAND_SZ: val = "REG_EXPAND_SZ"; break;
 
201
                case REG_BINARY: val = "REG_BINARY"; break;
 
202
                case REG_DWORD: val = "REG_DWORD"; break;
 
203
                case REG_DWORD_BIG_ENDIAN: val = "REG_DWORD_BIG_ENDIAN"; break;
 
204
                case REG_LINK: val = "REG_LINK"; break;
 
205
                case REG_MULTI_SZ: val = "REG_MULTI_SZ"; break;
 
206
                case REG_RESOURCE_LIST: val = "REG_RESOURCE_LIST"; break;
 
207
                case REG_FULL_RESOURCE_DESCRIPTOR: val = "REG_FULL_RESOURCE_DESCRIPTOR"; break;
 
208
                case REG_RESOURCE_REQUIREMENTS_LIST: val = "REG_RESOURCE_REQUIREMENTS_LIST"; break;
 
209
                case REG_QWORD: val = "REG_QWORD"; break;
 
210
        }
 
211
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
212
}
 
213
 
 
214
_PUBLIC_ enum ndr_err_code ndr_push_winreg_Data(struct ndr_push *ndr, int ndr_flags, const union winreg_Data *r)
 
215
{
 
216
        {
 
217
                uint32_t _flags_save_UNION = ndr->flags;
 
218
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 
219
                if (ndr_flags & NDR_SCALARS) {
 
220
                        int level = ndr_push_get_switch_value(ndr, r);
 
221
                        NDR_CHECK(ndr_push_union_align(ndr, 4));
 
222
                        switch (level) {
 
223
                                case REG_NONE: {
 
224
                                break; }
 
225
 
 
226
                                case REG_SZ: {
 
227
                                        {
 
228
                                                uint32_t _flags_save_string = ndr->flags;
 
229
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
230
                                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
 
231
                                                ndr->flags = _flags_save_string;
 
232
                                        }
 
233
                                break; }
 
234
 
 
235
                                case REG_EXPAND_SZ: {
 
236
                                        {
 
237
                                                uint32_t _flags_save_string = ndr->flags;
 
238
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
239
                                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
 
240
                                                ndr->flags = _flags_save_string;
 
241
                                        }
 
242
                                break; }
 
243
 
 
244
                                case REG_BINARY: {
 
245
                                        {
 
246
                                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
247
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
248
                                                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
 
249
                                                ndr->flags = _flags_save_DATA_BLOB;
 
250
                                        }
 
251
                                break; }
 
252
 
 
253
                                case REG_DWORD: {
 
254
                                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
 
255
                                break; }
 
256
 
 
257
                                case REG_DWORD_BIG_ENDIAN: {
 
258
                                        {
 
259
                                                uint32_t _flags_save_uint32 = ndr->flags;
 
260
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 
261
                                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
 
262
                                                ndr->flags = _flags_save_uint32;
 
263
                                        }
 
264
                                break; }
 
265
 
 
266
                                case REG_MULTI_SZ: {
 
267
                                        {
 
268
                                                uint32_t _flags_save_string_array = ndr->flags;
 
269
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
270
                                                NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
 
271
                                                ndr->flags = _flags_save_string_array;
 
272
                                        }
 
273
                                break; }
 
274
 
 
275
                                default: {
 
276
                                        {
 
277
                                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
278
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
279
                                                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
 
280
                                                ndr->flags = _flags_save_DATA_BLOB;
 
281
                                        }
 
282
                                break; }
 
283
 
 
284
                        }
 
285
                }
 
286
                if (ndr_flags & NDR_BUFFERS) {
 
287
                        int level = ndr_push_get_switch_value(ndr, r);
 
288
                        switch (level) {
 
289
                                case REG_NONE:
 
290
                                break;
 
291
 
 
292
                                case REG_SZ:
 
293
                                break;
 
294
 
 
295
                                case REG_EXPAND_SZ:
 
296
                                break;
 
297
 
 
298
                                case REG_BINARY:
 
299
                                break;
 
300
 
 
301
                                case REG_DWORD:
 
302
                                break;
 
303
 
 
304
                                case REG_DWORD_BIG_ENDIAN:
 
305
                                break;
 
306
 
 
307
                                case REG_MULTI_SZ:
 
308
                                break;
 
309
 
 
310
                                default:
 
311
                                break;
 
312
 
 
313
                        }
 
314
                }
 
315
                ndr->flags = _flags_save_UNION;
 
316
        }
 
317
        return NDR_ERR_SUCCESS;
 
318
}
 
319
 
 
320
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_Data(struct ndr_pull *ndr, int ndr_flags, union winreg_Data *r)
 
321
{
 
322
        int level;
 
323
        {
 
324
                uint32_t _flags_save_UNION = ndr->flags;
 
325
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 
326
                level = ndr_pull_get_switch_value(ndr, r);
 
327
                if (ndr_flags & NDR_SCALARS) {
 
328
                        NDR_CHECK(ndr_pull_union_align(ndr, 4));
 
329
                        switch (level) {
 
330
                                case REG_NONE: {
 
331
                                break; }
 
332
 
 
333
                                case REG_SZ: {
 
334
                                        {
 
335
                                                uint32_t _flags_save_string = ndr->flags;
 
336
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
337
                                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
 
338
                                                ndr->flags = _flags_save_string;
 
339
                                        }
 
340
                                break; }
 
341
 
 
342
                                case REG_EXPAND_SZ: {
 
343
                                        {
 
344
                                                uint32_t _flags_save_string = ndr->flags;
 
345
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
346
                                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
 
347
                                                ndr->flags = _flags_save_string;
 
348
                                        }
 
349
                                break; }
 
350
 
 
351
                                case REG_BINARY: {
 
352
                                        {
 
353
                                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
354
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
355
                                                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
 
356
                                                ndr->flags = _flags_save_DATA_BLOB;
 
357
                                        }
 
358
                                break; }
 
359
 
 
360
                                case REG_DWORD: {
 
361
                                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
 
362
                                break; }
 
363
 
 
364
                                case REG_DWORD_BIG_ENDIAN: {
 
365
                                        {
 
366
                                                uint32_t _flags_save_uint32 = ndr->flags;
 
367
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 
368
                                                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
 
369
                                                ndr->flags = _flags_save_uint32;
 
370
                                        }
 
371
                                break; }
 
372
 
 
373
                                case REG_MULTI_SZ: {
 
374
                                        {
 
375
                                                uint32_t _flags_save_string_array = ndr->flags;
 
376
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
377
                                                NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
 
378
                                                ndr->flags = _flags_save_string_array;
 
379
                                        }
 
380
                                break; }
 
381
 
 
382
                                default: {
 
383
                                        {
 
384
                                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
385
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
386
                                                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
 
387
                                                ndr->flags = _flags_save_DATA_BLOB;
 
388
                                        }
 
389
                                break; }
 
390
 
 
391
                        }
 
392
                }
 
393
                if (ndr_flags & NDR_BUFFERS) {
 
394
                        switch (level) {
 
395
                                case REG_NONE:
 
396
                                break;
 
397
 
 
398
                                case REG_SZ:
 
399
                                break;
 
400
 
 
401
                                case REG_EXPAND_SZ:
 
402
                                break;
 
403
 
 
404
                                case REG_BINARY:
 
405
                                break;
 
406
 
 
407
                                case REG_DWORD:
 
408
                                break;
 
409
 
 
410
                                case REG_DWORD_BIG_ENDIAN:
 
411
                                break;
 
412
 
 
413
                                case REG_MULTI_SZ:
 
414
                                break;
 
415
 
 
416
                                default:
 
417
                                break;
 
418
 
 
419
                        }
 
420
                }
 
421
                ndr->flags = _flags_save_UNION;
 
422
        }
 
423
        return NDR_ERR_SUCCESS;
 
424
}
 
425
 
 
426
_PUBLIC_ void ndr_print_winreg_Data(struct ndr_print *ndr, const char *name, const union winreg_Data *r)
 
427
{
 
428
        int level;
 
429
        {
 
430
                uint32_t _flags_save_UNION = ndr->flags;
 
431
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 
432
                level = ndr_print_get_switch_value(ndr, r);
 
433
                ndr_print_union(ndr, name, level, "winreg_Data");
 
434
                switch (level) {
 
435
                        case REG_NONE:
 
436
                        break;
 
437
 
 
438
                        case REG_SZ:
 
439
                                ndr_print_string(ndr, "string", r->string);
 
440
                        break;
 
441
 
 
442
                        case REG_EXPAND_SZ:
 
443
                                ndr_print_string(ndr, "string", r->string);
 
444
                        break;
 
445
 
 
446
                        case REG_BINARY:
 
447
                                ndr_print_DATA_BLOB(ndr, "binary", r->binary);
 
448
                        break;
 
449
 
 
450
                        case REG_DWORD:
 
451
                                ndr_print_uint32(ndr, "value", r->value);
 
452
                        break;
 
453
 
 
454
                        case REG_DWORD_BIG_ENDIAN:
 
455
                                ndr_print_uint32(ndr, "value", r->value);
 
456
                        break;
 
457
 
 
458
                        case REG_MULTI_SZ:
 
459
                                ndr_print_string_array(ndr, "string_array", r->string_array);
 
460
                        break;
 
461
 
 
462
                        default:
 
463
                                ndr_print_DATA_BLOB(ndr, "data", r->data);
 
464
                        break;
 
465
 
 
466
                }
 
467
                ndr->flags = _flags_save_UNION;
 
468
        }
 
469
}
 
470