← Back to branch summary

~lefteris-nikoltsios/+junk/samba-lp1016895

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/ndr_winreg.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
librpc/gen_ndr/ndr_winreg.c
1
 
/* parser auto-generated by pidl */
2
 
 
3
 
#include "includes.h"
4
 
#include "../librpc/gen_ndr/ndr_winreg.h"
5
 
 
6
 
#include "librpc/gen_ndr/ndr_lsa.h"
7
 
#include "librpc/gen_ndr/ndr_security.h"
8
 
#include "librpc/gen_ndr/ndr_misc.h"
9
 
static enum ndr_err_code ndr_push_winreg_AccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
10
 
{
11
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
12
 
        return NDR_ERR_SUCCESS;
13
 
}
14
 
 
15
 
static enum ndr_err_code ndr_pull_winreg_AccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16
 
{
17
 
        uint32_t v;
18
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19
 
        *r = v;
20
 
        return NDR_ERR_SUCCESS;
21
 
}
22
 
 
23
 
_PUBLIC_ void ndr_print_winreg_AccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
24
 
{
25
 
        ndr_print_uint32(ndr, name, r);
26
 
        ndr->depth++;
27
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_QUERY_VALUE", KEY_QUERY_VALUE, r);
28
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_SET_VALUE", KEY_SET_VALUE, r);
29
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_CREATE_SUB_KEY", KEY_CREATE_SUB_KEY, r);
30
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_ENUMERATE_SUB_KEYS", KEY_ENUMERATE_SUB_KEYS, r);
31
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_NOTIFY", KEY_NOTIFY, r);
32
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_CREATE_LINK", KEY_CREATE_LINK, r);
33
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_WOW64_64KEY", KEY_WOW64_64KEY, r);
34
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KEY_WOW64_32KEY", KEY_WOW64_32KEY, r);
35
 
        ndr->depth--;
36
 
}
37
 
 
38
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_String(struct ndr_push *ndr, int ndr_flags, const struct winreg_String *r)
39
 
{
40
 
        if (ndr_flags & NDR_SCALARS) {
41
 
                NDR_CHECK(ndr_push_align(ndr, 5));
42
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2));
43
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2));
44
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
45
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
46
 
        }
47
 
        if (ndr_flags & NDR_BUFFERS) {
48
 
                if (r->name) {
49
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
50
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
51
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
52
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
53
 
                }
54
 
        }
55
 
        return NDR_ERR_SUCCESS;
56
 
}
57
 
 
58
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_String(struct ndr_pull *ndr, int ndr_flags, struct winreg_String *r)
59
 
{
60
 
        uint32_t _ptr_name;
61
 
        TALLOC_CTX *_mem_save_name_0;
62
 
        if (ndr_flags & NDR_SCALARS) {
63
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
64
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->name_len));
65
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->name_size));
66
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
67
 
                if (_ptr_name) {
68
 
                        NDR_PULL_ALLOC(ndr, r->name);
69
 
                } else {
70
 
                        r->name = NULL;
71
 
                }
72
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
73
 
        }
74
 
        if (ndr_flags & NDR_BUFFERS) {
75
 
                if (r->name) {
76
 
                        _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
77
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
78
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
79
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
80
 
                        if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
81
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
82
 
                        }
83
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
84
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
85
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
86
 
                }
87
 
        }
88
 
        return NDR_ERR_SUCCESS;
89
 
}
90
 
 
91
 
_PUBLIC_ void ndr_print_winreg_String(struct ndr_print *ndr, const char *name, const struct winreg_String *r)
92
 
{
93
 
        ndr_print_struct(ndr, name, "winreg_String");
94
 
        ndr->depth++;
95
 
        ndr_print_uint16(ndr, "name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name) * 2:r->name_len);
96
 
        ndr_print_uint16(ndr, "name_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name) * 2:r->name_size);
97
 
        ndr_print_ptr(ndr, "name", r->name);
98
 
        ndr->depth++;
99
 
        if (r->name) {
100
 
                ndr_print_string(ndr, "name", r->name);
101
 
        }
102
 
        ndr->depth--;
103
 
        ndr->depth--;
104
 
}
105
 
 
106
 
static enum ndr_err_code ndr_push_KeySecurityData(struct ndr_push *ndr, int ndr_flags, const struct KeySecurityData *r)
107
 
{
108
 
        if (ndr_flags & NDR_SCALARS) {
109
 
                NDR_CHECK(ndr_push_align(ndr, 5));
110
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
111
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
112
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
113
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
114
 
        }
115
 
        if (ndr_flags & NDR_BUFFERS) {
116
 
                if (r->data) {
117
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
118
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
119
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->len));
120
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->len));
121
 
                }
122
 
        }
123
 
        return NDR_ERR_SUCCESS;
124
 
}
125
 
 
126
 
static enum ndr_err_code ndr_pull_KeySecurityData(struct ndr_pull *ndr, int ndr_flags, struct KeySecurityData *r)
127
 
{
128
 
        uint32_t _ptr_data;
129
 
        TALLOC_CTX *_mem_save_data_0;
130
 
        if (ndr_flags & NDR_SCALARS) {
131
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
132
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
133
 
                if (_ptr_data) {
134
 
                        NDR_PULL_ALLOC(ndr, r->data);
135
 
                } else {
136
 
                        r->data = NULL;
137
 
                }
138
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
139
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
140
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
141
 
        }
142
 
        if (ndr_flags & NDR_BUFFERS) {
143
 
                if (r->data) {
144
 
                        _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
145
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
146
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
147
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->data));
148
 
                        if (ndr_get_array_length(ndr, &r->data) > ndr_get_array_size(ndr, &r->data)) {
149
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data), ndr_get_array_length(ndr, &r->data));
150
 
                        }
151
 
                        NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
152
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_length(ndr, &r->data)));
153
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
154
 
                }
155
 
                if (r->data) {
156
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
157
 
                }
158
 
                if (r->data) {
159
 
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->data, r->len));
160
 
                }
161
 
        }
162
 
        return NDR_ERR_SUCCESS;
163
 
}
164
 
 
165
 
_PUBLIC_ void ndr_print_KeySecurityData(struct ndr_print *ndr, const char *name, const struct KeySecurityData *r)
166
 
{
167
 
        ndr_print_struct(ndr, name, "KeySecurityData");
168
 
        ndr->depth++;
169
 
        ndr_print_ptr(ndr, "data", r->data);
170
 
        ndr->depth++;
171
 
        if (r->data) {
172
 
                ndr_print_array_uint8(ndr, "data", r->data, r->len);
173
 
        }
174
 
        ndr->depth--;
175
 
        ndr_print_uint32(ndr, "size", r->size);
176
 
        ndr_print_uint32(ndr, "len", r->len);
177
 
        ndr->depth--;
178
 
}
179
 
 
180
 
static enum ndr_err_code ndr_push_winreg_SecBuf(struct ndr_push *ndr, int ndr_flags, const struct winreg_SecBuf *r)
181
 
{
182
 
        if (ndr_flags & NDR_SCALARS) {
183
 
                NDR_CHECK(ndr_push_align(ndr, 5));
184
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
185
 
                NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS, &r->sd));
186
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->inherit));
187
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
188
 
        }
189
 
        if (ndr_flags & NDR_BUFFERS) {
190
 
                NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_BUFFERS, &r->sd));
191
 
        }
192
 
        return NDR_ERR_SUCCESS;
193
 
}
194
 
 
195
 
static enum ndr_err_code ndr_pull_winreg_SecBuf(struct ndr_pull *ndr, int ndr_flags, struct winreg_SecBuf *r)
196
 
{
197
 
        if (ndr_flags & NDR_SCALARS) {
198
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
199
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
200
 
                NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS, &r->sd));
201
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->inherit));
202
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
203
 
        }
204
 
        if (ndr_flags & NDR_BUFFERS) {
205
 
                NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_BUFFERS, &r->sd));
206
 
        }
207
 
        return NDR_ERR_SUCCESS;
208
 
}
209
 
 
210
 
_PUBLIC_ void ndr_print_winreg_SecBuf(struct ndr_print *ndr, const char *name, const struct winreg_SecBuf *r)
211
 
{
212
 
        ndr_print_struct(ndr, name, "winreg_SecBuf");
213
 
        ndr->depth++;
214
 
        ndr_print_uint32(ndr, "length", r->length);
215
 
        ndr_print_KeySecurityData(ndr, "sd", &r->sd);
216
 
        ndr_print_uint8(ndr, "inherit", r->inherit);
217
 
        ndr->depth--;
218
 
}
219
 
 
220
 
static enum ndr_err_code ndr_push_winreg_CreateAction(struct ndr_push *ndr, int ndr_flags, enum winreg_CreateAction r)
221
 
{
222
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
223
 
        return NDR_ERR_SUCCESS;
224
 
}
225
 
 
226
 
static enum ndr_err_code ndr_pull_winreg_CreateAction(struct ndr_pull *ndr, int ndr_flags, enum winreg_CreateAction *r)
227
 
{
228
 
        uint32_t v;
229
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
230
 
        *r = v;
231
 
        return NDR_ERR_SUCCESS;
232
 
}
233
 
 
234
 
_PUBLIC_ void ndr_print_winreg_CreateAction(struct ndr_print *ndr, const char *name, enum winreg_CreateAction r)
235
 
{
236
 
        const char *val = NULL;
237
 
 
238
 
        switch (r) {
239
 
                case REG_ACTION_NONE: val = "REG_ACTION_NONE"; break;
240
 
                case REG_CREATED_NEW_KEY: val = "REG_CREATED_NEW_KEY"; break;
241
 
                case REG_OPENED_EXISTING_KEY: val = "REG_OPENED_EXISTING_KEY"; break;
242
 
        }
243
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
244
 
}
245
 
 
246
 
static enum ndr_err_code ndr_push_winreg_StringBuf(struct ndr_push *ndr, int ndr_flags, const struct winreg_StringBuf *r)
247
 
{
248
 
        if (ndr_flags & NDR_SCALARS) {
249
 
                NDR_CHECK(ndr_push_align(ndr, 5));
250
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term_null(r->name) * 2));
251
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
252
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
253
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
254
 
        }
255
 
        if (ndr_flags & NDR_BUFFERS) {
256
 
                if (r->name) {
257
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
258
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
259
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, strlen_m_term_null(r->name) * 2 / 2));
260
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, strlen_m_term_null(r->name) * 2 / 2, sizeof(uint16_t), CH_UTF16));
261
 
                }
262
 
        }
263
 
        return NDR_ERR_SUCCESS;
264
 
}
265
 
 
266
 
static enum ndr_err_code ndr_pull_winreg_StringBuf(struct ndr_pull *ndr, int ndr_flags, struct winreg_StringBuf *r)
267
 
{
268
 
        uint32_t _ptr_name;
269
 
        TALLOC_CTX *_mem_save_name_0;
270
 
        if (ndr_flags & NDR_SCALARS) {
271
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
272
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
273
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
274
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
275
 
                if (_ptr_name) {
276
 
                        NDR_PULL_ALLOC(ndr, r->name);
277
 
                } else {
278
 
                        r->name = NULL;
279
 
                }
280
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
281
 
        }
282
 
        if (ndr_flags & NDR_BUFFERS) {
283
 
                if (r->name) {
284
 
                        _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
285
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
286
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
287
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
288
 
                        if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
289
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
290
 
                        }
291
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
292
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
293
 
                }
294
 
                if (r->name) {
295
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->name, r->size / 2));
296
 
                }
297
 
                if (r->name) {
298
 
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->name, r->length / 2));
299
 
                }
300
 
        }
301
 
        return NDR_ERR_SUCCESS;
302
 
}
303
 
 
304
 
_PUBLIC_ void ndr_print_winreg_StringBuf(struct ndr_print *ndr, const char *name, const struct winreg_StringBuf *r)
305
 
{
306
 
        ndr_print_struct(ndr, name, "winreg_StringBuf");
307
 
        ndr->depth++;
308
 
        ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term_null(r->name) * 2:r->length);
309
 
        ndr_print_uint16(ndr, "size", r->size);
310
 
        ndr_print_ptr(ndr, "name", r->name);
311
 
        ndr->depth++;
312
 
        if (r->name) {
313
 
                ndr_print_string(ndr, "name", r->name);
314
 
        }
315
 
        ndr->depth--;
316
 
        ndr->depth--;
317
 
}
318
 
 
319
 
static enum ndr_err_code ndr_push_winreg_ValNameBuf(struct ndr_push *ndr, int ndr_flags, const struct winreg_ValNameBuf *r)
320
 
{
321
 
        if (ndr_flags & NDR_SCALARS) {
322
 
                NDR_CHECK(ndr_push_align(ndr, 5));
323
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2));
324
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
325
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
326
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
327
 
        }
328
 
        if (ndr_flags & NDR_BUFFERS) {
329
 
                if (r->name) {
330
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
331
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
332
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, strlen_m_term(r->name) * 2 / 2));
333
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, strlen_m_term(r->name) * 2 / 2, sizeof(uint16_t), CH_UTF16));
334
 
                }
335
 
        }
336
 
        return NDR_ERR_SUCCESS;
337
 
}
338
 
 
339
 
static enum ndr_err_code ndr_pull_winreg_ValNameBuf(struct ndr_pull *ndr, int ndr_flags, struct winreg_ValNameBuf *r)
340
 
{
341
 
        uint32_t _ptr_name;
342
 
        TALLOC_CTX *_mem_save_name_0;
343
 
        if (ndr_flags & NDR_SCALARS) {
344
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
345
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
346
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
347
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
348
 
                if (_ptr_name) {
349
 
                        NDR_PULL_ALLOC(ndr, r->name);
350
 
                } else {
351
 
                        r->name = NULL;
352
 
                }
353
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
354
 
        }
355
 
        if (ndr_flags & NDR_BUFFERS) {
356
 
                if (r->name) {
357
 
                        _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
358
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
359
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
360
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
361
 
                        if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
362
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
363
 
                        }
364
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
365
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
366
 
                }
367
 
                if (r->name) {
368
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->name, r->size / 2));
369
 
                }
370
 
                if (r->name) {
371
 
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->name, r->length / 2));
372
 
                }
373
 
        }
374
 
        return NDR_ERR_SUCCESS;
375
 
}
376
 
 
377
 
_PUBLIC_ void ndr_print_winreg_ValNameBuf(struct ndr_print *ndr, const char *name, const struct winreg_ValNameBuf *r)
378
 
{
379
 
        ndr_print_struct(ndr, name, "winreg_ValNameBuf");
380
 
        ndr->depth++;
381
 
        ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name) * 2:r->length);
382
 
        ndr_print_uint16(ndr, "size", r->size);
383
 
        ndr_print_ptr(ndr, "name", r->name);
384
 
        ndr->depth++;
385
 
        if (r->name) {
386
 
                ndr_print_string(ndr, "name", r->name);
387
 
        }
388
 
        ndr->depth--;
389
 
        ndr->depth--;
390
 
}
391
 
 
392
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_NotifyChangeType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
393
 
{
394
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
395
 
        return NDR_ERR_SUCCESS;
396
 
}
397
 
 
398
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_NotifyChangeType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
399
 
{
400
 
        uint32_t v;
401
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
402
 
        *r = v;
403
 
        return NDR_ERR_SUCCESS;
404
 
}
405
 
 
406
 
_PUBLIC_ void ndr_print_winreg_NotifyChangeType(struct ndr_print *ndr, const char *name, uint32_t r)
407
 
{
408
 
        ndr_print_uint32(ndr, name, r);
409
 
        ndr->depth++;
410
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_NOTIFY_CHANGE_NAME", REG_NOTIFY_CHANGE_NAME, r);
411
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_NOTIFY_CHANGE_ATTRIBUTES", REG_NOTIFY_CHANGE_ATTRIBUTES, r);
412
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_NOTIFY_CHANGE_LAST_SET", REG_NOTIFY_CHANGE_LAST_SET, r);
413
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "REG_NOTIFY_CHANGE_SECURITY", REG_NOTIFY_CHANGE_SECURITY, r);
414
 
        ndr->depth--;
415
 
}
416
 
 
417
 
static enum ndr_err_code ndr_push_KeySecurityAttribute(struct ndr_push *ndr, int ndr_flags, const struct KeySecurityAttribute *r)
418
 
{
419
 
        if (ndr_flags & NDR_SCALARS) {
420
 
                NDR_CHECK(ndr_push_align(ndr, 5));
421
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->data_size));
422
 
                NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS, &r->sec_data));
423
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->inherit));
424
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
425
 
        }
426
 
        if (ndr_flags & NDR_BUFFERS) {
427
 
                NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_BUFFERS, &r->sec_data));
428
 
        }
429
 
        return NDR_ERR_SUCCESS;
430
 
}
431
 
 
432
 
static enum ndr_err_code ndr_pull_KeySecurityAttribute(struct ndr_pull *ndr, int ndr_flags, struct KeySecurityAttribute *r)
433
 
{
434
 
        if (ndr_flags & NDR_SCALARS) {
435
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
436
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_size));
437
 
                NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS, &r->sec_data));
438
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->inherit));
439
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
440
 
        }
441
 
        if (ndr_flags & NDR_BUFFERS) {
442
 
                NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_BUFFERS, &r->sec_data));
443
 
        }
444
 
        return NDR_ERR_SUCCESS;
445
 
}
446
 
 
447
 
_PUBLIC_ void ndr_print_KeySecurityAttribute(struct ndr_print *ndr, const char *name, const struct KeySecurityAttribute *r)
448
 
{
449
 
        ndr_print_struct(ndr, name, "KeySecurityAttribute");
450
 
        ndr->depth++;
451
 
        ndr_print_uint32(ndr, "data_size", r->data_size);
452
 
        ndr_print_KeySecurityData(ndr, "sec_data", &r->sec_data);
453
 
        ndr_print_uint8(ndr, "inherit", r->inherit);
454
 
        ndr->depth--;
455
 
}
456
 
 
457
 
static enum ndr_err_code ndr_push_QueryMultipleValue(struct ndr_push *ndr, int ndr_flags, const struct QueryMultipleValue *r)
458
 
{
459
 
        if (ndr_flags & NDR_SCALARS) {
460
 
                NDR_CHECK(ndr_push_align(ndr, 5));
461
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
462
 
                NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
463
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->offset));
464
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
465
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
466
 
        }
467
 
        if (ndr_flags & NDR_BUFFERS) {
468
 
                if (r->name) {
469
 
                        NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->name));
470
 
                }
471
 
        }
472
 
        return NDR_ERR_SUCCESS;
473
 
}
474
 
 
475
 
static enum ndr_err_code ndr_pull_QueryMultipleValue(struct ndr_pull *ndr, int ndr_flags, struct QueryMultipleValue *r)
476
 
{
477
 
        uint32_t _ptr_name;
478
 
        TALLOC_CTX *_mem_save_name_0;
479
 
        if (ndr_flags & NDR_SCALARS) {
480
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
481
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
482
 
                if (_ptr_name) {
483
 
                        NDR_PULL_ALLOC(ndr, r->name);
484
 
                } else {
485
 
                        r->name = NULL;
486
 
                }
487
 
                NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
488
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->offset));
489
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
490
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
491
 
        }
492
 
        if (ndr_flags & NDR_BUFFERS) {
493
 
                if (r->name) {
494
 
                        _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
495
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
496
 
                        NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->name));
497
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
498
 
                }
499
 
        }
500
 
        return NDR_ERR_SUCCESS;
501
 
}
502
 
 
503
 
_PUBLIC_ void ndr_print_QueryMultipleValue(struct ndr_print *ndr, const char *name, const struct QueryMultipleValue *r)
504
 
{
505
 
        ndr_print_struct(ndr, name, "QueryMultipleValue");
506
 
        ndr->depth++;
507
 
        ndr_print_ptr(ndr, "name", r->name);
508
 
        ndr->depth++;
509
 
        if (r->name) {
510
 
                ndr_print_winreg_String(ndr, "name", r->name);
511
 
        }
512
 
        ndr->depth--;
513
 
        ndr_print_winreg_Type(ndr, "type", r->type);
514
 
        ndr_print_uint32(ndr, "offset", r->offset);
515
 
        ndr_print_uint32(ndr, "length", r->length);
516
 
        ndr->depth--;
517
 
}
518
 
 
519
 
static enum ndr_err_code ndr_push_winreg_OpenHKCR(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCR *r)
520
 
{
521
 
        if (flags & NDR_IN) {
522
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
523
 
                if (r->in.system_name) {
524
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
525
 
                }
526
 
                NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
527
 
        }
528
 
        if (flags & NDR_OUT) {
529
 
                if (r->out.handle == NULL) {
530
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
531
 
                }
532
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
533
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
534
 
        }
535
 
        return NDR_ERR_SUCCESS;
536
 
}
537
 
 
538
 
static enum ndr_err_code ndr_pull_winreg_OpenHKCR(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCR *r)
539
 
{
540
 
        uint32_t _ptr_system_name;
541
 
        TALLOC_CTX *_mem_save_system_name_0;
542
 
        TALLOC_CTX *_mem_save_handle_0;
543
 
        if (flags & NDR_IN) {
544
 
                ZERO_STRUCT(r->out);
545
 
 
546
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
547
 
                if (_ptr_system_name) {
548
 
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
549
 
                } else {
550
 
                        r->in.system_name = NULL;
551
 
                }
552
 
                if (r->in.system_name) {
553
 
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
554
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
555
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
556
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
557
 
                }
558
 
                NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
559
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
560
 
                ZERO_STRUCTP(r->out.handle);
561
 
        }
562
 
        if (flags & NDR_OUT) {
563
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
564
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
565
 
                }
566
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
567
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
568
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
569
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
570
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
571
 
        }
572
 
        return NDR_ERR_SUCCESS;
573
 
}
574
 
 
575
 
_PUBLIC_ void ndr_print_winreg_OpenHKCR(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCR *r)
576
 
{
577
 
        ndr_print_struct(ndr, name, "winreg_OpenHKCR");
578
 
        ndr->depth++;
579
 
        if (flags & NDR_SET_VALUES) {
580
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
581
 
        }
582
 
        if (flags & NDR_IN) {
583
 
                ndr_print_struct(ndr, "in", "winreg_OpenHKCR");
584
 
                ndr->depth++;
585
 
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
586
 
                ndr->depth++;
587
 
                if (r->in.system_name) {
588
 
                        ndr_print_uint16(ndr, "system_name", *r->in.system_name);
589
 
                }
590
 
                ndr->depth--;
591
 
                ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
592
 
                ndr->depth--;
593
 
        }
594
 
        if (flags & NDR_OUT) {
595
 
                ndr_print_struct(ndr, "out", "winreg_OpenHKCR");
596
 
                ndr->depth++;
597
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
598
 
                ndr->depth++;
599
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
600
 
                ndr->depth--;
601
 
                ndr_print_WERROR(ndr, "result", r->out.result);
602
 
                ndr->depth--;
603
 
        }
604
 
        ndr->depth--;
605
 
}
606
 
 
607
 
static enum ndr_err_code ndr_push_winreg_OpenHKCU(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCU *r)
608
 
{
609
 
        if (flags & NDR_IN) {
610
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
611
 
                if (r->in.system_name) {
612
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
613
 
                }
614
 
                NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
615
 
        }
616
 
        if (flags & NDR_OUT) {
617
 
                if (r->out.handle == NULL) {
618
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
619
 
                }
620
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
621
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
622
 
        }
623
 
        return NDR_ERR_SUCCESS;
624
 
}
625
 
 
626
 
static enum ndr_err_code ndr_pull_winreg_OpenHKCU(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCU *r)
627
 
{
628
 
        uint32_t _ptr_system_name;
629
 
        TALLOC_CTX *_mem_save_system_name_0;
630
 
        TALLOC_CTX *_mem_save_handle_0;
631
 
        if (flags & NDR_IN) {
632
 
                ZERO_STRUCT(r->out);
633
 
 
634
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
635
 
                if (_ptr_system_name) {
636
 
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
637
 
                } else {
638
 
                        r->in.system_name = NULL;
639
 
                }
640
 
                if (r->in.system_name) {
641
 
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
642
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
643
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
644
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
645
 
                }
646
 
                NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
647
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
648
 
                ZERO_STRUCTP(r->out.handle);
649
 
        }
650
 
        if (flags & NDR_OUT) {
651
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
652
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
653
 
                }
654
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
655
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
656
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
657
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
658
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
659
 
        }
660
 
        return NDR_ERR_SUCCESS;
661
 
}
662
 
 
663
 
_PUBLIC_ void ndr_print_winreg_OpenHKCU(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCU *r)
664
 
{
665
 
        ndr_print_struct(ndr, name, "winreg_OpenHKCU");
666
 
        ndr->depth++;
667
 
        if (flags & NDR_SET_VALUES) {
668
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
669
 
        }
670
 
        if (flags & NDR_IN) {
671
 
                ndr_print_struct(ndr, "in", "winreg_OpenHKCU");
672
 
                ndr->depth++;
673
 
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
674
 
                ndr->depth++;
675
 
                if (r->in.system_name) {
676
 
                        ndr_print_uint16(ndr, "system_name", *r->in.system_name);
677
 
                }
678
 
                ndr->depth--;
679
 
                ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
680
 
                ndr->depth--;
681
 
        }
682
 
        if (flags & NDR_OUT) {
683
 
                ndr_print_struct(ndr, "out", "winreg_OpenHKCU");
684
 
                ndr->depth++;
685
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
686
 
                ndr->depth++;
687
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
688
 
                ndr->depth--;
689
 
                ndr_print_WERROR(ndr, "result", r->out.result);
690
 
                ndr->depth--;
691
 
        }
692
 
        ndr->depth--;
693
 
}
694
 
 
695
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_OpenHKLM(struct ndr_push *ndr, int flags, const struct winreg_OpenHKLM *r)
696
 
{
697
 
        if (flags & NDR_IN) {
698
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
699
 
                if (r->in.system_name) {
700
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
701
 
                }
702
 
                NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
703
 
        }
704
 
        if (flags & NDR_OUT) {
705
 
                if (r->out.handle == NULL) {
706
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
707
 
                }
708
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
709
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
710
 
        }
711
 
        return NDR_ERR_SUCCESS;
712
 
}
713
 
 
714
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_OpenHKLM(struct ndr_pull *ndr, int flags, struct winreg_OpenHKLM *r)
715
 
{
716
 
        uint32_t _ptr_system_name;
717
 
        TALLOC_CTX *_mem_save_system_name_0;
718
 
        TALLOC_CTX *_mem_save_handle_0;
719
 
        if (flags & NDR_IN) {
720
 
                ZERO_STRUCT(r->out);
721
 
 
722
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
723
 
                if (_ptr_system_name) {
724
 
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
725
 
                } else {
726
 
                        r->in.system_name = NULL;
727
 
                }
728
 
                if (r->in.system_name) {
729
 
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
730
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
731
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
732
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
733
 
                }
734
 
                NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
735
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
736
 
                ZERO_STRUCTP(r->out.handle);
737
 
        }
738
 
        if (flags & NDR_OUT) {
739
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
740
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
741
 
                }
742
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
743
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
744
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
745
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
746
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
747
 
        }
748
 
        return NDR_ERR_SUCCESS;
749
 
}
750
 
 
751
 
_PUBLIC_ void ndr_print_winreg_OpenHKLM(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKLM *r)
752
 
{
753
 
        ndr_print_struct(ndr, name, "winreg_OpenHKLM");
754
 
        ndr->depth++;
755
 
        if (flags & NDR_SET_VALUES) {
756
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
757
 
        }
758
 
        if (flags & NDR_IN) {
759
 
                ndr_print_struct(ndr, "in", "winreg_OpenHKLM");
760
 
                ndr->depth++;
761
 
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
762
 
                ndr->depth++;
763
 
                if (r->in.system_name) {
764
 
                        ndr_print_uint16(ndr, "system_name", *r->in.system_name);
765
 
                }
766
 
                ndr->depth--;
767
 
                ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
768
 
                ndr->depth--;
769
 
        }
770
 
        if (flags & NDR_OUT) {
771
 
                ndr_print_struct(ndr, "out", "winreg_OpenHKLM");
772
 
                ndr->depth++;
773
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
774
 
                ndr->depth++;
775
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
776
 
                ndr->depth--;
777
 
                ndr_print_WERROR(ndr, "result", r->out.result);
778
 
                ndr->depth--;
779
 
        }
780
 
        ndr->depth--;
781
 
}
782
 
 
783
 
static enum ndr_err_code ndr_push_winreg_OpenHKPD(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPD *r)
784
 
{
785
 
        if (flags & NDR_IN) {
786
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
787
 
                if (r->in.system_name) {
788
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
789
 
                }
790
 
                NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
791
 
        }
792
 
        if (flags & NDR_OUT) {
793
 
                if (r->out.handle == NULL) {
794
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
795
 
                }
796
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
797
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
798
 
        }
799
 
        return NDR_ERR_SUCCESS;
800
 
}
801
 
 
802
 
static enum ndr_err_code ndr_pull_winreg_OpenHKPD(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPD *r)
803
 
{
804
 
        uint32_t _ptr_system_name;
805
 
        TALLOC_CTX *_mem_save_system_name_0;
806
 
        TALLOC_CTX *_mem_save_handle_0;
807
 
        if (flags & NDR_IN) {
808
 
                ZERO_STRUCT(r->out);
809
 
 
810
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
811
 
                if (_ptr_system_name) {
812
 
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
813
 
                } else {
814
 
                        r->in.system_name = NULL;
815
 
                }
816
 
                if (r->in.system_name) {
817
 
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
818
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
819
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
820
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
821
 
                }
822
 
                NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
823
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
824
 
                ZERO_STRUCTP(r->out.handle);
825
 
        }
826
 
        if (flags & NDR_OUT) {
827
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
828
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
829
 
                }
830
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
831
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
832
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
833
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
834
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
835
 
        }
836
 
        return NDR_ERR_SUCCESS;
837
 
}
838
 
 
839
 
_PUBLIC_ void ndr_print_winreg_OpenHKPD(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPD *r)
840
 
{
841
 
        ndr_print_struct(ndr, name, "winreg_OpenHKPD");
842
 
        ndr->depth++;
843
 
        if (flags & NDR_SET_VALUES) {
844
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
845
 
        }
846
 
        if (flags & NDR_IN) {
847
 
                ndr_print_struct(ndr, "in", "winreg_OpenHKPD");
848
 
                ndr->depth++;
849
 
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
850
 
                ndr->depth++;
851
 
                if (r->in.system_name) {
852
 
                        ndr_print_uint16(ndr, "system_name", *r->in.system_name);
853
 
                }
854
 
                ndr->depth--;
855
 
                ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
856
 
                ndr->depth--;
857
 
        }
858
 
        if (flags & NDR_OUT) {
859
 
                ndr_print_struct(ndr, "out", "winreg_OpenHKPD");
860
 
                ndr->depth++;
861
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
862
 
                ndr->depth++;
863
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
864
 
                ndr->depth--;
865
 
                ndr_print_WERROR(ndr, "result", r->out.result);
866
 
                ndr->depth--;
867
 
        }
868
 
        ndr->depth--;
869
 
}
870
 
 
871
 
static enum ndr_err_code ndr_push_winreg_OpenHKU(struct ndr_push *ndr, int flags, const struct winreg_OpenHKU *r)
872
 
{
873
 
        if (flags & NDR_IN) {
874
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
875
 
                if (r->in.system_name) {
876
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
877
 
                }
878
 
                NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
879
 
        }
880
 
        if (flags & NDR_OUT) {
881
 
                if (r->out.handle == NULL) {
882
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
883
 
                }
884
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
885
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
886
 
        }
887
 
        return NDR_ERR_SUCCESS;
888
 
}
889
 
 
890
 
static enum ndr_err_code ndr_pull_winreg_OpenHKU(struct ndr_pull *ndr, int flags, struct winreg_OpenHKU *r)
891
 
{
892
 
        uint32_t _ptr_system_name;
893
 
        TALLOC_CTX *_mem_save_system_name_0;
894
 
        TALLOC_CTX *_mem_save_handle_0;
895
 
        if (flags & NDR_IN) {
896
 
                ZERO_STRUCT(r->out);
897
 
 
898
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
899
 
                if (_ptr_system_name) {
900
 
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
901
 
                } else {
902
 
                        r->in.system_name = NULL;
903
 
                }
904
 
                if (r->in.system_name) {
905
 
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
906
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
907
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
908
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
909
 
                }
910
 
                NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
911
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
912
 
                ZERO_STRUCTP(r->out.handle);
913
 
        }
914
 
        if (flags & NDR_OUT) {
915
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
916
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
917
 
                }
918
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
919
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
920
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
921
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
922
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
923
 
        }
924
 
        return NDR_ERR_SUCCESS;
925
 
}
926
 
 
927
 
_PUBLIC_ void ndr_print_winreg_OpenHKU(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKU *r)
928
 
{
929
 
        ndr_print_struct(ndr, name, "winreg_OpenHKU");
930
 
        ndr->depth++;
931
 
        if (flags & NDR_SET_VALUES) {
932
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
933
 
        }
934
 
        if (flags & NDR_IN) {
935
 
                ndr_print_struct(ndr, "in", "winreg_OpenHKU");
936
 
                ndr->depth++;
937
 
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
938
 
                ndr->depth++;
939
 
                if (r->in.system_name) {
940
 
                        ndr_print_uint16(ndr, "system_name", *r->in.system_name);
941
 
                }
942
 
                ndr->depth--;
943
 
                ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
944
 
                ndr->depth--;
945
 
        }
946
 
        if (flags & NDR_OUT) {
947
 
                ndr_print_struct(ndr, "out", "winreg_OpenHKU");
948
 
                ndr->depth++;
949
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
950
 
                ndr->depth++;
951
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
952
 
                ndr->depth--;
953
 
                ndr_print_WERROR(ndr, "result", r->out.result);
954
 
                ndr->depth--;
955
 
        }
956
 
        ndr->depth--;
957
 
}
958
 
 
959
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_CloseKey(struct ndr_push *ndr, int flags, const struct winreg_CloseKey *r)
960
 
{
961
 
        if (flags & NDR_IN) {
962
 
                if (r->in.handle == NULL) {
963
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
964
 
                }
965
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
966
 
        }
967
 
        if (flags & NDR_OUT) {
968
 
                if (r->out.handle == NULL) {
969
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
970
 
                }
971
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
972
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
973
 
        }
974
 
        return NDR_ERR_SUCCESS;
975
 
}
976
 
 
977
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_CloseKey(struct ndr_pull *ndr, int flags, struct winreg_CloseKey *r)
978
 
{
979
 
        TALLOC_CTX *_mem_save_handle_0;
980
 
        if (flags & NDR_IN) {
981
 
                ZERO_STRUCT(r->out);
982
 
 
983
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
984
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
985
 
                }
986
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
987
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
988
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
989
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
990
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
991
 
                *r->out.handle = *r->in.handle;
992
 
        }
993
 
        if (flags & NDR_OUT) {
994
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
995
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
996
 
                }
997
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
998
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
999
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1000
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1001
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1002
 
        }
1003
 
        return NDR_ERR_SUCCESS;
1004
 
}
1005
 
 
1006
 
_PUBLIC_ void ndr_print_winreg_CloseKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_CloseKey *r)
1007
 
{
1008
 
        ndr_print_struct(ndr, name, "winreg_CloseKey");
1009
 
        ndr->depth++;
1010
 
        if (flags & NDR_SET_VALUES) {
1011
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1012
 
        }
1013
 
        if (flags & NDR_IN) {
1014
 
                ndr_print_struct(ndr, "in", "winreg_CloseKey");
1015
 
                ndr->depth++;
1016
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
1017
 
                ndr->depth++;
1018
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
1019
 
                ndr->depth--;
1020
 
                ndr->depth--;
1021
 
        }
1022
 
        if (flags & NDR_OUT) {
1023
 
                ndr_print_struct(ndr, "out", "winreg_CloseKey");
1024
 
                ndr->depth++;
1025
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
1026
 
                ndr->depth++;
1027
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
1028
 
                ndr->depth--;
1029
 
                ndr_print_WERROR(ndr, "result", r->out.result);
1030
 
                ndr->depth--;
1031
 
        }
1032
 
        ndr->depth--;
1033
 
}
1034
 
 
1035
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_CreateKey(struct ndr_push *ndr, int flags, const struct winreg_CreateKey *r)
1036
 
{
1037
 
        if (flags & NDR_IN) {
1038
 
                if (r->in.handle == NULL) {
1039
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1040
 
                }
1041
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1042
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
1043
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyclass));
1044
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
1045
 
                NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
1046
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.secdesc));
1047
 
                if (r->in.secdesc) {
1048
 
                        NDR_CHECK(ndr_push_winreg_SecBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
1049
 
                }
1050
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.action_taken));
1051
 
                if (r->in.action_taken) {
1052
 
                        NDR_CHECK(ndr_push_winreg_CreateAction(ndr, NDR_SCALARS, *r->in.action_taken));
1053
 
                }
1054
 
        }
1055
 
        if (flags & NDR_OUT) {
1056
 
                if (r->out.new_handle == NULL) {
1057
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1058
 
                }
1059
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.new_handle));
1060
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.action_taken));
1061
 
                if (r->out.action_taken) {
1062
 
                        NDR_CHECK(ndr_push_winreg_CreateAction(ndr, NDR_SCALARS, *r->out.action_taken));
1063
 
                }
1064
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1065
 
        }
1066
 
        return NDR_ERR_SUCCESS;
1067
 
}
1068
 
 
1069
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_CreateKey(struct ndr_pull *ndr, int flags, struct winreg_CreateKey *r)
1070
 
{
1071
 
        uint32_t _ptr_secdesc;
1072
 
        uint32_t _ptr_action_taken;
1073
 
        TALLOC_CTX *_mem_save_handle_0;
1074
 
        TALLOC_CTX *_mem_save_secdesc_0;
1075
 
        TALLOC_CTX *_mem_save_new_handle_0;
1076
 
        TALLOC_CTX *_mem_save_action_taken_0;
1077
 
        if (flags & NDR_IN) {
1078
 
                ZERO_STRUCT(r->out);
1079
 
 
1080
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1081
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
1082
 
                }
1083
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1084
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1085
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1086
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1087
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
1088
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyclass));
1089
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
1090
 
                NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
1091
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1092
 
                if (_ptr_secdesc) {
1093
 
                        NDR_PULL_ALLOC(ndr, r->in.secdesc);
1094
 
                } else {
1095
 
                        r->in.secdesc = NULL;
1096
 
                }
1097
 
                if (r->in.secdesc) {
1098
 
                        _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1099
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc, 0);
1100
 
                        NDR_CHECK(ndr_pull_winreg_SecBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
1101
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1102
 
                }
1103
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_action_taken));
1104
 
                if (_ptr_action_taken) {
1105
 
                        NDR_PULL_ALLOC(ndr, r->in.action_taken);
1106
 
                } else {
1107
 
                        r->in.action_taken = NULL;
1108
 
                }
1109
 
                if (r->in.action_taken) {
1110
 
                        _mem_save_action_taken_0 = NDR_PULL_GET_MEM_CTX(ndr);
1111
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.action_taken, 0);
1112
 
                        NDR_CHECK(ndr_pull_winreg_CreateAction(ndr, NDR_SCALARS, r->in.action_taken));
1113
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_action_taken_0, 0);
1114
 
                }
1115
 
                NDR_PULL_ALLOC(ndr, r->out.new_handle);
1116
 
                ZERO_STRUCTP(r->out.new_handle);
1117
 
        }
1118
 
        if (flags & NDR_OUT) {
1119
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1120
 
                        NDR_PULL_ALLOC(ndr, r->out.new_handle);
1121
 
                }
1122
 
                _mem_save_new_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1123
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.new_handle, LIBNDR_FLAG_REF_ALLOC);
1124
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.new_handle));
1125
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_new_handle_0, LIBNDR_FLAG_REF_ALLOC);
1126
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_action_taken));
1127
 
                if (_ptr_action_taken) {
1128
 
                        NDR_PULL_ALLOC(ndr, r->out.action_taken);
1129
 
                } else {
1130
 
                        r->out.action_taken = NULL;
1131
 
                }
1132
 
                if (r->out.action_taken) {
1133
 
                        _mem_save_action_taken_0 = NDR_PULL_GET_MEM_CTX(ndr);
1134
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.action_taken, 0);
1135
 
                        NDR_CHECK(ndr_pull_winreg_CreateAction(ndr, NDR_SCALARS, r->out.action_taken));
1136
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_action_taken_0, 0);
1137
 
                }
1138
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1139
 
        }
1140
 
        return NDR_ERR_SUCCESS;
1141
 
}
1142
 
 
1143
 
_PUBLIC_ void ndr_print_winreg_CreateKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_CreateKey *r)
1144
 
{
1145
 
        ndr_print_struct(ndr, name, "winreg_CreateKey");
1146
 
        ndr->depth++;
1147
 
        if (flags & NDR_SET_VALUES) {
1148
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1149
 
        }
1150
 
        if (flags & NDR_IN) {
1151
 
                ndr_print_struct(ndr, "in", "winreg_CreateKey");
1152
 
                ndr->depth++;
1153
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
1154
 
                ndr->depth++;
1155
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
1156
 
                ndr->depth--;
1157
 
                ndr_print_winreg_String(ndr, "name", &r->in.name);
1158
 
                ndr_print_winreg_String(ndr, "keyclass", &r->in.keyclass);
1159
 
                ndr_print_uint32(ndr, "options", r->in.options);
1160
 
                ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
1161
 
                ndr_print_ptr(ndr, "secdesc", r->in.secdesc);
1162
 
                ndr->depth++;
1163
 
                if (r->in.secdesc) {
1164
 
                        ndr_print_winreg_SecBuf(ndr, "secdesc", r->in.secdesc);
1165
 
                }
1166
 
                ndr->depth--;
1167
 
                ndr_print_ptr(ndr, "action_taken", r->in.action_taken);
1168
 
                ndr->depth++;
1169
 
                if (r->in.action_taken) {
1170
 
                        ndr_print_winreg_CreateAction(ndr, "action_taken", *r->in.action_taken);
1171
 
                }
1172
 
                ndr->depth--;
1173
 
                ndr->depth--;
1174
 
        }
1175
 
        if (flags & NDR_OUT) {
1176
 
                ndr_print_struct(ndr, "out", "winreg_CreateKey");
1177
 
                ndr->depth++;
1178
 
                ndr_print_ptr(ndr, "new_handle", r->out.new_handle);
1179
 
                ndr->depth++;
1180
 
                ndr_print_policy_handle(ndr, "new_handle", r->out.new_handle);
1181
 
                ndr->depth--;
1182
 
                ndr_print_ptr(ndr, "action_taken", r->out.action_taken);
1183
 
                ndr->depth++;
1184
 
                if (r->out.action_taken) {
1185
 
                        ndr_print_winreg_CreateAction(ndr, "action_taken", *r->out.action_taken);
1186
 
                }
1187
 
                ndr->depth--;
1188
 
                ndr_print_WERROR(ndr, "result", r->out.result);
1189
 
                ndr->depth--;
1190
 
        }
1191
 
        ndr->depth--;
1192
 
}
1193
 
 
1194
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_DeleteKey(struct ndr_push *ndr, int flags, const struct winreg_DeleteKey *r)
1195
 
{
1196
 
        if (flags & NDR_IN) {
1197
 
                if (r->in.handle == NULL) {
1198
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1199
 
                }
1200
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1201
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.key));
1202
 
        }
1203
 
        if (flags & NDR_OUT) {
1204
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1205
 
        }
1206
 
        return NDR_ERR_SUCCESS;
1207
 
}
1208
 
 
1209
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_DeleteKey(struct ndr_pull *ndr, int flags, struct winreg_DeleteKey *r)
1210
 
{
1211
 
        TALLOC_CTX *_mem_save_handle_0;
1212
 
        if (flags & NDR_IN) {
1213
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1214
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
1215
 
                }
1216
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1217
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1218
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1219
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1220
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.key));
1221
 
        }
1222
 
        if (flags & NDR_OUT) {
1223
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1224
 
        }
1225
 
        return NDR_ERR_SUCCESS;
1226
 
}
1227
 
 
1228
 
_PUBLIC_ void ndr_print_winreg_DeleteKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_DeleteKey *r)
1229
 
{
1230
 
        ndr_print_struct(ndr, name, "winreg_DeleteKey");
1231
 
        ndr->depth++;
1232
 
        if (flags & NDR_SET_VALUES) {
1233
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1234
 
        }
1235
 
        if (flags & NDR_IN) {
1236
 
                ndr_print_struct(ndr, "in", "winreg_DeleteKey");
1237
 
                ndr->depth++;
1238
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
1239
 
                ndr->depth++;
1240
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
1241
 
                ndr->depth--;
1242
 
                ndr_print_winreg_String(ndr, "key", &r->in.key);
1243
 
                ndr->depth--;
1244
 
        }
1245
 
        if (flags & NDR_OUT) {
1246
 
                ndr_print_struct(ndr, "out", "winreg_DeleteKey");
1247
 
                ndr->depth++;
1248
 
                ndr_print_WERROR(ndr, "result", r->out.result);
1249
 
                ndr->depth--;
1250
 
        }
1251
 
        ndr->depth--;
1252
 
}
1253
 
 
1254
 
static enum ndr_err_code ndr_push_winreg_DeleteValue(struct ndr_push *ndr, int flags, const struct winreg_DeleteValue *r)
1255
 
{
1256
 
        if (flags & NDR_IN) {
1257
 
                if (r->in.handle == NULL) {
1258
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1259
 
                }
1260
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1261
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.value));
1262
 
        }
1263
 
        if (flags & NDR_OUT) {
1264
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1265
 
        }
1266
 
        return NDR_ERR_SUCCESS;
1267
 
}
1268
 
 
1269
 
static enum ndr_err_code ndr_pull_winreg_DeleteValue(struct ndr_pull *ndr, int flags, struct winreg_DeleteValue *r)
1270
 
{
1271
 
        TALLOC_CTX *_mem_save_handle_0;
1272
 
        if (flags & NDR_IN) {
1273
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1274
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
1275
 
                }
1276
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1277
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1278
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1279
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1280
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.value));
1281
 
        }
1282
 
        if (flags & NDR_OUT) {
1283
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1284
 
        }
1285
 
        return NDR_ERR_SUCCESS;
1286
 
}
1287
 
 
1288
 
_PUBLIC_ void ndr_print_winreg_DeleteValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_DeleteValue *r)
1289
 
{
1290
 
        ndr_print_struct(ndr, name, "winreg_DeleteValue");
1291
 
        ndr->depth++;
1292
 
        if (flags & NDR_SET_VALUES) {
1293
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1294
 
        }
1295
 
        if (flags & NDR_IN) {
1296
 
                ndr_print_struct(ndr, "in", "winreg_DeleteValue");
1297
 
                ndr->depth++;
1298
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
1299
 
                ndr->depth++;
1300
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
1301
 
                ndr->depth--;
1302
 
                ndr_print_winreg_String(ndr, "value", &r->in.value);
1303
 
                ndr->depth--;
1304
 
        }
1305
 
        if (flags & NDR_OUT) {
1306
 
                ndr_print_struct(ndr, "out", "winreg_DeleteValue");
1307
 
                ndr->depth++;
1308
 
                ndr_print_WERROR(ndr, "result", r->out.result);
1309
 
                ndr->depth--;
1310
 
        }
1311
 
        ndr->depth--;
1312
 
}
1313
 
 
1314
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_EnumKey(struct ndr_push *ndr, int flags, const struct winreg_EnumKey *r)
1315
 
{
1316
 
        if (flags & NDR_IN) {
1317
 
                if (r->in.handle == NULL) {
1318
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1319
 
                }
1320
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1321
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
1322
 
                if (r->in.name == NULL) {
1323
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1324
 
                }
1325
 
                NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1326
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.keyclass));
1327
 
                if (r->in.keyclass) {
1328
 
                        NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyclass));
1329
 
                }
1330
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.last_changed_time));
1331
 
                if (r->in.last_changed_time) {
1332
 
                        NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->in.last_changed_time));
1333
 
                }
1334
 
        }
1335
 
        if (flags & NDR_OUT) {
1336
 
                if (r->out.name == NULL) {
1337
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1338
 
                }
1339
 
                NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1340
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.keyclass));
1341
 
                if (r->out.keyclass) {
1342
 
                        NDR_CHECK(ndr_push_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.keyclass));
1343
 
                }
1344
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.last_changed_time));
1345
 
                if (r->out.last_changed_time) {
1346
 
                        NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.last_changed_time));
1347
 
                }
1348
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1349
 
        }
1350
 
        return NDR_ERR_SUCCESS;
1351
 
}
1352
 
 
1353
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_EnumKey(struct ndr_pull *ndr, int flags, struct winreg_EnumKey *r)
1354
 
{
1355
 
        uint32_t _ptr_keyclass;
1356
 
        uint32_t _ptr_last_changed_time;
1357
 
        TALLOC_CTX *_mem_save_handle_0;
1358
 
        TALLOC_CTX *_mem_save_name_0;
1359
 
        TALLOC_CTX *_mem_save_keyclass_0;
1360
 
        TALLOC_CTX *_mem_save_last_changed_time_0;
1361
 
        if (flags & NDR_IN) {
1362
 
                ZERO_STRUCT(r->out);
1363
 
 
1364
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1365
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
1366
 
                }
1367
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1368
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1369
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1370
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1371
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
1372
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1373
 
                        NDR_PULL_ALLOC(ndr, r->in.name);
1374
 
                }
1375
 
                _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1376
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
1377
 
                NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1378
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1379
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyclass));
1380
 
                if (_ptr_keyclass) {
1381
 
                        NDR_PULL_ALLOC(ndr, r->in.keyclass);
1382
 
                } else {
1383
 
                        r->in.keyclass = NULL;
1384
 
                }
1385
 
                if (r->in.keyclass) {
1386
 
                        _mem_save_keyclass_0 = NDR_PULL_GET_MEM_CTX(ndr);
1387
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.keyclass, 0);
1388
 
                        NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyclass));
1389
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyclass_0, 0);
1390
 
                }
1391
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_last_changed_time));
1392
 
                if (_ptr_last_changed_time) {
1393
 
                        NDR_PULL_ALLOC(ndr, r->in.last_changed_time);
1394
 
                } else {
1395
 
                        r->in.last_changed_time = NULL;
1396
 
                }
1397
 
                if (r->in.last_changed_time) {
1398
 
                        _mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
1399
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.last_changed_time, 0);
1400
 
                        NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->in.last_changed_time));
1401
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, 0);
1402
 
                }
1403
 
                NDR_PULL_ALLOC(ndr, r->out.name);
1404
 
                *r->out.name = *r->in.name;
1405
 
        }
1406
 
        if (flags & NDR_OUT) {
1407
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1408
 
                        NDR_PULL_ALLOC(ndr, r->out.name);
1409
 
                }
1410
 
                _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1411
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);
1412
 
                NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1413
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1414
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyclass));
1415
 
                if (_ptr_keyclass) {
1416
 
                        NDR_PULL_ALLOC(ndr, r->out.keyclass);
1417
 
                } else {
1418
 
                        r->out.keyclass = NULL;
1419
 
                }
1420
 
                if (r->out.keyclass) {
1421
 
                        _mem_save_keyclass_0 = NDR_PULL_GET_MEM_CTX(ndr);
1422
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.keyclass, 0);
1423
 
                        NDR_CHECK(ndr_pull_winreg_StringBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.keyclass));
1424
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyclass_0, 0);
1425
 
                }
1426
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_last_changed_time));
1427
 
                if (_ptr_last_changed_time) {
1428
 
                        NDR_PULL_ALLOC(ndr, r->out.last_changed_time);
1429
 
                } else {
1430
 
                        r->out.last_changed_time = NULL;
1431
 
                }
1432
 
                if (r->out.last_changed_time) {
1433
 
                        _mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
1434
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.last_changed_time, 0);
1435
 
                        NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.last_changed_time));
1436
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, 0);
1437
 
                }
1438
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1439
 
        }
1440
 
        return NDR_ERR_SUCCESS;
1441
 
}
1442
 
 
1443
 
_PUBLIC_ void ndr_print_winreg_EnumKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_EnumKey *r)
1444
 
{
1445
 
        ndr_print_struct(ndr, name, "winreg_EnumKey");
1446
 
        ndr->depth++;
1447
 
        if (flags & NDR_SET_VALUES) {
1448
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1449
 
        }
1450
 
        if (flags & NDR_IN) {
1451
 
                ndr_print_struct(ndr, "in", "winreg_EnumKey");
1452
 
                ndr->depth++;
1453
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
1454
 
                ndr->depth++;
1455
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
1456
 
                ndr->depth--;
1457
 
                ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
1458
 
                ndr_print_ptr(ndr, "name", r->in.name);
1459
 
                ndr->depth++;
1460
 
                ndr_print_winreg_StringBuf(ndr, "name", r->in.name);
1461
 
                ndr->depth--;
1462
 
                ndr_print_ptr(ndr, "keyclass", r->in.keyclass);
1463
 
                ndr->depth++;
1464
 
                if (r->in.keyclass) {
1465
 
                        ndr_print_winreg_StringBuf(ndr, "keyclass", r->in.keyclass);
1466
 
                }
1467
 
                ndr->depth--;
1468
 
                ndr_print_ptr(ndr, "last_changed_time", r->in.last_changed_time);
1469
 
                ndr->depth++;
1470
 
                if (r->in.last_changed_time) {
1471
 
                        ndr_print_NTTIME(ndr, "last_changed_time", *r->in.last_changed_time);
1472
 
                }
1473
 
                ndr->depth--;
1474
 
                ndr->depth--;
1475
 
        }
1476
 
        if (flags & NDR_OUT) {
1477
 
                ndr_print_struct(ndr, "out", "winreg_EnumKey");
1478
 
                ndr->depth++;
1479
 
                ndr_print_ptr(ndr, "name", r->out.name);
1480
 
                ndr->depth++;
1481
 
                ndr_print_winreg_StringBuf(ndr, "name", r->out.name);
1482
 
                ndr->depth--;
1483
 
                ndr_print_ptr(ndr, "keyclass", r->out.keyclass);
1484
 
                ndr->depth++;
1485
 
                if (r->out.keyclass) {
1486
 
                        ndr_print_winreg_StringBuf(ndr, "keyclass", r->out.keyclass);
1487
 
                }
1488
 
                ndr->depth--;
1489
 
                ndr_print_ptr(ndr, "last_changed_time", r->out.last_changed_time);
1490
 
                ndr->depth++;
1491
 
                if (r->out.last_changed_time) {
1492
 
                        ndr_print_NTTIME(ndr, "last_changed_time", *r->out.last_changed_time);
1493
 
                }
1494
 
                ndr->depth--;
1495
 
                ndr_print_WERROR(ndr, "result", r->out.result);
1496
 
                ndr->depth--;
1497
 
        }
1498
 
        ndr->depth--;
1499
 
}
1500
 
 
1501
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_EnumValue(struct ndr_push *ndr, int flags, const struct winreg_EnumValue *r)
1502
 
{
1503
 
        if (flags & NDR_IN) {
1504
 
                if (r->in.handle == NULL) {
1505
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1506
 
                }
1507
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1508
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
1509
 
                if (r->in.name == NULL) {
1510
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1511
 
                }
1512
 
                NDR_CHECK(ndr_push_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1513
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.type));
1514
 
                if (r->in.type) {
1515
 
                        NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->in.type));
1516
 
                }
1517
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.value));
1518
 
                if (r->in.value) {
1519
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->in.size));
1520
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1521
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->in.length));
1522
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.value, *r->in.length));
1523
 
                }
1524
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.size));
1525
 
                if (r->in.size) {
1526
 
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.size));
1527
 
                }
1528
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.length));
1529
 
                if (r->in.length) {
1530
 
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.length));
1531
 
                }
1532
 
        }
1533
 
        if (flags & NDR_OUT) {
1534
 
                if (r->out.name == NULL) {
1535
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1536
 
                }
1537
 
                NDR_CHECK(ndr_push_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1538
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.type));
1539
 
                if (r->out.type) {
1540
 
                        NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
1541
 
                }
1542
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.value));
1543
 
                if (r->out.value) {
1544
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.size));
1545
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1546
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.length));
1547
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.value, *r->out.length));
1548
 
                }
1549
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.size));
1550
 
                if (r->out.size) {
1551
 
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.size));
1552
 
                }
1553
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.length));
1554
 
                if (r->out.length) {
1555
 
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.length));
1556
 
                }
1557
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1558
 
        }
1559
 
        return NDR_ERR_SUCCESS;
1560
 
}
1561
 
 
1562
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_EnumValue(struct ndr_pull *ndr, int flags, struct winreg_EnumValue *r)
1563
 
{
1564
 
        uint32_t _ptr_type;
1565
 
        uint32_t _ptr_value;
1566
 
        uint32_t _ptr_size;
1567
 
        uint32_t _ptr_length;
1568
 
        TALLOC_CTX *_mem_save_handle_0;
1569
 
        TALLOC_CTX *_mem_save_name_0;
1570
 
        TALLOC_CTX *_mem_save_type_0;
1571
 
        TALLOC_CTX *_mem_save_value_0;
1572
 
        TALLOC_CTX *_mem_save_size_0;
1573
 
        TALLOC_CTX *_mem_save_length_0;
1574
 
        if (flags & NDR_IN) {
1575
 
                ZERO_STRUCT(r->out);
1576
 
 
1577
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1578
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
1579
 
                }
1580
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1581
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1582
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1583
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1584
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
1585
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1586
 
                        NDR_PULL_ALLOC(ndr, r->in.name);
1587
 
                }
1588
 
                _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1589
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.name, LIBNDR_FLAG_REF_ALLOC);
1590
 
                NDR_CHECK(ndr_pull_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.name));
1591
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1592
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
1593
 
                if (_ptr_type) {
1594
 
                        NDR_PULL_ALLOC(ndr, r->in.type);
1595
 
                } else {
1596
 
                        r->in.type = NULL;
1597
 
                }
1598
 
                if (r->in.type) {
1599
 
                        _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
1600
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.type, 0);
1601
 
                        NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->in.type));
1602
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
1603
 
                }
1604
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
1605
 
                if (_ptr_value) {
1606
 
                        NDR_PULL_ALLOC(ndr, r->in.value);
1607
 
                } else {
1608
 
                        r->in.value = NULL;
1609
 
                }
1610
 
                if (r->in.value) {
1611
 
                        _mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
1612
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.value, 0);
1613
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value));
1614
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value));
1615
 
                        if (ndr_get_array_length(ndr, &r->in.value) > ndr_get_array_size(ndr, &r->in.value)) {
1616
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value), ndr_get_array_length(ndr, &r->in.value));
1617
 
                        }
1618
 
                        NDR_PULL_ALLOC_N(ndr, r->in.value, ndr_get_array_size(ndr, &r->in.value));
1619
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.value, ndr_get_array_length(ndr, &r->in.value)));
1620
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
1621
 
                }
1622
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_size));
1623
 
                if (_ptr_size) {
1624
 
                        NDR_PULL_ALLOC(ndr, r->in.size);
1625
 
                } else {
1626
 
                        r->in.size = NULL;
1627
 
                }
1628
 
                if (r->in.size) {
1629
 
                        _mem_save_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
1630
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.size, 0);
1631
 
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.size));
1632
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_size_0, 0);
1633
 
                }
1634
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_length));
1635
 
                if (_ptr_length) {
1636
 
                        NDR_PULL_ALLOC(ndr, r->in.length);
1637
 
                } else {
1638
 
                        r->in.length = NULL;
1639
 
                }
1640
 
                if (r->in.length) {
1641
 
                        _mem_save_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
1642
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.length, 0);
1643
 
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.length));
1644
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_length_0, 0);
1645
 
                }
1646
 
                NDR_PULL_ALLOC(ndr, r->out.name);
1647
 
                *r->out.name = *r->in.name;
1648
 
                if (r->in.value) {
1649
 
                        if (r->in.size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");
1650
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.value, *r->in.size));
1651
 
                }
1652
 
                if (r->in.value) {
1653
 
                        if (r->in.length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");
1654
 
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.value, *r->in.length));
1655
 
                }
1656
 
        }
1657
 
        if (flags & NDR_OUT) {
1658
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1659
 
                        NDR_PULL_ALLOC(ndr, r->out.name);
1660
 
                }
1661
 
                _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1662
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.name, LIBNDR_FLAG_REF_ALLOC);
1663
 
                NDR_CHECK(ndr_pull_winreg_ValNameBuf(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.name));
1664
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, LIBNDR_FLAG_REF_ALLOC);
1665
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
1666
 
                if (_ptr_type) {
1667
 
                        NDR_PULL_ALLOC(ndr, r->out.type);
1668
 
                } else {
1669
 
                        r->out.type = NULL;
1670
 
                }
1671
 
                if (r->out.type) {
1672
 
                        _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
1673
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.type, 0);
1674
 
                        NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
1675
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
1676
 
                }
1677
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
1678
 
                if (_ptr_value) {
1679
 
                        NDR_PULL_ALLOC(ndr, r->out.value);
1680
 
                } else {
1681
 
                        r->out.value = NULL;
1682
 
                }
1683
 
                if (r->out.value) {
1684
 
                        _mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
1685
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.value, 0);
1686
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value));
1687
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->out.value));
1688
 
                        if (ndr_get_array_length(ndr, &r->out.value) > ndr_get_array_size(ndr, &r->out.value)) {
1689
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->out.value), ndr_get_array_length(ndr, &r->out.value));
1690
 
                        }
1691
 
                        NDR_PULL_ALLOC_N(ndr, r->out.value, ndr_get_array_size(ndr, &r->out.value));
1692
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.value, ndr_get_array_length(ndr, &r->out.value)));
1693
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
1694
 
                }
1695
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_size));
1696
 
                if (_ptr_size) {
1697
 
                        NDR_PULL_ALLOC(ndr, r->out.size);
1698
 
                } else {
1699
 
                        r->out.size = NULL;
1700
 
                }
1701
 
                if (r->out.size) {
1702
 
                        _mem_save_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
1703
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.size, 0);
1704
 
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.size));
1705
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_size_0, 0);
1706
 
                }
1707
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_length));
1708
 
                if (_ptr_length) {
1709
 
                        NDR_PULL_ALLOC(ndr, r->out.length);
1710
 
                } else {
1711
 
                        r->out.length = NULL;
1712
 
                }
1713
 
                if (r->out.length) {
1714
 
                        _mem_save_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
1715
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.length, 0);
1716
 
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.length));
1717
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_length_0, 0);
1718
 
                }
1719
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1720
 
                if (r->out.value) {
1721
 
                        if (r->out.size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");
1722
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value, *r->out.size));
1723
 
                }
1724
 
                if (r->out.value) {
1725
 
                        if (r->out.length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");
1726
 
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.value, *r->out.length));
1727
 
                }
1728
 
        }
1729
 
        return NDR_ERR_SUCCESS;
1730
 
}
1731
 
 
1732
 
_PUBLIC_ void ndr_print_winreg_EnumValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_EnumValue *r)
1733
 
{
1734
 
        ndr_print_struct(ndr, name, "winreg_EnumValue");
1735
 
        ndr->depth++;
1736
 
        if (flags & NDR_SET_VALUES) {
1737
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1738
 
        }
1739
 
        if (flags & NDR_IN) {
1740
 
                ndr_print_struct(ndr, "in", "winreg_EnumValue");
1741
 
                ndr->depth++;
1742
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
1743
 
                ndr->depth++;
1744
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
1745
 
                ndr->depth--;
1746
 
                ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
1747
 
                ndr_print_ptr(ndr, "name", r->in.name);
1748
 
                ndr->depth++;
1749
 
                ndr_print_winreg_ValNameBuf(ndr, "name", r->in.name);
1750
 
                ndr->depth--;
1751
 
                ndr_print_ptr(ndr, "type", r->in.type);
1752
 
                ndr->depth++;
1753
 
                if (r->in.type) {
1754
 
                        ndr_print_winreg_Type(ndr, "type", *r->in.type);
1755
 
                }
1756
 
                ndr->depth--;
1757
 
                ndr_print_ptr(ndr, "value", r->in.value);
1758
 
                ndr->depth++;
1759
 
                if (r->in.value) {
1760
 
                        if (r->in.length == NULL) return;
1761
 
                        ndr_print_array_uint8(ndr, "value", r->in.value, *r->in.length);
1762
 
                }
1763
 
                ndr->depth--;
1764
 
                ndr_print_ptr(ndr, "size", r->in.size);
1765
 
                ndr->depth++;
1766
 
                if (r->in.size) {
1767
 
                        ndr_print_uint32(ndr, "size", *r->in.size);
1768
 
                }
1769
 
                ndr->depth--;
1770
 
                ndr_print_ptr(ndr, "length", r->in.length);
1771
 
                ndr->depth++;
1772
 
                if (r->in.length) {
1773
 
                        ndr_print_uint32(ndr, "length", *r->in.length);
1774
 
                }
1775
 
                ndr->depth--;
1776
 
                ndr->depth--;
1777
 
        }
1778
 
        if (flags & NDR_OUT) {
1779
 
                ndr_print_struct(ndr, "out", "winreg_EnumValue");
1780
 
                ndr->depth++;
1781
 
                ndr_print_ptr(ndr, "name", r->out.name);
1782
 
                ndr->depth++;
1783
 
                ndr_print_winreg_ValNameBuf(ndr, "name", r->out.name);
1784
 
                ndr->depth--;
1785
 
                ndr_print_ptr(ndr, "type", r->out.type);
1786
 
                ndr->depth++;
1787
 
                if (r->out.type) {
1788
 
                        ndr_print_winreg_Type(ndr, "type", *r->out.type);
1789
 
                }
1790
 
                ndr->depth--;
1791
 
                ndr_print_ptr(ndr, "value", r->out.value);
1792
 
                ndr->depth++;
1793
 
                if (r->out.value) {
1794
 
                        if (r->out.length == NULL) return;
1795
 
                        ndr_print_array_uint8(ndr, "value", r->out.value, *r->out.length);
1796
 
                }
1797
 
                ndr->depth--;
1798
 
                ndr_print_ptr(ndr, "size", r->out.size);
1799
 
                ndr->depth++;
1800
 
                if (r->out.size) {
1801
 
                        ndr_print_uint32(ndr, "size", *r->out.size);
1802
 
                }
1803
 
                ndr->depth--;
1804
 
                ndr_print_ptr(ndr, "length", r->out.length);
1805
 
                ndr->depth++;
1806
 
                if (r->out.length) {
1807
 
                        ndr_print_uint32(ndr, "length", *r->out.length);
1808
 
                }
1809
 
                ndr->depth--;
1810
 
                ndr_print_WERROR(ndr, "result", r->out.result);
1811
 
                ndr->depth--;
1812
 
        }
1813
 
        ndr->depth--;
1814
 
}
1815
 
 
1816
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_FlushKey(struct ndr_push *ndr, int flags, const struct winreg_FlushKey *r)
1817
 
{
1818
 
        if (flags & NDR_IN) {
1819
 
                if (r->in.handle == NULL) {
1820
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1821
 
                }
1822
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1823
 
        }
1824
 
        if (flags & NDR_OUT) {
1825
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1826
 
        }
1827
 
        return NDR_ERR_SUCCESS;
1828
 
}
1829
 
 
1830
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_FlushKey(struct ndr_pull *ndr, int flags, struct winreg_FlushKey *r)
1831
 
{
1832
 
        TALLOC_CTX *_mem_save_handle_0;
1833
 
        if (flags & NDR_IN) {
1834
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1835
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
1836
 
                }
1837
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1838
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1839
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1840
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1841
 
        }
1842
 
        if (flags & NDR_OUT) {
1843
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1844
 
        }
1845
 
        return NDR_ERR_SUCCESS;
1846
 
}
1847
 
 
1848
 
_PUBLIC_ void ndr_print_winreg_FlushKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_FlushKey *r)
1849
 
{
1850
 
        ndr_print_struct(ndr, name, "winreg_FlushKey");
1851
 
        ndr->depth++;
1852
 
        if (flags & NDR_SET_VALUES) {
1853
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1854
 
        }
1855
 
        if (flags & NDR_IN) {
1856
 
                ndr_print_struct(ndr, "in", "winreg_FlushKey");
1857
 
                ndr->depth++;
1858
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
1859
 
                ndr->depth++;
1860
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
1861
 
                ndr->depth--;
1862
 
                ndr->depth--;
1863
 
        }
1864
 
        if (flags & NDR_OUT) {
1865
 
                ndr_print_struct(ndr, "out", "winreg_FlushKey");
1866
 
                ndr->depth++;
1867
 
                ndr_print_WERROR(ndr, "result", r->out.result);
1868
 
                ndr->depth--;
1869
 
        }
1870
 
        ndr->depth--;
1871
 
}
1872
 
 
1873
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_GetKeySecurity(struct ndr_push *ndr, int flags, const struct winreg_GetKeySecurity *r)
1874
 
{
1875
 
        if (flags & NDR_IN) {
1876
 
                if (r->in.handle == NULL) {
1877
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1878
 
                }
1879
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1880
 
                NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
1881
 
                if (r->in.sd == NULL) {
1882
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1883
 
                }
1884
 
                NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
1885
 
        }
1886
 
        if (flags & NDR_OUT) {
1887
 
                if (r->out.sd == NULL) {
1888
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1889
 
                }
1890
 
                NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sd));
1891
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1892
 
        }
1893
 
        return NDR_ERR_SUCCESS;
1894
 
}
1895
 
 
1896
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_GetKeySecurity(struct ndr_pull *ndr, int flags, struct winreg_GetKeySecurity *r)
1897
 
{
1898
 
        TALLOC_CTX *_mem_save_handle_0;
1899
 
        TALLOC_CTX *_mem_save_sd_0;
1900
 
        if (flags & NDR_IN) {
1901
 
                ZERO_STRUCT(r->out);
1902
 
 
1903
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1904
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
1905
 
                }
1906
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1907
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1908
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1909
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1910
 
                NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
1911
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1912
 
                        NDR_PULL_ALLOC(ndr, r->in.sd);
1913
 
                }
1914
 
                _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
1915
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sd, LIBNDR_FLAG_REF_ALLOC);
1916
 
                NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
1917
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);
1918
 
                NDR_PULL_ALLOC(ndr, r->out.sd);
1919
 
                *r->out.sd = *r->in.sd;
1920
 
        }
1921
 
        if (flags & NDR_OUT) {
1922
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1923
 
                        NDR_PULL_ALLOC(ndr, r->out.sd);
1924
 
                }
1925
 
                _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
1926
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.sd, LIBNDR_FLAG_REF_ALLOC);
1927
 
                NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.sd));
1928
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);
1929
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1930
 
        }
1931
 
        return NDR_ERR_SUCCESS;
1932
 
}
1933
 
 
1934
 
_PUBLIC_ void ndr_print_winreg_GetKeySecurity(struct ndr_print *ndr, const char *name, int flags, const struct winreg_GetKeySecurity *r)
1935
 
{
1936
 
        ndr_print_struct(ndr, name, "winreg_GetKeySecurity");
1937
 
        ndr->depth++;
1938
 
        if (flags & NDR_SET_VALUES) {
1939
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1940
 
        }
1941
 
        if (flags & NDR_IN) {
1942
 
                ndr_print_struct(ndr, "in", "winreg_GetKeySecurity");
1943
 
                ndr->depth++;
1944
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
1945
 
                ndr->depth++;
1946
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
1947
 
                ndr->depth--;
1948
 
                ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
1949
 
                ndr_print_ptr(ndr, "sd", r->in.sd);
1950
 
                ndr->depth++;
1951
 
                ndr_print_KeySecurityData(ndr, "sd", r->in.sd);
1952
 
                ndr->depth--;
1953
 
                ndr->depth--;
1954
 
        }
1955
 
        if (flags & NDR_OUT) {
1956
 
                ndr_print_struct(ndr, "out", "winreg_GetKeySecurity");
1957
 
                ndr->depth++;
1958
 
                ndr_print_ptr(ndr, "sd", r->out.sd);
1959
 
                ndr->depth++;
1960
 
                ndr_print_KeySecurityData(ndr, "sd", r->out.sd);
1961
 
                ndr->depth--;
1962
 
                ndr_print_WERROR(ndr, "result", r->out.result);
1963
 
                ndr->depth--;
1964
 
        }
1965
 
        ndr->depth--;
1966
 
}
1967
 
 
1968
 
static enum ndr_err_code ndr_push_winreg_LoadKey(struct ndr_push *ndr, int flags, const struct winreg_LoadKey *r)
1969
 
{
1970
 
        if (flags & NDR_IN) {
1971
 
                if (r->in.handle == NULL) {
1972
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1973
 
                }
1974
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1975
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.keyname));
1976
 
                if (r->in.keyname) {
1977
 
                        NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyname));
1978
 
                }
1979
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.filename));
1980
 
                if (r->in.filename) {
1981
 
                        NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
1982
 
                }
1983
 
        }
1984
 
        if (flags & NDR_OUT) {
1985
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1986
 
        }
1987
 
        return NDR_ERR_SUCCESS;
1988
 
}
1989
 
 
1990
 
static enum ndr_err_code ndr_pull_winreg_LoadKey(struct ndr_pull *ndr, int flags, struct winreg_LoadKey *r)
1991
 
{
1992
 
        uint32_t _ptr_keyname;
1993
 
        uint32_t _ptr_filename;
1994
 
        TALLOC_CTX *_mem_save_handle_0;
1995
 
        TALLOC_CTX *_mem_save_keyname_0;
1996
 
        TALLOC_CTX *_mem_save_filename_0;
1997
 
        if (flags & NDR_IN) {
1998
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1999
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
2000
 
                }
2001
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2002
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2003
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2004
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2005
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyname));
2006
 
                if (_ptr_keyname) {
2007
 
                        NDR_PULL_ALLOC(ndr, r->in.keyname);
2008
 
                } else {
2009
 
                        r->in.keyname = NULL;
2010
 
                }
2011
 
                if (r->in.keyname) {
2012
 
                        _mem_save_keyname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2013
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.keyname, 0);
2014
 
                        NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.keyname));
2015
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyname_0, 0);
2016
 
                }
2017
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_filename));
2018
 
                if (_ptr_filename) {
2019
 
                        NDR_PULL_ALLOC(ndr, r->in.filename);
2020
 
                } else {
2021
 
                        r->in.filename = NULL;
2022
 
                }
2023
 
                if (r->in.filename) {
2024
 
                        _mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
2025
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, 0);
2026
 
                        NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
2027
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, 0);
2028
 
                }
2029
 
        }
2030
 
        if (flags & NDR_OUT) {
2031
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2032
 
        }
2033
 
        return NDR_ERR_SUCCESS;
2034
 
}
2035
 
 
2036
 
_PUBLIC_ void ndr_print_winreg_LoadKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_LoadKey *r)
2037
 
{
2038
 
        ndr_print_struct(ndr, name, "winreg_LoadKey");
2039
 
        ndr->depth++;
2040
 
        if (flags & NDR_SET_VALUES) {
2041
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2042
 
        }
2043
 
        if (flags & NDR_IN) {
2044
 
                ndr_print_struct(ndr, "in", "winreg_LoadKey");
2045
 
                ndr->depth++;
2046
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
2047
 
                ndr->depth++;
2048
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
2049
 
                ndr->depth--;
2050
 
                ndr_print_ptr(ndr, "keyname", r->in.keyname);
2051
 
                ndr->depth++;
2052
 
                if (r->in.keyname) {
2053
 
                        ndr_print_winreg_String(ndr, "keyname", r->in.keyname);
2054
 
                }
2055
 
                ndr->depth--;
2056
 
                ndr_print_ptr(ndr, "filename", r->in.filename);
2057
 
                ndr->depth++;
2058
 
                if (r->in.filename) {
2059
 
                        ndr_print_winreg_String(ndr, "filename", r->in.filename);
2060
 
                }
2061
 
                ndr->depth--;
2062
 
                ndr->depth--;
2063
 
        }
2064
 
        if (flags & NDR_OUT) {
2065
 
                ndr_print_struct(ndr, "out", "winreg_LoadKey");
2066
 
                ndr->depth++;
2067
 
                ndr_print_WERROR(ndr, "result", r->out.result);
2068
 
                ndr->depth--;
2069
 
        }
2070
 
        ndr->depth--;
2071
 
}
2072
 
 
2073
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_NotifyChangeKeyValue(struct ndr_push *ndr, int flags, const struct winreg_NotifyChangeKeyValue *r)
2074
 
{
2075
 
        if (flags & NDR_IN) {
2076
 
                if (r->in.handle == NULL) {
2077
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2078
 
                }
2079
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2080
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.watch_subtree));
2081
 
                NDR_CHECK(ndr_push_winreg_NotifyChangeType(ndr, NDR_SCALARS, r->in.notify_filter));
2082
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
2083
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string1));
2084
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string2));
2085
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
2086
 
        }
2087
 
        if (flags & NDR_OUT) {
2088
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2089
 
        }
2090
 
        return NDR_ERR_SUCCESS;
2091
 
}
2092
 
 
2093
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_NotifyChangeKeyValue(struct ndr_pull *ndr, int flags, struct winreg_NotifyChangeKeyValue *r)
2094
 
{
2095
 
        TALLOC_CTX *_mem_save_handle_0;
2096
 
        if (flags & NDR_IN) {
2097
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2098
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
2099
 
                }
2100
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2101
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2102
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2103
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2104
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.watch_subtree));
2105
 
                NDR_CHECK(ndr_pull_winreg_NotifyChangeType(ndr, NDR_SCALARS, &r->in.notify_filter));
2106
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
2107
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string1));
2108
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.string2));
2109
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
2110
 
        }
2111
 
        if (flags & NDR_OUT) {
2112
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2113
 
        }
2114
 
        return NDR_ERR_SUCCESS;
2115
 
}
2116
 
 
2117
 
_PUBLIC_ void ndr_print_winreg_NotifyChangeKeyValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_NotifyChangeKeyValue *r)
2118
 
{
2119
 
        ndr_print_struct(ndr, name, "winreg_NotifyChangeKeyValue");
2120
 
        ndr->depth++;
2121
 
        if (flags & NDR_SET_VALUES) {
2122
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2123
 
        }
2124
 
        if (flags & NDR_IN) {
2125
 
                ndr_print_struct(ndr, "in", "winreg_NotifyChangeKeyValue");
2126
 
                ndr->depth++;
2127
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
2128
 
                ndr->depth++;
2129
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
2130
 
                ndr->depth--;
2131
 
                ndr_print_uint8(ndr, "watch_subtree", r->in.watch_subtree);
2132
 
                ndr_print_winreg_NotifyChangeType(ndr, "notify_filter", r->in.notify_filter);
2133
 
                ndr_print_uint32(ndr, "unknown", r->in.unknown);
2134
 
                ndr_print_winreg_String(ndr, "string1", &r->in.string1);
2135
 
                ndr_print_winreg_String(ndr, "string2", &r->in.string2);
2136
 
                ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
2137
 
                ndr->depth--;
2138
 
        }
2139
 
        if (flags & NDR_OUT) {
2140
 
                ndr_print_struct(ndr, "out", "winreg_NotifyChangeKeyValue");
2141
 
                ndr->depth++;
2142
 
                ndr_print_WERROR(ndr, "result", r->out.result);
2143
 
                ndr->depth--;
2144
 
        }
2145
 
        ndr->depth--;
2146
 
}
2147
 
 
2148
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_OpenKey(struct ndr_push *ndr, int flags, const struct winreg_OpenKey *r)
2149
 
{
2150
 
        if (flags & NDR_IN) {
2151
 
                if (r->in.parent_handle == NULL) {
2152
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2153
 
                }
2154
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.parent_handle));
2155
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyname));
2156
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
2157
 
                NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
2158
 
        }
2159
 
        if (flags & NDR_OUT) {
2160
 
                if (r->out.handle == NULL) {
2161
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2162
 
                }
2163
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
2164
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2165
 
        }
2166
 
        return NDR_ERR_SUCCESS;
2167
 
}
2168
 
 
2169
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_OpenKey(struct ndr_pull *ndr, int flags, struct winreg_OpenKey *r)
2170
 
{
2171
 
        TALLOC_CTX *_mem_save_parent_handle_0;
2172
 
        TALLOC_CTX *_mem_save_handle_0;
2173
 
        if (flags & NDR_IN) {
2174
 
                ZERO_STRUCT(r->out);
2175
 
 
2176
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2177
 
                        NDR_PULL_ALLOC(ndr, r->in.parent_handle);
2178
 
                }
2179
 
                _mem_save_parent_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2180
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.parent_handle, LIBNDR_FLAG_REF_ALLOC);
2181
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.parent_handle));
2182
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_handle_0, LIBNDR_FLAG_REF_ALLOC);
2183
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.keyname));
2184
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
2185
 
                NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
2186
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
2187
 
                ZERO_STRUCTP(r->out.handle);
2188
 
        }
2189
 
        if (flags & NDR_OUT) {
2190
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2191
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
2192
 
                }
2193
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2194
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
2195
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
2196
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2197
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2198
 
        }
2199
 
        return NDR_ERR_SUCCESS;
2200
 
}
2201
 
 
2202
 
_PUBLIC_ void ndr_print_winreg_OpenKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenKey *r)
2203
 
{
2204
 
        ndr_print_struct(ndr, name, "winreg_OpenKey");
2205
 
        ndr->depth++;
2206
 
        if (flags & NDR_SET_VALUES) {
2207
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2208
 
        }
2209
 
        if (flags & NDR_IN) {
2210
 
                ndr_print_struct(ndr, "in", "winreg_OpenKey");
2211
 
                ndr->depth++;
2212
 
                ndr_print_ptr(ndr, "parent_handle", r->in.parent_handle);
2213
 
                ndr->depth++;
2214
 
                ndr_print_policy_handle(ndr, "parent_handle", r->in.parent_handle);
2215
 
                ndr->depth--;
2216
 
                ndr_print_winreg_String(ndr, "keyname", &r->in.keyname);
2217
 
                ndr_print_uint32(ndr, "unknown", r->in.unknown);
2218
 
                ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
2219
 
                ndr->depth--;
2220
 
        }
2221
 
        if (flags & NDR_OUT) {
2222
 
                ndr_print_struct(ndr, "out", "winreg_OpenKey");
2223
 
                ndr->depth++;
2224
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
2225
 
                ndr->depth++;
2226
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
2227
 
                ndr->depth--;
2228
 
                ndr_print_WERROR(ndr, "result", r->out.result);
2229
 
                ndr->depth--;
2230
 
        }
2231
 
        ndr->depth--;
2232
 
}
2233
 
 
2234
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_QueryInfoKey(struct ndr_push *ndr, int flags, const struct winreg_QueryInfoKey *r)
2235
 
{
2236
 
        if (flags & NDR_IN) {
2237
 
                if (r->in.handle == NULL) {
2238
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2239
 
                }
2240
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2241
 
                if (r->in.classname == NULL) {
2242
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2243
 
                }
2244
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.classname));
2245
 
        }
2246
 
        if (flags & NDR_OUT) {
2247
 
                if (r->out.classname == NULL) {
2248
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2249
 
                }
2250
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.classname));
2251
 
                if (r->out.num_subkeys == NULL) {
2252
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2253
 
                }
2254
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_subkeys));
2255
 
                if (r->out.max_subkeylen == NULL) {
2256
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2257
 
                }
2258
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_subkeylen));
2259
 
                if (r->out.max_classlen == NULL) {
2260
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2261
 
                }
2262
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_classlen));
2263
 
                if (r->out.num_values == NULL) {
2264
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2265
 
                }
2266
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_values));
2267
 
                if (r->out.max_valnamelen == NULL) {
2268
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2269
 
                }
2270
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valnamelen));
2271
 
                if (r->out.max_valbufsize == NULL) {
2272
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2273
 
                }
2274
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_valbufsize));
2275
 
                if (r->out.secdescsize == NULL) {
2276
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2277
 
                }
2278
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.secdescsize));
2279
 
                if (r->out.last_changed_time == NULL) {
2280
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2281
 
                }
2282
 
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, *r->out.last_changed_time));
2283
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2284
 
        }
2285
 
        return NDR_ERR_SUCCESS;
2286
 
}
2287
 
 
2288
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_QueryInfoKey(struct ndr_pull *ndr, int flags, struct winreg_QueryInfoKey *r)
2289
 
{
2290
 
        TALLOC_CTX *_mem_save_handle_0;
2291
 
        TALLOC_CTX *_mem_save_classname_0;
2292
 
        TALLOC_CTX *_mem_save_num_subkeys_0;
2293
 
        TALLOC_CTX *_mem_save_max_subkeylen_0;
2294
 
        TALLOC_CTX *_mem_save_max_classlen_0;
2295
 
        TALLOC_CTX *_mem_save_num_values_0;
2296
 
        TALLOC_CTX *_mem_save_max_valnamelen_0;
2297
 
        TALLOC_CTX *_mem_save_max_valbufsize_0;
2298
 
        TALLOC_CTX *_mem_save_secdescsize_0;
2299
 
        TALLOC_CTX *_mem_save_last_changed_time_0;
2300
 
        if (flags & NDR_IN) {
2301
 
                ZERO_STRUCT(r->out);
2302
 
 
2303
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2304
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
2305
 
                }
2306
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2307
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2308
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2309
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2310
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2311
 
                        NDR_PULL_ALLOC(ndr, r->in.classname);
2312
 
                }
2313
 
                _mem_save_classname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2314
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.classname, LIBNDR_FLAG_REF_ALLOC);
2315
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.classname));
2316
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_classname_0, LIBNDR_FLAG_REF_ALLOC);
2317
 
                NDR_PULL_ALLOC(ndr, r->out.classname);
2318
 
                *r->out.classname = *r->in.classname;
2319
 
                NDR_PULL_ALLOC(ndr, r->out.num_subkeys);
2320
 
                ZERO_STRUCTP(r->out.num_subkeys);
2321
 
                NDR_PULL_ALLOC(ndr, r->out.max_subkeylen);
2322
 
                ZERO_STRUCTP(r->out.max_subkeylen);
2323
 
                NDR_PULL_ALLOC(ndr, r->out.max_classlen);
2324
 
                ZERO_STRUCTP(r->out.max_classlen);
2325
 
                NDR_PULL_ALLOC(ndr, r->out.num_values);
2326
 
                ZERO_STRUCTP(r->out.num_values);
2327
 
                NDR_PULL_ALLOC(ndr, r->out.max_valnamelen);
2328
 
                ZERO_STRUCTP(r->out.max_valnamelen);
2329
 
                NDR_PULL_ALLOC(ndr, r->out.max_valbufsize);
2330
 
                ZERO_STRUCTP(r->out.max_valbufsize);
2331
 
                NDR_PULL_ALLOC(ndr, r->out.secdescsize);
2332
 
                ZERO_STRUCTP(r->out.secdescsize);
2333
 
                NDR_PULL_ALLOC(ndr, r->out.last_changed_time);
2334
 
                ZERO_STRUCTP(r->out.last_changed_time);
2335
 
        }
2336
 
        if (flags & NDR_OUT) {
2337
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2338
 
                        NDR_PULL_ALLOC(ndr, r->out.classname);
2339
 
                }
2340
 
                _mem_save_classname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2341
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.classname, LIBNDR_FLAG_REF_ALLOC);
2342
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.classname));
2343
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_classname_0, LIBNDR_FLAG_REF_ALLOC);
2344
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2345
 
                        NDR_PULL_ALLOC(ndr, r->out.num_subkeys);
2346
 
                }
2347
 
                _mem_save_num_subkeys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2348
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.num_subkeys, LIBNDR_FLAG_REF_ALLOC);
2349
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_subkeys));
2350
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_subkeys_0, LIBNDR_FLAG_REF_ALLOC);
2351
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2352
 
                        NDR_PULL_ALLOC(ndr, r->out.max_subkeylen);
2353
 
                }
2354
 
                _mem_save_max_subkeylen_0 = NDR_PULL_GET_MEM_CTX(ndr);
2355
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.max_subkeylen, LIBNDR_FLAG_REF_ALLOC);
2356
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_subkeylen));
2357
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_subkeylen_0, LIBNDR_FLAG_REF_ALLOC);
2358
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2359
 
                        NDR_PULL_ALLOC(ndr, r->out.max_classlen);
2360
 
                }
2361
 
                _mem_save_max_classlen_0 = NDR_PULL_GET_MEM_CTX(ndr);
2362
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.max_classlen, LIBNDR_FLAG_REF_ALLOC);
2363
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_classlen));
2364
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_classlen_0, LIBNDR_FLAG_REF_ALLOC);
2365
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2366
 
                        NDR_PULL_ALLOC(ndr, r->out.num_values);
2367
 
                }
2368
 
                _mem_save_num_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2369
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.num_values, LIBNDR_FLAG_REF_ALLOC);
2370
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_values));
2371
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_values_0, LIBNDR_FLAG_REF_ALLOC);
2372
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2373
 
                        NDR_PULL_ALLOC(ndr, r->out.max_valnamelen);
2374
 
                }
2375
 
                _mem_save_max_valnamelen_0 = NDR_PULL_GET_MEM_CTX(ndr);
2376
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valnamelen, LIBNDR_FLAG_REF_ALLOC);
2377
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valnamelen));
2378
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valnamelen_0, LIBNDR_FLAG_REF_ALLOC);
2379
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2380
 
                        NDR_PULL_ALLOC(ndr, r->out.max_valbufsize);
2381
 
                }
2382
 
                _mem_save_max_valbufsize_0 = NDR_PULL_GET_MEM_CTX(ndr);
2383
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.max_valbufsize, LIBNDR_FLAG_REF_ALLOC);
2384
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_valbufsize));
2385
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_valbufsize_0, LIBNDR_FLAG_REF_ALLOC);
2386
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2387
 
                        NDR_PULL_ALLOC(ndr, r->out.secdescsize);
2388
 
                }
2389
 
                _mem_save_secdescsize_0 = NDR_PULL_GET_MEM_CTX(ndr);
2390
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.secdescsize, LIBNDR_FLAG_REF_ALLOC);
2391
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.secdescsize));
2392
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdescsize_0, LIBNDR_FLAG_REF_ALLOC);
2393
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2394
 
                        NDR_PULL_ALLOC(ndr, r->out.last_changed_time);
2395
 
                }
2396
 
                _mem_save_last_changed_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
2397
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.last_changed_time, LIBNDR_FLAG_REF_ALLOC);
2398
 
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, r->out.last_changed_time));
2399
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_last_changed_time_0, LIBNDR_FLAG_REF_ALLOC);
2400
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2401
 
        }
2402
 
        return NDR_ERR_SUCCESS;
2403
 
}
2404
 
 
2405
 
_PUBLIC_ void ndr_print_winreg_QueryInfoKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryInfoKey *r)
2406
 
{
2407
 
        ndr_print_struct(ndr, name, "winreg_QueryInfoKey");
2408
 
        ndr->depth++;
2409
 
        if (flags & NDR_SET_VALUES) {
2410
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2411
 
        }
2412
 
        if (flags & NDR_IN) {
2413
 
                ndr_print_struct(ndr, "in", "winreg_QueryInfoKey");
2414
 
                ndr->depth++;
2415
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
2416
 
                ndr->depth++;
2417
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
2418
 
                ndr->depth--;
2419
 
                ndr_print_ptr(ndr, "classname", r->in.classname);
2420
 
                ndr->depth++;
2421
 
                ndr_print_winreg_String(ndr, "classname", r->in.classname);
2422
 
                ndr->depth--;
2423
 
                ndr->depth--;
2424
 
        }
2425
 
        if (flags & NDR_OUT) {
2426
 
                ndr_print_struct(ndr, "out", "winreg_QueryInfoKey");
2427
 
                ndr->depth++;
2428
 
                ndr_print_ptr(ndr, "classname", r->out.classname);
2429
 
                ndr->depth++;
2430
 
                ndr_print_winreg_String(ndr, "classname", r->out.classname);
2431
 
                ndr->depth--;
2432
 
                ndr_print_ptr(ndr, "num_subkeys", r->out.num_subkeys);
2433
 
                ndr->depth++;
2434
 
                ndr_print_uint32(ndr, "num_subkeys", *r->out.num_subkeys);
2435
 
                ndr->depth--;
2436
 
                ndr_print_ptr(ndr, "max_subkeylen", r->out.max_subkeylen);
2437
 
                ndr->depth++;
2438
 
                ndr_print_uint32(ndr, "max_subkeylen", *r->out.max_subkeylen);
2439
 
                ndr->depth--;
2440
 
                ndr_print_ptr(ndr, "max_classlen", r->out.max_classlen);
2441
 
                ndr->depth++;
2442
 
                ndr_print_uint32(ndr, "max_classlen", *r->out.max_classlen);
2443
 
                ndr->depth--;
2444
 
                ndr_print_ptr(ndr, "num_values", r->out.num_values);
2445
 
                ndr->depth++;
2446
 
                ndr_print_uint32(ndr, "num_values", *r->out.num_values);
2447
 
                ndr->depth--;
2448
 
                ndr_print_ptr(ndr, "max_valnamelen", r->out.max_valnamelen);
2449
 
                ndr->depth++;
2450
 
                ndr_print_uint32(ndr, "max_valnamelen", *r->out.max_valnamelen);
2451
 
                ndr->depth--;
2452
 
                ndr_print_ptr(ndr, "max_valbufsize", r->out.max_valbufsize);
2453
 
                ndr->depth++;
2454
 
                ndr_print_uint32(ndr, "max_valbufsize", *r->out.max_valbufsize);
2455
 
                ndr->depth--;
2456
 
                ndr_print_ptr(ndr, "secdescsize", r->out.secdescsize);
2457
 
                ndr->depth++;
2458
 
                ndr_print_uint32(ndr, "secdescsize", *r->out.secdescsize);
2459
 
                ndr->depth--;
2460
 
                ndr_print_ptr(ndr, "last_changed_time", r->out.last_changed_time);
2461
 
                ndr->depth++;
2462
 
                ndr_print_NTTIME(ndr, "last_changed_time", *r->out.last_changed_time);
2463
 
                ndr->depth--;
2464
 
                ndr_print_WERROR(ndr, "result", r->out.result);
2465
 
                ndr->depth--;
2466
 
        }
2467
 
        ndr->depth--;
2468
 
}
2469
 
 
2470
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_QueryValue(struct ndr_push *ndr, int flags, const struct winreg_QueryValue *r)
2471
 
{
2472
 
        if (flags & NDR_IN) {
2473
 
                if (r->in.handle == NULL) {
2474
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2475
 
                }
2476
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2477
 
                if (r->in.value_name == NULL) {
2478
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2479
 
                }
2480
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.value_name));
2481
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.type));
2482
 
                if (r->in.type) {
2483
 
                        NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->in.type));
2484
 
                }
2485
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));
2486
 
                if (r->in.data) {
2487
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size?*r->in.data_size:0));
2488
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2489
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_length?*r->in.data_length:0));
2490
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.data_length?*r->in.data_length:0));
2491
 
                }
2492
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_size));
2493
 
                if (r->in.data_size) {
2494
 
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_size));
2495
 
                }
2496
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_length));
2497
 
                if (r->in.data_length) {
2498
 
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.data_length));
2499
 
                }
2500
 
        }
2501
 
        if (flags & NDR_OUT) {
2502
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.type));
2503
 
                if (r->out.type) {
2504
 
                        NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
2505
 
                }
2506
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data));
2507
 
                if (r->out.data) {
2508
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->out.data_size?*r->out.data_size:0));
2509
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2510
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->out.data_length?*r->out.data_length:0));
2511
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->out.data_length?*r->out.data_length:0));
2512
 
                }
2513
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data_size));
2514
 
                if (r->out.data_size) {
2515
 
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_size));
2516
 
                }
2517
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.data_length));
2518
 
                if (r->out.data_length) {
2519
 
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_length));
2520
 
                }
2521
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2522
 
        }
2523
 
        return NDR_ERR_SUCCESS;
2524
 
}
2525
 
 
2526
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_QueryValue(struct ndr_pull *ndr, int flags, struct winreg_QueryValue *r)
2527
 
{
2528
 
        uint32_t _ptr_type;
2529
 
        uint32_t _ptr_data;
2530
 
        uint32_t _ptr_data_size;
2531
 
        uint32_t _ptr_data_length;
2532
 
        TALLOC_CTX *_mem_save_handle_0;
2533
 
        TALLOC_CTX *_mem_save_value_name_0;
2534
 
        TALLOC_CTX *_mem_save_type_0;
2535
 
        TALLOC_CTX *_mem_save_data_0;
2536
 
        TALLOC_CTX *_mem_save_data_size_0;
2537
 
        TALLOC_CTX *_mem_save_data_length_0;
2538
 
        if (flags & NDR_IN) {
2539
 
                ZERO_STRUCT(r->out);
2540
 
 
2541
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2542
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
2543
 
                }
2544
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2545
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2546
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2547
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2548
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2549
 
                        NDR_PULL_ALLOC(ndr, r->in.value_name);
2550
 
                }
2551
 
                _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2552
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.value_name, LIBNDR_FLAG_REF_ALLOC);
2553
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.value_name));
2554
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, LIBNDR_FLAG_REF_ALLOC);
2555
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
2556
 
                if (_ptr_type) {
2557
 
                        NDR_PULL_ALLOC(ndr, r->in.type);
2558
 
                } else {
2559
 
                        r->in.type = NULL;
2560
 
                }
2561
 
                if (r->in.type) {
2562
 
                        _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2563
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.type, 0);
2564
 
                        NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->in.type));
2565
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
2566
 
                }
2567
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2568
 
                if (_ptr_data) {
2569
 
                        NDR_PULL_ALLOC(ndr, r->in.data);
2570
 
                } else {
2571
 
                        r->in.data = NULL;
2572
 
                }
2573
 
                if (r->in.data) {
2574
 
                        _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2575
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);
2576
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
2577
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data));
2578
 
                        if (ndr_get_array_length(ndr, &r->in.data) > ndr_get_array_size(ndr, &r->in.data)) {
2579
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.data), ndr_get_array_length(ndr, &r->in.data));
2580
 
                        }
2581
 
                        NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
2582
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_length(ndr, &r->in.data)));
2583
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2584
 
                }
2585
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_size));
2586
 
                if (_ptr_data_size) {
2587
 
                        NDR_PULL_ALLOC(ndr, r->in.data_size);
2588
 
                } else {
2589
 
                        r->in.data_size = NULL;
2590
 
                }
2591
 
                if (r->in.data_size) {
2592
 
                        _mem_save_data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
2593
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.data_size, 0);
2594
 
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.data_size));
2595
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_size_0, 0);
2596
 
                }
2597
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_length));
2598
 
                if (_ptr_data_length) {
2599
 
                        NDR_PULL_ALLOC(ndr, r->in.data_length);
2600
 
                } else {
2601
 
                        r->in.data_length = NULL;
2602
 
                }
2603
 
                if (r->in.data_length) {
2604
 
                        _mem_save_data_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
2605
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.data_length, 0);
2606
 
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.data_length));
2607
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_length_0, 0);
2608
 
                }
2609
 
                if (r->in.data) {
2610
 
                        if (r->in.data_size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");
2611
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.data_size?*r->in.data_size:0));
2612
 
                }
2613
 
                if (r->in.data) {
2614
 
                        if (r->in.data_length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");
2615
 
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.data, r->in.data_length?*r->in.data_length:0));
2616
 
                }
2617
 
        }
2618
 
        if (flags & NDR_OUT) {
2619
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_type));
2620
 
                if (_ptr_type) {
2621
 
                        NDR_PULL_ALLOC(ndr, r->out.type);
2622
 
                } else {
2623
 
                        r->out.type = NULL;
2624
 
                }
2625
 
                if (r->out.type) {
2626
 
                        _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2627
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.type, 0);
2628
 
                        NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
2629
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, 0);
2630
 
                }
2631
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2632
 
                if (_ptr_data) {
2633
 
                        NDR_PULL_ALLOC(ndr, r->out.data);
2634
 
                } else {
2635
 
                        r->out.data = NULL;
2636
 
                }
2637
 
                if (r->out.data) {
2638
 
                        _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2639
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.data, 0);
2640
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
2641
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->out.data));
2642
 
                        if (ndr_get_array_length(ndr, &r->out.data) > ndr_get_array_size(ndr, &r->out.data)) {
2643
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->out.data), ndr_get_array_length(ndr, &r->out.data));
2644
 
                        }
2645
 
                        NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
2646
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_length(ndr, &r->out.data)));
2647
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2648
 
                }
2649
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_size));
2650
 
                if (_ptr_data_size) {
2651
 
                        NDR_PULL_ALLOC(ndr, r->out.data_size);
2652
 
                } else {
2653
 
                        r->out.data_size = NULL;
2654
 
                }
2655
 
                if (r->out.data_size) {
2656
 
                        _mem_save_data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
2657
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.data_size, 0);
2658
 
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_size));
2659
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_size_0, 0);
2660
 
                }
2661
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_length));
2662
 
                if (_ptr_data_length) {
2663
 
                        NDR_PULL_ALLOC(ndr, r->out.data_length);
2664
 
                } else {
2665
 
                        r->out.data_length = NULL;
2666
 
                }
2667
 
                if (r->out.data_length) {
2668
 
                        _mem_save_data_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
2669
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.data_length, 0);
2670
 
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_length));
2671
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_length_0, 0);
2672
 
                }
2673
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2674
 
                if (r->out.data) {
2675
 
                        if (r->out.data_size == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for size_is()");
2676
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->out.data_size?*r->out.data_size:0));
2677
 
                }
2678
 
                if (r->out.data) {
2679
 
                        if (r->out.data_length == NULL) return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER, "NULL Pointer for length_is()");
2680
 
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.data, r->out.data_length?*r->out.data_length:0));
2681
 
                }
2682
 
        }
2683
 
        return NDR_ERR_SUCCESS;
2684
 
}
2685
 
 
2686
 
_PUBLIC_ void ndr_print_winreg_QueryValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryValue *r)
2687
 
{
2688
 
        ndr_print_struct(ndr, name, "winreg_QueryValue");
2689
 
        ndr->depth++;
2690
 
        if (flags & NDR_SET_VALUES) {
2691
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2692
 
        }
2693
 
        if (flags & NDR_IN) {
2694
 
                ndr_print_struct(ndr, "in", "winreg_QueryValue");
2695
 
                ndr->depth++;
2696
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
2697
 
                ndr->depth++;
2698
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
2699
 
                ndr->depth--;
2700
 
                ndr_print_ptr(ndr, "value_name", r->in.value_name);
2701
 
                ndr->depth++;
2702
 
                ndr_print_winreg_String(ndr, "value_name", r->in.value_name);
2703
 
                ndr->depth--;
2704
 
                ndr_print_ptr(ndr, "type", r->in.type);
2705
 
                ndr->depth++;
2706
 
                if (r->in.type) {
2707
 
                        ndr_print_winreg_Type(ndr, "type", *r->in.type);
2708
 
                }
2709
 
                ndr->depth--;
2710
 
                ndr_print_ptr(ndr, "data", r->in.data);
2711
 
                ndr->depth++;
2712
 
                if (r->in.data) {
2713
 
                        if (r->in.data_length == NULL) return;
2714
 
                        ndr_print_array_uint8(ndr, "data", r->in.data, r->in.data_length?*r->in.data_length:0);
2715
 
                }
2716
 
                ndr->depth--;
2717
 
                ndr_print_ptr(ndr, "data_size", r->in.data_size);
2718
 
                ndr->depth++;
2719
 
                if (r->in.data_size) {
2720
 
                        ndr_print_uint32(ndr, "data_size", *r->in.data_size);
2721
 
                }
2722
 
                ndr->depth--;
2723
 
                ndr_print_ptr(ndr, "data_length", r->in.data_length);
2724
 
                ndr->depth++;
2725
 
                if (r->in.data_length) {
2726
 
                        ndr_print_uint32(ndr, "data_length", *r->in.data_length);
2727
 
                }
2728
 
                ndr->depth--;
2729
 
                ndr->depth--;
2730
 
        }
2731
 
        if (flags & NDR_OUT) {
2732
 
                ndr_print_struct(ndr, "out", "winreg_QueryValue");
2733
 
                ndr->depth++;
2734
 
                ndr_print_ptr(ndr, "type", r->out.type);
2735
 
                ndr->depth++;
2736
 
                if (r->out.type) {
2737
 
                        ndr_print_winreg_Type(ndr, "type", *r->out.type);
2738
 
                }
2739
 
                ndr->depth--;
2740
 
                ndr_print_ptr(ndr, "data", r->out.data);
2741
 
                ndr->depth++;
2742
 
                if (r->out.data) {
2743
 
                        if (r->out.data_length == NULL) return;
2744
 
                        ndr_print_array_uint8(ndr, "data", r->out.data, r->out.data_length?*r->out.data_length:0);
2745
 
                }
2746
 
                ndr->depth--;
2747
 
                ndr_print_ptr(ndr, "data_size", r->out.data_size);
2748
 
                ndr->depth++;
2749
 
                if (r->out.data_size) {
2750
 
                        ndr_print_uint32(ndr, "data_size", *r->out.data_size);
2751
 
                }
2752
 
                ndr->depth--;
2753
 
                ndr_print_ptr(ndr, "data_length", r->out.data_length);
2754
 
                ndr->depth++;
2755
 
                if (r->out.data_length) {
2756
 
                        ndr_print_uint32(ndr, "data_length", *r->out.data_length);
2757
 
                }
2758
 
                ndr->depth--;
2759
 
                ndr_print_WERROR(ndr, "result", r->out.result);
2760
 
                ndr->depth--;
2761
 
        }
2762
 
        ndr->depth--;
2763
 
}
2764
 
 
2765
 
static enum ndr_err_code ndr_push_winreg_ReplaceKey(struct ndr_push *ndr, int flags, const struct winreg_ReplaceKey *r)
2766
 
{
2767
 
        if (flags & NDR_IN) {
2768
 
        }
2769
 
        if (flags & NDR_OUT) {
2770
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2771
 
        }
2772
 
        return NDR_ERR_SUCCESS;
2773
 
}
2774
 
 
2775
 
static enum ndr_err_code ndr_pull_winreg_ReplaceKey(struct ndr_pull *ndr, int flags, struct winreg_ReplaceKey *r)
2776
 
{
2777
 
        if (flags & NDR_IN) {
2778
 
        }
2779
 
        if (flags & NDR_OUT) {
2780
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2781
 
        }
2782
 
        return NDR_ERR_SUCCESS;
2783
 
}
2784
 
 
2785
 
_PUBLIC_ void ndr_print_winreg_ReplaceKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_ReplaceKey *r)
2786
 
{
2787
 
        ndr_print_struct(ndr, name, "winreg_ReplaceKey");
2788
 
        ndr->depth++;
2789
 
        if (flags & NDR_SET_VALUES) {
2790
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2791
 
        }
2792
 
        if (flags & NDR_IN) {
2793
 
                ndr_print_struct(ndr, "in", "winreg_ReplaceKey");
2794
 
                ndr->depth++;
2795
 
                ndr->depth--;
2796
 
        }
2797
 
        if (flags & NDR_OUT) {
2798
 
                ndr_print_struct(ndr, "out", "winreg_ReplaceKey");
2799
 
                ndr->depth++;
2800
 
                ndr_print_WERROR(ndr, "result", r->out.result);
2801
 
                ndr->depth--;
2802
 
        }
2803
 
        ndr->depth--;
2804
 
}
2805
 
 
2806
 
static enum ndr_err_code ndr_push_winreg_RestoreKey(struct ndr_push *ndr, int flags, const struct winreg_RestoreKey *r)
2807
 
{
2808
 
        if (flags & NDR_IN) {
2809
 
                if (r->in.handle == NULL) {
2810
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2811
 
                }
2812
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2813
 
                if (r->in.filename == NULL) {
2814
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2815
 
                }
2816
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
2817
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
2818
 
        }
2819
 
        if (flags & NDR_OUT) {
2820
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2821
 
        }
2822
 
        return NDR_ERR_SUCCESS;
2823
 
}
2824
 
 
2825
 
static enum ndr_err_code ndr_pull_winreg_RestoreKey(struct ndr_pull *ndr, int flags, struct winreg_RestoreKey *r)
2826
 
{
2827
 
        TALLOC_CTX *_mem_save_handle_0;
2828
 
        TALLOC_CTX *_mem_save_filename_0;
2829
 
        if (flags & NDR_IN) {
2830
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2831
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
2832
 
                }
2833
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2834
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2835
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2836
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2837
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2838
 
                        NDR_PULL_ALLOC(ndr, r->in.filename);
2839
 
                }
2840
 
                _mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
2841
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, LIBNDR_FLAG_REF_ALLOC);
2842
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
2843
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, LIBNDR_FLAG_REF_ALLOC);
2844
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
2845
 
        }
2846
 
        if (flags & NDR_OUT) {
2847
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2848
 
        }
2849
 
        return NDR_ERR_SUCCESS;
2850
 
}
2851
 
 
2852
 
_PUBLIC_ void ndr_print_winreg_RestoreKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_RestoreKey *r)
2853
 
{
2854
 
        ndr_print_struct(ndr, name, "winreg_RestoreKey");
2855
 
        ndr->depth++;
2856
 
        if (flags & NDR_SET_VALUES) {
2857
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2858
 
        }
2859
 
        if (flags & NDR_IN) {
2860
 
                ndr_print_struct(ndr, "in", "winreg_RestoreKey");
2861
 
                ndr->depth++;
2862
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
2863
 
                ndr->depth++;
2864
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
2865
 
                ndr->depth--;
2866
 
                ndr_print_ptr(ndr, "filename", r->in.filename);
2867
 
                ndr->depth++;
2868
 
                ndr_print_winreg_String(ndr, "filename", r->in.filename);
2869
 
                ndr->depth--;
2870
 
                ndr_print_uint32(ndr, "flags", r->in.flags);
2871
 
                ndr->depth--;
2872
 
        }
2873
 
        if (flags & NDR_OUT) {
2874
 
                ndr_print_struct(ndr, "out", "winreg_RestoreKey");
2875
 
                ndr->depth++;
2876
 
                ndr_print_WERROR(ndr, "result", r->out.result);
2877
 
                ndr->depth--;
2878
 
        }
2879
 
        ndr->depth--;
2880
 
}
2881
 
 
2882
 
static enum ndr_err_code ndr_push_winreg_SaveKey(struct ndr_push *ndr, int flags, const struct winreg_SaveKey *r)
2883
 
{
2884
 
        if (flags & NDR_IN) {
2885
 
                if (r->in.handle == NULL) {
2886
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2887
 
                }
2888
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2889
 
                if (r->in.filename == NULL) {
2890
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2891
 
                }
2892
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
2893
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.sec_attrib));
2894
 
                if (r->in.sec_attrib) {
2895
 
                        NDR_CHECK(ndr_push_KeySecurityAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_attrib));
2896
 
                }
2897
 
        }
2898
 
        if (flags & NDR_OUT) {
2899
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2900
 
        }
2901
 
        return NDR_ERR_SUCCESS;
2902
 
}
2903
 
 
2904
 
static enum ndr_err_code ndr_pull_winreg_SaveKey(struct ndr_pull *ndr, int flags, struct winreg_SaveKey *r)
2905
 
{
2906
 
        uint32_t _ptr_sec_attrib;
2907
 
        TALLOC_CTX *_mem_save_handle_0;
2908
 
        TALLOC_CTX *_mem_save_filename_0;
2909
 
        TALLOC_CTX *_mem_save_sec_attrib_0;
2910
 
        if (flags & NDR_IN) {
2911
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2912
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
2913
 
                }
2914
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2915
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2916
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2917
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2918
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2919
 
                        NDR_PULL_ALLOC(ndr, r->in.filename);
2920
 
                }
2921
 
                _mem_save_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
2922
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.filename, LIBNDR_FLAG_REF_ALLOC);
2923
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.filename));
2924
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_filename_0, LIBNDR_FLAG_REF_ALLOC);
2925
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sec_attrib));
2926
 
                if (_ptr_sec_attrib) {
2927
 
                        NDR_PULL_ALLOC(ndr, r->in.sec_attrib);
2928
 
                } else {
2929
 
                        r->in.sec_attrib = NULL;
2930
 
                }
2931
 
                if (r->in.sec_attrib) {
2932
 
                        _mem_save_sec_attrib_0 = NDR_PULL_GET_MEM_CTX(ndr);
2933
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.sec_attrib, 0);
2934
 
                        NDR_CHECK(ndr_pull_KeySecurityAttribute(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sec_attrib));
2935
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sec_attrib_0, 0);
2936
 
                }
2937
 
        }
2938
 
        if (flags & NDR_OUT) {
2939
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2940
 
        }
2941
 
        return NDR_ERR_SUCCESS;
2942
 
}
2943
 
 
2944
 
_PUBLIC_ void ndr_print_winreg_SaveKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SaveKey *r)
2945
 
{
2946
 
        ndr_print_struct(ndr, name, "winreg_SaveKey");
2947
 
        ndr->depth++;
2948
 
        if (flags & NDR_SET_VALUES) {
2949
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2950
 
        }
2951
 
        if (flags & NDR_IN) {
2952
 
                ndr_print_struct(ndr, "in", "winreg_SaveKey");
2953
 
                ndr->depth++;
2954
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
2955
 
                ndr->depth++;
2956
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
2957
 
                ndr->depth--;
2958
 
                ndr_print_ptr(ndr, "filename", r->in.filename);
2959
 
                ndr->depth++;
2960
 
                ndr_print_winreg_String(ndr, "filename", r->in.filename);
2961
 
                ndr->depth--;
2962
 
                ndr_print_ptr(ndr, "sec_attrib", r->in.sec_attrib);
2963
 
                ndr->depth++;
2964
 
                if (r->in.sec_attrib) {
2965
 
                        ndr_print_KeySecurityAttribute(ndr, "sec_attrib", r->in.sec_attrib);
2966
 
                }
2967
 
                ndr->depth--;
2968
 
                ndr->depth--;
2969
 
        }
2970
 
        if (flags & NDR_OUT) {
2971
 
                ndr_print_struct(ndr, "out", "winreg_SaveKey");
2972
 
                ndr->depth++;
2973
 
                ndr_print_WERROR(ndr, "result", r->out.result);
2974
 
                ndr->depth--;
2975
 
        }
2976
 
        ndr->depth--;
2977
 
}
2978
 
 
2979
 
static enum ndr_err_code ndr_push_winreg_SetKeySecurity(struct ndr_push *ndr, int flags, const struct winreg_SetKeySecurity *r)
2980
 
{
2981
 
        if (flags & NDR_IN) {
2982
 
                if (r->in.handle == NULL) {
2983
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2984
 
                }
2985
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2986
 
                NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.sec_info));
2987
 
                if (r->in.sd == NULL) {
2988
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2989
 
                }
2990
 
                NDR_CHECK(ndr_push_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
2991
 
        }
2992
 
        if (flags & NDR_OUT) {
2993
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2994
 
        }
2995
 
        return NDR_ERR_SUCCESS;
2996
 
}
2997
 
 
2998
 
static enum ndr_err_code ndr_pull_winreg_SetKeySecurity(struct ndr_pull *ndr, int flags, struct winreg_SetKeySecurity *r)
2999
 
{
3000
 
        TALLOC_CTX *_mem_save_handle_0;
3001
 
        TALLOC_CTX *_mem_save_sd_0;
3002
 
        if (flags & NDR_IN) {
3003
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3004
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
3005
 
                }
3006
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3007
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3008
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3009
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3010
 
                NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.sec_info));
3011
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3012
 
                        NDR_PULL_ALLOC(ndr, r->in.sd);
3013
 
                }
3014
 
                _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
3015
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.sd, LIBNDR_FLAG_REF_ALLOC);
3016
 
                NDR_CHECK(ndr_pull_KeySecurityData(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sd));
3017
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, LIBNDR_FLAG_REF_ALLOC);
3018
 
        }
3019
 
        if (flags & NDR_OUT) {
3020
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3021
 
        }
3022
 
        return NDR_ERR_SUCCESS;
3023
 
}
3024
 
 
3025
 
_PUBLIC_ void ndr_print_winreg_SetKeySecurity(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SetKeySecurity *r)
3026
 
{
3027
 
        ndr_print_struct(ndr, name, "winreg_SetKeySecurity");
3028
 
        ndr->depth++;
3029
 
        if (flags & NDR_SET_VALUES) {
3030
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3031
 
        }
3032
 
        if (flags & NDR_IN) {
3033
 
                ndr_print_struct(ndr, "in", "winreg_SetKeySecurity");
3034
 
                ndr->depth++;
3035
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
3036
 
                ndr->depth++;
3037
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
3038
 
                ndr->depth--;
3039
 
                ndr_print_security_secinfo(ndr, "sec_info", r->in.sec_info);
3040
 
                ndr_print_ptr(ndr, "sd", r->in.sd);
3041
 
                ndr->depth++;
3042
 
                ndr_print_KeySecurityData(ndr, "sd", r->in.sd);
3043
 
                ndr->depth--;
3044
 
                ndr->depth--;
3045
 
        }
3046
 
        if (flags & NDR_OUT) {
3047
 
                ndr_print_struct(ndr, "out", "winreg_SetKeySecurity");
3048
 
                ndr->depth++;
3049
 
                ndr_print_WERROR(ndr, "result", r->out.result);
3050
 
                ndr->depth--;
3051
 
        }
3052
 
        ndr->depth--;
3053
 
}
3054
 
 
3055
 
static enum ndr_err_code ndr_push_winreg_SetValue(struct ndr_push *ndr, int flags, const struct winreg_SetValue *r)
3056
 
{
3057
 
        if (flags & NDR_IN) {
3058
 
                if (r->in.handle == NULL) {
3059
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3060
 
                }
3061
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3062
 
                NDR_CHECK(ndr_push_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
3063
 
                NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
3064
 
                if (r->in.data == NULL) {
3065
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3066
 
                }
3067
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.size));
3068
 
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.size));
3069
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.size));
3070
 
        }
3071
 
        if (flags & NDR_OUT) {
3072
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3073
 
        }
3074
 
        return NDR_ERR_SUCCESS;
3075
 
}
3076
 
 
3077
 
static enum ndr_err_code ndr_pull_winreg_SetValue(struct ndr_pull *ndr, int flags, struct winreg_SetValue *r)
3078
 
{
3079
 
        TALLOC_CTX *_mem_save_handle_0;
3080
 
        if (flags & NDR_IN) {
3081
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3082
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
3083
 
                }
3084
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3085
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3086
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3087
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3088
 
                NDR_CHECK(ndr_pull_winreg_String(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.name));
3089
 
                NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
3090
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
3091
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3092
 
                        NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
3093
 
                }
3094
 
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
3095
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.size));
3096
 
                if (r->in.data) {
3097
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.size));
3098
 
                }
3099
 
        }
3100
 
        if (flags & NDR_OUT) {
3101
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3102
 
        }
3103
 
        return NDR_ERR_SUCCESS;
3104
 
}
3105
 
 
3106
 
_PUBLIC_ void ndr_print_winreg_SetValue(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SetValue *r)
3107
 
{
3108
 
        ndr_print_struct(ndr, name, "winreg_SetValue");
3109
 
        ndr->depth++;
3110
 
        if (flags & NDR_SET_VALUES) {
3111
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3112
 
        }
3113
 
        if (flags & NDR_IN) {
3114
 
                ndr_print_struct(ndr, "in", "winreg_SetValue");
3115
 
                ndr->depth++;
3116
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
3117
 
                ndr->depth++;
3118
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
3119
 
                ndr->depth--;
3120
 
                ndr_print_winreg_String(ndr, "name", &r->in.name);
3121
 
                ndr_print_winreg_Type(ndr, "type", r->in.type);
3122
 
                ndr_print_ptr(ndr, "data", r->in.data);
3123
 
                ndr->depth++;
3124
 
                ndr_print_array_uint8(ndr, "data", r->in.data, r->in.size);
3125
 
                ndr->depth--;
3126
 
                ndr_print_uint32(ndr, "size", r->in.size);
3127
 
                ndr->depth--;
3128
 
        }
3129
 
        if (flags & NDR_OUT) {
3130
 
                ndr_print_struct(ndr, "out", "winreg_SetValue");
3131
 
                ndr->depth++;
3132
 
                ndr_print_WERROR(ndr, "result", r->out.result);
3133
 
                ndr->depth--;
3134
 
        }
3135
 
        ndr->depth--;
3136
 
}
3137
 
 
3138
 
static enum ndr_err_code ndr_push_winreg_UnLoadKey(struct ndr_push *ndr, int flags, const struct winreg_UnLoadKey *r)
3139
 
{
3140
 
        if (flags & NDR_IN) {
3141
 
        }
3142
 
        if (flags & NDR_OUT) {
3143
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3144
 
        }
3145
 
        return NDR_ERR_SUCCESS;
3146
 
}
3147
 
 
3148
 
static enum ndr_err_code ndr_pull_winreg_UnLoadKey(struct ndr_pull *ndr, int flags, struct winreg_UnLoadKey *r)
3149
 
{
3150
 
        if (flags & NDR_IN) {
3151
 
        }
3152
 
        if (flags & NDR_OUT) {
3153
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3154
 
        }
3155
 
        return NDR_ERR_SUCCESS;
3156
 
}
3157
 
 
3158
 
_PUBLIC_ void ndr_print_winreg_UnLoadKey(struct ndr_print *ndr, const char *name, int flags, const struct winreg_UnLoadKey *r)
3159
 
{
3160
 
        ndr_print_struct(ndr, name, "winreg_UnLoadKey");
3161
 
        ndr->depth++;
3162
 
        if (flags & NDR_SET_VALUES) {
3163
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3164
 
        }
3165
 
        if (flags & NDR_IN) {
3166
 
                ndr_print_struct(ndr, "in", "winreg_UnLoadKey");
3167
 
                ndr->depth++;
3168
 
                ndr->depth--;
3169
 
        }
3170
 
        if (flags & NDR_OUT) {
3171
 
                ndr_print_struct(ndr, "out", "winreg_UnLoadKey");
3172
 
                ndr->depth++;
3173
 
                ndr_print_WERROR(ndr, "result", r->out.result);
3174
 
                ndr->depth--;
3175
 
        }
3176
 
        ndr->depth--;
3177
 
}
3178
 
 
3179
 
static enum ndr_err_code ndr_push_winreg_InitiateSystemShutdown(struct ndr_push *ndr, int flags, const struct winreg_InitiateSystemShutdown *r)
3180
 
{
3181
 
        if (flags & NDR_IN) {
3182
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hostname));
3183
 
                if (r->in.hostname) {
3184
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.hostname));
3185
 
                }
3186
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message));
3187
 
                if (r->in.message) {
3188
 
                        NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
3189
 
                }
3190
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.timeout));
3191
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.force_apps));
3192
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.do_reboot));
3193
 
        }
3194
 
        if (flags & NDR_OUT) {
3195
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3196
 
        }
3197
 
        return NDR_ERR_SUCCESS;
3198
 
}
3199
 
 
3200
 
static enum ndr_err_code ndr_pull_winreg_InitiateSystemShutdown(struct ndr_pull *ndr, int flags, struct winreg_InitiateSystemShutdown *r)
3201
 
{
3202
 
        uint32_t _ptr_hostname;
3203
 
        uint32_t _ptr_message;
3204
 
        TALLOC_CTX *_mem_save_hostname_0;
3205
 
        TALLOC_CTX *_mem_save_message_0;
3206
 
        if (flags & NDR_IN) {
3207
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hostname));
3208
 
                if (_ptr_hostname) {
3209
 
                        NDR_PULL_ALLOC(ndr, r->in.hostname);
3210
 
                } else {
3211
 
                        r->in.hostname = NULL;
3212
 
                }
3213
 
                if (r->in.hostname) {
3214
 
                        _mem_save_hostname_0 = NDR_PULL_GET_MEM_CTX(ndr);
3215
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.hostname, 0);
3216
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.hostname));
3217
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hostname_0, 0);
3218
 
                }
3219
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message));
3220
 
                if (_ptr_message) {
3221
 
                        NDR_PULL_ALLOC(ndr, r->in.message);
3222
 
                } else {
3223
 
                        r->in.message = NULL;
3224
 
                }
3225
 
                if (r->in.message) {
3226
 
                        _mem_save_message_0 = NDR_PULL_GET_MEM_CTX(ndr);
3227
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.message, 0);
3228
 
                        NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
3229
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_0, 0);
3230
 
                }
3231
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.timeout));
3232
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.force_apps));
3233
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.do_reboot));
3234
 
        }
3235
 
        if (flags & NDR_OUT) {
3236
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3237
 
        }
3238
 
        return NDR_ERR_SUCCESS;
3239
 
}
3240
 
 
3241
 
_PUBLIC_ void ndr_print_winreg_InitiateSystemShutdown(struct ndr_print *ndr, const char *name, int flags, const struct winreg_InitiateSystemShutdown *r)
3242
 
{
3243
 
        ndr_print_struct(ndr, name, "winreg_InitiateSystemShutdown");
3244
 
        ndr->depth++;
3245
 
        if (flags & NDR_SET_VALUES) {
3246
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3247
 
        }
3248
 
        if (flags & NDR_IN) {
3249
 
                ndr_print_struct(ndr, "in", "winreg_InitiateSystemShutdown");
3250
 
                ndr->depth++;
3251
 
                ndr_print_ptr(ndr, "hostname", r->in.hostname);
3252
 
                ndr->depth++;
3253
 
                if (r->in.hostname) {
3254
 
                        ndr_print_uint16(ndr, "hostname", *r->in.hostname);
3255
 
                }
3256
 
                ndr->depth--;
3257
 
                ndr_print_ptr(ndr, "message", r->in.message);
3258
 
                ndr->depth++;
3259
 
                if (r->in.message) {
3260
 
                        ndr_print_lsa_StringLarge(ndr, "message", r->in.message);
3261
 
                }
3262
 
                ndr->depth--;
3263
 
                ndr_print_uint32(ndr, "timeout", r->in.timeout);
3264
 
                ndr_print_uint8(ndr, "force_apps", r->in.force_apps);
3265
 
                ndr_print_uint8(ndr, "do_reboot", r->in.do_reboot);
3266
 
                ndr->depth--;
3267
 
        }
3268
 
        if (flags & NDR_OUT) {
3269
 
                ndr_print_struct(ndr, "out", "winreg_InitiateSystemShutdown");
3270
 
                ndr->depth++;
3271
 
                ndr_print_WERROR(ndr, "result", r->out.result);
3272
 
                ndr->depth--;
3273
 
        }
3274
 
        ndr->depth--;
3275
 
}
3276
 
 
3277
 
static enum ndr_err_code ndr_push_winreg_AbortSystemShutdown(struct ndr_push *ndr, int flags, const struct winreg_AbortSystemShutdown *r)
3278
 
{
3279
 
        if (flags & NDR_IN) {
3280
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
3281
 
                if (r->in.server) {
3282
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.server));
3283
 
                }
3284
 
        }
3285
 
        if (flags & NDR_OUT) {
3286
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3287
 
        }
3288
 
        return NDR_ERR_SUCCESS;
3289
 
}
3290
 
 
3291
 
static enum ndr_err_code ndr_pull_winreg_AbortSystemShutdown(struct ndr_pull *ndr, int flags, struct winreg_AbortSystemShutdown *r)
3292
 
{
3293
 
        uint32_t _ptr_server;
3294
 
        TALLOC_CTX *_mem_save_server_0;
3295
 
        if (flags & NDR_IN) {
3296
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
3297
 
                if (_ptr_server) {
3298
 
                        NDR_PULL_ALLOC(ndr, r->in.server);
3299
 
                } else {
3300
 
                        r->in.server = NULL;
3301
 
                }
3302
 
                if (r->in.server) {
3303
 
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
3304
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
3305
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.server));
3306
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
3307
 
                }
3308
 
        }
3309
 
        if (flags & NDR_OUT) {
3310
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3311
 
        }
3312
 
        return NDR_ERR_SUCCESS;
3313
 
}
3314
 
 
3315
 
_PUBLIC_ void ndr_print_winreg_AbortSystemShutdown(struct ndr_print *ndr, const char *name, int flags, const struct winreg_AbortSystemShutdown *r)
3316
 
{
3317
 
        ndr_print_struct(ndr, name, "winreg_AbortSystemShutdown");
3318
 
        ndr->depth++;
3319
 
        if (flags & NDR_SET_VALUES) {
3320
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3321
 
        }
3322
 
        if (flags & NDR_IN) {
3323
 
                ndr_print_struct(ndr, "in", "winreg_AbortSystemShutdown");
3324
 
                ndr->depth++;
3325
 
                ndr_print_ptr(ndr, "server", r->in.server);
3326
 
                ndr->depth++;
3327
 
                if (r->in.server) {
3328
 
                        ndr_print_uint16(ndr, "server", *r->in.server);
3329
 
                }
3330
 
                ndr->depth--;
3331
 
                ndr->depth--;
3332
 
        }
3333
 
        if (flags & NDR_OUT) {
3334
 
                ndr_print_struct(ndr, "out", "winreg_AbortSystemShutdown");
3335
 
                ndr->depth++;
3336
 
                ndr_print_WERROR(ndr, "result", r->out.result);
3337
 
                ndr->depth--;
3338
 
        }
3339
 
        ndr->depth--;
3340
 
}
3341
 
 
3342
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_GetVersion(struct ndr_push *ndr, int flags, const struct winreg_GetVersion *r)
3343
 
{
3344
 
        if (flags & NDR_IN) {
3345
 
                if (r->in.handle == NULL) {
3346
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3347
 
                }
3348
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3349
 
        }
3350
 
        if (flags & NDR_OUT) {
3351
 
                if (r->out.version == NULL) {
3352
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3353
 
                }
3354
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.version));
3355
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3356
 
        }
3357
 
        return NDR_ERR_SUCCESS;
3358
 
}
3359
 
 
3360
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_GetVersion(struct ndr_pull *ndr, int flags, struct winreg_GetVersion *r)
3361
 
{
3362
 
        TALLOC_CTX *_mem_save_handle_0;
3363
 
        TALLOC_CTX *_mem_save_version_0;
3364
 
        if (flags & NDR_IN) {
3365
 
                ZERO_STRUCT(r->out);
3366
 
 
3367
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3368
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
3369
 
                }
3370
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3371
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3372
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3373
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3374
 
                NDR_PULL_ALLOC(ndr, r->out.version);
3375
 
                ZERO_STRUCTP(r->out.version);
3376
 
        }
3377
 
        if (flags & NDR_OUT) {
3378
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3379
 
                        NDR_PULL_ALLOC(ndr, r->out.version);
3380
 
                }
3381
 
                _mem_save_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
3382
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.version, LIBNDR_FLAG_REF_ALLOC);
3383
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.version));
3384
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_0, LIBNDR_FLAG_REF_ALLOC);
3385
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3386
 
        }
3387
 
        return NDR_ERR_SUCCESS;
3388
 
}
3389
 
 
3390
 
_PUBLIC_ void ndr_print_winreg_GetVersion(struct ndr_print *ndr, const char *name, int flags, const struct winreg_GetVersion *r)
3391
 
{
3392
 
        ndr_print_struct(ndr, name, "winreg_GetVersion");
3393
 
        ndr->depth++;
3394
 
        if (flags & NDR_SET_VALUES) {
3395
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3396
 
        }
3397
 
        if (flags & NDR_IN) {
3398
 
                ndr_print_struct(ndr, "in", "winreg_GetVersion");
3399
 
                ndr->depth++;
3400
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
3401
 
                ndr->depth++;
3402
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
3403
 
                ndr->depth--;
3404
 
                ndr->depth--;
3405
 
        }
3406
 
        if (flags & NDR_OUT) {
3407
 
                ndr_print_struct(ndr, "out", "winreg_GetVersion");
3408
 
                ndr->depth++;
3409
 
                ndr_print_ptr(ndr, "version", r->out.version);
3410
 
                ndr->depth++;
3411
 
                ndr_print_uint32(ndr, "version", *r->out.version);
3412
 
                ndr->depth--;
3413
 
                ndr_print_WERROR(ndr, "result", r->out.result);
3414
 
                ndr->depth--;
3415
 
        }
3416
 
        ndr->depth--;
3417
 
}
3418
 
 
3419
 
static enum ndr_err_code ndr_push_winreg_OpenHKCC(struct ndr_push *ndr, int flags, const struct winreg_OpenHKCC *r)
3420
 
{
3421
 
        if (flags & NDR_IN) {
3422
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
3423
 
                if (r->in.system_name) {
3424
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
3425
 
                }
3426
 
                NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
3427
 
        }
3428
 
        if (flags & NDR_OUT) {
3429
 
                if (r->out.handle == NULL) {
3430
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3431
 
                }
3432
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3433
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3434
 
        }
3435
 
        return NDR_ERR_SUCCESS;
3436
 
}
3437
 
 
3438
 
static enum ndr_err_code ndr_pull_winreg_OpenHKCC(struct ndr_pull *ndr, int flags, struct winreg_OpenHKCC *r)
3439
 
{
3440
 
        uint32_t _ptr_system_name;
3441
 
        TALLOC_CTX *_mem_save_system_name_0;
3442
 
        TALLOC_CTX *_mem_save_handle_0;
3443
 
        if (flags & NDR_IN) {
3444
 
                ZERO_STRUCT(r->out);
3445
 
 
3446
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
3447
 
                if (_ptr_system_name) {
3448
 
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
3449
 
                } else {
3450
 
                        r->in.system_name = NULL;
3451
 
                }
3452
 
                if (r->in.system_name) {
3453
 
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3454
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
3455
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
3456
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
3457
 
                }
3458
 
                NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
3459
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
3460
 
                ZERO_STRUCTP(r->out.handle);
3461
 
        }
3462
 
        if (flags & NDR_OUT) {
3463
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3464
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
3465
 
                }
3466
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3467
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3468
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3469
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3470
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3471
 
        }
3472
 
        return NDR_ERR_SUCCESS;
3473
 
}
3474
 
 
3475
 
_PUBLIC_ void ndr_print_winreg_OpenHKCC(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKCC *r)
3476
 
{
3477
 
        ndr_print_struct(ndr, name, "winreg_OpenHKCC");
3478
 
        ndr->depth++;
3479
 
        if (flags & NDR_SET_VALUES) {
3480
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3481
 
        }
3482
 
        if (flags & NDR_IN) {
3483
 
                ndr_print_struct(ndr, "in", "winreg_OpenHKCC");
3484
 
                ndr->depth++;
3485
 
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
3486
 
                ndr->depth++;
3487
 
                if (r->in.system_name) {
3488
 
                        ndr_print_uint16(ndr, "system_name", *r->in.system_name);
3489
 
                }
3490
 
                ndr->depth--;
3491
 
                ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
3492
 
                ndr->depth--;
3493
 
        }
3494
 
        if (flags & NDR_OUT) {
3495
 
                ndr_print_struct(ndr, "out", "winreg_OpenHKCC");
3496
 
                ndr->depth++;
3497
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
3498
 
                ndr->depth++;
3499
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
3500
 
                ndr->depth--;
3501
 
                ndr_print_WERROR(ndr, "result", r->out.result);
3502
 
                ndr->depth--;
3503
 
        }
3504
 
        ndr->depth--;
3505
 
}
3506
 
 
3507
 
static enum ndr_err_code ndr_push_winreg_OpenHKDD(struct ndr_push *ndr, int flags, const struct winreg_OpenHKDD *r)
3508
 
{
3509
 
        if (flags & NDR_IN) {
3510
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
3511
 
                if (r->in.system_name) {
3512
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
3513
 
                }
3514
 
                NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
3515
 
        }
3516
 
        if (flags & NDR_OUT) {
3517
 
                if (r->out.handle == NULL) {
3518
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3519
 
                }
3520
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3521
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3522
 
        }
3523
 
        return NDR_ERR_SUCCESS;
3524
 
}
3525
 
 
3526
 
static enum ndr_err_code ndr_pull_winreg_OpenHKDD(struct ndr_pull *ndr, int flags, struct winreg_OpenHKDD *r)
3527
 
{
3528
 
        uint32_t _ptr_system_name;
3529
 
        TALLOC_CTX *_mem_save_system_name_0;
3530
 
        TALLOC_CTX *_mem_save_handle_0;
3531
 
        if (flags & NDR_IN) {
3532
 
                ZERO_STRUCT(r->out);
3533
 
 
3534
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
3535
 
                if (_ptr_system_name) {
3536
 
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
3537
 
                } else {
3538
 
                        r->in.system_name = NULL;
3539
 
                }
3540
 
                if (r->in.system_name) {
3541
 
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3542
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
3543
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
3544
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
3545
 
                }
3546
 
                NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
3547
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
3548
 
                ZERO_STRUCTP(r->out.handle);
3549
 
        }
3550
 
        if (flags & NDR_OUT) {
3551
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3552
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
3553
 
                }
3554
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3555
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3556
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3557
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3558
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3559
 
        }
3560
 
        return NDR_ERR_SUCCESS;
3561
 
}
3562
 
 
3563
 
_PUBLIC_ void ndr_print_winreg_OpenHKDD(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKDD *r)
3564
 
{
3565
 
        ndr_print_struct(ndr, name, "winreg_OpenHKDD");
3566
 
        ndr->depth++;
3567
 
        if (flags & NDR_SET_VALUES) {
3568
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3569
 
        }
3570
 
        if (flags & NDR_IN) {
3571
 
                ndr_print_struct(ndr, "in", "winreg_OpenHKDD");
3572
 
                ndr->depth++;
3573
 
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
3574
 
                ndr->depth++;
3575
 
                if (r->in.system_name) {
3576
 
                        ndr_print_uint16(ndr, "system_name", *r->in.system_name);
3577
 
                }
3578
 
                ndr->depth--;
3579
 
                ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
3580
 
                ndr->depth--;
3581
 
        }
3582
 
        if (flags & NDR_OUT) {
3583
 
                ndr_print_struct(ndr, "out", "winreg_OpenHKDD");
3584
 
                ndr->depth++;
3585
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
3586
 
                ndr->depth++;
3587
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
3588
 
                ndr->depth--;
3589
 
                ndr_print_WERROR(ndr, "result", r->out.result);
3590
 
                ndr->depth--;
3591
 
        }
3592
 
        ndr->depth--;
3593
 
}
3594
 
 
3595
 
_PUBLIC_ enum ndr_err_code ndr_push_winreg_QueryMultipleValues(struct ndr_push *ndr, int flags, const struct winreg_QueryMultipleValues *r)
3596
 
{
3597
 
        uint32_t cntr_values_1;
3598
 
        if (flags & NDR_IN) {
3599
 
                if (r->in.key_handle == NULL) {
3600
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3601
 
                }
3602
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.key_handle));
3603
 
                if (r->in.values == NULL) {
3604
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3605
 
                }
3606
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
3607
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3608
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
3609
 
                for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3610
 
                        NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_SCALARS, &r->in.values[cntr_values_1]));
3611
 
                }
3612
 
                for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3613
 
                        NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_BUFFERS, &r->in.values[cntr_values_1]));
3614
 
                }
3615
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_values));
3616
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
3617
 
                if (r->in.buffer) {
3618
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->in.buffer_size));
3619
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3620
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->in.buffer_size));
3621
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, *r->in.buffer_size));
3622
 
                }
3623
 
                if (r->in.buffer_size == NULL) {
3624
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3625
 
                }
3626
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.buffer_size));
3627
 
        }
3628
 
        if (flags & NDR_OUT) {
3629
 
                if (r->out.values == NULL) {
3630
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3631
 
                }
3632
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
3633
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3634
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_values));
3635
 
                for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3636
 
                        NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_SCALARS, &r->out.values[cntr_values_1]));
3637
 
                }
3638
 
                for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
3639
 
                        NDR_CHECK(ndr_push_QueryMultipleValue(ndr, NDR_BUFFERS, &r->out.values[cntr_values_1]));
3640
 
                }
3641
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
3642
 
                if (r->out.buffer) {
3643
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.buffer_size));
3644
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3645
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.buffer_size));
3646
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, *r->out.buffer_size));
3647
 
                }
3648
 
                if (r->out.buffer_size == NULL) {
3649
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3650
 
                }
3651
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.buffer_size));
3652
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3653
 
        }
3654
 
        return NDR_ERR_SUCCESS;
3655
 
}
3656
 
 
3657
 
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_QueryMultipleValues(struct ndr_pull *ndr, int flags, struct winreg_QueryMultipleValues *r)
3658
 
{
3659
 
        uint32_t cntr_values_1;
3660
 
        uint32_t _ptr_buffer;
3661
 
        TALLOC_CTX *_mem_save_key_handle_0;
3662
 
        TALLOC_CTX *_mem_save_values_1;
3663
 
        TALLOC_CTX *_mem_save_buffer_0;
3664
 
        TALLOC_CTX *_mem_save_buffer_size_0;
3665
 
        if (flags & NDR_IN) {
3666
 
                ZERO_STRUCT(r->out);
3667
 
 
3668
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3669
 
                        NDR_PULL_ALLOC(ndr, r->in.key_handle);
3670
 
                }
3671
 
                _mem_save_key_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3672
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.key_handle, LIBNDR_FLAG_REF_ALLOC);
3673
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.key_handle));
3674
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_handle_0, LIBNDR_FLAG_REF_ALLOC);
3675
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.values));
3676
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.values));
3677
 
                if (ndr_get_array_length(ndr, &r->in.values) > ndr_get_array_size(ndr, &r->in.values)) {
3678
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.values), ndr_get_array_length(ndr, &r->in.values));
3679
 
                }
3680
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3681
 
                        NDR_PULL_ALLOC_N(ndr, r->in.values, ndr_get_array_size(ndr, &r->in.values));
3682
 
                }
3683
 
                memcpy(r->out.values, r->in.values, (ndr_get_array_size(ndr, &r->in.values)) * sizeof(*r->in.values));
3684
 
                _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
3685
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.values, 0);
3686
 
                for (cntr_values_1 = 0; cntr_values_1 < ndr_get_array_length(ndr, &r->in.values); cntr_values_1++) {
3687
 
                        NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_SCALARS, &r->in.values[cntr_values_1]));
3688
 
                }
3689
 
                for (cntr_values_1 = 0; cntr_values_1 < ndr_get_array_length(ndr, &r->in.values); cntr_values_1++) {
3690
 
                        NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_BUFFERS, &r->in.values[cntr_values_1]));
3691
 
                }
3692
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
3693
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_values));
3694
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
3695
 
                if (_ptr_buffer) {
3696
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
3697
 
                } else {
3698
 
                        r->in.buffer = NULL;
3699
 
                }
3700
 
                if (r->in.buffer) {
3701
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
3702
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
3703
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
3704
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.buffer));
3705
 
                        if (ndr_get_array_length(ndr, &r->in.buffer) > ndr_get_array_size(ndr, &r->in.buffer)) {
3706
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.buffer), ndr_get_array_length(ndr, &r->in.buffer));
3707
 
                        }
3708
 
                        NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
3709
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_length(ndr, &r->in.buffer)));
3710
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
3711
 
                }
3712
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3713
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer_size);
3714
 
                }
3715
 
                _mem_save_buffer_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
3716
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer_size, LIBNDR_FLAG_REF_ALLOC);
3717
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.buffer_size));
3718
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_size_0, LIBNDR_FLAG_REF_ALLOC);
3719
 
                NDR_PULL_ALLOC_N(ndr, r->out.values, r->in.num_values);
3720
 
                memcpy(r->out.values, r->in.values, (r->in.num_values) * sizeof(*r->in.values));
3721
 
                NDR_PULL_ALLOC(ndr, r->out.buffer_size);
3722
 
                *r->out.buffer_size = *r->in.buffer_size;
3723
 
                if (r->in.values) {
3724
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.values, r->in.num_values));
3725
 
                }
3726
 
                if (r->in.values) {
3727
 
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.values, r->in.num_values));
3728
 
                }
3729
 
                if (r->in.buffer) {
3730
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, *r->in.buffer_size));
3731
 
                }
3732
 
                if (r->in.buffer) {
3733
 
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->in.buffer, *r->in.buffer_size));
3734
 
                }
3735
 
        }
3736
 
        if (flags & NDR_OUT) {
3737
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->out.values));
3738
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->out.values));
3739
 
                if (ndr_get_array_length(ndr, &r->out.values) > ndr_get_array_size(ndr, &r->out.values)) {
3740
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->out.values), ndr_get_array_length(ndr, &r->out.values));
3741
 
                }
3742
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3743
 
                        NDR_PULL_ALLOC_N(ndr, r->out.values, ndr_get_array_size(ndr, &r->out.values));
3744
 
                }
3745
 
                memcpy(r->out.values, r->in.values, (ndr_get_array_size(ndr, &r->out.values)) * sizeof(*r->in.values));
3746
 
                _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
3747
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.values, 0);
3748
 
                for (cntr_values_1 = 0; cntr_values_1 < ndr_get_array_length(ndr, &r->out.values); cntr_values_1++) {
3749
 
                        NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_SCALARS, &r->out.values[cntr_values_1]));
3750
 
                }
3751
 
                for (cntr_values_1 = 0; cntr_values_1 < ndr_get_array_length(ndr, &r->out.values); cntr_values_1++) {
3752
 
                        NDR_CHECK(ndr_pull_QueryMultipleValue(ndr, NDR_BUFFERS, &r->out.values[cntr_values_1]));
3753
 
                }
3754
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
3755
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
3756
 
                if (_ptr_buffer) {
3757
 
                        NDR_PULL_ALLOC(ndr, r->out.buffer);
3758
 
                } else {
3759
 
                        r->out.buffer = NULL;
3760
 
                }
3761
 
                if (r->out.buffer) {
3762
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
3763
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
3764
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
3765
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->out.buffer));
3766
 
                        if (ndr_get_array_length(ndr, &r->out.buffer) > ndr_get_array_size(ndr, &r->out.buffer)) {
3767
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->out.buffer), ndr_get_array_length(ndr, &r->out.buffer));
3768
 
                        }
3769
 
                        NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
3770
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_length(ndr, &r->out.buffer)));
3771
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
3772
 
                }
3773
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3774
 
                        NDR_PULL_ALLOC(ndr, r->out.buffer_size);
3775
 
                }
3776
 
                _mem_save_buffer_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
3777
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer_size, LIBNDR_FLAG_REF_ALLOC);
3778
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.buffer_size));
3779
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_size_0, LIBNDR_FLAG_REF_ALLOC);
3780
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3781
 
                if (r->out.values) {
3782
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.values, r->in.num_values));
3783
 
                }
3784
 
                if (r->out.values) {
3785
 
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.values, r->in.num_values));
3786
 
                }
3787
 
                if (r->out.buffer) {
3788
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, *r->out.buffer_size));
3789
 
                }
3790
 
                if (r->out.buffer) {
3791
 
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.buffer, *r->out.buffer_size));
3792
 
                }
3793
 
        }
3794
 
        return NDR_ERR_SUCCESS;
3795
 
}
3796
 
 
3797
 
_PUBLIC_ void ndr_print_winreg_QueryMultipleValues(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryMultipleValues *r)
3798
 
{
3799
 
        uint32_t cntr_values_1;
3800
 
        ndr_print_struct(ndr, name, "winreg_QueryMultipleValues");
3801
 
        ndr->depth++;
3802
 
        if (flags & NDR_SET_VALUES) {
3803
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3804
 
        }
3805
 
        if (flags & NDR_IN) {
3806
 
                ndr_print_struct(ndr, "in", "winreg_QueryMultipleValues");
3807
 
                ndr->depth++;
3808
 
                ndr_print_ptr(ndr, "key_handle", r->in.key_handle);
3809
 
                ndr->depth++;
3810
 
                ndr_print_policy_handle(ndr, "key_handle", r->in.key_handle);
3811
 
                ndr->depth--;
3812
 
                ndr_print_ptr(ndr, "values", r->in.values);
3813
 
                ndr->depth++;
3814
 
                ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->in.num_values);
3815
 
                ndr->depth++;
3816
 
                for (cntr_values_1=0;cntr_values_1<r->in.num_values;cntr_values_1++) {
3817
 
                        char *idx_1=NULL;
3818
 
                        if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
3819
 
                                ndr_print_QueryMultipleValue(ndr, "values", &r->in.values[cntr_values_1]);
3820
 
                                free(idx_1);
3821
 
                        }
3822
 
                }
3823
 
                ndr->depth--;
3824
 
                ndr->depth--;
3825
 
                ndr_print_uint32(ndr, "num_values", r->in.num_values);
3826
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
3827
 
                ndr->depth++;
3828
 
                if (r->in.buffer) {
3829
 
                        ndr_print_array_uint8(ndr, "buffer", r->in.buffer, *r->in.buffer_size);
3830
 
                }
3831
 
                ndr->depth--;
3832
 
                ndr_print_ptr(ndr, "buffer_size", r->in.buffer_size);
3833
 
                ndr->depth++;
3834
 
                ndr_print_uint32(ndr, "buffer_size", *r->in.buffer_size);
3835
 
                ndr->depth--;
3836
 
                ndr->depth--;
3837
 
        }
3838
 
        if (flags & NDR_OUT) {
3839
 
                ndr_print_struct(ndr, "out", "winreg_QueryMultipleValues");
3840
 
                ndr->depth++;
3841
 
                ndr_print_ptr(ndr, "values", r->out.values);
3842
 
                ndr->depth++;
3843
 
                ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->in.num_values);
3844
 
                ndr->depth++;
3845
 
                for (cntr_values_1=0;cntr_values_1<r->in.num_values;cntr_values_1++) {
3846
 
                        char *idx_1=NULL;
3847
 
                        if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
3848
 
                                ndr_print_QueryMultipleValue(ndr, "values", &r->out.values[cntr_values_1]);
3849
 
                                free(idx_1);
3850
 
                        }
3851
 
                }
3852
 
                ndr->depth--;
3853
 
                ndr->depth--;
3854
 
                ndr_print_ptr(ndr, "buffer", r->out.buffer);
3855
 
                ndr->depth++;
3856
 
                if (r->out.buffer) {
3857
 
                        ndr_print_array_uint8(ndr, "buffer", r->out.buffer, *r->out.buffer_size);
3858
 
                }
3859
 
                ndr->depth--;
3860
 
                ndr_print_ptr(ndr, "buffer_size", r->out.buffer_size);
3861
 
                ndr->depth++;
3862
 
                ndr_print_uint32(ndr, "buffer_size", *r->out.buffer_size);
3863
 
                ndr->depth--;
3864
 
                ndr_print_WERROR(ndr, "result", r->out.result);
3865
 
                ndr->depth--;
3866
 
        }
3867
 
        ndr->depth--;
3868
 
}
3869
 
 
3870
 
static enum ndr_err_code ndr_push_winreg_InitiateSystemShutdownEx(struct ndr_push *ndr, int flags, const struct winreg_InitiateSystemShutdownEx *r)
3871
 
{
3872
 
        if (flags & NDR_IN) {
3873
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.hostname));
3874
 
                if (r->in.hostname) {
3875
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.hostname));
3876
 
                }
3877
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.message));
3878
 
                if (r->in.message) {
3879
 
                        NDR_CHECK(ndr_push_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
3880
 
                }
3881
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.timeout));
3882
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.force_apps));
3883
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->in.do_reboot));
3884
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reason));
3885
 
        }
3886
 
        if (flags & NDR_OUT) {
3887
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3888
 
        }
3889
 
        return NDR_ERR_SUCCESS;
3890
 
}
3891
 
 
3892
 
static enum ndr_err_code ndr_pull_winreg_InitiateSystemShutdownEx(struct ndr_pull *ndr, int flags, struct winreg_InitiateSystemShutdownEx *r)
3893
 
{
3894
 
        uint32_t _ptr_hostname;
3895
 
        uint32_t _ptr_message;
3896
 
        TALLOC_CTX *_mem_save_hostname_0;
3897
 
        TALLOC_CTX *_mem_save_message_0;
3898
 
        if (flags & NDR_IN) {
3899
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hostname));
3900
 
                if (_ptr_hostname) {
3901
 
                        NDR_PULL_ALLOC(ndr, r->in.hostname);
3902
 
                } else {
3903
 
                        r->in.hostname = NULL;
3904
 
                }
3905
 
                if (r->in.hostname) {
3906
 
                        _mem_save_hostname_0 = NDR_PULL_GET_MEM_CTX(ndr);
3907
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.hostname, 0);
3908
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.hostname));
3909
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hostname_0, 0);
3910
 
                }
3911
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_message));
3912
 
                if (_ptr_message) {
3913
 
                        NDR_PULL_ALLOC(ndr, r->in.message);
3914
 
                } else {
3915
 
                        r->in.message = NULL;
3916
 
                }
3917
 
                if (r->in.message) {
3918
 
                        _mem_save_message_0 = NDR_PULL_GET_MEM_CTX(ndr);
3919
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.message, 0);
3920
 
                        NDR_CHECK(ndr_pull_lsa_StringLarge(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.message));
3921
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_message_0, 0);
3922
 
                }
3923
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.timeout));
3924
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.force_apps));
3925
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->in.do_reboot));
3926
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reason));
3927
 
        }
3928
 
        if (flags & NDR_OUT) {
3929
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3930
 
        }
3931
 
        return NDR_ERR_SUCCESS;
3932
 
}
3933
 
 
3934
 
_PUBLIC_ void ndr_print_winreg_InitiateSystemShutdownEx(struct ndr_print *ndr, const char *name, int flags, const struct winreg_InitiateSystemShutdownEx *r)
3935
 
{
3936
 
        ndr_print_struct(ndr, name, "winreg_InitiateSystemShutdownEx");
3937
 
        ndr->depth++;
3938
 
        if (flags & NDR_SET_VALUES) {
3939
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3940
 
        }
3941
 
        if (flags & NDR_IN) {
3942
 
                ndr_print_struct(ndr, "in", "winreg_InitiateSystemShutdownEx");
3943
 
                ndr->depth++;
3944
 
                ndr_print_ptr(ndr, "hostname", r->in.hostname);
3945
 
                ndr->depth++;
3946
 
                if (r->in.hostname) {
3947
 
                        ndr_print_uint16(ndr, "hostname", *r->in.hostname);
3948
 
                }
3949
 
                ndr->depth--;
3950
 
                ndr_print_ptr(ndr, "message", r->in.message);
3951
 
                ndr->depth++;
3952
 
                if (r->in.message) {
3953
 
                        ndr_print_lsa_StringLarge(ndr, "message", r->in.message);
3954
 
                }
3955
 
                ndr->depth--;
3956
 
                ndr_print_uint32(ndr, "timeout", r->in.timeout);
3957
 
                ndr_print_uint8(ndr, "force_apps", r->in.force_apps);
3958
 
                ndr_print_uint8(ndr, "do_reboot", r->in.do_reboot);
3959
 
                ndr_print_uint32(ndr, "reason", r->in.reason);
3960
 
                ndr->depth--;
3961
 
        }
3962
 
        if (flags & NDR_OUT) {
3963
 
                ndr_print_struct(ndr, "out", "winreg_InitiateSystemShutdownEx");
3964
 
                ndr->depth++;
3965
 
                ndr_print_WERROR(ndr, "result", r->out.result);
3966
 
                ndr->depth--;
3967
 
        }
3968
 
        ndr->depth--;
3969
 
}
3970
 
 
3971
 
static enum ndr_err_code ndr_push_winreg_SaveKeyEx(struct ndr_push *ndr, int flags, const struct winreg_SaveKeyEx *r)
3972
 
{
3973
 
        if (flags & NDR_IN) {
3974
 
        }
3975
 
        if (flags & NDR_OUT) {
3976
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3977
 
        }
3978
 
        return NDR_ERR_SUCCESS;
3979
 
}
3980
 
 
3981
 
static enum ndr_err_code ndr_pull_winreg_SaveKeyEx(struct ndr_pull *ndr, int flags, struct winreg_SaveKeyEx *r)
3982
 
{
3983
 
        if (flags & NDR_IN) {
3984
 
        }
3985
 
        if (flags & NDR_OUT) {
3986
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3987
 
        }
3988
 
        return NDR_ERR_SUCCESS;
3989
 
}
3990
 
 
3991
 
_PUBLIC_ void ndr_print_winreg_SaveKeyEx(struct ndr_print *ndr, const char *name, int flags, const struct winreg_SaveKeyEx *r)
3992
 
{
3993
 
        ndr_print_struct(ndr, name, "winreg_SaveKeyEx");
3994
 
        ndr->depth++;
3995
 
        if (flags & NDR_SET_VALUES) {
3996
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3997
 
        }
3998
 
        if (flags & NDR_IN) {
3999
 
                ndr_print_struct(ndr, "in", "winreg_SaveKeyEx");
4000
 
                ndr->depth++;
4001
 
                ndr->depth--;
4002
 
        }
4003
 
        if (flags & NDR_OUT) {
4004
 
                ndr_print_struct(ndr, "out", "winreg_SaveKeyEx");
4005
 
                ndr->depth++;
4006
 
                ndr_print_WERROR(ndr, "result", r->out.result);
4007
 
                ndr->depth--;
4008
 
        }
4009
 
        ndr->depth--;
4010
 
}
4011
 
 
4012
 
static enum ndr_err_code ndr_push_winreg_OpenHKPT(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPT *r)
4013
 
{
4014
 
        if (flags & NDR_IN) {
4015
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
4016
 
                if (r->in.system_name) {
4017
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
4018
 
                }
4019
 
                NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
4020
 
        }
4021
 
        if (flags & NDR_OUT) {
4022
 
                if (r->out.handle == NULL) {
4023
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4024
 
                }
4025
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4026
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4027
 
        }
4028
 
        return NDR_ERR_SUCCESS;
4029
 
}
4030
 
 
4031
 
static enum ndr_err_code ndr_pull_winreg_OpenHKPT(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPT *r)
4032
 
{
4033
 
        uint32_t _ptr_system_name;
4034
 
        TALLOC_CTX *_mem_save_system_name_0;
4035
 
        TALLOC_CTX *_mem_save_handle_0;
4036
 
        if (flags & NDR_IN) {
4037
 
                ZERO_STRUCT(r->out);
4038
 
 
4039
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
4040
 
                if (_ptr_system_name) {
4041
 
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
4042
 
                } else {
4043
 
                        r->in.system_name = NULL;
4044
 
                }
4045
 
                if (r->in.system_name) {
4046
 
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4047
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
4048
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
4049
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
4050
 
                }
4051
 
                NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
4052
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
4053
 
                ZERO_STRUCTP(r->out.handle);
4054
 
        }
4055
 
        if (flags & NDR_OUT) {
4056
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4057
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
4058
 
                }
4059
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4060
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
4061
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4062
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4063
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4064
 
        }
4065
 
        return NDR_ERR_SUCCESS;
4066
 
}
4067
 
 
4068
 
_PUBLIC_ void ndr_print_winreg_OpenHKPT(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPT *r)
4069
 
{
4070
 
        ndr_print_struct(ndr, name, "winreg_OpenHKPT");
4071
 
        ndr->depth++;
4072
 
        if (flags & NDR_SET_VALUES) {
4073
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4074
 
        }
4075
 
        if (flags & NDR_IN) {
4076
 
                ndr_print_struct(ndr, "in", "winreg_OpenHKPT");
4077
 
                ndr->depth++;
4078
 
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
4079
 
                ndr->depth++;
4080
 
                if (r->in.system_name) {
4081
 
                        ndr_print_uint16(ndr, "system_name", *r->in.system_name);
4082
 
                }
4083
 
                ndr->depth--;
4084
 
                ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
4085
 
                ndr->depth--;
4086
 
        }
4087
 
        if (flags & NDR_OUT) {
4088
 
                ndr_print_struct(ndr, "out", "winreg_OpenHKPT");
4089
 
                ndr->depth++;
4090
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
4091
 
                ndr->depth++;
4092
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
4093
 
                ndr->depth--;
4094
 
                ndr_print_WERROR(ndr, "result", r->out.result);
4095
 
                ndr->depth--;
4096
 
        }
4097
 
        ndr->depth--;
4098
 
}
4099
 
 
4100
 
static enum ndr_err_code ndr_push_winreg_OpenHKPN(struct ndr_push *ndr, int flags, const struct winreg_OpenHKPN *r)
4101
 
{
4102
 
        if (flags & NDR_IN) {
4103
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.system_name));
4104
 
                if (r->in.system_name) {
4105
 
                        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, *r->in.system_name));
4106
 
                }
4107
 
                NDR_CHECK(ndr_push_winreg_AccessMask(ndr, NDR_SCALARS, r->in.access_mask));
4108
 
        }
4109
 
        if (flags & NDR_OUT) {
4110
 
                if (r->out.handle == NULL) {
4111
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4112
 
                }
4113
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4114
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4115
 
        }
4116
 
        return NDR_ERR_SUCCESS;
4117
 
}
4118
 
 
4119
 
static enum ndr_err_code ndr_pull_winreg_OpenHKPN(struct ndr_pull *ndr, int flags, struct winreg_OpenHKPN *r)
4120
 
{
4121
 
        uint32_t _ptr_system_name;
4122
 
        TALLOC_CTX *_mem_save_system_name_0;
4123
 
        TALLOC_CTX *_mem_save_handle_0;
4124
 
        if (flags & NDR_IN) {
4125
 
                ZERO_STRUCT(r->out);
4126
 
 
4127
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_system_name));
4128
 
                if (_ptr_system_name) {
4129
 
                        NDR_PULL_ALLOC(ndr, r->in.system_name);
4130
 
                } else {
4131
 
                        r->in.system_name = NULL;
4132
 
                }
4133
 
                if (r->in.system_name) {
4134
 
                        _mem_save_system_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4135
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.system_name, 0);
4136
 
                        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, r->in.system_name));
4137
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_system_name_0, 0);
4138
 
                }
4139
 
                NDR_CHECK(ndr_pull_winreg_AccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
4140
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
4141
 
                ZERO_STRUCTP(r->out.handle);
4142
 
        }
4143
 
        if (flags & NDR_OUT) {
4144
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4145
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
4146
 
                }
4147
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4148
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
4149
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
4150
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4151
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4152
 
        }
4153
 
        return NDR_ERR_SUCCESS;
4154
 
}
4155
 
 
4156
 
_PUBLIC_ void ndr_print_winreg_OpenHKPN(struct ndr_print *ndr, const char *name, int flags, const struct winreg_OpenHKPN *r)
4157
 
{
4158
 
        ndr_print_struct(ndr, name, "winreg_OpenHKPN");
4159
 
        ndr->depth++;
4160
 
        if (flags & NDR_SET_VALUES) {
4161
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4162
 
        }
4163
 
        if (flags & NDR_IN) {
4164
 
                ndr_print_struct(ndr, "in", "winreg_OpenHKPN");
4165
 
                ndr->depth++;
4166
 
                ndr_print_ptr(ndr, "system_name", r->in.system_name);
4167
 
                ndr->depth++;
4168
 
                if (r->in.system_name) {
4169
 
                        ndr_print_uint16(ndr, "system_name", *r->in.system_name);
4170
 
                }
4171
 
                ndr->depth--;
4172
 
                ndr_print_winreg_AccessMask(ndr, "access_mask", r->in.access_mask);
4173
 
                ndr->depth--;
4174
 
        }
4175
 
        if (flags & NDR_OUT) {
4176
 
                ndr_print_struct(ndr, "out", "winreg_OpenHKPN");
4177
 
                ndr->depth++;
4178
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
4179
 
                ndr->depth++;
4180
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
4181
 
                ndr->depth--;
4182
 
                ndr_print_WERROR(ndr, "result", r->out.result);
4183
 
                ndr->depth--;
4184
 
        }
4185
 
        ndr->depth--;
4186
 
}
4187
 
 
4188
 
static enum ndr_err_code ndr_push_winreg_QueryMultipleValues2(struct ndr_push *ndr, int flags, const struct winreg_QueryMultipleValues2 *r)
4189
 
{
4190
 
        if (flags & NDR_IN) {
4191
 
        }
4192
 
        if (flags & NDR_OUT) {
4193
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4194
 
        }
4195
 
        return NDR_ERR_SUCCESS;
4196
 
}
4197
 
 
4198
 
static enum ndr_err_code ndr_pull_winreg_QueryMultipleValues2(struct ndr_pull *ndr, int flags, struct winreg_QueryMultipleValues2 *r)
4199
 
{
4200
 
        if (flags & NDR_IN) {
4201
 
        }
4202
 
        if (flags & NDR_OUT) {
4203
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4204
 
        }
4205
 
        return NDR_ERR_SUCCESS;
4206
 
}
4207
 
 
4208
 
_PUBLIC_ void ndr_print_winreg_QueryMultipleValues2(struct ndr_print *ndr, const char *name, int flags, const struct winreg_QueryMultipleValues2 *r)
4209
 
{
4210
 
        ndr_print_struct(ndr, name, "winreg_QueryMultipleValues2");
4211
 
        ndr->depth++;
4212
 
        if (flags & NDR_SET_VALUES) {
4213
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4214
 
        }
4215
 
        if (flags & NDR_IN) {
4216
 
                ndr_print_struct(ndr, "in", "winreg_QueryMultipleValues2");
4217
 
                ndr->depth++;
4218
 
                ndr->depth--;
4219
 
        }
4220
 
        if (flags & NDR_OUT) {
4221
 
                ndr_print_struct(ndr, "out", "winreg_QueryMultipleValues2");
4222
 
                ndr->depth++;
4223
 
                ndr_print_WERROR(ndr, "result", r->out.result);
4224
 
                ndr->depth--;
4225
 
        }
4226
 
        ndr->depth--;
4227
 
}
4228
 
 
4229
 
static const struct ndr_interface_call winreg_calls[] = {
4230
 
        {
4231
 
                "winreg_OpenHKCR",
4232
 
                sizeof(struct winreg_OpenHKCR),
4233
 
                (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCR,
4234
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCR,
4235
 
                (ndr_print_function_t) ndr_print_winreg_OpenHKCR,
4236
 
                false,
4237
 
        },
4238
 
        {
4239
 
                "winreg_OpenHKCU",
4240
 
                sizeof(struct winreg_OpenHKCU),
4241
 
                (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCU,
4242
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCU,
4243
 
                (ndr_print_function_t) ndr_print_winreg_OpenHKCU,
4244
 
                false,
4245
 
        },
4246
 
        {
4247
 
                "winreg_OpenHKLM",
4248
 
                sizeof(struct winreg_OpenHKLM),
4249
 
                (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKLM,
4250
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKLM,
4251
 
                (ndr_print_function_t) ndr_print_winreg_OpenHKLM,
4252
 
                false,
4253
 
        },
4254
 
        {
4255
 
                "winreg_OpenHKPD",
4256
 
                sizeof(struct winreg_OpenHKPD),
4257
 
                (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPD,
4258
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPD,
4259
 
                (ndr_print_function_t) ndr_print_winreg_OpenHKPD,
4260
 
                false,
4261
 
        },
4262
 
        {
4263
 
                "winreg_OpenHKU",
4264
 
                sizeof(struct winreg_OpenHKU),
4265
 
                (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKU,
4266
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKU,
4267
 
                (ndr_print_function_t) ndr_print_winreg_OpenHKU,
4268
 
                false,
4269
 
        },
4270
 
        {
4271
 
                "winreg_CloseKey",
4272
 
                sizeof(struct winreg_CloseKey),
4273
 
                (ndr_push_flags_fn_t) ndr_push_winreg_CloseKey,
4274
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_CloseKey,
4275
 
                (ndr_print_function_t) ndr_print_winreg_CloseKey,
4276
 
                false,
4277
 
        },
4278
 
        {
4279
 
                "winreg_CreateKey",
4280
 
                sizeof(struct winreg_CreateKey),
4281
 
                (ndr_push_flags_fn_t) ndr_push_winreg_CreateKey,
4282
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_CreateKey,
4283
 
                (ndr_print_function_t) ndr_print_winreg_CreateKey,
4284
 
                false,
4285
 
        },
4286
 
        {
4287
 
                "winreg_DeleteKey",
4288
 
                sizeof(struct winreg_DeleteKey),
4289
 
                (ndr_push_flags_fn_t) ndr_push_winreg_DeleteKey,
4290
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_DeleteKey,
4291
 
                (ndr_print_function_t) ndr_print_winreg_DeleteKey,
4292
 
                false,
4293
 
        },
4294
 
        {
4295
 
                "winreg_DeleteValue",
4296
 
                sizeof(struct winreg_DeleteValue),
4297
 
                (ndr_push_flags_fn_t) ndr_push_winreg_DeleteValue,
4298
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_DeleteValue,
4299
 
                (ndr_print_function_t) ndr_print_winreg_DeleteValue,
4300
 
                false,
4301
 
        },
4302
 
        {
4303
 
                "winreg_EnumKey",
4304
 
                sizeof(struct winreg_EnumKey),
4305
 
                (ndr_push_flags_fn_t) ndr_push_winreg_EnumKey,
4306
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_EnumKey,
4307
 
                (ndr_print_function_t) ndr_print_winreg_EnumKey,
4308
 
                false,
4309
 
        },
4310
 
        {
4311
 
                "winreg_EnumValue",
4312
 
                sizeof(struct winreg_EnumValue),
4313
 
                (ndr_push_flags_fn_t) ndr_push_winreg_EnumValue,
4314
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_EnumValue,
4315
 
                (ndr_print_function_t) ndr_print_winreg_EnumValue,
4316
 
                false,
4317
 
        },
4318
 
        {
4319
 
                "winreg_FlushKey",
4320
 
                sizeof(struct winreg_FlushKey),
4321
 
                (ndr_push_flags_fn_t) ndr_push_winreg_FlushKey,
4322
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_FlushKey,
4323
 
                (ndr_print_function_t) ndr_print_winreg_FlushKey,
4324
 
                false,
4325
 
        },
4326
 
        {
4327
 
                "winreg_GetKeySecurity",
4328
 
                sizeof(struct winreg_GetKeySecurity),
4329
 
                (ndr_push_flags_fn_t) ndr_push_winreg_GetKeySecurity,
4330
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_GetKeySecurity,
4331
 
                (ndr_print_function_t) ndr_print_winreg_GetKeySecurity,
4332
 
                false,
4333
 
        },
4334
 
        {
4335
 
                "winreg_LoadKey",
4336
 
                sizeof(struct winreg_LoadKey),
4337
 
                (ndr_push_flags_fn_t) ndr_push_winreg_LoadKey,
4338
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_LoadKey,
4339
 
                (ndr_print_function_t) ndr_print_winreg_LoadKey,
4340
 
                false,
4341
 
        },
4342
 
        {
4343
 
                "winreg_NotifyChangeKeyValue",
4344
 
                sizeof(struct winreg_NotifyChangeKeyValue),
4345
 
                (ndr_push_flags_fn_t) ndr_push_winreg_NotifyChangeKeyValue,
4346
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_NotifyChangeKeyValue,
4347
 
                (ndr_print_function_t) ndr_print_winreg_NotifyChangeKeyValue,
4348
 
                false,
4349
 
        },
4350
 
        {
4351
 
                "winreg_OpenKey",
4352
 
                sizeof(struct winreg_OpenKey),
4353
 
                (ndr_push_flags_fn_t) ndr_push_winreg_OpenKey,
4354
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenKey,
4355
 
                (ndr_print_function_t) ndr_print_winreg_OpenKey,
4356
 
                false,
4357
 
        },
4358
 
        {
4359
 
                "winreg_QueryInfoKey",
4360
 
                sizeof(struct winreg_QueryInfoKey),
4361
 
                (ndr_push_flags_fn_t) ndr_push_winreg_QueryInfoKey,
4362
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryInfoKey,
4363
 
                (ndr_print_function_t) ndr_print_winreg_QueryInfoKey,
4364
 
                false,
4365
 
        },
4366
 
        {
4367
 
                "winreg_QueryValue",
4368
 
                sizeof(struct winreg_QueryValue),
4369
 
                (ndr_push_flags_fn_t) ndr_push_winreg_QueryValue,
4370
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryValue,
4371
 
                (ndr_print_function_t) ndr_print_winreg_QueryValue,
4372
 
                false,
4373
 
        },
4374
 
        {
4375
 
                "winreg_ReplaceKey",
4376
 
                sizeof(struct winreg_ReplaceKey),
4377
 
                (ndr_push_flags_fn_t) ndr_push_winreg_ReplaceKey,
4378
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_ReplaceKey,
4379
 
                (ndr_print_function_t) ndr_print_winreg_ReplaceKey,
4380
 
                false,
4381
 
        },
4382
 
        {
4383
 
                "winreg_RestoreKey",
4384
 
                sizeof(struct winreg_RestoreKey),
4385
 
                (ndr_push_flags_fn_t) ndr_push_winreg_RestoreKey,
4386
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_RestoreKey,
4387
 
                (ndr_print_function_t) ndr_print_winreg_RestoreKey,
4388
 
                false,
4389
 
        },
4390
 
        {
4391
 
                "winreg_SaveKey",
4392
 
                sizeof(struct winreg_SaveKey),
4393
 
                (ndr_push_flags_fn_t) ndr_push_winreg_SaveKey,
4394
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_SaveKey,
4395
 
                (ndr_print_function_t) ndr_print_winreg_SaveKey,
4396
 
                false,
4397
 
        },
4398
 
        {
4399
 
                "winreg_SetKeySecurity",
4400
 
                sizeof(struct winreg_SetKeySecurity),
4401
 
                (ndr_push_flags_fn_t) ndr_push_winreg_SetKeySecurity,
4402
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_SetKeySecurity,
4403
 
                (ndr_print_function_t) ndr_print_winreg_SetKeySecurity,
4404
 
                false,
4405
 
        },
4406
 
        {
4407
 
                "winreg_SetValue",
4408
 
                sizeof(struct winreg_SetValue),
4409
 
                (ndr_push_flags_fn_t) ndr_push_winreg_SetValue,
4410
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_SetValue,
4411
 
                (ndr_print_function_t) ndr_print_winreg_SetValue,
4412
 
                false,
4413
 
        },
4414
 
        {
4415
 
                "winreg_UnLoadKey",
4416
 
                sizeof(struct winreg_UnLoadKey),
4417
 
                (ndr_push_flags_fn_t) ndr_push_winreg_UnLoadKey,
4418
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_UnLoadKey,
4419
 
                (ndr_print_function_t) ndr_print_winreg_UnLoadKey,
4420
 
                false,
4421
 
        },
4422
 
        {
4423
 
                "winreg_InitiateSystemShutdown",
4424
 
                sizeof(struct winreg_InitiateSystemShutdown),
4425
 
                (ndr_push_flags_fn_t) ndr_push_winreg_InitiateSystemShutdown,
4426
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_InitiateSystemShutdown,
4427
 
                (ndr_print_function_t) ndr_print_winreg_InitiateSystemShutdown,
4428
 
                false,
4429
 
        },
4430
 
        {
4431
 
                "winreg_AbortSystemShutdown",
4432
 
                sizeof(struct winreg_AbortSystemShutdown),
4433
 
                (ndr_push_flags_fn_t) ndr_push_winreg_AbortSystemShutdown,
4434
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_AbortSystemShutdown,
4435
 
                (ndr_print_function_t) ndr_print_winreg_AbortSystemShutdown,
4436
 
                false,
4437
 
        },
4438
 
        {
4439
 
                "winreg_GetVersion",
4440
 
                sizeof(struct winreg_GetVersion),
4441
 
                (ndr_push_flags_fn_t) ndr_push_winreg_GetVersion,
4442
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_GetVersion,
4443
 
                (ndr_print_function_t) ndr_print_winreg_GetVersion,
4444
 
                false,
4445
 
        },
4446
 
        {
4447
 
                "winreg_OpenHKCC",
4448
 
                sizeof(struct winreg_OpenHKCC),
4449
 
                (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKCC,
4450
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKCC,
4451
 
                (ndr_print_function_t) ndr_print_winreg_OpenHKCC,
4452
 
                false,
4453
 
        },
4454
 
        {
4455
 
                "winreg_OpenHKDD",
4456
 
                sizeof(struct winreg_OpenHKDD),
4457
 
                (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKDD,
4458
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKDD,
4459
 
                (ndr_print_function_t) ndr_print_winreg_OpenHKDD,
4460
 
                false,
4461
 
        },
4462
 
        {
4463
 
                "winreg_QueryMultipleValues",
4464
 
                sizeof(struct winreg_QueryMultipleValues),
4465
 
                (ndr_push_flags_fn_t) ndr_push_winreg_QueryMultipleValues,
4466
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryMultipleValues,
4467
 
                (ndr_print_function_t) ndr_print_winreg_QueryMultipleValues,
4468
 
                false,
4469
 
        },
4470
 
        {
4471
 
                "winreg_InitiateSystemShutdownEx",
4472
 
                sizeof(struct winreg_InitiateSystemShutdownEx),
4473
 
                (ndr_push_flags_fn_t) ndr_push_winreg_InitiateSystemShutdownEx,
4474
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_InitiateSystemShutdownEx,
4475
 
                (ndr_print_function_t) ndr_print_winreg_InitiateSystemShutdownEx,
4476
 
                false,
4477
 
        },
4478
 
        {
4479
 
                "winreg_SaveKeyEx",
4480
 
                sizeof(struct winreg_SaveKeyEx),
4481
 
                (ndr_push_flags_fn_t) ndr_push_winreg_SaveKeyEx,
4482
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_SaveKeyEx,
4483
 
                (ndr_print_function_t) ndr_print_winreg_SaveKeyEx,
4484
 
                false,
4485
 
        },
4486
 
        {
4487
 
                "winreg_OpenHKPT",
4488
 
                sizeof(struct winreg_OpenHKPT),
4489
 
                (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPT,
4490
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPT,
4491
 
                (ndr_print_function_t) ndr_print_winreg_OpenHKPT,
4492
 
                false,
4493
 
        },
4494
 
        {
4495
 
                "winreg_OpenHKPN",
4496
 
                sizeof(struct winreg_OpenHKPN),
4497
 
                (ndr_push_flags_fn_t) ndr_push_winreg_OpenHKPN,
4498
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_OpenHKPN,
4499
 
                (ndr_print_function_t) ndr_print_winreg_OpenHKPN,
4500
 
                false,
4501
 
        },
4502
 
        {
4503
 
                "winreg_QueryMultipleValues2",
4504
 
                sizeof(struct winreg_QueryMultipleValues2),
4505
 
                (ndr_push_flags_fn_t) ndr_push_winreg_QueryMultipleValues2,
4506
 
                (ndr_pull_flags_fn_t) ndr_pull_winreg_QueryMultipleValues2,
4507
 
                (ndr_print_function_t) ndr_print_winreg_QueryMultipleValues2,
4508
 
                false,
4509
 
        },
4510
 
        { NULL, 0, NULL, NULL, NULL, false }
4511
 
};
4512
 
 
4513
 
static const char * const winreg_endpoint_strings[] = {
4514
 
        "ncacn_np:[\\pipe\\winreg]", 
4515
 
        "ncacn_ip_tcp:", 
4516
 
        "ncalrpc:", 
4517
 
};
4518
 
 
4519
 
static const struct ndr_interface_string_array winreg_endpoints = {
4520
 
        .count  = 3,
4521
 
        .names  = winreg_endpoint_strings
4522
 
};
4523
 
 
4524
 
static const char * const winreg_authservice_strings[] = {
4525
 
        "host", 
4526
 
};
4527
 
 
4528
 
static const struct ndr_interface_string_array winreg_authservices = {
4529
 
        .count  = 1,
4530
 
        .names  = winreg_authservice_strings
4531
 
};
4532
 
 
4533
 
 
4534
 
const struct ndr_interface_table ndr_table_winreg = {
4535
 
        .name           = "winreg",
4536
 
        .syntax_id      = {
4537
 
                {0x338cd001,0x2244,0x31f1,{0xaa,0xaa},{0x90,0x00,0x38,0x00,0x10,0x03}},
4538
 
                NDR_WINREG_VERSION
4539
 
        },
4540
 
        .helpstring     = NDR_WINREG_HELPSTRING,
4541
 
        .num_calls      = 35,
4542
 
        .calls          = winreg_calls,
4543
 
        .endpoints      = &winreg_endpoints,
4544
 
        .authservices   = &winreg_authservices
4545
 
};
4546