~ubuntu-branches/ubuntu/wily/samba/wily
» Revision
179
: .pc/CVE-2012-1182-2.patch/source3/librpc/gen_ndr/ndr_svcctl.c
« back to all changes in this revision
Viewing changes to .pc/CVE-2012-1182-2.patch/source3/librpc/gen_ndr/ndr_svcctl.c
- browse files at revision 179
- compare with another revision
- download diff
- download tarball
- view history from revision 179
- Committer: Package Import Robot
- Author(s): James Page
- Date: 2012-05-15 17:00:56 UTC
- mfrom: (178.1.1 precise-security) (0.39.27 sid)
- Revision ID: package-import@ubuntu.com-20120515170056-gludtas4257eb61q
Tags: 2:3.6.5-2ubuntu1
* Merge from Debian unstable, remaining changes:
+ debian/patches/VERSION.patch:
- set SAMBA_VERSION_SUFFIX to Ubuntu.
+ debian/smb.conf:
- add "(Samba, Ubuntu)" to server string.
- comment out the default [homes] share, and add a comment about
"valid users = %S" to show users how to restrict access to
\\server\username to only username.
- Other changes now in Debian packaging.
+ 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.install: install profile.
- debian/control: have samba suggest ufw.
+ Add apport hook:
- Created debian/source_samba.py.
- debian/rules, debian/samba-common-bin.install: install hook.
+ Switch to upstart:
- Added debian/samba.{nmbd,smbd}.upstart.
- debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
Make upstart compatible.
* d/samba.install, d/samba-common-bin.install: Restore apport hook and ufw
profile (LP: #999764).
* Dropped:
+ debian/patches/CVE-2012-1182-*.patch: fixed in upstream release 3.6.4.
+ debian/patches/CVE-2012-2111.patch: fixed in upstream release 3.6.5.
+ debian/patches/fix-debuglevel-name-conflict.patch: fixed upstream -
debug_level is no longer used as a global variable name.
+ debian/patches/error-trans.fix-276472: fixed upstream.
+ debian/patches/VERSION.patch:
- set SAMBA_VERSION_SUFFIX to Ubuntu.
+ debian/smb.conf:
- add "(Samba, Ubuntu)" to server string.
- comment out the default [homes] share, and add a comment about
"valid users = %S" to show users how to restrict access to
\\server\username to only username.
- Other changes now in Debian packaging.
+ 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.install: install profile.
- debian/control: have samba suggest ufw.
+ Add apport hook:
- Created debian/source_samba.py.
- debian/rules, debian/samba-common-bin.install: install hook.
+ Switch to upstart:
- Added debian/samba.{nmbd,smbd}.upstart.
- debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
Make upstart compatible.
* d/samba.install, d/samba-common-bin.install: Restore apport hook and ufw
profile (LP: #999764).
* Dropped:
+ debian/patches/CVE-2012-1182-*.patch: fixed in upstream release 3.6.4.
+ debian/patches/CVE-2012-2111.patch: fixed in upstream release 3.6.5.
+ debian/patches/fix-debuglevel-name-conflict.patch: fixed upstream -
debug_level is no longer used as a global variable name.
+ debian/patches/error-trans.fix-276472: fixed upstream.
- files added:
- .pc/bug_387266_upstream_4104_mention-kerberos-in-smbspool-manpage.patch
- .pc/bug_387266_upstream_4104_mention-kerberos-in-smbspool-manpage.patch/docs
- .pc/bug_387266_upstream_4104_mention-kerberos-in-smbspool-manpage.patch/docs-xml
- .pc/bug_387266_upstream_4104_mention-kerberos-in-smbspool-manpage.patch/docs-xml/manpages-3
- .pc/bug_387266_upstream_4104_mention-kerberos-in-smbspool-manpage.patch/docs/manpages
- .pc/bug_598313_upstream_7499-nss_wins-dont-clobber-daemons-logs.patch
- .pc/bug_598313_upstream_7499-nss_wins-dont-clobber-daemons-logs.patch/lib
- .pc/bug_598313_upstream_7499-nss_wins-dont-clobber-daemons-logs.patch/lib/util
- .pc/bug_598313_upstream_7499-nss_wins-dont-clobber-daemons-logs.patch/nsswitch
- .pc/bug_604768_upstream_7826_drop-using-samba-link.patch
- .pc/bug_604768_upstream_7826_drop-using-samba-link.patch/docs
- .pc/bug_604768_upstream_7826_drop-using-samba-link.patch/docs/htmldocs
- .pc/bug_604768_upstream_7826_fix-WHATSNEW-link.patch
- .pc/bug_604768_upstream_7826_fix-WHATSNEW-link.patch/docs
- .pc/bug_604768_upstream_7826_fix-WHATSNEW-link.patch/docs/htmldocs
- .pc/fhs-filespaths.patch/docs
- .pc/fhs-filespaths.patch/docs/manpages
- .pc/fix-samba.ldif-syntax.patch
- .pc/fix-samba.ldif-syntax.patch/examples
- .pc/fix-samba.ldif-syntax.patch/examples/LDAP
- .pc/smbtorture-manpage.patch
- .pc/smbtorture-manpage.patch/docs
- .pc/smbtorture-manpage.patch/docs/manpages
- .pc/waf-as-source.patch
- .pc/waf-as-source.patch/buildtools
- .pc/waf-as-source.patch/buildtools/bin
- .pc/waf-as-source.patch/buildtools/wafadmin
- .pc/waf-as-source.patch/buildtools/wafadmin/3rdparty
- .pc/waf-as-source.patch/buildtools/wafadmin/Tools
- buildtools/wafadmin
- buildtools/wafadmin/3rdparty
- buildtools/wafadmin/Tools
- files removed:
- .pc/CVE-2012-1182-1.patch
- .pc/CVE-2012-1182-1.patch/pidl
- .pc/CVE-2012-1182-1.patch/pidl/lib
- .pc/CVE-2012-1182-1.patch/pidl/lib/Parse
- .pc/CVE-2012-1182-1.patch/pidl/lib/Parse/Pidl
- .pc/CVE-2012-1182-1.patch/pidl/lib/Parse/Pidl/Samba4
- .pc/CVE-2012-1182-1.patch/pidl/lib/Parse/Pidl/Samba4/NDR
- .pc/CVE-2012-1182-2.patch
- .pc/CVE-2012-1182-2.patch/source3
- .pc/CVE-2012-1182-2.patch/source3/librpc
- .pc/CVE-2012-1182-2.patch/source3/librpc/gen_ndr
- .pc/fix-samba.ldip-syntax.patch
- .pc/fix-samba.ldip-syntax.patch/examples
- .pc/fix-samba.ldip-syntax.patch/examples/LDAP
- files modified:
- .pc/VERSION.patch/source3/VERSION
added
removed
.pc/CVE-2012-1182-2.patch/source3/librpc/gen_ndr/ndr_svcctl.c
1
/* parser auto-generated by pidl */
2
3
#include "includes.h"
4
#include "librpc/gen_ndr/ndr_svcctl.h"
5
6
#include "librpc/gen_ndr/ndr_misc.h"
7
#include "librpc/gen_ndr/ndr_security.h"
8
static enum ndr_err_code ndr_push_SERVICE_LOCK_STATUS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_LOCK_STATUS *r)
9
{
10
if (ndr_flags & NDR_SCALARS) {
11
NDR_CHECK(ndr_push_align(ndr, 5));
12
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_locked));
13
NDR_CHECK(ndr_push_unique_ptr(ndr, r->lock_owner));
14
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_duration));
15
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16
}
17
if (ndr_flags & NDR_BUFFERS) {
18
if (r->lock_owner) {
19
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));
20
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));
22
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lock_owner, ndr_charset_length(r->lock_owner, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23
}
24
}
25
return NDR_ERR_SUCCESS;
26
}
27
28
static enum ndr_err_code ndr_pull_SERVICE_LOCK_STATUS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_LOCK_STATUS *r)
29
{
30
uint32_t _ptr_lock_owner;
31
TALLOC_CTX *_mem_save_lock_owner_0;
32
if (ndr_flags & NDR_SCALARS) {
33
NDR_CHECK(ndr_pull_align(ndr, 5));
34
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_locked));
35
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lock_owner));
36
if (_ptr_lock_owner) {
37
NDR_PULL_ALLOC(ndr, r->lock_owner);
38
} else {
39
r->lock_owner = NULL;
40
}
41
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_duration));
42
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
43
}
44
if (ndr_flags & NDR_BUFFERS) {
45
if (r->lock_owner) {
46
_mem_save_lock_owner_0 = NDR_PULL_GET_MEM_CTX(ndr);
47
NDR_PULL_SET_MEM_CTX(ndr, r->lock_owner, 0);
48
NDR_CHECK(ndr_pull_array_size(ndr, &r->lock_owner));
49
NDR_CHECK(ndr_pull_array_length(ndr, &r->lock_owner));
50
if (ndr_get_array_length(ndr, &r->lock_owner) > ndr_get_array_size(ndr, &r->lock_owner)) {
51
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->lock_owner), ndr_get_array_length(ndr, &r->lock_owner));
52
}
53
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lock_owner), sizeof(uint16_t)));
54
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lock_owner, ndr_get_array_length(ndr, &r->lock_owner), sizeof(uint16_t), CH_UTF16));
55
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_owner_0, 0);
56
}
57
}
58
return NDR_ERR_SUCCESS;
59
}
60
61
_PUBLIC_ void ndr_print_SERVICE_LOCK_STATUS(struct ndr_print *ndr, const char *name, const struct SERVICE_LOCK_STATUS *r)
62
{
63
ndr_print_struct(ndr, name, "SERVICE_LOCK_STATUS");
64
if (r == NULL) { ndr_print_null(ndr); return; }
65
ndr->depth++;
66
ndr_print_uint32(ndr, "is_locked", r->is_locked);
67
ndr_print_ptr(ndr, "lock_owner", r->lock_owner);
68
ndr->depth++;
69
if (r->lock_owner) {
70
ndr_print_string(ndr, "lock_owner", r->lock_owner);
71
}
72
ndr->depth--;
73
ndr_print_uint32(ndr, "lock_duration", r->lock_duration);
74
ndr->depth--;
75
}
76
77
static enum ndr_err_code ndr_push_svcctl_ServiceStatus(struct ndr_push *ndr, int ndr_flags, enum svcctl_ServiceStatus r)
78
{
79
NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
80
return NDR_ERR_SUCCESS;
81
}
82
83
static enum ndr_err_code ndr_pull_svcctl_ServiceStatus(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ServiceStatus *r)
84
{
85
uint32_t v;
86
NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
87
*r = v;
88
return NDR_ERR_SUCCESS;
89
}
90
91
_PUBLIC_ void ndr_print_svcctl_ServiceStatus(struct ndr_print *ndr, const char *name, enum svcctl_ServiceStatus r)
92
{
93
const char *val = NULL;
94
95
switch (r) {
96
case SVCCTL_STATE_UNKNOWN: val = "SVCCTL_STATE_UNKNOWN"; break;
97
case SVCCTL_STOPPED: val = "SVCCTL_STOPPED"; break;
98
case SVCCTL_START_PENDING: val = "SVCCTL_START_PENDING"; break;
99
case SVCCTL_STOP_PENDING: val = "SVCCTL_STOP_PENDING"; break;
100
case SVCCTL_RUNNING: val = "SVCCTL_RUNNING"; break;
101
case SVCCTL_CONTINUE_PENDING: val = "SVCCTL_CONTINUE_PENDING"; break;
102
case SVCCTL_PAUSE_PENDING: val = "SVCCTL_PAUSE_PENDING"; break;
103
case SVCCTL_PAUSED: val = "SVCCTL_PAUSED"; break;
104
}
105
ndr_print_enum(ndr, name, "ENUM", val, r);
106
}
107
108
static enum ndr_err_code ndr_push_svcctl_ControlsAccepted(struct ndr_push *ndr, int ndr_flags, uint32_t r)
109
{
110
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
111
return NDR_ERR_SUCCESS;
112
}
113
114
static enum ndr_err_code ndr_pull_svcctl_ControlsAccepted(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
115
{
116
uint32_t v;
117
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
118
*r = v;
119
return NDR_ERR_SUCCESS;
120
}
121
122
_PUBLIC_ void ndr_print_svcctl_ControlsAccepted(struct ndr_print *ndr, const char *name, uint32_t r)
123
{
124
ndr_print_uint32(ndr, name, r);
125
ndr->depth++;
126
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_STOP", SVCCTL_ACCEPT_STOP, r);
127
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_PAUSE_CONTINUE", SVCCTL_ACCEPT_PAUSE_CONTINUE, r);
128
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_SHUTDOWN", SVCCTL_ACCEPT_SHUTDOWN, r);
129
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_PARAMCHANGE", SVCCTL_ACCEPT_PARAMCHANGE, r);
130
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_NETBINDCHANGE", SVCCTL_ACCEPT_NETBINDCHANGE, r);
131
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_HARDWAREPROFILECHANGE", SVCCTL_ACCEPT_HARDWAREPROFILECHANGE, r);
132
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_POWEREVENT", SVCCTL_ACCEPT_POWEREVENT, r);
133
ndr->depth--;
134
}
135
136
static enum ndr_err_code ndr_push_SERVICE_STATUS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_STATUS *r)
137
{
138
if (ndr_flags & NDR_SCALARS) {
139
NDR_CHECK(ndr_push_align(ndr, 4));
140
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->type));
141
NDR_CHECK(ndr_push_svcctl_ServiceStatus(ndr, NDR_SCALARS, r->state));
142
NDR_CHECK(ndr_push_svcctl_ControlsAccepted(ndr, NDR_SCALARS, r->controls_accepted));
143
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->win32_exit_code));
144
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_exit_code));
145
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->check_point));
146
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wait_hint));
147
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
148
}
149
if (ndr_flags & NDR_BUFFERS) {
150
}
151
return NDR_ERR_SUCCESS;
152
}
153
154
static enum ndr_err_code ndr_pull_SERVICE_STATUS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_STATUS *r)
155
{
156
if (ndr_flags & NDR_SCALARS) {
157
NDR_CHECK(ndr_pull_align(ndr, 4));
158
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->type));
159
NDR_CHECK(ndr_pull_svcctl_ServiceStatus(ndr, NDR_SCALARS, &r->state));
160
NDR_CHECK(ndr_pull_svcctl_ControlsAccepted(ndr, NDR_SCALARS, &r->controls_accepted));
161
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->win32_exit_code));
162
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_exit_code));
163
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->check_point));
164
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wait_hint));
165
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
166
}
167
if (ndr_flags & NDR_BUFFERS) {
168
}
169
return NDR_ERR_SUCCESS;
170
}
171
172
_PUBLIC_ void ndr_print_SERVICE_STATUS(struct ndr_print *ndr, const char *name, const struct SERVICE_STATUS *r)
173
{
174
ndr_print_struct(ndr, name, "SERVICE_STATUS");
175
if (r == NULL) { ndr_print_null(ndr); return; }
176
ndr->depth++;
177
ndr_print_uint32(ndr, "type", r->type);
178
ndr_print_svcctl_ServiceStatus(ndr, "state", r->state);
179
ndr_print_svcctl_ControlsAccepted(ndr, "controls_accepted", r->controls_accepted);
180
ndr_print_WERROR(ndr, "win32_exit_code", r->win32_exit_code);
181
ndr_print_uint32(ndr, "service_exit_code", r->service_exit_code);
182
ndr_print_uint32(ndr, "check_point", r->check_point);
183
ndr_print_uint32(ndr, "wait_hint", r->wait_hint);
184
ndr->depth--;
185
}
186
187
_PUBLIC_ enum ndr_err_code ndr_push_SERVICE_STATUS_PROCESS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_STATUS_PROCESS *r)
188
{
189
if (ndr_flags & NDR_SCALARS) {
190
NDR_CHECK(ndr_push_align(ndr, 4));
191
NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
192
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->process_id));
193
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_flags));
194
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
195
}
196
if (ndr_flags & NDR_BUFFERS) {
197
}
198
return NDR_ERR_SUCCESS;
199
}
200
201
_PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_STATUS_PROCESS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_STATUS_PROCESS *r)
202
{
203
if (ndr_flags & NDR_SCALARS) {
204
NDR_CHECK(ndr_pull_align(ndr, 4));
205
NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
206
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->process_id));
207
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_flags));
208
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
209
}
210
if (ndr_flags & NDR_BUFFERS) {
211
}
212
return NDR_ERR_SUCCESS;
213
}
214
215
_PUBLIC_ void ndr_print_SERVICE_STATUS_PROCESS(struct ndr_print *ndr, const char *name, const struct SERVICE_STATUS_PROCESS *r)
216
{
217
ndr_print_struct(ndr, name, "SERVICE_STATUS_PROCESS");
218
if (r == NULL) { ndr_print_null(ndr); return; }
219
ndr->depth++;
220
ndr_print_SERVICE_STATUS(ndr, "status", &r->status);
221
ndr_print_uint32(ndr, "process_id", r->process_id);
222
ndr_print_uint32(ndr, "service_flags", r->service_flags);
223
ndr->depth--;
224
}
225
226
_PUBLIC_ enum ndr_err_code ndr_push_ENUM_SERVICE_STATUSW(struct ndr_push *ndr, int ndr_flags, const struct ENUM_SERVICE_STATUSW *r)
227
{
228
if (ndr_flags & NDR_SCALARS) {
229
NDR_CHECK(ndr_push_align(ndr, 5));
230
{
231
uint32_t _flags_save_string = ndr->flags;
232
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
233
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->service_name));
234
ndr->flags = _flags_save_string;
235
}
236
{
237
uint32_t _flags_save_string = ndr->flags;
238
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
239
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
240
ndr->flags = _flags_save_string;
241
}
242
NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
243
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
244
}
245
if (ndr_flags & NDR_BUFFERS) {
246
{
247
uint32_t _flags_save_string = ndr->flags;
248
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
249
if (r->service_name) {
250
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->service_name));
251
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->service_name));
252
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->service_name));
253
}
254
ndr->flags = _flags_save_string;
255
}
256
{
257
uint32_t _flags_save_string = ndr->flags;
258
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
259
if (r->display_name) {
260
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
261
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
262
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
263
}
264
ndr->flags = _flags_save_string;
265
}
266
}
267
return NDR_ERR_SUCCESS;
268
}
269
270
_PUBLIC_ enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUSW(struct ndr_pull *ndr, int ndr_flags, struct ENUM_SERVICE_STATUSW *r)
271
{
272
uint32_t _ptr_service_name;
273
TALLOC_CTX *_mem_save_service_name_0;
274
uint32_t _ptr_display_name;
275
TALLOC_CTX *_mem_save_display_name_0;
276
if (ndr_flags & NDR_SCALARS) {
277
NDR_CHECK(ndr_pull_align(ndr, 5));
278
{
279
uint32_t _flags_save_string = ndr->flags;
280
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
281
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
282
if (_ptr_service_name) {
283
NDR_PULL_ALLOC(ndr, r->service_name);
284
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->service_name, _ptr_service_name));
285
} else {
286
r->service_name = NULL;
287
}
288
ndr->flags = _flags_save_string;
289
}
290
{
291
uint32_t _flags_save_string = ndr->flags;
292
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
293
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
294
if (_ptr_display_name) {
295
NDR_PULL_ALLOC(ndr, r->display_name);
296
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
297
} else {
298
r->display_name = NULL;
299
}
300
ndr->flags = _flags_save_string;
301
}
302
NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
303
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
304
}
305
if (ndr_flags & NDR_BUFFERS) {
306
{
307
uint32_t _flags_save_string = ndr->flags;
308
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
309
if (r->service_name) {
310
uint32_t _relative_save_offset;
311
_relative_save_offset = ndr->offset;
312
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->service_name));
313
_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
314
NDR_PULL_SET_MEM_CTX(ndr, r->service_name, 0);
315
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->service_name));
316
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
317
if (ndr->offset > ndr->relative_highest_offset) {
318
ndr->relative_highest_offset = ndr->offset;
319
}
320
ndr->offset = _relative_save_offset;
321
}
322
ndr->flags = _flags_save_string;
323
}
324
{
325
uint32_t _flags_save_string = ndr->flags;
326
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
327
if (r->display_name) {
328
uint32_t _relative_save_offset;
329
_relative_save_offset = ndr->offset;
330
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
331
_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
332
NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
333
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
334
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
335
if (ndr->offset > ndr->relative_highest_offset) {
336
ndr->relative_highest_offset = ndr->offset;
337
}
338
ndr->offset = _relative_save_offset;
339
}
340
ndr->flags = _flags_save_string;
341
}
342
}
343
return NDR_ERR_SUCCESS;
344
}
345
346
_PUBLIC_ void ndr_print_ENUM_SERVICE_STATUSW(struct ndr_print *ndr, const char *name, const struct ENUM_SERVICE_STATUSW *r)
347
{
348
ndr_print_struct(ndr, name, "ENUM_SERVICE_STATUSW");
349
if (r == NULL) { ndr_print_null(ndr); return; }
350
ndr->depth++;
351
ndr_print_ptr(ndr, "service_name", r->service_name);
352
ndr->depth++;
353
if (r->service_name) {
354
ndr_print_string(ndr, "service_name", r->service_name);
355
}
356
ndr->depth--;
357
ndr_print_ptr(ndr, "display_name", r->display_name);
358
ndr->depth++;
359
if (r->display_name) {
360
ndr_print_string(ndr, "display_name", r->display_name);
361
}
362
ndr->depth--;
363
ndr_print_SERVICE_STATUS(ndr, "status", &r->status);
364
ndr->depth--;
365
}
366
367
_PUBLIC_ size_t ndr_size_ENUM_SERVICE_STATUSW(const struct ENUM_SERVICE_STATUSW *r, int flags)
368
{
369
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSW);
370
}
371
372
_PUBLIC_ enum ndr_err_code ndr_push_ENUM_SERVICE_STATUSA(struct ndr_push *ndr, int ndr_flags, const struct ENUM_SERVICE_STATUSA *r)
373
{
374
if (ndr_flags & NDR_SCALARS) {
375
NDR_CHECK(ndr_push_align(ndr, 5));
376
{
377
uint32_t _flags_save_string = ndr->flags;
378
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
379
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->service_name));
380
ndr->flags = _flags_save_string;
381
}
382
{
383
uint32_t _flags_save_string = ndr->flags;
384
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
385
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
386
ndr->flags = _flags_save_string;
387
}
388
NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
389
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
390
}
391
if (ndr_flags & NDR_BUFFERS) {
392
{
393
uint32_t _flags_save_string = ndr->flags;
394
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
395
if (r->service_name) {
396
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->service_name));
397
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->service_name));
398
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->service_name));
399
}
400
ndr->flags = _flags_save_string;
401
}
402
{
403
uint32_t _flags_save_string = ndr->flags;
404
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
405
if (r->display_name) {
406
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
407
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
408
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
409
}
410
ndr->flags = _flags_save_string;
411
}
412
}
413
return NDR_ERR_SUCCESS;
414
}
415
416
_PUBLIC_ enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUSA(struct ndr_pull *ndr, int ndr_flags, struct ENUM_SERVICE_STATUSA *r)
417
{
418
uint32_t _ptr_service_name;
419
TALLOC_CTX *_mem_save_service_name_0;
420
uint32_t _ptr_display_name;
421
TALLOC_CTX *_mem_save_display_name_0;
422
if (ndr_flags & NDR_SCALARS) {
423
NDR_CHECK(ndr_pull_align(ndr, 5));
424
{
425
uint32_t _flags_save_string = ndr->flags;
426
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
427
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
428
if (_ptr_service_name) {
429
NDR_PULL_ALLOC(ndr, r->service_name);
430
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->service_name, _ptr_service_name));
431
} else {
432
r->service_name = NULL;
433
}
434
ndr->flags = _flags_save_string;
435
}
436
{
437
uint32_t _flags_save_string = ndr->flags;
438
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
439
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
440
if (_ptr_display_name) {
441
NDR_PULL_ALLOC(ndr, r->display_name);
442
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
443
} else {
444
r->display_name = NULL;
445
}
446
ndr->flags = _flags_save_string;
447
}
448
NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
449
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
450
}
451
if (ndr_flags & NDR_BUFFERS) {
452
{
453
uint32_t _flags_save_string = ndr->flags;
454
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
455
if (r->service_name) {
456
uint32_t _relative_save_offset;
457
_relative_save_offset = ndr->offset;
458
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->service_name));
459
_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
460
NDR_PULL_SET_MEM_CTX(ndr, r->service_name, 0);
461
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->service_name));
462
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
463
if (ndr->offset > ndr->relative_highest_offset) {
464
ndr->relative_highest_offset = ndr->offset;
465
}
466
ndr->offset = _relative_save_offset;
467
}
468
ndr->flags = _flags_save_string;
469
}
470
{
471
uint32_t _flags_save_string = ndr->flags;
472
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
473
if (r->display_name) {
474
uint32_t _relative_save_offset;
475
_relative_save_offset = ndr->offset;
476
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
477
_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
478
NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
479
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
480
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
481
if (ndr->offset > ndr->relative_highest_offset) {
482
ndr->relative_highest_offset = ndr->offset;
483
}
484
ndr->offset = _relative_save_offset;
485
}
486
ndr->flags = _flags_save_string;
487
}
488
}
489
return NDR_ERR_SUCCESS;
490
}
491
492
_PUBLIC_ void ndr_print_ENUM_SERVICE_STATUSA(struct ndr_print *ndr, const char *name, const struct ENUM_SERVICE_STATUSA *r)
493
{
494
ndr_print_struct(ndr, name, "ENUM_SERVICE_STATUSA");
495
if (r == NULL) { ndr_print_null(ndr); return; }
496
ndr->depth++;
497
ndr_print_ptr(ndr, "service_name", r->service_name);
498
ndr->depth++;
499
if (r->service_name) {
500
ndr_print_string(ndr, "service_name", r->service_name);
501
}
502
ndr->depth--;
503
ndr_print_ptr(ndr, "display_name", r->display_name);
504
ndr->depth++;
505
if (r->display_name) {
506
ndr_print_string(ndr, "display_name", r->display_name);
507
}
508
ndr->depth--;
509
ndr_print_SERVICE_STATUS(ndr, "status", &r->status);
510
ndr->depth--;
511
}
512
513
_PUBLIC_ size_t ndr_size_ENUM_SERVICE_STATUSA(const struct ENUM_SERVICE_STATUSA *r, int flags)
514
{
515
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSA);
516
}
517
518
_PUBLIC_ enum ndr_err_code ndr_push_svcctl_ServerType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
519
{
520
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
521
return NDR_ERR_SUCCESS;
522
}
523
524
_PUBLIC_ enum ndr_err_code ndr_pull_svcctl_ServerType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
525
{
526
uint32_t v;
527
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
528
*r = v;
529
return NDR_ERR_SUCCESS;
530
}
531
532
_PUBLIC_ void ndr_print_svcctl_ServerType(struct ndr_print *ndr, const char *name, uint32_t r)
533
{
534
ndr_print_uint32(ndr, name, r);
535
ndr->depth++;
536
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_WORKSTATION", SV_TYPE_WORKSTATION, r);
537
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER", SV_TYPE_SERVER, r);
538
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SQLSERVER", SV_TYPE_SQLSERVER, r);
539
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DOMAIN_CTRL", SV_TYPE_DOMAIN_CTRL, r);
540
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DOMAIN_BAKCTRL", SV_TYPE_DOMAIN_BAKCTRL, r);
541
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_TIME_SOURCE", SV_TYPE_TIME_SOURCE, r);
542
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_AFP", SV_TYPE_AFP, r);
543
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_NOVELL", SV_TYPE_NOVELL, r);
544
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DOMAIN_MEMBER", SV_TYPE_DOMAIN_MEMBER, r);
545
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_PRINTQ_SERVER", SV_TYPE_PRINTQ_SERVER, r);
546
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DIALIN_SERVER", SV_TYPE_DIALIN_SERVER, r);
547
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER_UNIX", SV_TYPE_SERVER_UNIX, r);
548
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_NT", SV_TYPE_NT, r);
549
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_WFW", SV_TYPE_WFW, r);
550
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER_MFPN", SV_TYPE_SERVER_MFPN, r);
551
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER_NT", SV_TYPE_SERVER_NT, r);
552
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_POTENTIAL_BROWSER", SV_TYPE_POTENTIAL_BROWSER, r);
553
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_BACKUP_BROWSER", SV_TYPE_BACKUP_BROWSER, r);
554
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_MASTER_BROWSER", SV_TYPE_MASTER_BROWSER, r);
555
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DOMAIN_MASTER", SV_TYPE_DOMAIN_MASTER, r);
556
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER_OSF", SV_TYPE_SERVER_OSF, r);
557
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER_VMS", SV_TYPE_SERVER_VMS, r);
558
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_WIN95_PLUS", SV_TYPE_WIN95_PLUS, r);
559
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DFS_SERVER", SV_TYPE_DFS_SERVER, r);
560
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_ALTERNATE_XPORT", SV_TYPE_ALTERNATE_XPORT, r);
561
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_LOCAL_LIST_ONLY", SV_TYPE_LOCAL_LIST_ONLY, r);
562
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DOMAIN_ENUM", SV_TYPE_DOMAIN_ENUM, r);
563
ndr->depth--;
564
}
565
566
static enum ndr_err_code ndr_push_SERVICE_CONTROL(struct ndr_push *ndr, int ndr_flags, enum SERVICE_CONTROL r)
567
{
568
NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
569
return NDR_ERR_SUCCESS;
570
}
571
572
static enum ndr_err_code ndr_pull_SERVICE_CONTROL(struct ndr_pull *ndr, int ndr_flags, enum SERVICE_CONTROL *r)
573
{
574
uint32_t v;
575
NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
576
*r = v;
577
return NDR_ERR_SUCCESS;
578
}
579
580
_PUBLIC_ void ndr_print_SERVICE_CONTROL(struct ndr_print *ndr, const char *name, enum SERVICE_CONTROL r)
581
{
582
const char *val = NULL;
583
584
switch (r) {
585
case SVCCTL_CONTROL_STOP: val = "SVCCTL_CONTROL_STOP"; break;
586
case SVCCTL_CONTROL_PAUSE: val = "SVCCTL_CONTROL_PAUSE"; break;
587
case SVCCTL_CONTROL_CONTINUE: val = "SVCCTL_CONTROL_CONTINUE"; break;
588
case SVCCTL_CONTROL_INTERROGATE: val = "SVCCTL_CONTROL_INTERROGATE"; break;
589
case SVCCTL_CONTROL_SHUTDOWN: val = "SVCCTL_CONTROL_SHUTDOWN"; break;
590
}
591
ndr_print_enum(ndr, name, "ENUM", val, r);
592
}
593
594
static enum ndr_err_code ndr_push_svcctl_ErrorControl(struct ndr_push *ndr, int ndr_flags, enum svcctl_ErrorControl r)
595
{
596
NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
597
return NDR_ERR_SUCCESS;
598
}
599
600
static enum ndr_err_code ndr_pull_svcctl_ErrorControl(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ErrorControl *r)
601
{
602
uint32_t v;
603
NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
604
*r = v;
605
return NDR_ERR_SUCCESS;
606
}
607
608
_PUBLIC_ void ndr_print_svcctl_ErrorControl(struct ndr_print *ndr, const char *name, enum svcctl_ErrorControl r)
609
{
610
const char *val = NULL;
611
612
switch (r) {
613
case SVCCTL_SVC_ERROR_IGNORE: val = "SVCCTL_SVC_ERROR_IGNORE"; break;
614
case SVCCTL_SVC_ERROR_NORMAL: val = "SVCCTL_SVC_ERROR_NORMAL"; break;
615
case SVCCTL_SVC_ERROR_CRITICAL: val = "SVCCTL_SVC_ERROR_CRITICAL"; break;
616
case SVCCTL_SVC_ERROR_SEVERE: val = "SVCCTL_SVC_ERROR_SEVERE"; break;
617
}
618
ndr_print_enum(ndr, name, "ENUM", val, r);
619
}
620
621
static enum ndr_err_code ndr_push_svcctl_StartType(struct ndr_push *ndr, int ndr_flags, enum svcctl_StartType r)
622
{
623
NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
624
return NDR_ERR_SUCCESS;
625
}
626
627
static enum ndr_err_code ndr_pull_svcctl_StartType(struct ndr_pull *ndr, int ndr_flags, enum svcctl_StartType *r)
628
{
629
uint32_t v;
630
NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
631
*r = v;
632
return NDR_ERR_SUCCESS;
633
}
634
635
_PUBLIC_ void ndr_print_svcctl_StartType(struct ndr_print *ndr, const char *name, enum svcctl_StartType r)
636
{
637
const char *val = NULL;
638
639
switch (r) {
640
case SVCCTL_BOOT_START: val = "SVCCTL_BOOT_START"; break;
641
case SVCCTL_SYSTEM_START: val = "SVCCTL_SYSTEM_START"; break;
642
case SVCCTL_AUTO_START: val = "SVCCTL_AUTO_START"; break;
643
case SVCCTL_DEMAND_START: val = "SVCCTL_DEMAND_START"; break;
644
case SVCCTL_DISABLED: val = "SVCCTL_DISABLED"; break;
645
}
646
ndr_print_enum(ndr, name, "ENUM", val, r);
647
}
648
649
static enum ndr_err_code ndr_push_svcctl_ServiceState(struct ndr_push *ndr, int ndr_flags, enum svcctl_ServiceState r)
650
{
651
NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
652
return NDR_ERR_SUCCESS;
653
}
654
655
static enum ndr_err_code ndr_pull_svcctl_ServiceState(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ServiceState *r)
656
{
657
uint32_t v;
658
NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
659
*r = v;
660
return NDR_ERR_SUCCESS;
661
}
662
663
_PUBLIC_ void ndr_print_svcctl_ServiceState(struct ndr_print *ndr, const char *name, enum svcctl_ServiceState r)
664
{
665
const char *val = NULL;
666
667
switch (r) {
668
case SERVICE_STATE_ACTIVE: val = "SERVICE_STATE_ACTIVE"; break;
669
case SERVICE_STATE_INACTIVE: val = "SERVICE_STATE_INACTIVE"; break;
670
case SERVICE_STATE_ALL: val = "SERVICE_STATE_ALL"; break;
671
}
672
ndr_print_enum(ndr, name, "ENUM", val, r);
673
}
674
675
static enum ndr_err_code ndr_push_svcctl_MgrAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
676
{
677
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
678
return NDR_ERR_SUCCESS;
679
}
680
681
static enum ndr_err_code ndr_pull_svcctl_MgrAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
682
{
683
uint32_t v;
684
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
685
*r = v;
686
return NDR_ERR_SUCCESS;
687
}
688
689
_PUBLIC_ void ndr_print_svcctl_MgrAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
690
{
691
ndr_print_uint32(ndr, name, r);
692
ndr->depth++;
693
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_CONNECT", SC_RIGHT_MGR_CONNECT, r);
694
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_CREATE_SERVICE", SC_RIGHT_MGR_CREATE_SERVICE, r);
695
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_ENUMERATE_SERVICE", SC_RIGHT_MGR_ENUMERATE_SERVICE, r);
696
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_LOCK", SC_RIGHT_MGR_LOCK, r);
697
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_QUERY_LOCK_STATUS", SC_RIGHT_MGR_QUERY_LOCK_STATUS, r);
698
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_MODIFY_BOOT_CONFIG", SC_RIGHT_MGR_MODIFY_BOOT_CONFIG, r);
699
ndr->depth--;
700
}
701
702
static enum ndr_err_code ndr_push_svcctl_ServiceAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
703
{
704
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
705
return NDR_ERR_SUCCESS;
706
}
707
708
static enum ndr_err_code ndr_pull_svcctl_ServiceAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
709
{
710
uint32_t v;
711
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
712
*r = v;
713
return NDR_ERR_SUCCESS;
714
}
715
716
_PUBLIC_ void ndr_print_svcctl_ServiceAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
717
{
718
ndr_print_uint32(ndr, name, r);
719
ndr->depth++;
720
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_QUERY_CONFIG", SC_RIGHT_SVC_QUERY_CONFIG, r);
721
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_CHANGE_CONFIG", SC_RIGHT_SVC_CHANGE_CONFIG, r);
722
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_QUERY_STATUS", SC_RIGHT_SVC_QUERY_STATUS, r);
723
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_ENUMERATE_DEPENDENTS", SC_RIGHT_SVC_ENUMERATE_DEPENDENTS, r);
724
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_START", SC_RIGHT_SVC_START, r);
725
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_STOP", SC_RIGHT_SVC_STOP, r);
726
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_PAUSE_CONTINUE", SC_RIGHT_SVC_PAUSE_CONTINUE, r);
727
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_INTERROGATE", SC_RIGHT_SVC_INTERROGATE, r);
728
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_USER_DEFINED_CONTROL", SC_RIGHT_SVC_USER_DEFINED_CONTROL, r);
729
ndr->depth--;
730
}
731
732
_PUBLIC_ enum ndr_err_code ndr_push_QUERY_SERVICE_CONFIG(struct ndr_push *ndr, int ndr_flags, const struct QUERY_SERVICE_CONFIG *r)
733
{
734
if (ndr_flags & NDR_SCALARS) {
735
NDR_CHECK(ndr_push_align(ndr, 5));
736
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_type));
737
NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->start_type));
738
NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->error_control));
739
NDR_CHECK(ndr_push_unique_ptr(ndr, r->executablepath));
740
NDR_CHECK(ndr_push_unique_ptr(ndr, r->loadordergroup));
741
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->tag_id));
742
NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependencies));
743
NDR_CHECK(ndr_push_unique_ptr(ndr, r->startname));
744
NDR_CHECK(ndr_push_unique_ptr(ndr, r->displayname));
745
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
746
}
747
if (ndr_flags & NDR_BUFFERS) {
748
if (r->executablepath) {
749
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->executablepath, CH_UTF16)));
750
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
751
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->executablepath, CH_UTF16)));
752
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->executablepath, ndr_charset_length(r->executablepath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
753
}
754
if (r->loadordergroup) {
755
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->loadordergroup, CH_UTF16)));
756
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
757
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->loadordergroup, CH_UTF16)));
758
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->loadordergroup, ndr_charset_length(r->loadordergroup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
759
}
760
if (r->dependencies) {
761
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dependencies, CH_UTF16)));
762
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
763
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dependencies, CH_UTF16)));
764
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dependencies, ndr_charset_length(r->dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
765
}
766
if (r->startname) {
767
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->startname, CH_UTF16)));
768
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
769
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->startname, CH_UTF16)));
770
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->startname, ndr_charset_length(r->startname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
771
}
772
if (r->displayname) {
773
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->displayname, CH_UTF16)));
774
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
775
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->displayname, CH_UTF16)));
776
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->displayname, ndr_charset_length(r->displayname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
777
}
778
}
779
return NDR_ERR_SUCCESS;
780
}
781
782
_PUBLIC_ enum ndr_err_code ndr_pull_QUERY_SERVICE_CONFIG(struct ndr_pull *ndr, int ndr_flags, struct QUERY_SERVICE_CONFIG *r)
783
{
784
uint32_t _ptr_executablepath;
785
TALLOC_CTX *_mem_save_executablepath_0;
786
uint32_t _ptr_loadordergroup;
787
TALLOC_CTX *_mem_save_loadordergroup_0;
788
uint32_t _ptr_dependencies;
789
TALLOC_CTX *_mem_save_dependencies_0;
790
uint32_t _ptr_startname;
791
TALLOC_CTX *_mem_save_startname_0;
792
uint32_t _ptr_displayname;
793
TALLOC_CTX *_mem_save_displayname_0;
794
if (ndr_flags & NDR_SCALARS) {
795
NDR_CHECK(ndr_pull_align(ndr, 5));
796
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_type));
797
NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->start_type));
798
NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->error_control));
799
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_executablepath));
800
if (_ptr_executablepath) {
801
NDR_PULL_ALLOC(ndr, r->executablepath);
802
} else {
803
r->executablepath = NULL;
804
}
805
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_loadordergroup));
806
if (_ptr_loadordergroup) {
807
NDR_PULL_ALLOC(ndr, r->loadordergroup);
808
} else {
809
r->loadordergroup = NULL;
810
}
811
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->tag_id));
812
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
813
if (_ptr_dependencies) {
814
NDR_PULL_ALLOC(ndr, r->dependencies);
815
} else {
816
r->dependencies = NULL;
817
}
818
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_startname));
819
if (_ptr_startname) {
820
NDR_PULL_ALLOC(ndr, r->startname);
821
} else {
822
r->startname = NULL;
823
}
824
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_displayname));
825
if (_ptr_displayname) {
826
NDR_PULL_ALLOC(ndr, r->displayname);
827
} else {
828
r->displayname = NULL;
829
}
830
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
831
}
832
if (ndr_flags & NDR_BUFFERS) {
833
if (r->executablepath) {
834
_mem_save_executablepath_0 = NDR_PULL_GET_MEM_CTX(ndr);
835
NDR_PULL_SET_MEM_CTX(ndr, r->executablepath, 0);
836
NDR_CHECK(ndr_pull_array_size(ndr, &r->executablepath));
837
NDR_CHECK(ndr_pull_array_length(ndr, &r->executablepath));
838
if (ndr_get_array_length(ndr, &r->executablepath) > ndr_get_array_size(ndr, &r->executablepath)) {
839
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->executablepath), ndr_get_array_length(ndr, &r->executablepath));
840
}
841
if (ndr_get_array_length(ndr, &r->executablepath) > 8192) {
842
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
843
}
844
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->executablepath), sizeof(uint16_t)));
845
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->executablepath, ndr_get_array_length(ndr, &r->executablepath), sizeof(uint16_t), CH_UTF16));
846
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_executablepath_0, 0);
847
}
848
if (r->loadordergroup) {
849
_mem_save_loadordergroup_0 = NDR_PULL_GET_MEM_CTX(ndr);
850
NDR_PULL_SET_MEM_CTX(ndr, r->loadordergroup, 0);
851
NDR_CHECK(ndr_pull_array_size(ndr, &r->loadordergroup));
852
NDR_CHECK(ndr_pull_array_length(ndr, &r->loadordergroup));
853
if (ndr_get_array_length(ndr, &r->loadordergroup) > ndr_get_array_size(ndr, &r->loadordergroup)) {
854
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->loadordergroup), ndr_get_array_length(ndr, &r->loadordergroup));
855
}
856
if (ndr_get_array_length(ndr, &r->loadordergroup) > 8192) {
857
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
858
}
859
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->loadordergroup), sizeof(uint16_t)));
860
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->loadordergroup, ndr_get_array_length(ndr, &r->loadordergroup), sizeof(uint16_t), CH_UTF16));
861
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_loadordergroup_0, 0);
862
}
863
if (r->dependencies) {
864
_mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
865
NDR_PULL_SET_MEM_CTX(ndr, r->dependencies, 0);
866
NDR_CHECK(ndr_pull_array_size(ndr, &r->dependencies));
867
NDR_CHECK(ndr_pull_array_length(ndr, &r->dependencies));
868
if (ndr_get_array_length(ndr, &r->dependencies) > ndr_get_array_size(ndr, &r->dependencies)) {
869
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dependencies), ndr_get_array_length(ndr, &r->dependencies));
870
}
871
if (ndr_get_array_length(ndr, &r->dependencies) > 8192) {
872
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
873
}
874
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dependencies), sizeof(uint16_t)));
875
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dependencies, ndr_get_array_length(ndr, &r->dependencies), sizeof(uint16_t), CH_UTF16));
876
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
877
}
878
if (r->startname) {
879
_mem_save_startname_0 = NDR_PULL_GET_MEM_CTX(ndr);
880
NDR_PULL_SET_MEM_CTX(ndr, r->startname, 0);
881
NDR_CHECK(ndr_pull_array_size(ndr, &r->startname));
882
NDR_CHECK(ndr_pull_array_length(ndr, &r->startname));
883
if (ndr_get_array_length(ndr, &r->startname) > ndr_get_array_size(ndr, &r->startname)) {
884
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->startname), ndr_get_array_length(ndr, &r->startname));
885
}
886
if (ndr_get_array_length(ndr, &r->startname) > 8192) {
887
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
888
}
889
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->startname), sizeof(uint16_t)));
890
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->startname, ndr_get_array_length(ndr, &r->startname), sizeof(uint16_t), CH_UTF16));
891
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_startname_0, 0);
892
}
893
if (r->displayname) {
894
_mem_save_displayname_0 = NDR_PULL_GET_MEM_CTX(ndr);
895
NDR_PULL_SET_MEM_CTX(ndr, r->displayname, 0);
896
NDR_CHECK(ndr_pull_array_size(ndr, &r->displayname));
897
NDR_CHECK(ndr_pull_array_length(ndr, &r->displayname));
898
if (ndr_get_array_length(ndr, &r->displayname) > ndr_get_array_size(ndr, &r->displayname)) {
899
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->displayname), ndr_get_array_length(ndr, &r->displayname));
900
}
901
if (ndr_get_array_length(ndr, &r->displayname) > 8192) {
902
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
903
}
904
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->displayname), sizeof(uint16_t)));
905
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->displayname, ndr_get_array_length(ndr, &r->displayname), sizeof(uint16_t), CH_UTF16));
906
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_displayname_0, 0);
907
}
908
}
909
return NDR_ERR_SUCCESS;
910
}
911
912
_PUBLIC_ void ndr_print_QUERY_SERVICE_CONFIG(struct ndr_print *ndr, const char *name, const struct QUERY_SERVICE_CONFIG *r)
913
{
914
ndr_print_struct(ndr, name, "QUERY_SERVICE_CONFIG");
915
if (r == NULL) { ndr_print_null(ndr); return; }
916
ndr->depth++;
917
ndr_print_uint32(ndr, "service_type", r->service_type);
918
ndr_print_svcctl_StartType(ndr, "start_type", r->start_type);
919
ndr_print_svcctl_ErrorControl(ndr, "error_control", r->error_control);
920
ndr_print_ptr(ndr, "executablepath", r->executablepath);
921
ndr->depth++;
922
if (r->executablepath) {
923
ndr_print_string(ndr, "executablepath", r->executablepath);
924
}
925
ndr->depth--;
926
ndr_print_ptr(ndr, "loadordergroup", r->loadordergroup);
927
ndr->depth++;
928
if (r->loadordergroup) {
929
ndr_print_string(ndr, "loadordergroup", r->loadordergroup);
930
}
931
ndr->depth--;
932
ndr_print_uint32(ndr, "tag_id", r->tag_id);
933
ndr_print_ptr(ndr, "dependencies", r->dependencies);
934
ndr->depth++;
935
if (r->dependencies) {
936
ndr_print_string(ndr, "dependencies", r->dependencies);
937
}
938
ndr->depth--;
939
ndr_print_ptr(ndr, "startname", r->startname);
940
ndr->depth++;
941
if (r->startname) {
942
ndr_print_string(ndr, "startname", r->startname);
943
}
944
ndr->depth--;
945
ndr_print_ptr(ndr, "displayname", r->displayname);
946
ndr->depth++;
947
if (r->displayname) {
948
ndr_print_string(ndr, "displayname", r->displayname);
949
}
950
ndr->depth--;
951
ndr->depth--;
952
}
953
954
_PUBLIC_ size_t ndr_size_QUERY_SERVICE_CONFIG(const struct QUERY_SERVICE_CONFIG *r, int flags)
955
{
956
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_QUERY_SERVICE_CONFIG);
957
}
958
959
static enum ndr_err_code ndr_push_svcctl_ArgumentString(struct ndr_push *ndr, int ndr_flags, const struct svcctl_ArgumentString *r)
960
{
961
if (ndr_flags & NDR_SCALARS) {
962
NDR_CHECK(ndr_push_align(ndr, 5));
963
NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
964
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
965
}
966
if (ndr_flags & NDR_BUFFERS) {
967
if (r->string) {
968
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string, CH_UTF16)));
969
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
970
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string, CH_UTF16)));
971
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, ndr_charset_length(r->string, CH_UTF16), sizeof(uint16_t), CH_UTF16));
972
}
973
}
974
return NDR_ERR_SUCCESS;
975
}
976
977
static enum ndr_err_code ndr_pull_svcctl_ArgumentString(struct ndr_pull *ndr, int ndr_flags, struct svcctl_ArgumentString *r)
978
{
979
uint32_t _ptr_string;
980
TALLOC_CTX *_mem_save_string_0;
981
if (ndr_flags & NDR_SCALARS) {
982
NDR_CHECK(ndr_pull_align(ndr, 5));
983
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
984
if (_ptr_string) {
985
NDR_PULL_ALLOC(ndr, r->string);
986
} else {
987
r->string = NULL;
988
}
989
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
990
}
991
if (ndr_flags & NDR_BUFFERS) {
992
if (r->string) {
993
_mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
994
NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
995
NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
996
NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
997
if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
998
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string), ndr_get_array_length(ndr, &r->string));
999
}
1000
if (ndr_get_array_length(ndr, &r->string) > SC_MAX_ARGUMENT_LENGTH) {
1001
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1002
}
1003
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string), sizeof(uint16_t)));
1004
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
1005
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
1006
}
1007
}
1008
return NDR_ERR_SUCCESS;
1009
}
1010
1011
_PUBLIC_ void ndr_print_svcctl_ArgumentString(struct ndr_print *ndr, const char *name, const struct svcctl_ArgumentString *r)
1012
{
1013
ndr_print_struct(ndr, name, "svcctl_ArgumentString");
1014
if (r == NULL) { ndr_print_null(ndr); return; }
1015
ndr->depth++;
1016
ndr_print_ptr(ndr, "string", r->string);
1017
ndr->depth++;
1018
if (r->string) {
1019
ndr_print_string(ndr, "string", r->string);
1020
}
1021
ndr->depth--;
1022
ndr->depth--;
1023
}
1024
1025
static enum ndr_err_code ndr_push_svcctl_ConfigLevel(struct ndr_push *ndr, int ndr_flags, enum svcctl_ConfigLevel r)
1026
{
1027
NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1028
return NDR_ERR_SUCCESS;
1029
}
1030
1031
static enum ndr_err_code ndr_pull_svcctl_ConfigLevel(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ConfigLevel *r)
1032
{
1033
uint32_t v;
1034
NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1035
*r = v;
1036
return NDR_ERR_SUCCESS;
1037
}
1038
1039
_PUBLIC_ void ndr_print_svcctl_ConfigLevel(struct ndr_print *ndr, const char *name, enum svcctl_ConfigLevel r)
1040
{
1041
const char *val = NULL;
1042
1043
switch (r) {
1044
case SERVICE_CONFIG_DESCRIPTION: val = "SERVICE_CONFIG_DESCRIPTION"; break;
1045
case SERVICE_CONFIG_FAILURE_ACTIONS: val = "SERVICE_CONFIG_FAILURE_ACTIONS"; break;
1046
}
1047
ndr_print_enum(ndr, name, "ENUM", val, r);
1048
}
1049
1050
_PUBLIC_ enum ndr_err_code ndr_push_SERVICE_DESCRIPTION(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_DESCRIPTION *r)
1051
{
1052
if (ndr_flags & NDR_SCALARS) {
1053
NDR_CHECK(ndr_push_align(ndr, 5));
1054
{
1055
uint32_t _flags_save_string = ndr->flags;
1056
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1057
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1058
ndr->flags = _flags_save_string;
1059
}
1060
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1061
}
1062
if (ndr_flags & NDR_BUFFERS) {
1063
{
1064
uint32_t _flags_save_string = ndr->flags;
1065
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1066
if (r->description) {
1067
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
1068
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1069
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
1070
}
1071
ndr->flags = _flags_save_string;
1072
}
1073
}
1074
return NDR_ERR_SUCCESS;
1075
}
1076
1077
_PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_DESCRIPTION(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_DESCRIPTION *r)
1078
{
1079
uint32_t _ptr_description;
1080
TALLOC_CTX *_mem_save_description_0;
1081
if (ndr_flags & NDR_SCALARS) {
1082
NDR_CHECK(ndr_pull_align(ndr, 5));
1083
{
1084
uint32_t _flags_save_string = ndr->flags;
1085
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1086
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1087
if (_ptr_description) {
1088
NDR_PULL_ALLOC(ndr, r->description);
1089
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1090
} else {
1091
r->description = NULL;
1092
}
1093
ndr->flags = _flags_save_string;
1094
}
1095
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1096
}
1097
if (ndr_flags & NDR_BUFFERS) {
1098
{
1099
uint32_t _flags_save_string = ndr->flags;
1100
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1101
if (r->description) {
1102
uint32_t _relative_save_offset;
1103
_relative_save_offset = ndr->offset;
1104
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1105
_mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1106
NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1107
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1108
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1109
if (ndr->offset > ndr->relative_highest_offset) {
1110
ndr->relative_highest_offset = ndr->offset;
1111
}
1112
ndr->offset = _relative_save_offset;
1113
}
1114
ndr->flags = _flags_save_string;
1115
}
1116
}
1117
return NDR_ERR_SUCCESS;
1118
}
1119
1120
_PUBLIC_ void ndr_print_SERVICE_DESCRIPTION(struct ndr_print *ndr, const char *name, const struct SERVICE_DESCRIPTION *r)
1121
{
1122
ndr_print_struct(ndr, name, "SERVICE_DESCRIPTION");
1123
if (r == NULL) { ndr_print_null(ndr); return; }
1124
ndr->depth++;
1125
ndr_print_ptr(ndr, "description", r->description);
1126
ndr->depth++;
1127
if (r->description) {
1128
ndr_print_string(ndr, "description", r->description);
1129
}
1130
ndr->depth--;
1131
ndr->depth--;
1132
}
1133
1134
_PUBLIC_ size_t ndr_size_SERVICE_DESCRIPTION(const struct SERVICE_DESCRIPTION *r, int flags)
1135
{
1136
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_SERVICE_DESCRIPTION);
1137
}
1138
1139
static enum ndr_err_code ndr_push_SC_ACTION_TYPE(struct ndr_push *ndr, int ndr_flags, enum SC_ACTION_TYPE r)
1140
{
1141
NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1142
return NDR_ERR_SUCCESS;
1143
}
1144
1145
static enum ndr_err_code ndr_pull_SC_ACTION_TYPE(struct ndr_pull *ndr, int ndr_flags, enum SC_ACTION_TYPE *r)
1146
{
1147
uint32_t v;
1148
NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1149
*r = v;
1150
return NDR_ERR_SUCCESS;
1151
}
1152
1153
_PUBLIC_ void ndr_print_SC_ACTION_TYPE(struct ndr_print *ndr, const char *name, enum SC_ACTION_TYPE r)
1154
{
1155
const char *val = NULL;
1156
1157
switch (r) {
1158
case SC_ACTION_NONE: val = "SC_ACTION_NONE"; break;
1159
case SC_ACTION_RESTART: val = "SC_ACTION_RESTART"; break;
1160
case SC_ACTION_REBOOT: val = "SC_ACTION_REBOOT"; break;
1161
case SC_ACTION_RUN_COMMAND: val = "SC_ACTION_RUN_COMMAND"; break;
1162
}
1163
ndr_print_enum(ndr, name, "ENUM", val, r);
1164
}
1165
1166
static enum ndr_err_code ndr_push_SC_ACTION(struct ndr_push *ndr, int ndr_flags, const struct SC_ACTION *r)
1167
{
1168
if (ndr_flags & NDR_SCALARS) {
1169
NDR_CHECK(ndr_push_align(ndr, 4));
1170
NDR_CHECK(ndr_push_SC_ACTION_TYPE(ndr, NDR_SCALARS, r->type));
1171
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->delay));
1172
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1173
}
1174
if (ndr_flags & NDR_BUFFERS) {
1175
}
1176
return NDR_ERR_SUCCESS;
1177
}
1178
1179
static enum ndr_err_code ndr_pull_SC_ACTION(struct ndr_pull *ndr, int ndr_flags, struct SC_ACTION *r)
1180
{
1181
if (ndr_flags & NDR_SCALARS) {
1182
NDR_CHECK(ndr_pull_align(ndr, 4));
1183
NDR_CHECK(ndr_pull_SC_ACTION_TYPE(ndr, NDR_SCALARS, &r->type));
1184
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->delay));
1185
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1186
}
1187
if (ndr_flags & NDR_BUFFERS) {
1188
}
1189
return NDR_ERR_SUCCESS;
1190
}
1191
1192
_PUBLIC_ void ndr_print_SC_ACTION(struct ndr_print *ndr, const char *name, const struct SC_ACTION *r)
1193
{
1194
ndr_print_struct(ndr, name, "SC_ACTION");
1195
if (r == NULL) { ndr_print_null(ndr); return; }
1196
ndr->depth++;
1197
ndr_print_SC_ACTION_TYPE(ndr, "type", r->type);
1198
ndr_print_uint32(ndr, "delay", r->delay);
1199
ndr->depth--;
1200
}
1201
1202
_PUBLIC_ enum ndr_err_code ndr_push_SERVICE_FAILURE_ACTIONS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_FAILURE_ACTIONS *r)
1203
{
1204
uint32_t cntr_actions_1;
1205
if (ndr_flags & NDR_SCALARS) {
1206
NDR_CHECK(ndr_push_align(ndr, 5));
1207
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reset_period));
1208
{
1209
uint32_t _flags_save_string = ndr->flags;
1210
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1211
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->rebootmsg));
1212
ndr->flags = _flags_save_string;
1213
}
1214
{
1215
uint32_t _flags_save_string = ndr->flags;
1216
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1217
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->command));
1218
ndr->flags = _flags_save_string;
1219
}
1220
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_actions));
1221
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->actions));
1222
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1223
}
1224
if (ndr_flags & NDR_BUFFERS) {
1225
{
1226
uint32_t _flags_save_string = ndr->flags;
1227
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1228
if (r->rebootmsg) {
1229
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->rebootmsg));
1230
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->rebootmsg));
1231
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->rebootmsg));
1232
}
1233
ndr->flags = _flags_save_string;
1234
}
1235
{
1236
uint32_t _flags_save_string = ndr->flags;
1237
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1238
if (r->command) {
1239
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->command));
1240
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->command));
1241
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->command));
1242
}
1243
ndr->flags = _flags_save_string;
1244
}
1245
if (r->actions) {
1246
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->actions));
1247
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_actions));
1248
for (cntr_actions_1 = 0; cntr_actions_1 < r->num_actions; cntr_actions_1++) {
1249
NDR_CHECK(ndr_push_SC_ACTION(ndr, NDR_SCALARS, &r->actions[cntr_actions_1]));
1250
}
1251
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->actions));
1252
}
1253
}
1254
return NDR_ERR_SUCCESS;
1255
}
1256
1257
_PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_FAILURE_ACTIONS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_FAILURE_ACTIONS *r)
1258
{
1259
uint32_t _ptr_rebootmsg;
1260
TALLOC_CTX *_mem_save_rebootmsg_0;
1261
uint32_t _ptr_command;
1262
TALLOC_CTX *_mem_save_command_0;
1263
uint32_t _ptr_actions;
1264
uint32_t cntr_actions_1;
1265
TALLOC_CTX *_mem_save_actions_0;
1266
TALLOC_CTX *_mem_save_actions_1;
1267
if (ndr_flags & NDR_SCALARS) {
1268
NDR_CHECK(ndr_pull_align(ndr, 5));
1269
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reset_period));
1270
{
1271
uint32_t _flags_save_string = ndr->flags;
1272
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1273
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rebootmsg));
1274
if (_ptr_rebootmsg) {
1275
NDR_PULL_ALLOC(ndr, r->rebootmsg);
1276
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->rebootmsg, _ptr_rebootmsg));
1277
} else {
1278
r->rebootmsg = NULL;
1279
}
1280
ndr->flags = _flags_save_string;
1281
}
1282
{
1283
uint32_t _flags_save_string = ndr->flags;
1284
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1285
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_command));
1286
if (_ptr_command) {
1287
NDR_PULL_ALLOC(ndr, r->command);
1288
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->command, _ptr_command));
1289
} else {
1290
r->command = NULL;
1291
}
1292
ndr->flags = _flags_save_string;
1293
}
1294
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_actions));
1295
if (r->num_actions > 1024) {
1296
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1297
}
1298
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_actions));
1299
if (_ptr_actions) {
1300
NDR_PULL_ALLOC(ndr, r->actions);
1301
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->actions, _ptr_actions));
1302
} else {
1303
r->actions = NULL;
1304
}
1305
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1306
}
1307
if (ndr_flags & NDR_BUFFERS) {
1308
{
1309
uint32_t _flags_save_string = ndr->flags;
1310
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1311
if (r->rebootmsg) {
1312
uint32_t _relative_save_offset;
1313
_relative_save_offset = ndr->offset;
1314
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->rebootmsg));
1315
_mem_save_rebootmsg_0 = NDR_PULL_GET_MEM_CTX(ndr);
1316
NDR_PULL_SET_MEM_CTX(ndr, r->rebootmsg, 0);
1317
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->rebootmsg));
1318
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rebootmsg_0, 0);
1319
if (ndr->offset > ndr->relative_highest_offset) {
1320
ndr->relative_highest_offset = ndr->offset;
1321
}
1322
ndr->offset = _relative_save_offset;
1323
}
1324
ndr->flags = _flags_save_string;
1325
}
1326
{
1327
uint32_t _flags_save_string = ndr->flags;
1328
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1329
if (r->command) {
1330
uint32_t _relative_save_offset;
1331
_relative_save_offset = ndr->offset;
1332
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->command));
1333
_mem_save_command_0 = NDR_PULL_GET_MEM_CTX(ndr);
1334
NDR_PULL_SET_MEM_CTX(ndr, r->command, 0);
1335
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->command));
1336
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_command_0, 0);
1337
if (ndr->offset > ndr->relative_highest_offset) {
1338
ndr->relative_highest_offset = ndr->offset;
1339
}
1340
ndr->offset = _relative_save_offset;
1341
}
1342
ndr->flags = _flags_save_string;
1343
}
1344
if (r->actions) {
1345
uint32_t _relative_save_offset;
1346
_relative_save_offset = ndr->offset;
1347
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->actions));
1348
_mem_save_actions_0 = NDR_PULL_GET_MEM_CTX(ndr);
1349
NDR_PULL_SET_MEM_CTX(ndr, r->actions, 0);
1350
NDR_CHECK(ndr_pull_array_size(ndr, &r->actions));
1351
NDR_PULL_ALLOC_N(ndr, r->actions, ndr_get_array_size(ndr, &r->actions));
1352
_mem_save_actions_1 = NDR_PULL_GET_MEM_CTX(ndr);
1353
NDR_PULL_SET_MEM_CTX(ndr, r->actions, 0);
1354
for (cntr_actions_1 = 0; cntr_actions_1 < r->num_actions; cntr_actions_1++) {
1355
NDR_CHECK(ndr_pull_SC_ACTION(ndr, NDR_SCALARS, &r->actions[cntr_actions_1]));
1356
}
1357
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_actions_1, 0);
1358
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_actions_0, 0);
1359
if (ndr->offset > ndr->relative_highest_offset) {
1360
ndr->relative_highest_offset = ndr->offset;
1361
}
1362
ndr->offset = _relative_save_offset;
1363
}
1364
if (r->actions) {
1365
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->actions, r->num_actions));
1366
}
1367
}
1368
return NDR_ERR_SUCCESS;
1369
}
1370
1371
_PUBLIC_ void ndr_print_SERVICE_FAILURE_ACTIONS(struct ndr_print *ndr, const char *name, const struct SERVICE_FAILURE_ACTIONS *r)
1372
{
1373
uint32_t cntr_actions_1;
1374
ndr_print_struct(ndr, name, "SERVICE_FAILURE_ACTIONS");
1375
if (r == NULL) { ndr_print_null(ndr); return; }
1376
ndr->depth++;
1377
ndr_print_uint32(ndr, "reset_period", r->reset_period);
1378
ndr_print_ptr(ndr, "rebootmsg", r->rebootmsg);
1379
ndr->depth++;
1380
if (r->rebootmsg) {
1381
ndr_print_string(ndr, "rebootmsg", r->rebootmsg);
1382
}
1383
ndr->depth--;
1384
ndr_print_ptr(ndr, "command", r->command);
1385
ndr->depth++;
1386
if (r->command) {
1387
ndr_print_string(ndr, "command", r->command);
1388
}
1389
ndr->depth--;
1390
ndr_print_uint32(ndr, "num_actions", r->num_actions);
1391
ndr_print_ptr(ndr, "actions", r->actions);
1392
ndr->depth++;
1393
if (r->actions) {
1394
ndr->print(ndr, "%s: ARRAY(%d)", "actions", (int)r->num_actions);
1395
ndr->depth++;
1396
for (cntr_actions_1=0;cntr_actions_1<r->num_actions;cntr_actions_1++) {
1397
ndr_print_SC_ACTION(ndr, "actions", &r->actions[cntr_actions_1]);
1398
}
1399
ndr->depth--;
1400
}
1401
ndr->depth--;
1402
ndr->depth--;
1403
}
1404
1405
_PUBLIC_ size_t ndr_size_SERVICE_FAILURE_ACTIONS(const struct SERVICE_FAILURE_ACTIONS *r, int flags)
1406
{
1407
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_SERVICE_FAILURE_ACTIONS);
1408
}
1409
1410
static enum ndr_err_code ndr_push_svcctl_StatusLevel(struct ndr_push *ndr, int ndr_flags, enum svcctl_StatusLevel r)
1411
{
1412
NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1413
return NDR_ERR_SUCCESS;
1414
}
1415
1416
static enum ndr_err_code ndr_pull_svcctl_StatusLevel(struct ndr_pull *ndr, int ndr_flags, enum svcctl_StatusLevel *r)
1417
{
1418
uint32_t v;
1419
NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1420
*r = v;
1421
return NDR_ERR_SUCCESS;
1422
}
1423
1424
_PUBLIC_ void ndr_print_svcctl_StatusLevel(struct ndr_print *ndr, const char *name, enum svcctl_StatusLevel r)
1425
{
1426
const char *val = NULL;
1427
1428
switch (r) {
1429
case SVC_STATUS_PROCESS_INFO: val = "SVC_STATUS_PROCESS_INFO"; break;
1430
}
1431
ndr_print_enum(ndr, name, "ENUM", val, r);
1432
}
1433
1434
static enum ndr_err_code ndr_push_svcctl_CloseServiceHandle(struct ndr_push *ndr, int flags, const struct svcctl_CloseServiceHandle *r)
1435
{
1436
if (flags & NDR_IN) {
1437
if (r->in.handle == NULL) {
1438
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1439
}
1440
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1441
}
1442
if (flags & NDR_OUT) {
1443
if (r->out.handle == NULL) {
1444
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1445
}
1446
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1447
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1448
}
1449
return NDR_ERR_SUCCESS;
1450
}
1451
1452
static enum ndr_err_code ndr_pull_svcctl_CloseServiceHandle(struct ndr_pull *ndr, int flags, struct svcctl_CloseServiceHandle *r)
1453
{
1454
TALLOC_CTX *_mem_save_handle_0;
1455
if (flags & NDR_IN) {
1456
ZERO_STRUCT(r->out);
1457
1458
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1459
NDR_PULL_ALLOC(ndr, r->in.handle);
1460
}
1461
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1462
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1463
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1464
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1465
NDR_PULL_ALLOC(ndr, r->out.handle);
1466
*r->out.handle = *r->in.handle;
1467
}
1468
if (flags & NDR_OUT) {
1469
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1470
NDR_PULL_ALLOC(ndr, r->out.handle);
1471
}
1472
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1473
NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
1474
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1475
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1476
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1477
}
1478
return NDR_ERR_SUCCESS;
1479
}
1480
1481
_PUBLIC_ void ndr_print_svcctl_CloseServiceHandle(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CloseServiceHandle *r)
1482
{
1483
ndr_print_struct(ndr, name, "svcctl_CloseServiceHandle");
1484
if (r == NULL) { ndr_print_null(ndr); return; }
1485
ndr->depth++;
1486
if (flags & NDR_SET_VALUES) {
1487
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1488
}
1489
if (flags & NDR_IN) {
1490
ndr_print_struct(ndr, "in", "svcctl_CloseServiceHandle");
1491
ndr->depth++;
1492
ndr_print_ptr(ndr, "handle", r->in.handle);
1493
ndr->depth++;
1494
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1495
ndr->depth--;
1496
ndr->depth--;
1497
}
1498
if (flags & NDR_OUT) {
1499
ndr_print_struct(ndr, "out", "svcctl_CloseServiceHandle");
1500
ndr->depth++;
1501
ndr_print_ptr(ndr, "handle", r->out.handle);
1502
ndr->depth++;
1503
ndr_print_policy_handle(ndr, "handle", r->out.handle);
1504
ndr->depth--;
1505
ndr_print_WERROR(ndr, "result", r->out.result);
1506
ndr->depth--;
1507
}
1508
ndr->depth--;
1509
}
1510
1511
static enum ndr_err_code ndr_push_svcctl_ControlService(struct ndr_push *ndr, int flags, const struct svcctl_ControlService *r)
1512
{
1513
if (flags & NDR_IN) {
1514
if (r->in.handle == NULL) {
1515
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1516
}
1517
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1518
NDR_CHECK(ndr_push_SERVICE_CONTROL(ndr, NDR_SCALARS, r->in.control));
1519
}
1520
if (flags & NDR_OUT) {
1521
if (r->out.service_status == NULL) {
1522
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1523
}
1524
NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
1525
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1526
}
1527
return NDR_ERR_SUCCESS;
1528
}
1529
1530
static enum ndr_err_code ndr_pull_svcctl_ControlService(struct ndr_pull *ndr, int flags, struct svcctl_ControlService *r)
1531
{
1532
TALLOC_CTX *_mem_save_handle_0;
1533
TALLOC_CTX *_mem_save_service_status_0;
1534
if (flags & NDR_IN) {
1535
ZERO_STRUCT(r->out);
1536
1537
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1538
NDR_PULL_ALLOC(ndr, r->in.handle);
1539
}
1540
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1541
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1542
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1543
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1544
NDR_CHECK(ndr_pull_SERVICE_CONTROL(ndr, NDR_SCALARS, &r->in.control));
1545
NDR_PULL_ALLOC(ndr, r->out.service_status);
1546
ZERO_STRUCTP(r->out.service_status);
1547
}
1548
if (flags & NDR_OUT) {
1549
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1550
NDR_PULL_ALLOC(ndr, r->out.service_status);
1551
}
1552
_mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
1553
NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, LIBNDR_FLAG_REF_ALLOC);
1554
NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
1555
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, LIBNDR_FLAG_REF_ALLOC);
1556
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1557
}
1558
return NDR_ERR_SUCCESS;
1559
}
1560
1561
_PUBLIC_ void ndr_print_svcctl_ControlService(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ControlService *r)
1562
{
1563
ndr_print_struct(ndr, name, "svcctl_ControlService");
1564
if (r == NULL) { ndr_print_null(ndr); return; }
1565
ndr->depth++;
1566
if (flags & NDR_SET_VALUES) {
1567
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1568
}
1569
if (flags & NDR_IN) {
1570
ndr_print_struct(ndr, "in", "svcctl_ControlService");
1571
ndr->depth++;
1572
ndr_print_ptr(ndr, "handle", r->in.handle);
1573
ndr->depth++;
1574
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1575
ndr->depth--;
1576
ndr_print_SERVICE_CONTROL(ndr, "control", r->in.control);
1577
ndr->depth--;
1578
}
1579
if (flags & NDR_OUT) {
1580
ndr_print_struct(ndr, "out", "svcctl_ControlService");
1581
ndr->depth++;
1582
ndr_print_ptr(ndr, "service_status", r->out.service_status);
1583
ndr->depth++;
1584
ndr_print_SERVICE_STATUS(ndr, "service_status", r->out.service_status);
1585
ndr->depth--;
1586
ndr_print_WERROR(ndr, "result", r->out.result);
1587
ndr->depth--;
1588
}
1589
ndr->depth--;
1590
}
1591
1592
static enum ndr_err_code ndr_push_svcctl_DeleteService(struct ndr_push *ndr, int flags, const struct svcctl_DeleteService *r)
1593
{
1594
if (flags & NDR_IN) {
1595
if (r->in.handle == NULL) {
1596
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1597
}
1598
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1599
}
1600
if (flags & NDR_OUT) {
1601
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1602
}
1603
return NDR_ERR_SUCCESS;
1604
}
1605
1606
static enum ndr_err_code ndr_pull_svcctl_DeleteService(struct ndr_pull *ndr, int flags, struct svcctl_DeleteService *r)
1607
{
1608
TALLOC_CTX *_mem_save_handle_0;
1609
if (flags & NDR_IN) {
1610
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1611
NDR_PULL_ALLOC(ndr, r->in.handle);
1612
}
1613
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1614
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1615
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1616
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1617
}
1618
if (flags & NDR_OUT) {
1619
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1620
}
1621
return NDR_ERR_SUCCESS;
1622
}
1623
1624
_PUBLIC_ void ndr_print_svcctl_DeleteService(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_DeleteService *r)
1625
{
1626
ndr_print_struct(ndr, name, "svcctl_DeleteService");
1627
if (r == NULL) { ndr_print_null(ndr); return; }
1628
ndr->depth++;
1629
if (flags & NDR_SET_VALUES) {
1630
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1631
}
1632
if (flags & NDR_IN) {
1633
ndr_print_struct(ndr, "in", "svcctl_DeleteService");
1634
ndr->depth++;
1635
ndr_print_ptr(ndr, "handle", r->in.handle);
1636
ndr->depth++;
1637
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1638
ndr->depth--;
1639
ndr->depth--;
1640
}
1641
if (flags & NDR_OUT) {
1642
ndr_print_struct(ndr, "out", "svcctl_DeleteService");
1643
ndr->depth++;
1644
ndr_print_WERROR(ndr, "result", r->out.result);
1645
ndr->depth--;
1646
}
1647
ndr->depth--;
1648
}
1649
1650
static enum ndr_err_code ndr_push_svcctl_LockServiceDatabase(struct ndr_push *ndr, int flags, const struct svcctl_LockServiceDatabase *r)
1651
{
1652
if (flags & NDR_IN) {
1653
if (r->in.handle == NULL) {
1654
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1655
}
1656
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1657
}
1658
if (flags & NDR_OUT) {
1659
if (r->out.lock == NULL) {
1660
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1661
}
1662
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.lock));
1663
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1664
}
1665
return NDR_ERR_SUCCESS;
1666
}
1667
1668
static enum ndr_err_code ndr_pull_svcctl_LockServiceDatabase(struct ndr_pull *ndr, int flags, struct svcctl_LockServiceDatabase *r)
1669
{
1670
TALLOC_CTX *_mem_save_handle_0;
1671
TALLOC_CTX *_mem_save_lock_0;
1672
if (flags & NDR_IN) {
1673
ZERO_STRUCT(r->out);
1674
1675
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1676
NDR_PULL_ALLOC(ndr, r->in.handle);
1677
}
1678
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1679
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1680
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1681
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1682
NDR_PULL_ALLOC(ndr, r->out.lock);
1683
ZERO_STRUCTP(r->out.lock);
1684
}
1685
if (flags & NDR_OUT) {
1686
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1687
NDR_PULL_ALLOC(ndr, r->out.lock);
1688
}
1689
_mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);
1690
NDR_PULL_SET_MEM_CTX(ndr, r->out.lock, LIBNDR_FLAG_REF_ALLOC);
1691
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.lock));
1692
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);
1693
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1694
}
1695
return NDR_ERR_SUCCESS;
1696
}
1697
1698
_PUBLIC_ void ndr_print_svcctl_LockServiceDatabase(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_LockServiceDatabase *r)
1699
{
1700
ndr_print_struct(ndr, name, "svcctl_LockServiceDatabase");
1701
if (r == NULL) { ndr_print_null(ndr); return; }
1702
ndr->depth++;
1703
if (flags & NDR_SET_VALUES) {
1704
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1705
}
1706
if (flags & NDR_IN) {
1707
ndr_print_struct(ndr, "in", "svcctl_LockServiceDatabase");
1708
ndr->depth++;
1709
ndr_print_ptr(ndr, "handle", r->in.handle);
1710
ndr->depth++;
1711
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1712
ndr->depth--;
1713
ndr->depth--;
1714
}
1715
if (flags & NDR_OUT) {
1716
ndr_print_struct(ndr, "out", "svcctl_LockServiceDatabase");
1717
ndr->depth++;
1718
ndr_print_ptr(ndr, "lock", r->out.lock);
1719
ndr->depth++;
1720
ndr_print_policy_handle(ndr, "lock", r->out.lock);
1721
ndr->depth--;
1722
ndr_print_WERROR(ndr, "result", r->out.result);
1723
ndr->depth--;
1724
}
1725
ndr->depth--;
1726
}
1727
1728
static enum ndr_err_code ndr_push_svcctl_QueryServiceObjectSecurity(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceObjectSecurity *r)
1729
{
1730
if (flags & NDR_IN) {
1731
if (r->in.handle == NULL) {
1732
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1733
}
1734
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1735
NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.security_flags));
1736
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
1737
}
1738
if (flags & NDR_OUT) {
1739
if (r->out.buffer == NULL) {
1740
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1741
}
1742
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
1743
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
1744
if (r->out.needed == NULL) {
1745
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1746
}
1747
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
1748
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1749
}
1750
return NDR_ERR_SUCCESS;
1751
}
1752
1753
static enum ndr_err_code ndr_pull_svcctl_QueryServiceObjectSecurity(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceObjectSecurity *r)
1754
{
1755
TALLOC_CTX *_mem_save_handle_0;
1756
TALLOC_CTX *_mem_save_needed_0;
1757
if (flags & NDR_IN) {
1758
ZERO_STRUCT(r->out);
1759
1760
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1761
NDR_PULL_ALLOC(ndr, r->in.handle);
1762
}
1763
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1764
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1765
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1766
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1767
NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.security_flags));
1768
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
1769
if (r->in.offered > 0x40000) {
1770
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1771
}
1772
NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
1773
memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
1774
NDR_PULL_ALLOC(ndr, r->out.needed);
1775
ZERO_STRUCTP(r->out.needed);
1776
}
1777
if (flags & NDR_OUT) {
1778
NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
1779
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1780
NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
1781
}
1782
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
1783
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1784
NDR_PULL_ALLOC(ndr, r->out.needed);
1785
}
1786
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
1787
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
1788
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
1789
if (*r->out.needed > 0x40000) {
1790
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1791
}
1792
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
1793
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1794
if (r->out.buffer) {
1795
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
1796
}
1797
}
1798
return NDR_ERR_SUCCESS;
1799
}
1800
1801
_PUBLIC_ void ndr_print_svcctl_QueryServiceObjectSecurity(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceObjectSecurity *r)
1802
{
1803
ndr_print_struct(ndr, name, "svcctl_QueryServiceObjectSecurity");
1804
if (r == NULL) { ndr_print_null(ndr); return; }
1805
ndr->depth++;
1806
if (flags & NDR_SET_VALUES) {
1807
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1808
}
1809
if (flags & NDR_IN) {
1810
ndr_print_struct(ndr, "in", "svcctl_QueryServiceObjectSecurity");
1811
ndr->depth++;
1812
ndr_print_ptr(ndr, "handle", r->in.handle);
1813
ndr->depth++;
1814
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1815
ndr->depth--;
1816
ndr_print_security_secinfo(ndr, "security_flags", r->in.security_flags);
1817
ndr_print_uint32(ndr, "offered", r->in.offered);
1818
ndr->depth--;
1819
}
1820
if (flags & NDR_OUT) {
1821
ndr_print_struct(ndr, "out", "svcctl_QueryServiceObjectSecurity");
1822
ndr->depth++;
1823
ndr_print_ptr(ndr, "buffer", r->out.buffer);
1824
ndr->depth++;
1825
ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
1826
ndr->depth--;
1827
ndr_print_ptr(ndr, "needed", r->out.needed);
1828
ndr->depth++;
1829
ndr_print_uint32(ndr, "needed", *r->out.needed);
1830
ndr->depth--;
1831
ndr_print_WERROR(ndr, "result", r->out.result);
1832
ndr->depth--;
1833
}
1834
ndr->depth--;
1835
}
1836
1837
static enum ndr_err_code ndr_push_svcctl_SetServiceObjectSecurity(struct ndr_push *ndr, int flags, const struct svcctl_SetServiceObjectSecurity *r)
1838
{
1839
if (flags & NDR_IN) {
1840
if (r->in.handle == NULL) {
1841
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1842
}
1843
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1844
NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.security_flags));
1845
if (r->in.buffer == NULL) {
1846
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1847
}
1848
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
1849
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
1850
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
1851
}
1852
if (flags & NDR_OUT) {
1853
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1854
}
1855
return NDR_ERR_SUCCESS;
1856
}
1857
1858
static enum ndr_err_code ndr_pull_svcctl_SetServiceObjectSecurity(struct ndr_pull *ndr, int flags, struct svcctl_SetServiceObjectSecurity *r)
1859
{
1860
TALLOC_CTX *_mem_save_handle_0;
1861
if (flags & NDR_IN) {
1862
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1863
NDR_PULL_ALLOC(ndr, r->in.handle);
1864
}
1865
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1866
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1867
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1868
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1869
NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.security_flags));
1870
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
1871
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1872
NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
1873
}
1874
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
1875
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
1876
if (r->in.buffer) {
1877
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
1878
}
1879
}
1880
if (flags & NDR_OUT) {
1881
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1882
}
1883
return NDR_ERR_SUCCESS;
1884
}
1885
1886
_PUBLIC_ void ndr_print_svcctl_SetServiceObjectSecurity(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SetServiceObjectSecurity *r)
1887
{
1888
ndr_print_struct(ndr, name, "svcctl_SetServiceObjectSecurity");
1889
if (r == NULL) { ndr_print_null(ndr); return; }
1890
ndr->depth++;
1891
if (flags & NDR_SET_VALUES) {
1892
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1893
}
1894
if (flags & NDR_IN) {
1895
ndr_print_struct(ndr, "in", "svcctl_SetServiceObjectSecurity");
1896
ndr->depth++;
1897
ndr_print_ptr(ndr, "handle", r->in.handle);
1898
ndr->depth++;
1899
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1900
ndr->depth--;
1901
ndr_print_security_secinfo(ndr, "security_flags", r->in.security_flags);
1902
ndr_print_ptr(ndr, "buffer", r->in.buffer);
1903
ndr->depth++;
1904
ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
1905
ndr->depth--;
1906
ndr_print_uint32(ndr, "offered", r->in.offered);
1907
ndr->depth--;
1908
}
1909
if (flags & NDR_OUT) {
1910
ndr_print_struct(ndr, "out", "svcctl_SetServiceObjectSecurity");
1911
ndr->depth++;
1912
ndr_print_WERROR(ndr, "result", r->out.result);
1913
ndr->depth--;
1914
}
1915
ndr->depth--;
1916
}
1917
1918
static enum ndr_err_code ndr_push_svcctl_QueryServiceStatus(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceStatus *r)
1919
{
1920
if (flags & NDR_IN) {
1921
if (r->in.handle == NULL) {
1922
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1923
}
1924
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1925
}
1926
if (flags & NDR_OUT) {
1927
if (r->out.service_status == NULL) {
1928
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1929
}
1930
NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
1931
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1932
}
1933
return NDR_ERR_SUCCESS;
1934
}
1935
1936
static enum ndr_err_code ndr_pull_svcctl_QueryServiceStatus(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceStatus *r)
1937
{
1938
TALLOC_CTX *_mem_save_handle_0;
1939
TALLOC_CTX *_mem_save_service_status_0;
1940
if (flags & NDR_IN) {
1941
ZERO_STRUCT(r->out);
1942
1943
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1944
NDR_PULL_ALLOC(ndr, r->in.handle);
1945
}
1946
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1947
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1948
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1949
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1950
NDR_PULL_ALLOC(ndr, r->out.service_status);
1951
ZERO_STRUCTP(r->out.service_status);
1952
}
1953
if (flags & NDR_OUT) {
1954
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1955
NDR_PULL_ALLOC(ndr, r->out.service_status);
1956
}
1957
_mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
1958
NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, LIBNDR_FLAG_REF_ALLOC);
1959
NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
1960
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, LIBNDR_FLAG_REF_ALLOC);
1961
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1962
}
1963
return NDR_ERR_SUCCESS;
1964
}
1965
1966
_PUBLIC_ void ndr_print_svcctl_QueryServiceStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceStatus *r)
1967
{
1968
ndr_print_struct(ndr, name, "svcctl_QueryServiceStatus");
1969
if (r == NULL) { ndr_print_null(ndr); return; }
1970
ndr->depth++;
1971
if (flags & NDR_SET_VALUES) {
1972
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1973
}
1974
if (flags & NDR_IN) {
1975
ndr_print_struct(ndr, "in", "svcctl_QueryServiceStatus");
1976
ndr->depth++;
1977
ndr_print_ptr(ndr, "handle", r->in.handle);
1978
ndr->depth++;
1979
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1980
ndr->depth--;
1981
ndr->depth--;
1982
}
1983
if (flags & NDR_OUT) {
1984
ndr_print_struct(ndr, "out", "svcctl_QueryServiceStatus");
1985
ndr->depth++;
1986
ndr_print_ptr(ndr, "service_status", r->out.service_status);
1987
ndr->depth++;
1988
ndr_print_SERVICE_STATUS(ndr, "service_status", r->out.service_status);
1989
ndr->depth--;
1990
ndr_print_WERROR(ndr, "result", r->out.result);
1991
ndr->depth--;
1992
}
1993
ndr->depth--;
1994
}
1995
1996
static enum ndr_err_code ndr_push_svcctl_SetServiceStatus(struct ndr_push *ndr, int flags, const struct svcctl_SetServiceStatus *r)
1997
{
1998
if (flags & NDR_IN) {
1999
}
2000
if (flags & NDR_OUT) {
2001
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2002
}
2003
return NDR_ERR_SUCCESS;
2004
}
2005
2006
static enum ndr_err_code ndr_pull_svcctl_SetServiceStatus(struct ndr_pull *ndr, int flags, struct svcctl_SetServiceStatus *r)
2007
{
2008
if (flags & NDR_IN) {
2009
}
2010
if (flags & NDR_OUT) {
2011
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2012
}
2013
return NDR_ERR_SUCCESS;
2014
}
2015
2016
_PUBLIC_ void ndr_print_svcctl_SetServiceStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SetServiceStatus *r)
2017
{
2018
ndr_print_struct(ndr, name, "svcctl_SetServiceStatus");
2019
if (r == NULL) { ndr_print_null(ndr); return; }
2020
ndr->depth++;
2021
if (flags & NDR_SET_VALUES) {
2022
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2023
}
2024
if (flags & NDR_IN) {
2025
ndr_print_struct(ndr, "in", "svcctl_SetServiceStatus");
2026
ndr->depth++;
2027
ndr->depth--;
2028
}
2029
if (flags & NDR_OUT) {
2030
ndr_print_struct(ndr, "out", "svcctl_SetServiceStatus");
2031
ndr->depth++;
2032
ndr_print_WERROR(ndr, "result", r->out.result);
2033
ndr->depth--;
2034
}
2035
ndr->depth--;
2036
}
2037
2038
static enum ndr_err_code ndr_push_svcctl_UnlockServiceDatabase(struct ndr_push *ndr, int flags, const struct svcctl_UnlockServiceDatabase *r)
2039
{
2040
if (flags & NDR_IN) {
2041
if (r->in.lock == NULL) {
2042
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2043
}
2044
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.lock));
2045
}
2046
if (flags & NDR_OUT) {
2047
if (r->out.lock == NULL) {
2048
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2049
}
2050
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.lock));
2051
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2052
}
2053
return NDR_ERR_SUCCESS;
2054
}
2055
2056
static enum ndr_err_code ndr_pull_svcctl_UnlockServiceDatabase(struct ndr_pull *ndr, int flags, struct svcctl_UnlockServiceDatabase *r)
2057
{
2058
TALLOC_CTX *_mem_save_lock_0;
2059
if (flags & NDR_IN) {
2060
ZERO_STRUCT(r->out);
2061
2062
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2063
NDR_PULL_ALLOC(ndr, r->in.lock);
2064
}
2065
_mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);
2066
NDR_PULL_SET_MEM_CTX(ndr, r->in.lock, LIBNDR_FLAG_REF_ALLOC);
2067
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.lock));
2068
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);
2069
NDR_PULL_ALLOC(ndr, r->out.lock);
2070
*r->out.lock = *r->in.lock;
2071
}
2072
if (flags & NDR_OUT) {
2073
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2074
NDR_PULL_ALLOC(ndr, r->out.lock);
2075
}
2076
_mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);
2077
NDR_PULL_SET_MEM_CTX(ndr, r->out.lock, LIBNDR_FLAG_REF_ALLOC);
2078
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.lock));
2079
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);
2080
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2081
}
2082
return NDR_ERR_SUCCESS;
2083
}
2084
2085
_PUBLIC_ void ndr_print_svcctl_UnlockServiceDatabase(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_UnlockServiceDatabase *r)
2086
{
2087
ndr_print_struct(ndr, name, "svcctl_UnlockServiceDatabase");
2088
if (r == NULL) { ndr_print_null(ndr); return; }
2089
ndr->depth++;
2090
if (flags & NDR_SET_VALUES) {
2091
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2092
}
2093
if (flags & NDR_IN) {
2094
ndr_print_struct(ndr, "in", "svcctl_UnlockServiceDatabase");
2095
ndr->depth++;
2096
ndr_print_ptr(ndr, "lock", r->in.lock);
2097
ndr->depth++;
2098
ndr_print_policy_handle(ndr, "lock", r->in.lock);
2099
ndr->depth--;
2100
ndr->depth--;
2101
}
2102
if (flags & NDR_OUT) {
2103
ndr_print_struct(ndr, "out", "svcctl_UnlockServiceDatabase");
2104
ndr->depth++;
2105
ndr_print_ptr(ndr, "lock", r->out.lock);
2106
ndr->depth++;
2107
ndr_print_policy_handle(ndr, "lock", r->out.lock);
2108
ndr->depth--;
2109
ndr_print_WERROR(ndr, "result", r->out.result);
2110
ndr->depth--;
2111
}
2112
ndr->depth--;
2113
}
2114
2115
static enum ndr_err_code ndr_push_svcctl_NotifyBootConfigStatus(struct ndr_push *ndr, int flags, const struct svcctl_NotifyBootConfigStatus *r)
2116
{
2117
if (flags & NDR_IN) {
2118
}
2119
if (flags & NDR_OUT) {
2120
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2121
}
2122
return NDR_ERR_SUCCESS;
2123
}
2124
2125
static enum ndr_err_code ndr_pull_svcctl_NotifyBootConfigStatus(struct ndr_pull *ndr, int flags, struct svcctl_NotifyBootConfigStatus *r)
2126
{
2127
if (flags & NDR_IN) {
2128
}
2129
if (flags & NDR_OUT) {
2130
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2131
}
2132
return NDR_ERR_SUCCESS;
2133
}
2134
2135
_PUBLIC_ void ndr_print_svcctl_NotifyBootConfigStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_NotifyBootConfigStatus *r)
2136
{
2137
ndr_print_struct(ndr, name, "svcctl_NotifyBootConfigStatus");
2138
if (r == NULL) { ndr_print_null(ndr); return; }
2139
ndr->depth++;
2140
if (flags & NDR_SET_VALUES) {
2141
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2142
}
2143
if (flags & NDR_IN) {
2144
ndr_print_struct(ndr, "in", "svcctl_NotifyBootConfigStatus");
2145
ndr->depth++;
2146
ndr->depth--;
2147
}
2148
if (flags & NDR_OUT) {
2149
ndr_print_struct(ndr, "out", "svcctl_NotifyBootConfigStatus");
2150
ndr->depth++;
2151
ndr_print_WERROR(ndr, "result", r->out.result);
2152
ndr->depth--;
2153
}
2154
ndr->depth--;
2155
}
2156
2157
static enum ndr_err_code ndr_push_svcctl_SCSetServiceBitsW(struct ndr_push *ndr, int flags, const struct svcctl_SCSetServiceBitsW *r)
2158
{
2159
if (flags & NDR_IN) {
2160
if (r->in.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->in.handle));
2164
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bits));
2165
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bitson));
2166
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.immediate));
2167
}
2168
if (flags & NDR_OUT) {
2169
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2170
}
2171
return NDR_ERR_SUCCESS;
2172
}
2173
2174
static enum ndr_err_code ndr_pull_svcctl_SCSetServiceBitsW(struct ndr_pull *ndr, int flags, struct svcctl_SCSetServiceBitsW *r)
2175
{
2176
TALLOC_CTX *_mem_save_handle_0;
2177
if (flags & NDR_IN) {
2178
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2179
NDR_PULL_ALLOC(ndr, r->in.handle);
2180
}
2181
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2182
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2183
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2184
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2185
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bits));
2186
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bitson));
2187
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.immediate));
2188
}
2189
if (flags & NDR_OUT) {
2190
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2191
}
2192
return NDR_ERR_SUCCESS;
2193
}
2194
2195
_PUBLIC_ void ndr_print_svcctl_SCSetServiceBitsW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSetServiceBitsW *r)
2196
{
2197
ndr_print_struct(ndr, name, "svcctl_SCSetServiceBitsW");
2198
if (r == NULL) { ndr_print_null(ndr); return; }
2199
ndr->depth++;
2200
if (flags & NDR_SET_VALUES) {
2201
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2202
}
2203
if (flags & NDR_IN) {
2204
ndr_print_struct(ndr, "in", "svcctl_SCSetServiceBitsW");
2205
ndr->depth++;
2206
ndr_print_ptr(ndr, "handle", r->in.handle);
2207
ndr->depth++;
2208
ndr_print_policy_handle(ndr, "handle", r->in.handle);
2209
ndr->depth--;
2210
ndr_print_uint32(ndr, "bits", r->in.bits);
2211
ndr_print_uint32(ndr, "bitson", r->in.bitson);
2212
ndr_print_uint32(ndr, "immediate", r->in.immediate);
2213
ndr->depth--;
2214
}
2215
if (flags & NDR_OUT) {
2216
ndr_print_struct(ndr, "out", "svcctl_SCSetServiceBitsW");
2217
ndr->depth++;
2218
ndr_print_WERROR(ndr, "result", r->out.result);
2219
ndr->depth--;
2220
}
2221
ndr->depth--;
2222
}
2223
2224
static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfigW(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfigW *r)
2225
{
2226
if (flags & NDR_IN) {
2227
if (r->in.handle == NULL) {
2228
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2229
}
2230
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2231
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
2232
NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
2233
NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
2234
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
2235
if (r->in.binary_path) {
2236
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
2237
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2238
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
2239
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2240
}
2241
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.load_order_group));
2242
if (r->in.load_order_group) {
2243
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
2244
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2245
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
2246
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.load_order_group, ndr_charset_length(r->in.load_order_group, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2247
}
2248
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
2249
if (r->in.dependencies) {
2250
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
2251
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2252
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
2253
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2254
}
2255
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
2256
if (r->in.service_start_name) {
2257
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
2258
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2259
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
2260
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2261
}
2262
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
2263
if (r->in.password) {
2264
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
2265
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2266
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
2267
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2268
}
2269
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name));
2270
if (r->in.display_name) {
2271
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
2272
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2273
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
2274
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.display_name, ndr_charset_length(r->in.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2275
}
2276
}
2277
if (flags & NDR_OUT) {
2278
if (r->out.tag_id == NULL) {
2279
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2280
}
2281
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.tag_id));
2282
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2283
}
2284
return NDR_ERR_SUCCESS;
2285
}
2286
2287
static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfigW(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfigW *r)
2288
{
2289
uint32_t _ptr_binary_path;
2290
uint32_t _ptr_load_order_group;
2291
uint32_t _ptr_dependencies;
2292
uint32_t _ptr_service_start_name;
2293
uint32_t _ptr_password;
2294
uint32_t _ptr_display_name;
2295
TALLOC_CTX *_mem_save_handle_0;
2296
TALLOC_CTX *_mem_save_binary_path_0;
2297
TALLOC_CTX *_mem_save_load_order_group_0;
2298
TALLOC_CTX *_mem_save_tag_id_0;
2299
TALLOC_CTX *_mem_save_dependencies_0;
2300
TALLOC_CTX *_mem_save_service_start_name_0;
2301
TALLOC_CTX *_mem_save_password_0;
2302
TALLOC_CTX *_mem_save_display_name_0;
2303
if (flags & NDR_IN) {
2304
ZERO_STRUCT(r->out);
2305
2306
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2307
NDR_PULL_ALLOC(ndr, r->in.handle);
2308
}
2309
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2310
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2311
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2312
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2313
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
2314
NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
2315
NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
2316
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
2317
if (_ptr_binary_path) {
2318
NDR_PULL_ALLOC(ndr, r->in.binary_path);
2319
} else {
2320
r->in.binary_path = NULL;
2321
}
2322
if (r->in.binary_path) {
2323
_mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
2324
NDR_PULL_SET_MEM_CTX(ndr, r->in.binary_path, 0);
2325
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
2326
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
2327
if (ndr_get_array_length(ndr, &r->in.binary_path) > ndr_get_array_size(ndr, &r->in.binary_path)) {
2328
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.binary_path), ndr_get_array_length(ndr, &r->in.binary_path));
2329
}
2330
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));
2331
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t), CH_UTF16));
2332
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);
2333
}
2334
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_load_order_group));
2335
if (_ptr_load_order_group) {
2336
NDR_PULL_ALLOC(ndr, r->in.load_order_group);
2337
} else {
2338
r->in.load_order_group = NULL;
2339
}
2340
if (r->in.load_order_group) {
2341
_mem_save_load_order_group_0 = NDR_PULL_GET_MEM_CTX(ndr);
2342
NDR_PULL_SET_MEM_CTX(ndr, r->in.load_order_group, 0);
2343
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.load_order_group));
2344
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.load_order_group));
2345
if (ndr_get_array_length(ndr, &r->in.load_order_group) > ndr_get_array_size(ndr, &r->in.load_order_group)) {
2346
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.load_order_group), ndr_get_array_length(ndr, &r->in.load_order_group));
2347
}
2348
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.load_order_group), sizeof(uint16_t)));
2349
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.load_order_group, ndr_get_array_length(ndr, &r->in.load_order_group), sizeof(uint16_t), CH_UTF16));
2350
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_load_order_group_0, 0);
2351
}
2352
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
2353
if (_ptr_dependencies) {
2354
NDR_PULL_ALLOC(ndr, r->in.dependencies);
2355
} else {
2356
r->in.dependencies = NULL;
2357
}
2358
if (r->in.dependencies) {
2359
_mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
2360
NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
2361
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
2362
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dependencies));
2363
if (ndr_get_array_length(ndr, &r->in.dependencies) > ndr_get_array_size(ndr, &r->in.dependencies)) {
2364
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.dependencies), ndr_get_array_length(ndr, &r->in.dependencies));
2365
}
2366
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t)));
2367
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dependencies, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t), CH_UTF16));
2368
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
2369
}
2370
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
2371
if (_ptr_service_start_name) {
2372
NDR_PULL_ALLOC(ndr, r->in.service_start_name);
2373
} else {
2374
r->in.service_start_name = NULL;
2375
}
2376
if (r->in.service_start_name) {
2377
_mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2378
NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
2379
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
2380
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
2381
if (ndr_get_array_length(ndr, &r->in.service_start_name) > ndr_get_array_size(ndr, &r->in.service_start_name)) {
2382
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.service_start_name), ndr_get_array_length(ndr, &r->in.service_start_name));
2383
}
2384
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));
2385
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t), CH_UTF16));
2386
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
2387
}
2388
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
2389
if (_ptr_password) {
2390
NDR_PULL_ALLOC(ndr, r->in.password);
2391
} else {
2392
r->in.password = NULL;
2393
}
2394
if (r->in.password) {
2395
_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
2396
NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
2397
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
2398
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
2399
if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
2400
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.password), ndr_get_array_length(ndr, &r->in.password));
2401
}
2402
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
2403
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
2404
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
2405
}
2406
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
2407
if (_ptr_display_name) {
2408
NDR_PULL_ALLOC(ndr, r->in.display_name);
2409
} else {
2410
r->in.display_name = NULL;
2411
}
2412
if (r->in.display_name) {
2413
_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2414
NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name, 0);
2415
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.display_name));
2416
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.display_name));
2417
if (ndr_get_array_length(ndr, &r->in.display_name) > ndr_get_array_size(ndr, &r->in.display_name)) {
2418
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.display_name), ndr_get_array_length(ndr, &r->in.display_name));
2419
}
2420
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.display_name), sizeof(uint16_t)));
2421
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.display_name, ndr_get_array_length(ndr, &r->in.display_name), sizeof(uint16_t), CH_UTF16));
2422
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
2423
}
2424
NDR_PULL_ALLOC(ndr, r->out.tag_id);
2425
ZERO_STRUCTP(r->out.tag_id);
2426
}
2427
if (flags & NDR_OUT) {
2428
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2429
NDR_PULL_ALLOC(ndr, r->out.tag_id);
2430
}
2431
_mem_save_tag_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
2432
NDR_PULL_SET_MEM_CTX(ndr, r->out.tag_id, LIBNDR_FLAG_REF_ALLOC);
2433
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.tag_id));
2434
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tag_id_0, LIBNDR_FLAG_REF_ALLOC);
2435
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2436
}
2437
return NDR_ERR_SUCCESS;
2438
}
2439
2440
_PUBLIC_ void ndr_print_svcctl_ChangeServiceConfigW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfigW *r)
2441
{
2442
ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfigW");
2443
if (r == NULL) { ndr_print_null(ndr); return; }
2444
ndr->depth++;
2445
if (flags & NDR_SET_VALUES) {
2446
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2447
}
2448
if (flags & NDR_IN) {
2449
ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfigW");
2450
ndr->depth++;
2451
ndr_print_ptr(ndr, "handle", r->in.handle);
2452
ndr->depth++;
2453
ndr_print_policy_handle(ndr, "handle", r->in.handle);
2454
ndr->depth--;
2455
ndr_print_uint32(ndr, "type", r->in.type);
2456
ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
2457
ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
2458
ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
2459
ndr->depth++;
2460
if (r->in.binary_path) {
2461
ndr_print_string(ndr, "binary_path", r->in.binary_path);
2462
}
2463
ndr->depth--;
2464
ndr_print_ptr(ndr, "load_order_group", r->in.load_order_group);
2465
ndr->depth++;
2466
if (r->in.load_order_group) {
2467
ndr_print_string(ndr, "load_order_group", r->in.load_order_group);
2468
}
2469
ndr->depth--;
2470
ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
2471
ndr->depth++;
2472
if (r->in.dependencies) {
2473
ndr_print_string(ndr, "dependencies", r->in.dependencies);
2474
}
2475
ndr->depth--;
2476
ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
2477
ndr->depth++;
2478
if (r->in.service_start_name) {
2479
ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
2480
}
2481
ndr->depth--;
2482
ndr_print_ptr(ndr, "password", r->in.password);
2483
ndr->depth++;
2484
if (r->in.password) {
2485
ndr_print_string(ndr, "password", r->in.password);
2486
}
2487
ndr->depth--;
2488
ndr_print_ptr(ndr, "display_name", r->in.display_name);
2489
ndr->depth++;
2490
if (r->in.display_name) {
2491
ndr_print_string(ndr, "display_name", r->in.display_name);
2492
}
2493
ndr->depth--;
2494
ndr->depth--;
2495
}
2496
if (flags & NDR_OUT) {
2497
ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfigW");
2498
ndr->depth++;
2499
ndr_print_ptr(ndr, "tag_id", r->out.tag_id);
2500
ndr->depth++;
2501
ndr_print_uint32(ndr, "tag_id", *r->out.tag_id);
2502
ndr->depth--;
2503
ndr_print_WERROR(ndr, "result", r->out.result);
2504
ndr->depth--;
2505
}
2506
ndr->depth--;
2507
}
2508
2509
static enum ndr_err_code ndr_push_svcctl_CreateServiceW(struct ndr_push *ndr, int flags, const struct svcctl_CreateServiceW *r)
2510
{
2511
if (flags & NDR_IN) {
2512
if (r->in.scmanager_handle == NULL) {
2513
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2514
}
2515
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
2516
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
2517
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2518
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
2519
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2520
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DisplayName));
2521
if (r->in.DisplayName) {
2522
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
2523
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2524
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
2525
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DisplayName, ndr_charset_length(r->in.DisplayName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2526
}
2527
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.desired_access));
2528
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
2529
NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
2530
NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
2531
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
2532
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2533
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
2534
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2535
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.LoadOrderGroupKey));
2536
if (r->in.LoadOrderGroupKey) {
2537
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
2538
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2539
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
2540
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.LoadOrderGroupKey, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2541
}
2542
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.TagId));
2543
if (r->in.TagId) {
2544
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.TagId));
2545
}
2546
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
2547
if (r->in.dependencies) {
2548
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.dependencies_size));
2549
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.dependencies, r->in.dependencies_size));
2550
}
2551
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dependencies_size));
2552
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
2553
if (r->in.service_start_name) {
2554
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
2555
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2556
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
2557
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2558
}
2559
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
2560
if (r->in.password) {
2561
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.password_size));
2562
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.password, r->in.password_size));
2563
}
2564
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.password_size));
2565
}
2566
if (flags & NDR_OUT) {
2567
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.TagId));
2568
if (r->out.TagId) {
2569
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.TagId));
2570
}
2571
if (r->out.handle == NULL) {
2572
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2573
}
2574
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
2575
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2576
}
2577
return NDR_ERR_SUCCESS;
2578
}
2579
2580
static enum ndr_err_code ndr_pull_svcctl_CreateServiceW(struct ndr_pull *ndr, int flags, struct svcctl_CreateServiceW *r)
2581
{
2582
uint32_t _ptr_DisplayName;
2583
uint32_t _ptr_LoadOrderGroupKey;
2584
uint32_t _ptr_TagId;
2585
uint32_t _ptr_dependencies;
2586
uint32_t _ptr_service_start_name;
2587
uint32_t _ptr_password;
2588
TALLOC_CTX *_mem_save_scmanager_handle_0;
2589
TALLOC_CTX *_mem_save_DisplayName_0;
2590
TALLOC_CTX *_mem_save_LoadOrderGroupKey_0;
2591
TALLOC_CTX *_mem_save_TagId_0;
2592
TALLOC_CTX *_mem_save_dependencies_0;
2593
TALLOC_CTX *_mem_save_service_start_name_0;
2594
TALLOC_CTX *_mem_save_password_0;
2595
TALLOC_CTX *_mem_save_handle_0;
2596
if (flags & NDR_IN) {
2597
ZERO_STRUCT(r->out);
2598
2599
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2600
NDR_PULL_ALLOC(ndr, r->in.scmanager_handle);
2601
}
2602
_mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2603
NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager_handle, LIBNDR_FLAG_REF_ALLOC);
2604
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
2605
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);
2606
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
2607
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
2608
if (ndr_get_array_length(ndr, &r->in.ServiceName) > ndr_get_array_size(ndr, &r->in.ServiceName)) {
2609
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.ServiceName), ndr_get_array_length(ndr, &r->in.ServiceName));
2610
}
2611
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));
2612
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t), CH_UTF16));
2613
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DisplayName));
2614
if (_ptr_DisplayName) {
2615
NDR_PULL_ALLOC(ndr, r->in.DisplayName);
2616
} else {
2617
r->in.DisplayName = NULL;
2618
}
2619
if (r->in.DisplayName) {
2620
_mem_save_DisplayName_0 = NDR_PULL_GET_MEM_CTX(ndr);
2621
NDR_PULL_SET_MEM_CTX(ndr, r->in.DisplayName, 0);
2622
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DisplayName));
2623
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DisplayName));
2624
if (ndr_get_array_length(ndr, &r->in.DisplayName) > ndr_get_array_size(ndr, &r->in.DisplayName)) {
2625
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.DisplayName), ndr_get_array_length(ndr, &r->in.DisplayName));
2626
}
2627
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DisplayName), sizeof(uint16_t)));
2628
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DisplayName, ndr_get_array_length(ndr, &r->in.DisplayName), sizeof(uint16_t), CH_UTF16));
2629
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DisplayName_0, 0);
2630
}
2631
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.desired_access));
2632
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
2633
NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
2634
NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
2635
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
2636
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
2637
if (ndr_get_array_length(ndr, &r->in.binary_path) > ndr_get_array_size(ndr, &r->in.binary_path)) {
2638
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.binary_path), ndr_get_array_length(ndr, &r->in.binary_path));
2639
}
2640
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));
2641
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t), CH_UTF16));
2642
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_LoadOrderGroupKey));
2643
if (_ptr_LoadOrderGroupKey) {
2644
NDR_PULL_ALLOC(ndr, r->in.LoadOrderGroupKey);
2645
} else {
2646
r->in.LoadOrderGroupKey = NULL;
2647
}
2648
if (r->in.LoadOrderGroupKey) {
2649
_mem_save_LoadOrderGroupKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
2650
NDR_PULL_SET_MEM_CTX(ndr, r->in.LoadOrderGroupKey, 0);
2651
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.LoadOrderGroupKey));
2652
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.LoadOrderGroupKey));
2653
if (ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey) > ndr_get_array_size(ndr, &r->in.LoadOrderGroupKey)) {
2654
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.LoadOrderGroupKey), ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey));
2655
}
2656
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey), sizeof(uint16_t)));
2657
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.LoadOrderGroupKey, ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey), sizeof(uint16_t), CH_UTF16));
2658
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_LoadOrderGroupKey_0, 0);
2659
}
2660
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));
2661
if (_ptr_TagId) {
2662
NDR_PULL_ALLOC(ndr, r->in.TagId);
2663
} else {
2664
r->in.TagId = NULL;
2665
}
2666
if (r->in.TagId) {
2667
_mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);
2668
NDR_PULL_SET_MEM_CTX(ndr, r->in.TagId, 0);
2669
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.TagId));
2670
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);
2671
}
2672
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
2673
if (_ptr_dependencies) {
2674
NDR_PULL_ALLOC(ndr, r->in.dependencies);
2675
} else {
2676
r->in.dependencies = NULL;
2677
}
2678
if (r->in.dependencies) {
2679
_mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
2680
NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
2681
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
2682
NDR_PULL_ALLOC_N(ndr, r->in.dependencies, ndr_get_array_size(ndr, &r->in.dependencies));
2683
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.dependencies, ndr_get_array_size(ndr, &r->in.dependencies)));
2684
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
2685
}
2686
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.dependencies_size));
2687
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
2688
if (_ptr_service_start_name) {
2689
NDR_PULL_ALLOC(ndr, r->in.service_start_name);
2690
} else {
2691
r->in.service_start_name = NULL;
2692
}
2693
if (r->in.service_start_name) {
2694
_mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2695
NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
2696
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
2697
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
2698
if (ndr_get_array_length(ndr, &r->in.service_start_name) > ndr_get_array_size(ndr, &r->in.service_start_name)) {
2699
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.service_start_name), ndr_get_array_length(ndr, &r->in.service_start_name));
2700
}
2701
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));
2702
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t), CH_UTF16));
2703
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
2704
}
2705
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
2706
if (_ptr_password) {
2707
NDR_PULL_ALLOC(ndr, r->in.password);
2708
} else {
2709
r->in.password = NULL;
2710
}
2711
if (r->in.password) {
2712
_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
2713
NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
2714
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
2715
NDR_PULL_ALLOC_N(ndr, r->in.password, ndr_get_array_size(ndr, &r->in.password));
2716
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.password, ndr_get_array_size(ndr, &r->in.password)));
2717
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
2718
}
2719
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.password_size));
2720
NDR_PULL_ALLOC(ndr, r->out.handle);
2721
ZERO_STRUCTP(r->out.handle);
2722
if (r->in.dependencies) {
2723
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.dependencies, r->in.dependencies_size));
2724
}
2725
if (r->in.password) {
2726
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.password, r->in.password_size));
2727
}
2728
}
2729
if (flags & NDR_OUT) {
2730
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));
2731
if (_ptr_TagId) {
2732
NDR_PULL_ALLOC(ndr, r->out.TagId);
2733
} else {
2734
r->out.TagId = NULL;
2735
}
2736
if (r->out.TagId) {
2737
_mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);
2738
NDR_PULL_SET_MEM_CTX(ndr, r->out.TagId, 0);
2739
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.TagId));
2740
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);
2741
}
2742
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2743
NDR_PULL_ALLOC(ndr, r->out.handle);
2744
}
2745
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2746
NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
2747
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
2748
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2749
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2750
}
2751
return NDR_ERR_SUCCESS;
2752
}
2753
2754
_PUBLIC_ void ndr_print_svcctl_CreateServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CreateServiceW *r)
2755
{
2756
ndr_print_struct(ndr, name, "svcctl_CreateServiceW");
2757
if (r == NULL) { ndr_print_null(ndr); return; }
2758
ndr->depth++;
2759
if (flags & NDR_SET_VALUES) {
2760
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2761
}
2762
if (flags & NDR_IN) {
2763
ndr_print_struct(ndr, "in", "svcctl_CreateServiceW");
2764
ndr->depth++;
2765
ndr_print_ptr(ndr, "scmanager_handle", r->in.scmanager_handle);
2766
ndr->depth++;
2767
ndr_print_policy_handle(ndr, "scmanager_handle", r->in.scmanager_handle);
2768
ndr->depth--;
2769
ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
2770
ndr_print_ptr(ndr, "DisplayName", r->in.DisplayName);
2771
ndr->depth++;
2772
if (r->in.DisplayName) {
2773
ndr_print_string(ndr, "DisplayName", r->in.DisplayName);
2774
}
2775
ndr->depth--;
2776
ndr_print_uint32(ndr, "desired_access", r->in.desired_access);
2777
ndr_print_uint32(ndr, "type", r->in.type);
2778
ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
2779
ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
2780
ndr_print_string(ndr, "binary_path", r->in.binary_path);
2781
ndr_print_ptr(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
2782
ndr->depth++;
2783
if (r->in.LoadOrderGroupKey) {
2784
ndr_print_string(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
2785
}
2786
ndr->depth--;
2787
ndr_print_ptr(ndr, "TagId", r->in.TagId);
2788
ndr->depth++;
2789
if (r->in.TagId) {
2790
ndr_print_uint32(ndr, "TagId", *r->in.TagId);
2791
}
2792
ndr->depth--;
2793
ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
2794
ndr->depth++;
2795
if (r->in.dependencies) {
2796
ndr_print_array_uint8(ndr, "dependencies", r->in.dependencies, r->in.dependencies_size);
2797
}
2798
ndr->depth--;
2799
ndr_print_uint32(ndr, "dependencies_size", r->in.dependencies_size);
2800
ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
2801
ndr->depth++;
2802
if (r->in.service_start_name) {
2803
ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
2804
}
2805
ndr->depth--;
2806
ndr_print_ptr(ndr, "password", r->in.password);
2807
ndr->depth++;
2808
if (r->in.password) {
2809
ndr_print_array_uint8(ndr, "password", r->in.password, r->in.password_size);
2810
}
2811
ndr->depth--;
2812
ndr_print_uint32(ndr, "password_size", r->in.password_size);
2813
ndr->depth--;
2814
}
2815
if (flags & NDR_OUT) {
2816
ndr_print_struct(ndr, "out", "svcctl_CreateServiceW");
2817
ndr->depth++;
2818
ndr_print_ptr(ndr, "TagId", r->out.TagId);
2819
ndr->depth++;
2820
if (r->out.TagId) {
2821
ndr_print_uint32(ndr, "TagId", *r->out.TagId);
2822
}
2823
ndr->depth--;
2824
ndr_print_ptr(ndr, "handle", r->out.handle);
2825
ndr->depth++;
2826
ndr_print_policy_handle(ndr, "handle", r->out.handle);
2827
ndr->depth--;
2828
ndr_print_WERROR(ndr, "result", r->out.result);
2829
ndr->depth--;
2830
}
2831
ndr->depth--;
2832
}
2833
2834
static enum ndr_err_code ndr_push_svcctl_EnumDependentServicesW(struct ndr_push *ndr, int flags, const struct svcctl_EnumDependentServicesW *r)
2835
{
2836
if (flags & NDR_IN) {
2837
if (r->in.service == NULL) {
2838
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2839
}
2840
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.service));
2841
NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
2842
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
2843
}
2844
if (flags & NDR_OUT) {
2845
if (r->out.service_status == NULL) {
2846
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2847
}
2848
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
2849
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service_status, r->in.offered));
2850
if (r->out.needed == NULL) {
2851
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2852
}
2853
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
2854
if (r->out.services_returned == NULL) {
2855
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2856
}
2857
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
2858
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2859
}
2860
return NDR_ERR_SUCCESS;
2861
}
2862
2863
static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesW(struct ndr_pull *ndr, int flags, struct svcctl_EnumDependentServicesW *r)
2864
{
2865
TALLOC_CTX *_mem_save_service_0;
2866
TALLOC_CTX *_mem_save_needed_0;
2867
TALLOC_CTX *_mem_save_services_returned_0;
2868
if (flags & NDR_IN) {
2869
ZERO_STRUCT(r->out);
2870
2871
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2872
NDR_PULL_ALLOC(ndr, r->in.service);
2873
}
2874
_mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);
2875
NDR_PULL_SET_MEM_CTX(ndr, r->in.service, LIBNDR_FLAG_REF_ALLOC);
2876
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.service));
2877
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, LIBNDR_FLAG_REF_ALLOC);
2878
NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
2879
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
2880
if (r->in.offered > 0x40000) {
2881
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2882
}
2883
NDR_PULL_ALLOC_N(ndr, r->out.service_status, r->in.offered);
2884
memset(r->out.service_status, 0, (r->in.offered) * sizeof(*r->out.service_status));
2885
NDR_PULL_ALLOC(ndr, r->out.needed);
2886
ZERO_STRUCTP(r->out.needed);
2887
NDR_PULL_ALLOC(ndr, r->out.services_returned);
2888
ZERO_STRUCTP(r->out.services_returned);
2889
}
2890
if (flags & NDR_OUT) {
2891
NDR_CHECK(ndr_pull_array_size(ndr, &r->out.service_status));
2892
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2893
NDR_PULL_ALLOC_N(ndr, r->out.service_status, ndr_get_array_size(ndr, &r->out.service_status));
2894
}
2895
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service_status, ndr_get_array_size(ndr, &r->out.service_status)));
2896
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2897
NDR_PULL_ALLOC(ndr, r->out.needed);
2898
}
2899
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
2900
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
2901
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
2902
if (*r->out.needed > 0x40000) {
2903
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2904
}
2905
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
2906
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2907
NDR_PULL_ALLOC(ndr, r->out.services_returned);
2908
}
2909
_mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
2910
NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
2911
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
2912
if (*r->out.services_returned > 0x40000) {
2913
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2914
}
2915
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
2916
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2917
if (r->out.service_status) {
2918
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service_status, r->in.offered));
2919
}
2920
}
2921
return NDR_ERR_SUCCESS;
2922
}
2923
2924
_PUBLIC_ void ndr_print_svcctl_EnumDependentServicesW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumDependentServicesW *r)
2925
{
2926
ndr_print_struct(ndr, name, "svcctl_EnumDependentServicesW");
2927
if (r == NULL) { ndr_print_null(ndr); return; }
2928
ndr->depth++;
2929
if (flags & NDR_SET_VALUES) {
2930
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2931
}
2932
if (flags & NDR_IN) {
2933
ndr_print_struct(ndr, "in", "svcctl_EnumDependentServicesW");
2934
ndr->depth++;
2935
ndr_print_ptr(ndr, "service", r->in.service);
2936
ndr->depth++;
2937
ndr_print_policy_handle(ndr, "service", r->in.service);
2938
ndr->depth--;
2939
ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
2940
ndr_print_uint32(ndr, "offered", r->in.offered);
2941
ndr->depth--;
2942
}
2943
if (flags & NDR_OUT) {
2944
ndr_print_struct(ndr, "out", "svcctl_EnumDependentServicesW");
2945
ndr->depth++;
2946
ndr_print_ptr(ndr, "service_status", r->out.service_status);
2947
ndr->depth++;
2948
ndr_print_array_uint8(ndr, "service_status", r->out.service_status, r->in.offered);
2949
ndr->depth--;
2950
ndr_print_ptr(ndr, "needed", r->out.needed);
2951
ndr->depth++;
2952
ndr_print_uint32(ndr, "needed", *r->out.needed);
2953
ndr->depth--;
2954
ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
2955
ndr->depth++;
2956
ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
2957
ndr->depth--;
2958
ndr_print_WERROR(ndr, "result", r->out.result);
2959
ndr->depth--;
2960
}
2961
ndr->depth--;
2962
}
2963
2964
static enum ndr_err_code ndr_push_svcctl_EnumServicesStatusW(struct ndr_push *ndr, int flags, const struct svcctl_EnumServicesStatusW *r)
2965
{
2966
if (flags & NDR_IN) {
2967
if (r->in.handle == NULL) {
2968
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2969
}
2970
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2971
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
2972
NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
2973
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
2974
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
2975
if (r->in.resume_handle) {
2976
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
2977
}
2978
}
2979
if (flags & NDR_OUT) {
2980
if (r->out.service == NULL) {
2981
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2982
}
2983
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
2984
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service, r->in.offered));
2985
if (r->out.needed == NULL) {
2986
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2987
}
2988
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
2989
if (r->out.services_returned == NULL) {
2990
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2991
}
2992
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
2993
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
2994
if (r->out.resume_handle) {
2995
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
2996
}
2997
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2998
}
2999
return NDR_ERR_SUCCESS;
3000
}
3001
3002
static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusW(struct ndr_pull *ndr, int flags, struct svcctl_EnumServicesStatusW *r)
3003
{
3004
uint32_t _ptr_resume_handle;
3005
TALLOC_CTX *_mem_save_handle_0;
3006
TALLOC_CTX *_mem_save_needed_0;
3007
TALLOC_CTX *_mem_save_services_returned_0;
3008
TALLOC_CTX *_mem_save_resume_handle_0;
3009
if (flags & NDR_IN) {
3010
ZERO_STRUCT(r->out);
3011
3012
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3013
NDR_PULL_ALLOC(ndr, r->in.handle);
3014
}
3015
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3016
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3017
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3018
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3019
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
3020
NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
3021
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
3022
if (r->in.offered > 0x40000) {
3023
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3024
}
3025
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
3026
if (_ptr_resume_handle) {
3027
NDR_PULL_ALLOC(ndr, r->in.resume_handle);
3028
} else {
3029
r->in.resume_handle = NULL;
3030
}
3031
if (r->in.resume_handle) {
3032
_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3033
NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
3034
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
3035
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
3036
}
3037
NDR_PULL_ALLOC_N(ndr, r->out.service, r->in.offered);
3038
memset(r->out.service, 0, (r->in.offered) * sizeof(*r->out.service));
3039
NDR_PULL_ALLOC(ndr, r->out.needed);
3040
ZERO_STRUCTP(r->out.needed);
3041
NDR_PULL_ALLOC(ndr, r->out.services_returned);
3042
ZERO_STRUCTP(r->out.services_returned);
3043
}
3044
if (flags & NDR_OUT) {
3045
NDR_CHECK(ndr_pull_array_size(ndr, &r->out.service));
3046
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3047
NDR_PULL_ALLOC_N(ndr, r->out.service, ndr_get_array_size(ndr, &r->out.service));
3048
}
3049
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service, ndr_get_array_size(ndr, &r->out.service)));
3050
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3051
NDR_PULL_ALLOC(ndr, r->out.needed);
3052
}
3053
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
3054
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
3055
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
3056
if (*r->out.needed > 0x40000) {
3057
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3058
}
3059
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
3060
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3061
NDR_PULL_ALLOC(ndr, r->out.services_returned);
3062
}
3063
_mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
3064
NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
3065
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
3066
if (*r->out.services_returned > 0x40000) {
3067
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3068
}
3069
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
3070
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
3071
if (_ptr_resume_handle) {
3072
NDR_PULL_ALLOC(ndr, r->out.resume_handle);
3073
} else {
3074
r->out.resume_handle = NULL;
3075
}
3076
if (r->out.resume_handle) {
3077
_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3078
NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
3079
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
3080
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
3081
}
3082
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3083
if (r->out.service) {
3084
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.offered));
3085
}
3086
}
3087
return NDR_ERR_SUCCESS;
3088
}
3089
3090
_PUBLIC_ void ndr_print_svcctl_EnumServicesStatusW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServicesStatusW *r)
3091
{
3092
ndr_print_struct(ndr, name, "svcctl_EnumServicesStatusW");
3093
if (r == NULL) { ndr_print_null(ndr); return; }
3094
ndr->depth++;
3095
if (flags & NDR_SET_VALUES) {
3096
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3097
}
3098
if (flags & NDR_IN) {
3099
ndr_print_struct(ndr, "in", "svcctl_EnumServicesStatusW");
3100
ndr->depth++;
3101
ndr_print_ptr(ndr, "handle", r->in.handle);
3102
ndr->depth++;
3103
ndr_print_policy_handle(ndr, "handle", r->in.handle);
3104
ndr->depth--;
3105
ndr_print_uint32(ndr, "type", r->in.type);
3106
ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
3107
ndr_print_uint32(ndr, "offered", r->in.offered);
3108
ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
3109
ndr->depth++;
3110
if (r->in.resume_handle) {
3111
ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
3112
}
3113
ndr->depth--;
3114
ndr->depth--;
3115
}
3116
if (flags & NDR_OUT) {
3117
ndr_print_struct(ndr, "out", "svcctl_EnumServicesStatusW");
3118
ndr->depth++;
3119
ndr_print_ptr(ndr, "service", r->out.service);
3120
ndr->depth++;
3121
ndr_print_array_uint8(ndr, "service", r->out.service, r->in.offered);
3122
ndr->depth--;
3123
ndr_print_ptr(ndr, "needed", r->out.needed);
3124
ndr->depth++;
3125
ndr_print_uint32(ndr, "needed", *r->out.needed);
3126
ndr->depth--;
3127
ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
3128
ndr->depth++;
3129
ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
3130
ndr->depth--;
3131
ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
3132
ndr->depth++;
3133
if (r->out.resume_handle) {
3134
ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
3135
}
3136
ndr->depth--;
3137
ndr_print_WERROR(ndr, "result", r->out.result);
3138
ndr->depth--;
3139
}
3140
ndr->depth--;
3141
}
3142
3143
static enum ndr_err_code ndr_push_svcctl_OpenSCManagerW(struct ndr_push *ndr, int flags, const struct svcctl_OpenSCManagerW *r)
3144
{
3145
if (flags & NDR_IN) {
3146
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.MachineName));
3147
if (r->in.MachineName) {
3148
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
3149
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3150
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
3151
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.MachineName, ndr_charset_length(r->in.MachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3152
}
3153
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DatabaseName));
3154
if (r->in.DatabaseName) {
3155
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
3156
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3157
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
3158
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DatabaseName, ndr_charset_length(r->in.DatabaseName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3159
}
3160
NDR_CHECK(ndr_push_svcctl_MgrAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
3161
}
3162
if (flags & NDR_OUT) {
3163
if (r->out.handle == NULL) {
3164
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3165
}
3166
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3167
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3168
}
3169
return NDR_ERR_SUCCESS;
3170
}
3171
3172
static enum ndr_err_code ndr_pull_svcctl_OpenSCManagerW(struct ndr_pull *ndr, int flags, struct svcctl_OpenSCManagerW *r)
3173
{
3174
uint32_t _ptr_MachineName;
3175
uint32_t _ptr_DatabaseName;
3176
TALLOC_CTX *_mem_save_MachineName_0;
3177
TALLOC_CTX *_mem_save_DatabaseName_0;
3178
TALLOC_CTX *_mem_save_handle_0;
3179
if (flags & NDR_IN) {
3180
ZERO_STRUCT(r->out);
3181
3182
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_MachineName));
3183
if (_ptr_MachineName) {
3184
NDR_PULL_ALLOC(ndr, r->in.MachineName);
3185
} else {
3186
r->in.MachineName = NULL;
3187
}
3188
if (r->in.MachineName) {
3189
_mem_save_MachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
3190
NDR_PULL_SET_MEM_CTX(ndr, r->in.MachineName, 0);
3191
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.MachineName));
3192
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.MachineName));
3193
if (ndr_get_array_length(ndr, &r->in.MachineName) > ndr_get_array_size(ndr, &r->in.MachineName)) {
3194
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.MachineName), ndr_get_array_length(ndr, &r->in.MachineName));
3195
}
3196
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.MachineName), sizeof(uint16_t)));
3197
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.MachineName, ndr_get_array_length(ndr, &r->in.MachineName), sizeof(uint16_t), CH_UTF16));
3198
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_MachineName_0, 0);
3199
}
3200
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DatabaseName));
3201
if (_ptr_DatabaseName) {
3202
NDR_PULL_ALLOC(ndr, r->in.DatabaseName);
3203
} else {
3204
r->in.DatabaseName = NULL;
3205
}
3206
if (r->in.DatabaseName) {
3207
_mem_save_DatabaseName_0 = NDR_PULL_GET_MEM_CTX(ndr);
3208
NDR_PULL_SET_MEM_CTX(ndr, r->in.DatabaseName, 0);
3209
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DatabaseName));
3210
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DatabaseName));
3211
if (ndr_get_array_length(ndr, &r->in.DatabaseName) > ndr_get_array_size(ndr, &r->in.DatabaseName)) {
3212
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.DatabaseName), ndr_get_array_length(ndr, &r->in.DatabaseName));
3213
}
3214
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DatabaseName), sizeof(uint16_t)));
3215
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DatabaseName, ndr_get_array_length(ndr, &r->in.DatabaseName), sizeof(uint16_t), CH_UTF16));
3216
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DatabaseName_0, 0);
3217
}
3218
NDR_CHECK(ndr_pull_svcctl_MgrAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
3219
NDR_PULL_ALLOC(ndr, r->out.handle);
3220
ZERO_STRUCTP(r->out.handle);
3221
}
3222
if (flags & NDR_OUT) {
3223
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3224
NDR_PULL_ALLOC(ndr, r->out.handle);
3225
}
3226
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3227
NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3228
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3229
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3230
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3231
}
3232
return NDR_ERR_SUCCESS;
3233
}
3234
3235
_PUBLIC_ void ndr_print_svcctl_OpenSCManagerW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenSCManagerW *r)
3236
{
3237
ndr_print_struct(ndr, name, "svcctl_OpenSCManagerW");
3238
if (r == NULL) { ndr_print_null(ndr); return; }
3239
ndr->depth++;
3240
if (flags & NDR_SET_VALUES) {
3241
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3242
}
3243
if (flags & NDR_IN) {
3244
ndr_print_struct(ndr, "in", "svcctl_OpenSCManagerW");
3245
ndr->depth++;
3246
ndr_print_ptr(ndr, "MachineName", r->in.MachineName);
3247
ndr->depth++;
3248
if (r->in.MachineName) {
3249
ndr_print_string(ndr, "MachineName", r->in.MachineName);
3250
}
3251
ndr->depth--;
3252
ndr_print_ptr(ndr, "DatabaseName", r->in.DatabaseName);
3253
ndr->depth++;
3254
if (r->in.DatabaseName) {
3255
ndr_print_string(ndr, "DatabaseName", r->in.DatabaseName);
3256
}
3257
ndr->depth--;
3258
ndr_print_svcctl_MgrAccessMask(ndr, "access_mask", r->in.access_mask);
3259
ndr->depth--;
3260
}
3261
if (flags & NDR_OUT) {
3262
ndr_print_struct(ndr, "out", "svcctl_OpenSCManagerW");
3263
ndr->depth++;
3264
ndr_print_ptr(ndr, "handle", r->out.handle);
3265
ndr->depth++;
3266
ndr_print_policy_handle(ndr, "handle", r->out.handle);
3267
ndr->depth--;
3268
ndr_print_WERROR(ndr, "result", r->out.result);
3269
ndr->depth--;
3270
}
3271
ndr->depth--;
3272
}
3273
3274
static enum ndr_err_code ndr_push_svcctl_OpenServiceW(struct ndr_push *ndr, int flags, const struct svcctl_OpenServiceW *r)
3275
{
3276
if (flags & NDR_IN) {
3277
if (r->in.scmanager_handle == NULL) {
3278
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3279
}
3280
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
3281
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
3282
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3283
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
3284
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3285
NDR_CHECK(ndr_push_svcctl_ServiceAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
3286
}
3287
if (flags & NDR_OUT) {
3288
if (r->out.handle == NULL) {
3289
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3290
}
3291
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3292
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3293
}
3294
return NDR_ERR_SUCCESS;
3295
}
3296
3297
static enum ndr_err_code ndr_pull_svcctl_OpenServiceW(struct ndr_pull *ndr, int flags, struct svcctl_OpenServiceW *r)
3298
{
3299
TALLOC_CTX *_mem_save_scmanager_handle_0;
3300
TALLOC_CTX *_mem_save_handle_0;
3301
if (flags & NDR_IN) {
3302
ZERO_STRUCT(r->out);
3303
3304
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3305
NDR_PULL_ALLOC(ndr, r->in.scmanager_handle);
3306
}
3307
_mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3308
NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager_handle, LIBNDR_FLAG_REF_ALLOC);
3309
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
3310
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);
3311
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
3312
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
3313
if (ndr_get_array_length(ndr, &r->in.ServiceName) > ndr_get_array_size(ndr, &r->in.ServiceName)) {
3314
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.ServiceName), ndr_get_array_length(ndr, &r->in.ServiceName));
3315
}
3316
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));
3317
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t), CH_UTF16));
3318
NDR_CHECK(ndr_pull_svcctl_ServiceAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
3319
NDR_PULL_ALLOC(ndr, r->out.handle);
3320
ZERO_STRUCTP(r->out.handle);
3321
}
3322
if (flags & NDR_OUT) {
3323
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3324
NDR_PULL_ALLOC(ndr, r->out.handle);
3325
}
3326
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3327
NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3328
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3329
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3330
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3331
}
3332
return NDR_ERR_SUCCESS;
3333
}
3334
3335
_PUBLIC_ void ndr_print_svcctl_OpenServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenServiceW *r)
3336
{
3337
ndr_print_struct(ndr, name, "svcctl_OpenServiceW");
3338
if (r == NULL) { ndr_print_null(ndr); return; }
3339
ndr->depth++;
3340
if (flags & NDR_SET_VALUES) {
3341
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3342
}
3343
if (flags & NDR_IN) {
3344
ndr_print_struct(ndr, "in", "svcctl_OpenServiceW");
3345
ndr->depth++;
3346
ndr_print_ptr(ndr, "scmanager_handle", r->in.scmanager_handle);
3347
ndr->depth++;
3348
ndr_print_policy_handle(ndr, "scmanager_handle", r->in.scmanager_handle);
3349
ndr->depth--;
3350
ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
3351
ndr_print_svcctl_ServiceAccessMask(ndr, "access_mask", r->in.access_mask);
3352
ndr->depth--;
3353
}
3354
if (flags & NDR_OUT) {
3355
ndr_print_struct(ndr, "out", "svcctl_OpenServiceW");
3356
ndr->depth++;
3357
ndr_print_ptr(ndr, "handle", r->out.handle);
3358
ndr->depth++;
3359
ndr_print_policy_handle(ndr, "handle", r->out.handle);
3360
ndr->depth--;
3361
ndr_print_WERROR(ndr, "result", r->out.result);
3362
ndr->depth--;
3363
}
3364
ndr->depth--;
3365
}
3366
3367
static enum ndr_err_code ndr_push_svcctl_QueryServiceConfigW(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfigW *r)
3368
{
3369
if (flags & NDR_IN) {
3370
if (r->in.handle == NULL) {
3371
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3372
}
3373
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3374
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
3375
}
3376
if (flags & NDR_OUT) {
3377
if (r->out.query == NULL) {
3378
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3379
}
3380
NDR_CHECK(ndr_push_QUERY_SERVICE_CONFIG(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.query));
3381
if (r->out.needed == NULL) {
3382
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3383
}
3384
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
3385
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3386
}
3387
return NDR_ERR_SUCCESS;
3388
}
3389
3390
static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfigW(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfigW *r)
3391
{
3392
TALLOC_CTX *_mem_save_handle_0;
3393
TALLOC_CTX *_mem_save_query_0;
3394
TALLOC_CTX *_mem_save_needed_0;
3395
if (flags & NDR_IN) {
3396
ZERO_STRUCT(r->out);
3397
3398
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3399
NDR_PULL_ALLOC(ndr, r->in.handle);
3400
}
3401
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3402
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3403
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3404
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3405
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
3406
if (r->in.offered > 8192) {
3407
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3408
}
3409
NDR_PULL_ALLOC(ndr, r->out.query);
3410
ZERO_STRUCTP(r->out.query);
3411
NDR_PULL_ALLOC(ndr, r->out.needed);
3412
ZERO_STRUCTP(r->out.needed);
3413
}
3414
if (flags & NDR_OUT) {
3415
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3416
NDR_PULL_ALLOC(ndr, r->out.query);
3417
}
3418
_mem_save_query_0 = NDR_PULL_GET_MEM_CTX(ndr);
3419
NDR_PULL_SET_MEM_CTX(ndr, r->out.query, LIBNDR_FLAG_REF_ALLOC);
3420
NDR_CHECK(ndr_pull_QUERY_SERVICE_CONFIG(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.query));
3421
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_query_0, LIBNDR_FLAG_REF_ALLOC);
3422
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3423
NDR_PULL_ALLOC(ndr, r->out.needed);
3424
}
3425
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
3426
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
3427
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
3428
if (*r->out.needed > 8192) {
3429
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3430
}
3431
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
3432
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3433
}
3434
return NDR_ERR_SUCCESS;
3435
}
3436
3437
_PUBLIC_ void ndr_print_svcctl_QueryServiceConfigW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfigW *r)
3438
{
3439
ndr_print_struct(ndr, name, "svcctl_QueryServiceConfigW");
3440
if (r == NULL) { ndr_print_null(ndr); return; }
3441
ndr->depth++;
3442
if (flags & NDR_SET_VALUES) {
3443
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3444
}
3445
if (flags & NDR_IN) {
3446
ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfigW");
3447
ndr->depth++;
3448
ndr_print_ptr(ndr, "handle", r->in.handle);
3449
ndr->depth++;
3450
ndr_print_policy_handle(ndr, "handle", r->in.handle);
3451
ndr->depth--;
3452
ndr_print_uint32(ndr, "offered", r->in.offered);
3453
ndr->depth--;
3454
}
3455
if (flags & NDR_OUT) {
3456
ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfigW");
3457
ndr->depth++;
3458
ndr_print_ptr(ndr, "query", r->out.query);
3459
ndr->depth++;
3460
ndr_print_QUERY_SERVICE_CONFIG(ndr, "query", r->out.query);
3461
ndr->depth--;
3462
ndr_print_ptr(ndr, "needed", r->out.needed);
3463
ndr->depth++;
3464
ndr_print_uint32(ndr, "needed", *r->out.needed);
3465
ndr->depth--;
3466
ndr_print_WERROR(ndr, "result", r->out.result);
3467
ndr->depth--;
3468
}
3469
ndr->depth--;
3470
}
3471
3472
static enum ndr_err_code ndr_push_svcctl_QueryServiceLockStatusW(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceLockStatusW *r)
3473
{
3474
if (flags & NDR_IN) {
3475
if (r->in.handle == NULL) {
3476
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3477
}
3478
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3479
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
3480
}
3481
if (flags & NDR_OUT) {
3482
if (r->out.lock_status == NULL) {
3483
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3484
}
3485
NDR_CHECK(ndr_push_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
3486
if (r->out.needed == NULL) {
3487
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3488
}
3489
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
3490
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3491
}
3492
return NDR_ERR_SUCCESS;
3493
}
3494
3495
static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusW(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceLockStatusW *r)
3496
{
3497
TALLOC_CTX *_mem_save_handle_0;
3498
TALLOC_CTX *_mem_save_lock_status_0;
3499
TALLOC_CTX *_mem_save_needed_0;
3500
if (flags & NDR_IN) {
3501
ZERO_STRUCT(r->out);
3502
3503
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3504
NDR_PULL_ALLOC(ndr, r->in.handle);
3505
}
3506
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3507
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3508
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3509
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3510
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
3511
NDR_PULL_ALLOC(ndr, r->out.lock_status);
3512
ZERO_STRUCTP(r->out.lock_status);
3513
NDR_PULL_ALLOC(ndr, r->out.needed);
3514
ZERO_STRUCTP(r->out.needed);
3515
}
3516
if (flags & NDR_OUT) {
3517
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3518
NDR_PULL_ALLOC(ndr, r->out.lock_status);
3519
}
3520
_mem_save_lock_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3521
NDR_PULL_SET_MEM_CTX(ndr, r->out.lock_status, LIBNDR_FLAG_REF_ALLOC);
3522
NDR_CHECK(ndr_pull_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
3523
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_status_0, LIBNDR_FLAG_REF_ALLOC);
3524
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3525
NDR_PULL_ALLOC(ndr, r->out.needed);
3526
}
3527
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
3528
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
3529
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
3530
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
3531
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3532
}
3533
return NDR_ERR_SUCCESS;
3534
}
3535
3536
_PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceLockStatusW *r)
3537
{
3538
ndr_print_struct(ndr, name, "svcctl_QueryServiceLockStatusW");
3539
if (r == NULL) { ndr_print_null(ndr); return; }
3540
ndr->depth++;
3541
if (flags & NDR_SET_VALUES) {
3542
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3543
}
3544
if (flags & NDR_IN) {
3545
ndr_print_struct(ndr, "in", "svcctl_QueryServiceLockStatusW");
3546
ndr->depth++;
3547
ndr_print_ptr(ndr, "handle", r->in.handle);
3548
ndr->depth++;
3549
ndr_print_policy_handle(ndr, "handle", r->in.handle);
3550
ndr->depth--;
3551
ndr_print_uint32(ndr, "offered", r->in.offered);
3552
ndr->depth--;
3553
}
3554
if (flags & NDR_OUT) {
3555
ndr_print_struct(ndr, "out", "svcctl_QueryServiceLockStatusW");
3556
ndr->depth++;
3557
ndr_print_ptr(ndr, "lock_status", r->out.lock_status);
3558
ndr->depth++;
3559
ndr_print_SERVICE_LOCK_STATUS(ndr, "lock_status", r->out.lock_status);
3560
ndr->depth--;
3561
ndr_print_ptr(ndr, "needed", r->out.needed);
3562
ndr->depth++;
3563
ndr_print_uint32(ndr, "needed", *r->out.needed);
3564
ndr->depth--;
3565
ndr_print_WERROR(ndr, "result", r->out.result);
3566
ndr->depth--;
3567
}
3568
ndr->depth--;
3569
}
3570
3571
static enum ndr_err_code ndr_push_svcctl_StartServiceW(struct ndr_push *ndr, int flags, const struct svcctl_StartServiceW *r)
3572
{
3573
uint32_t cntr_Arguments_1;
3574
if (flags & NDR_IN) {
3575
if (r->in.handle == NULL) {
3576
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3577
}
3578
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3579
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.NumArgs));
3580
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Arguments));
3581
if (r->in.Arguments) {
3582
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.NumArgs));
3583
for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {
3584
NDR_CHECK(ndr_push_svcctl_ArgumentString(ndr, NDR_SCALARS, &r->in.Arguments[cntr_Arguments_1]));
3585
}
3586
for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {
3587
NDR_CHECK(ndr_push_svcctl_ArgumentString(ndr, NDR_BUFFERS, &r->in.Arguments[cntr_Arguments_1]));
3588
}
3589
}
3590
}
3591
if (flags & NDR_OUT) {
3592
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3593
}
3594
return NDR_ERR_SUCCESS;
3595
}
3596
3597
static enum ndr_err_code ndr_pull_svcctl_StartServiceW(struct ndr_pull *ndr, int flags, struct svcctl_StartServiceW *r)
3598
{
3599
uint32_t _ptr_Arguments;
3600
uint32_t cntr_Arguments_1;
3601
TALLOC_CTX *_mem_save_handle_0;
3602
TALLOC_CTX *_mem_save_Arguments_0;
3603
TALLOC_CTX *_mem_save_Arguments_1;
3604
if (flags & NDR_IN) {
3605
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3606
NDR_PULL_ALLOC(ndr, r->in.handle);
3607
}
3608
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3609
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3610
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3611
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3612
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.NumArgs));
3613
if (r->in.NumArgs > SC_MAX_ARGUMENTS) {
3614
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3615
}
3616
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Arguments));
3617
if (_ptr_Arguments) {
3618
NDR_PULL_ALLOC(ndr, r->in.Arguments);
3619
} else {
3620
r->in.Arguments = NULL;
3621
}
3622
if (r->in.Arguments) {
3623
_mem_save_Arguments_0 = NDR_PULL_GET_MEM_CTX(ndr);
3624
NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);
3625
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Arguments));
3626
NDR_PULL_ALLOC_N(ndr, r->in.Arguments, ndr_get_array_size(ndr, &r->in.Arguments));
3627
_mem_save_Arguments_1 = NDR_PULL_GET_MEM_CTX(ndr);
3628
NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);
3629
for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {
3630
NDR_CHECK(ndr_pull_svcctl_ArgumentString(ndr, NDR_SCALARS, &r->in.Arguments[cntr_Arguments_1]));
3631
}
3632
for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {
3633
NDR_CHECK(ndr_pull_svcctl_ArgumentString(ndr, NDR_BUFFERS, &r->in.Arguments[cntr_Arguments_1]));
3634
}
3635
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_1, 0);
3636
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_0, 0);
3637
}
3638
if (r->in.Arguments) {
3639
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.Arguments, r->in.NumArgs));
3640
}
3641
}
3642
if (flags & NDR_OUT) {
3643
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3644
}
3645
return NDR_ERR_SUCCESS;
3646
}
3647
3648
_PUBLIC_ void ndr_print_svcctl_StartServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_StartServiceW *r)
3649
{
3650
uint32_t cntr_Arguments_1;
3651
ndr_print_struct(ndr, name, "svcctl_StartServiceW");
3652
if (r == NULL) { ndr_print_null(ndr); return; }
3653
ndr->depth++;
3654
if (flags & NDR_SET_VALUES) {
3655
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3656
}
3657
if (flags & NDR_IN) {
3658
ndr_print_struct(ndr, "in", "svcctl_StartServiceW");
3659
ndr->depth++;
3660
ndr_print_ptr(ndr, "handle", r->in.handle);
3661
ndr->depth++;
3662
ndr_print_policy_handle(ndr, "handle", r->in.handle);
3663
ndr->depth--;
3664
ndr_print_uint32(ndr, "NumArgs", r->in.NumArgs);
3665
ndr_print_ptr(ndr, "Arguments", r->in.Arguments);
3666
ndr->depth++;
3667
if (r->in.Arguments) {
3668
ndr->print(ndr, "%s: ARRAY(%d)", "Arguments", (int)r->in.NumArgs);
3669
ndr->depth++;
3670
for (cntr_Arguments_1=0;cntr_Arguments_1<r->in.NumArgs;cntr_Arguments_1++) {
3671
ndr_print_svcctl_ArgumentString(ndr, "Arguments", &r->in.Arguments[cntr_Arguments_1]);
3672
}
3673
ndr->depth--;
3674
}
3675
ndr->depth--;
3676
ndr->depth--;
3677
}
3678
if (flags & NDR_OUT) {
3679
ndr_print_struct(ndr, "out", "svcctl_StartServiceW");
3680
ndr->depth++;
3681
ndr_print_WERROR(ndr, "result", r->out.result);
3682
ndr->depth--;
3683
}
3684
ndr->depth--;
3685
}
3686
3687
static enum ndr_err_code ndr_push_svcctl_GetServiceDisplayNameW(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceDisplayNameW *r)
3688
{
3689
if (flags & NDR_IN) {
3690
if (r->in.handle == NULL) {
3691
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3692
}
3693
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3694
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
3695
if (r->in.service_name) {
3696
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
3697
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3698
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
3699
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3700
}
3701
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
3702
if (r->in.display_name_length) {
3703
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
3704
}
3705
}
3706
if (flags & NDR_OUT) {
3707
if (r->out.display_name == NULL) {
3708
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3709
}
3710
NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.display_name));
3711
if (*r->out.display_name) {
3712
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
3713
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3714
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
3715
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.display_name, ndr_charset_length(*r->out.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3716
}
3717
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
3718
if (r->out.display_name_length) {
3719
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
3720
}
3721
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3722
}
3723
return NDR_ERR_SUCCESS;
3724
}
3725
3726
static enum ndr_err_code ndr_pull_svcctl_GetServiceDisplayNameW(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceDisplayNameW *r)
3727
{
3728
uint32_t _ptr_service_name;
3729
uint32_t _ptr_display_name;
3730
uint32_t _ptr_display_name_length;
3731
TALLOC_CTX *_mem_save_handle_0;
3732
TALLOC_CTX *_mem_save_service_name_0;
3733
TALLOC_CTX *_mem_save_display_name_0;
3734
TALLOC_CTX *_mem_save_display_name_1;
3735
TALLOC_CTX *_mem_save_display_name_length_0;
3736
if (flags & NDR_IN) {
3737
ZERO_STRUCT(r->out);
3738
3739
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3740
NDR_PULL_ALLOC(ndr, r->in.handle);
3741
}
3742
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3743
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3744
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3745
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3746
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
3747
if (_ptr_service_name) {
3748
NDR_PULL_ALLOC(ndr, r->in.service_name);
3749
} else {
3750
r->in.service_name = NULL;
3751
}
3752
if (r->in.service_name) {
3753
_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3754
NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
3755
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
3756
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
3757
if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {
3758
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.service_name), ndr_get_array_length(ndr, &r->in.service_name));
3759
}
3760
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));
3761
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));
3762
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
3763
}
3764
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
3765
if (_ptr_display_name_length) {
3766
NDR_PULL_ALLOC(ndr, r->in.display_name_length);
3767
} else {
3768
r->in.display_name_length = NULL;
3769
}
3770
if (r->in.display_name_length) {
3771
_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
3772
NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
3773
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
3774
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
3775
}
3776
NDR_PULL_ALLOC(ndr, r->out.display_name);
3777
ZERO_STRUCTP(r->out.display_name);
3778
}
3779
if (flags & NDR_OUT) {
3780
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3781
NDR_PULL_ALLOC(ndr, r->out.display_name);
3782
}
3783
_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3784
NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name, LIBNDR_FLAG_REF_ALLOC);
3785
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
3786
if (_ptr_display_name) {
3787
NDR_PULL_ALLOC(ndr, *r->out.display_name);
3788
} else {
3789
*r->out.display_name = NULL;
3790
}
3791
if (*r->out.display_name) {
3792
_mem_save_display_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
3793
NDR_PULL_SET_MEM_CTX(ndr, *r->out.display_name, 0);
3794
NDR_CHECK(ndr_pull_array_size(ndr, r->out.display_name));
3795
NDR_CHECK(ndr_pull_array_length(ndr, r->out.display_name));
3796
if (ndr_get_array_length(ndr, r->out.display_name) > ndr_get_array_size(ndr, r->out.display_name)) {
3797
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.display_name), ndr_get_array_length(ndr, r->out.display_name));
3798
}
3799
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t)));
3800
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.display_name, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t), CH_UTF16));
3801
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_1, 0);
3802
}
3803
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, LIBNDR_FLAG_REF_ALLOC);
3804
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
3805
if (_ptr_display_name_length) {
3806
NDR_PULL_ALLOC(ndr, r->out.display_name_length);
3807
} else {
3808
r->out.display_name_length = NULL;
3809
}
3810
if (r->out.display_name_length) {
3811
_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
3812
NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
3813
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
3814
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
3815
}
3816
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3817
}
3818
return NDR_ERR_SUCCESS;
3819
}
3820
3821
_PUBLIC_ void ndr_print_svcctl_GetServiceDisplayNameW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceDisplayNameW *r)
3822
{
3823
ndr_print_struct(ndr, name, "svcctl_GetServiceDisplayNameW");
3824
if (r == NULL) { ndr_print_null(ndr); return; }
3825
ndr->depth++;
3826
if (flags & NDR_SET_VALUES) {
3827
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3828
}
3829
if (flags & NDR_IN) {
3830
ndr_print_struct(ndr, "in", "svcctl_GetServiceDisplayNameW");
3831
ndr->depth++;
3832
ndr_print_ptr(ndr, "handle", r->in.handle);
3833
ndr->depth++;
3834
ndr_print_policy_handle(ndr, "handle", r->in.handle);
3835
ndr->depth--;
3836
ndr_print_ptr(ndr, "service_name", r->in.service_name);
3837
ndr->depth++;
3838
if (r->in.service_name) {
3839
ndr_print_string(ndr, "service_name", r->in.service_name);
3840
}
3841
ndr->depth--;
3842
ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
3843
ndr->depth++;
3844
if (r->in.display_name_length) {
3845
ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
3846
}
3847
ndr->depth--;
3848
ndr->depth--;
3849
}
3850
if (flags & NDR_OUT) {
3851
ndr_print_struct(ndr, "out", "svcctl_GetServiceDisplayNameW");
3852
ndr->depth++;
3853
ndr_print_ptr(ndr, "display_name", r->out.display_name);
3854
ndr->depth++;
3855
ndr_print_ptr(ndr, "display_name", *r->out.display_name);
3856
ndr->depth++;
3857
if (*r->out.display_name) {
3858
ndr_print_string(ndr, "display_name", *r->out.display_name);
3859
}
3860
ndr->depth--;
3861
ndr->depth--;
3862
ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
3863
ndr->depth++;
3864
if (r->out.display_name_length) {
3865
ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
3866
}
3867
ndr->depth--;
3868
ndr_print_WERROR(ndr, "result", r->out.result);
3869
ndr->depth--;
3870
}
3871
ndr->depth--;
3872
}
3873
3874
static enum ndr_err_code ndr_push_svcctl_GetServiceKeyNameW(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceKeyNameW *r)
3875
{
3876
if (flags & NDR_IN) {
3877
if (r->in.handle == NULL) {
3878
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3879
}
3880
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3881
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
3882
if (r->in.service_name) {
3883
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
3884
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3885
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
3886
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3887
}
3888
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
3889
if (r->in.display_name_length) {
3890
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
3891
}
3892
}
3893
if (flags & NDR_OUT) {
3894
if (r->out.key_name == NULL) {
3895
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3896
}
3897
NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_name));
3898
if (*r->out.key_name) {
3899
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
3900
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3901
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
3902
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.key_name, ndr_charset_length(*r->out.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3903
}
3904
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
3905
if (r->out.display_name_length) {
3906
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
3907
}
3908
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3909
}
3910
return NDR_ERR_SUCCESS;
3911
}
3912
3913
static enum ndr_err_code ndr_pull_svcctl_GetServiceKeyNameW(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceKeyNameW *r)
3914
{
3915
uint32_t _ptr_service_name;
3916
uint32_t _ptr_key_name;
3917
uint32_t _ptr_display_name_length;
3918
TALLOC_CTX *_mem_save_handle_0;
3919
TALLOC_CTX *_mem_save_service_name_0;
3920
TALLOC_CTX *_mem_save_key_name_0;
3921
TALLOC_CTX *_mem_save_key_name_1;
3922
TALLOC_CTX *_mem_save_display_name_length_0;
3923
if (flags & NDR_IN) {
3924
ZERO_STRUCT(r->out);
3925
3926
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3927
NDR_PULL_ALLOC(ndr, r->in.handle);
3928
}
3929
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3930
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3931
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3932
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3933
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
3934
if (_ptr_service_name) {
3935
NDR_PULL_ALLOC(ndr, r->in.service_name);
3936
} else {
3937
r->in.service_name = NULL;
3938
}
3939
if (r->in.service_name) {
3940
_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3941
NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
3942
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
3943
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
3944
if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {
3945
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.service_name), ndr_get_array_length(ndr, &r->in.service_name));
3946
}
3947
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));
3948
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));
3949
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
3950
}
3951
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
3952
if (_ptr_display_name_length) {
3953
NDR_PULL_ALLOC(ndr, r->in.display_name_length);
3954
} else {
3955
r->in.display_name_length = NULL;
3956
}
3957
if (r->in.display_name_length) {
3958
_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
3959
NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
3960
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
3961
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
3962
}
3963
NDR_PULL_ALLOC(ndr, r->out.key_name);
3964
ZERO_STRUCTP(r->out.key_name);
3965
}
3966
if (flags & NDR_OUT) {
3967
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3968
NDR_PULL_ALLOC(ndr, r->out.key_name);
3969
}
3970
_mem_save_key_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3971
NDR_PULL_SET_MEM_CTX(ndr, r->out.key_name, LIBNDR_FLAG_REF_ALLOC);
3972
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_name));
3973
if (_ptr_key_name) {
3974
NDR_PULL_ALLOC(ndr, *r->out.key_name);
3975
} else {
3976
*r->out.key_name = NULL;
3977
}
3978
if (*r->out.key_name) {
3979
_mem_save_key_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
3980
NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_name, 0);
3981
NDR_CHECK(ndr_pull_array_size(ndr, r->out.key_name));
3982
NDR_CHECK(ndr_pull_array_length(ndr, r->out.key_name));
3983
if (ndr_get_array_length(ndr, r->out.key_name) > ndr_get_array_size(ndr, r->out.key_name)) {
3984
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.key_name), ndr_get_array_length(ndr, r->out.key_name));
3985
}
3986
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t)));
3987
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.key_name, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t), CH_UTF16));
3988
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_1, 0);
3989
}
3990
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_0, LIBNDR_FLAG_REF_ALLOC);
3991
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
3992
if (_ptr_display_name_length) {
3993
NDR_PULL_ALLOC(ndr, r->out.display_name_length);
3994
} else {
3995
r->out.display_name_length = NULL;
3996
}
3997
if (r->out.display_name_length) {
3998
_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
3999
NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
4000
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
4001
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
4002
}
4003
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4004
}
4005
return NDR_ERR_SUCCESS;
4006
}
4007
4008
_PUBLIC_ void ndr_print_svcctl_GetServiceKeyNameW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceKeyNameW *r)
4009
{
4010
ndr_print_struct(ndr, name, "svcctl_GetServiceKeyNameW");
4011
if (r == NULL) { ndr_print_null(ndr); return; }
4012
ndr->depth++;
4013
if (flags & NDR_SET_VALUES) {
4014
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4015
}
4016
if (flags & NDR_IN) {
4017
ndr_print_struct(ndr, "in", "svcctl_GetServiceKeyNameW");
4018
ndr->depth++;
4019
ndr_print_ptr(ndr, "handle", r->in.handle);
4020
ndr->depth++;
4021
ndr_print_policy_handle(ndr, "handle", r->in.handle);
4022
ndr->depth--;
4023
ndr_print_ptr(ndr, "service_name", r->in.service_name);
4024
ndr->depth++;
4025
if (r->in.service_name) {
4026
ndr_print_string(ndr, "service_name", r->in.service_name);
4027
}
4028
ndr->depth--;
4029
ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
4030
ndr->depth++;
4031
if (r->in.display_name_length) {
4032
ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
4033
}
4034
ndr->depth--;
4035
ndr->depth--;
4036
}
4037
if (flags & NDR_OUT) {
4038
ndr_print_struct(ndr, "out", "svcctl_GetServiceKeyNameW");
4039
ndr->depth++;
4040
ndr_print_ptr(ndr, "key_name", r->out.key_name);
4041
ndr->depth++;
4042
ndr_print_ptr(ndr, "key_name", *r->out.key_name);
4043
ndr->depth++;
4044
if (*r->out.key_name) {
4045
ndr_print_string(ndr, "key_name", *r->out.key_name);
4046
}
4047
ndr->depth--;
4048
ndr->depth--;
4049
ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
4050
ndr->depth++;
4051
if (r->out.display_name_length) {
4052
ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
4053
}
4054
ndr->depth--;
4055
ndr_print_WERROR(ndr, "result", r->out.result);
4056
ndr->depth--;
4057
}
4058
ndr->depth--;
4059
}
4060
4061
static enum ndr_err_code ndr_push_svcctl_SCSetServiceBitsA(struct ndr_push *ndr, int flags, const struct svcctl_SCSetServiceBitsA *r)
4062
{
4063
if (flags & NDR_IN) {
4064
if (r->in.handle == NULL) {
4065
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4066
}
4067
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4068
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bits));
4069
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bitson));
4070
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.immediate));
4071
}
4072
if (flags & NDR_OUT) {
4073
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4074
}
4075
return NDR_ERR_SUCCESS;
4076
}
4077
4078
static enum ndr_err_code ndr_pull_svcctl_SCSetServiceBitsA(struct ndr_pull *ndr, int flags, struct svcctl_SCSetServiceBitsA *r)
4079
{
4080
TALLOC_CTX *_mem_save_handle_0;
4081
if (flags & NDR_IN) {
4082
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4083
NDR_PULL_ALLOC(ndr, r->in.handle);
4084
}
4085
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4086
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4087
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4088
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4089
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bits));
4090
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bitson));
4091
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.immediate));
4092
}
4093
if (flags & NDR_OUT) {
4094
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4095
}
4096
return NDR_ERR_SUCCESS;
4097
}
4098
4099
_PUBLIC_ void ndr_print_svcctl_SCSetServiceBitsA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSetServiceBitsA *r)
4100
{
4101
ndr_print_struct(ndr, name, "svcctl_SCSetServiceBitsA");
4102
if (r == NULL) { ndr_print_null(ndr); return; }
4103
ndr->depth++;
4104
if (flags & NDR_SET_VALUES) {
4105
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4106
}
4107
if (flags & NDR_IN) {
4108
ndr_print_struct(ndr, "in", "svcctl_SCSetServiceBitsA");
4109
ndr->depth++;
4110
ndr_print_ptr(ndr, "handle", r->in.handle);
4111
ndr->depth++;
4112
ndr_print_policy_handle(ndr, "handle", r->in.handle);
4113
ndr->depth--;
4114
ndr_print_uint32(ndr, "bits", r->in.bits);
4115
ndr_print_uint32(ndr, "bitson", r->in.bitson);
4116
ndr_print_uint32(ndr, "immediate", r->in.immediate);
4117
ndr->depth--;
4118
}
4119
if (flags & NDR_OUT) {
4120
ndr_print_struct(ndr, "out", "svcctl_SCSetServiceBitsA");
4121
ndr->depth++;
4122
ndr_print_WERROR(ndr, "result", r->out.result);
4123
ndr->depth--;
4124
}
4125
ndr->depth--;
4126
}
4127
4128
static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfigA(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfigA *r)
4129
{
4130
if (flags & NDR_IN) {
4131
if (r->in.handle == NULL) {
4132
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4133
}
4134
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4135
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
4136
NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
4137
NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
4138
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
4139
if (r->in.binary_path) {
4140
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
4141
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4142
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
4143
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4144
}
4145
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.load_order_group));
4146
if (r->in.load_order_group) {
4147
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
4148
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4149
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
4150
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.load_order_group, ndr_charset_length(r->in.load_order_group, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4151
}
4152
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
4153
if (r->in.dependencies) {
4154
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
4155
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4156
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
4157
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4158
}
4159
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
4160
if (r->in.service_start_name) {
4161
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
4162
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4163
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
4164
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4165
}
4166
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
4167
if (r->in.password) {
4168
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
4169
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4170
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
4171
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4172
}
4173
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name));
4174
if (r->in.display_name) {
4175
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
4176
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4177
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
4178
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.display_name, ndr_charset_length(r->in.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4179
}
4180
}
4181
if (flags & NDR_OUT) {
4182
if (r->out.tag_id == NULL) {
4183
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4184
}
4185
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.tag_id));
4186
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4187
}
4188
return NDR_ERR_SUCCESS;
4189
}
4190
4191
static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfigA(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfigA *r)
4192
{
4193
uint32_t _ptr_binary_path;
4194
uint32_t _ptr_load_order_group;
4195
uint32_t _ptr_dependencies;
4196
uint32_t _ptr_service_start_name;
4197
uint32_t _ptr_password;
4198
uint32_t _ptr_display_name;
4199
TALLOC_CTX *_mem_save_handle_0;
4200
TALLOC_CTX *_mem_save_binary_path_0;
4201
TALLOC_CTX *_mem_save_load_order_group_0;
4202
TALLOC_CTX *_mem_save_tag_id_0;
4203
TALLOC_CTX *_mem_save_dependencies_0;
4204
TALLOC_CTX *_mem_save_service_start_name_0;
4205
TALLOC_CTX *_mem_save_password_0;
4206
TALLOC_CTX *_mem_save_display_name_0;
4207
if (flags & NDR_IN) {
4208
ZERO_STRUCT(r->out);
4209
4210
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4211
NDR_PULL_ALLOC(ndr, r->in.handle);
4212
}
4213
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4214
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4215
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4216
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4217
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
4218
NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
4219
NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
4220
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
4221
if (_ptr_binary_path) {
4222
NDR_PULL_ALLOC(ndr, r->in.binary_path);
4223
} else {
4224
r->in.binary_path = NULL;
4225
}
4226
if (r->in.binary_path) {
4227
_mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4228
NDR_PULL_SET_MEM_CTX(ndr, r->in.binary_path, 0);
4229
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
4230
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
4231
if (ndr_get_array_length(ndr, &r->in.binary_path) > ndr_get_array_size(ndr, &r->in.binary_path)) {
4232
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.binary_path), ndr_get_array_length(ndr, &r->in.binary_path));
4233
}
4234
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));
4235
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t), CH_UTF16));
4236
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);
4237
}
4238
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_load_order_group));
4239
if (_ptr_load_order_group) {
4240
NDR_PULL_ALLOC(ndr, r->in.load_order_group);
4241
} else {
4242
r->in.load_order_group = NULL;
4243
}
4244
if (r->in.load_order_group) {
4245
_mem_save_load_order_group_0 = NDR_PULL_GET_MEM_CTX(ndr);
4246
NDR_PULL_SET_MEM_CTX(ndr, r->in.load_order_group, 0);
4247
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.load_order_group));
4248
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.load_order_group));
4249
if (ndr_get_array_length(ndr, &r->in.load_order_group) > ndr_get_array_size(ndr, &r->in.load_order_group)) {
4250
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.load_order_group), ndr_get_array_length(ndr, &r->in.load_order_group));
4251
}
4252
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.load_order_group), sizeof(uint16_t)));
4253
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.load_order_group, ndr_get_array_length(ndr, &r->in.load_order_group), sizeof(uint16_t), CH_UTF16));
4254
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_load_order_group_0, 0);
4255
}
4256
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
4257
if (_ptr_dependencies) {
4258
NDR_PULL_ALLOC(ndr, r->in.dependencies);
4259
} else {
4260
r->in.dependencies = NULL;
4261
}
4262
if (r->in.dependencies) {
4263
_mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
4264
NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
4265
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
4266
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dependencies));
4267
if (ndr_get_array_length(ndr, &r->in.dependencies) > ndr_get_array_size(ndr, &r->in.dependencies)) {
4268
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.dependencies), ndr_get_array_length(ndr, &r->in.dependencies));
4269
}
4270
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t)));
4271
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dependencies, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t), CH_UTF16));
4272
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
4273
}
4274
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
4275
if (_ptr_service_start_name) {
4276
NDR_PULL_ALLOC(ndr, r->in.service_start_name);
4277
} else {
4278
r->in.service_start_name = NULL;
4279
}
4280
if (r->in.service_start_name) {
4281
_mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4282
NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
4283
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
4284
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
4285
if (ndr_get_array_length(ndr, &r->in.service_start_name) > ndr_get_array_size(ndr, &r->in.service_start_name)) {
4286
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.service_start_name), ndr_get_array_length(ndr, &r->in.service_start_name));
4287
}
4288
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));
4289
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t), CH_UTF16));
4290
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
4291
}
4292
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4293
if (_ptr_password) {
4294
NDR_PULL_ALLOC(ndr, r->in.password);
4295
} else {
4296
r->in.password = NULL;
4297
}
4298
if (r->in.password) {
4299
_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4300
NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
4301
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
4302
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
4303
if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
4304
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.password), ndr_get_array_length(ndr, &r->in.password));
4305
}
4306
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
4307
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
4308
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4309
}
4310
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
4311
if (_ptr_display_name) {
4312
NDR_PULL_ALLOC(ndr, r->in.display_name);
4313
} else {
4314
r->in.display_name = NULL;
4315
}
4316
if (r->in.display_name) {
4317
_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4318
NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name, 0);
4319
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.display_name));
4320
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.display_name));
4321
if (ndr_get_array_length(ndr, &r->in.display_name) > ndr_get_array_size(ndr, &r->in.display_name)) {
4322
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.display_name), ndr_get_array_length(ndr, &r->in.display_name));
4323
}
4324
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.display_name), sizeof(uint16_t)));
4325
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.display_name, ndr_get_array_length(ndr, &r->in.display_name), sizeof(uint16_t), CH_UTF16));
4326
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
4327
}
4328
NDR_PULL_ALLOC(ndr, r->out.tag_id);
4329
ZERO_STRUCTP(r->out.tag_id);
4330
}
4331
if (flags & NDR_OUT) {
4332
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4333
NDR_PULL_ALLOC(ndr, r->out.tag_id);
4334
}
4335
_mem_save_tag_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
4336
NDR_PULL_SET_MEM_CTX(ndr, r->out.tag_id, LIBNDR_FLAG_REF_ALLOC);
4337
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.tag_id));
4338
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tag_id_0, LIBNDR_FLAG_REF_ALLOC);
4339
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4340
}
4341
return NDR_ERR_SUCCESS;
4342
}
4343
4344
_PUBLIC_ void ndr_print_svcctl_ChangeServiceConfigA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfigA *r)
4345
{
4346
ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfigA");
4347
if (r == NULL) { ndr_print_null(ndr); return; }
4348
ndr->depth++;
4349
if (flags & NDR_SET_VALUES) {
4350
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4351
}
4352
if (flags & NDR_IN) {
4353
ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfigA");
4354
ndr->depth++;
4355
ndr_print_ptr(ndr, "handle", r->in.handle);
4356
ndr->depth++;
4357
ndr_print_policy_handle(ndr, "handle", r->in.handle);
4358
ndr->depth--;
4359
ndr_print_uint32(ndr, "type", r->in.type);
4360
ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
4361
ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
4362
ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
4363
ndr->depth++;
4364
if (r->in.binary_path) {
4365
ndr_print_string(ndr, "binary_path", r->in.binary_path);
4366
}
4367
ndr->depth--;
4368
ndr_print_ptr(ndr, "load_order_group", r->in.load_order_group);
4369
ndr->depth++;
4370
if (r->in.load_order_group) {
4371
ndr_print_string(ndr, "load_order_group", r->in.load_order_group);
4372
}
4373
ndr->depth--;
4374
ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
4375
ndr->depth++;
4376
if (r->in.dependencies) {
4377
ndr_print_string(ndr, "dependencies", r->in.dependencies);
4378
}
4379
ndr->depth--;
4380
ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
4381
ndr->depth++;
4382
if (r->in.service_start_name) {
4383
ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
4384
}
4385
ndr->depth--;
4386
ndr_print_ptr(ndr, "password", r->in.password);
4387
ndr->depth++;
4388
if (r->in.password) {
4389
ndr_print_string(ndr, "password", r->in.password);
4390
}
4391
ndr->depth--;
4392
ndr_print_ptr(ndr, "display_name", r->in.display_name);
4393
ndr->depth++;
4394
if (r->in.display_name) {
4395
ndr_print_string(ndr, "display_name", r->in.display_name);
4396
}
4397
ndr->depth--;
4398
ndr->depth--;
4399
}
4400
if (flags & NDR_OUT) {
4401
ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfigA");
4402
ndr->depth++;
4403
ndr_print_ptr(ndr, "tag_id", r->out.tag_id);
4404
ndr->depth++;
4405
ndr_print_uint32(ndr, "tag_id", *r->out.tag_id);
4406
ndr->depth--;
4407
ndr_print_WERROR(ndr, "result", r->out.result);
4408
ndr->depth--;
4409
}
4410
ndr->depth--;
4411
}
4412
4413
static enum ndr_err_code ndr_push_svcctl_CreateServiceA(struct ndr_push *ndr, int flags, const struct svcctl_CreateServiceA *r)
4414
{
4415
if (flags & NDR_IN) {
4416
if (r->in.handle == NULL) {
4417
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4418
}
4419
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4420
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ServiceName));
4421
if (r->in.ServiceName) {
4422
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
4423
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4424
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
4425
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4426
}
4427
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DisplayName));
4428
if (r->in.DisplayName) {
4429
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
4430
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4431
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
4432
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DisplayName, ndr_charset_length(r->in.DisplayName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4433
}
4434
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.desired_access));
4435
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
4436
NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
4437
NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
4438
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
4439
if (r->in.binary_path) {
4440
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
4441
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4442
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
4443
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4444
}
4445
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.LoadOrderGroupKey));
4446
if (r->in.LoadOrderGroupKey) {
4447
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
4448
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4449
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
4450
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.LoadOrderGroupKey, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4451
}
4452
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
4453
if (r->in.dependencies) {
4454
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
4455
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4456
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
4457
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4458
}
4459
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
4460
if (r->in.service_start_name) {
4461
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
4462
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4463
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
4464
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4465
}
4466
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
4467
if (r->in.password) {
4468
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
4469
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4470
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
4471
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4472
}
4473
}
4474
if (flags & NDR_OUT) {
4475
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.TagId));
4476
if (r->out.TagId) {
4477
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.TagId));
4478
}
4479
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4480
}
4481
return NDR_ERR_SUCCESS;
4482
}
4483
4484
static enum ndr_err_code ndr_pull_svcctl_CreateServiceA(struct ndr_pull *ndr, int flags, struct svcctl_CreateServiceA *r)
4485
{
4486
uint32_t _ptr_ServiceName;
4487
uint32_t _ptr_DisplayName;
4488
uint32_t _ptr_binary_path;
4489
uint32_t _ptr_LoadOrderGroupKey;
4490
uint32_t _ptr_TagId;
4491
uint32_t _ptr_dependencies;
4492
uint32_t _ptr_service_start_name;
4493
uint32_t _ptr_password;
4494
TALLOC_CTX *_mem_save_handle_0;
4495
TALLOC_CTX *_mem_save_ServiceName_0;
4496
TALLOC_CTX *_mem_save_DisplayName_0;
4497
TALLOC_CTX *_mem_save_binary_path_0;
4498
TALLOC_CTX *_mem_save_LoadOrderGroupKey_0;
4499
TALLOC_CTX *_mem_save_TagId_0;
4500
TALLOC_CTX *_mem_save_dependencies_0;
4501
TALLOC_CTX *_mem_save_service_start_name_0;
4502
TALLOC_CTX *_mem_save_password_0;
4503
if (flags & NDR_IN) {
4504
ZERO_STRUCT(r->out);
4505
4506
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4507
NDR_PULL_ALLOC(ndr, r->in.handle);
4508
}
4509
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4510
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4511
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4512
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4513
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ServiceName));
4514
if (_ptr_ServiceName) {
4515
NDR_PULL_ALLOC(ndr, r->in.ServiceName);
4516
} else {
4517
r->in.ServiceName = NULL;
4518
}
4519
if (r->in.ServiceName) {
4520
_mem_save_ServiceName_0 = NDR_PULL_GET_MEM_CTX(ndr);
4521
NDR_PULL_SET_MEM_CTX(ndr, r->in.ServiceName, 0);
4522
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
4523
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
4524
if (ndr_get_array_length(ndr, &r->in.ServiceName) > ndr_get_array_size(ndr, &r->in.ServiceName)) {
4525
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.ServiceName), ndr_get_array_length(ndr, &r->in.ServiceName));
4526
}
4527
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));
4528
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t), CH_UTF16));
4529
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ServiceName_0, 0);
4530
}
4531
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DisplayName));
4532
if (_ptr_DisplayName) {
4533
NDR_PULL_ALLOC(ndr, r->in.DisplayName);
4534
} else {
4535
r->in.DisplayName = NULL;
4536
}
4537
if (r->in.DisplayName) {
4538
_mem_save_DisplayName_0 = NDR_PULL_GET_MEM_CTX(ndr);
4539
NDR_PULL_SET_MEM_CTX(ndr, r->in.DisplayName, 0);
4540
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DisplayName));
4541
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DisplayName));
4542
if (ndr_get_array_length(ndr, &r->in.DisplayName) > ndr_get_array_size(ndr, &r->in.DisplayName)) {
4543
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.DisplayName), ndr_get_array_length(ndr, &r->in.DisplayName));
4544
}
4545
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DisplayName), sizeof(uint16_t)));
4546
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DisplayName, ndr_get_array_length(ndr, &r->in.DisplayName), sizeof(uint16_t), CH_UTF16));
4547
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DisplayName_0, 0);
4548
}
4549
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.desired_access));
4550
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
4551
NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
4552
NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
4553
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
4554
if (_ptr_binary_path) {
4555
NDR_PULL_ALLOC(ndr, r->in.binary_path);
4556
} else {
4557
r->in.binary_path = NULL;
4558
}
4559
if (r->in.binary_path) {
4560
_mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4561
NDR_PULL_SET_MEM_CTX(ndr, r->in.binary_path, 0);
4562
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
4563
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
4564
if (ndr_get_array_length(ndr, &r->in.binary_path) > ndr_get_array_size(ndr, &r->in.binary_path)) {
4565
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.binary_path), ndr_get_array_length(ndr, &r->in.binary_path));
4566
}
4567
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));
4568
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t), CH_UTF16));
4569
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);
4570
}
4571
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_LoadOrderGroupKey));
4572
if (_ptr_LoadOrderGroupKey) {
4573
NDR_PULL_ALLOC(ndr, r->in.LoadOrderGroupKey);
4574
} else {
4575
r->in.LoadOrderGroupKey = NULL;
4576
}
4577
if (r->in.LoadOrderGroupKey) {
4578
_mem_save_LoadOrderGroupKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
4579
NDR_PULL_SET_MEM_CTX(ndr, r->in.LoadOrderGroupKey, 0);
4580
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.LoadOrderGroupKey));
4581
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.LoadOrderGroupKey));
4582
if (ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey) > ndr_get_array_size(ndr, &r->in.LoadOrderGroupKey)) {
4583
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.LoadOrderGroupKey), ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey));
4584
}
4585
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey), sizeof(uint16_t)));
4586
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.LoadOrderGroupKey, ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey), sizeof(uint16_t), CH_UTF16));
4587
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_LoadOrderGroupKey_0, 0);
4588
}
4589
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
4590
if (_ptr_dependencies) {
4591
NDR_PULL_ALLOC(ndr, r->in.dependencies);
4592
} else {
4593
r->in.dependencies = NULL;
4594
}
4595
if (r->in.dependencies) {
4596
_mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
4597
NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
4598
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
4599
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dependencies));
4600
if (ndr_get_array_length(ndr, &r->in.dependencies) > ndr_get_array_size(ndr, &r->in.dependencies)) {
4601
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.dependencies), ndr_get_array_length(ndr, &r->in.dependencies));
4602
}
4603
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t)));
4604
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dependencies, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t), CH_UTF16));
4605
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
4606
}
4607
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
4608
if (_ptr_service_start_name) {
4609
NDR_PULL_ALLOC(ndr, r->in.service_start_name);
4610
} else {
4611
r->in.service_start_name = NULL;
4612
}
4613
if (r->in.service_start_name) {
4614
_mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4615
NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
4616
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
4617
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
4618
if (ndr_get_array_length(ndr, &r->in.service_start_name) > ndr_get_array_size(ndr, &r->in.service_start_name)) {
4619
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.service_start_name), ndr_get_array_length(ndr, &r->in.service_start_name));
4620
}
4621
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));
4622
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t), CH_UTF16));
4623
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
4624
}
4625
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4626
if (_ptr_password) {
4627
NDR_PULL_ALLOC(ndr, r->in.password);
4628
} else {
4629
r->in.password = NULL;
4630
}
4631
if (r->in.password) {
4632
_mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4633
NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
4634
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
4635
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
4636
if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
4637
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.password), ndr_get_array_length(ndr, &r->in.password));
4638
}
4639
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
4640
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
4641
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4642
}
4643
}
4644
if (flags & NDR_OUT) {
4645
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));
4646
if (_ptr_TagId) {
4647
NDR_PULL_ALLOC(ndr, r->out.TagId);
4648
} else {
4649
r->out.TagId = NULL;
4650
}
4651
if (r->out.TagId) {
4652
_mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);
4653
NDR_PULL_SET_MEM_CTX(ndr, r->out.TagId, 0);
4654
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.TagId));
4655
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);
4656
}
4657
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4658
}
4659
return NDR_ERR_SUCCESS;
4660
}
4661
4662
_PUBLIC_ void ndr_print_svcctl_CreateServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CreateServiceA *r)
4663
{
4664
ndr_print_struct(ndr, name, "svcctl_CreateServiceA");
4665
if (r == NULL) { ndr_print_null(ndr); return; }
4666
ndr->depth++;
4667
if (flags & NDR_SET_VALUES) {
4668
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4669
}
4670
if (flags & NDR_IN) {
4671
ndr_print_struct(ndr, "in", "svcctl_CreateServiceA");
4672
ndr->depth++;
4673
ndr_print_ptr(ndr, "handle", r->in.handle);
4674
ndr->depth++;
4675
ndr_print_policy_handle(ndr, "handle", r->in.handle);
4676
ndr->depth--;
4677
ndr_print_ptr(ndr, "ServiceName", r->in.ServiceName);
4678
ndr->depth++;
4679
if (r->in.ServiceName) {
4680
ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
4681
}
4682
ndr->depth--;
4683
ndr_print_ptr(ndr, "DisplayName", r->in.DisplayName);
4684
ndr->depth++;
4685
if (r->in.DisplayName) {
4686
ndr_print_string(ndr, "DisplayName", r->in.DisplayName);
4687
}
4688
ndr->depth--;
4689
ndr_print_uint32(ndr, "desired_access", r->in.desired_access);
4690
ndr_print_uint32(ndr, "type", r->in.type);
4691
ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
4692
ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
4693
ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
4694
ndr->depth++;
4695
if (r->in.binary_path) {
4696
ndr_print_string(ndr, "binary_path", r->in.binary_path);
4697
}
4698
ndr->depth--;
4699
ndr_print_ptr(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
4700
ndr->depth++;
4701
if (r->in.LoadOrderGroupKey) {
4702
ndr_print_string(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
4703
}
4704
ndr->depth--;
4705
ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
4706
ndr->depth++;
4707
if (r->in.dependencies) {
4708
ndr_print_string(ndr, "dependencies", r->in.dependencies);
4709
}
4710
ndr->depth--;
4711
ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
4712
ndr->depth++;
4713
if (r->in.service_start_name) {
4714
ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
4715
}
4716
ndr->depth--;
4717
ndr_print_ptr(ndr, "password", r->in.password);
4718
ndr->depth++;
4719
if (r->in.password) {
4720
ndr_print_string(ndr, "password", r->in.password);
4721
}
4722
ndr->depth--;
4723
ndr->depth--;
4724
}
4725
if (flags & NDR_OUT) {
4726
ndr_print_struct(ndr, "out", "svcctl_CreateServiceA");
4727
ndr->depth++;
4728
ndr_print_ptr(ndr, "TagId", r->out.TagId);
4729
ndr->depth++;
4730
if (r->out.TagId) {
4731
ndr_print_uint32(ndr, "TagId", *r->out.TagId);
4732
}
4733
ndr->depth--;
4734
ndr_print_WERROR(ndr, "result", r->out.result);
4735
ndr->depth--;
4736
}
4737
ndr->depth--;
4738
}
4739
4740
static enum ndr_err_code ndr_push_svcctl_EnumDependentServicesA(struct ndr_push *ndr, int flags, const struct svcctl_EnumDependentServicesA *r)
4741
{
4742
if (flags & NDR_IN) {
4743
if (r->in.service == NULL) {
4744
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4745
}
4746
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.service));
4747
NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
4748
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
4749
}
4750
if (flags & NDR_OUT) {
4751
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.service_status));
4752
if (r->out.service_status) {
4753
NDR_CHECK(ndr_push_ENUM_SERVICE_STATUSA(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
4754
}
4755
if (r->out.needed == NULL) {
4756
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4757
}
4758
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
4759
if (r->out.services_returned == NULL) {
4760
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4761
}
4762
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
4763
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4764
}
4765
return NDR_ERR_SUCCESS;
4766
}
4767
4768
static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesA(struct ndr_pull *ndr, int flags, struct svcctl_EnumDependentServicesA *r)
4769
{
4770
uint32_t _ptr_service_status;
4771
TALLOC_CTX *_mem_save_service_0;
4772
TALLOC_CTX *_mem_save_service_status_0;
4773
TALLOC_CTX *_mem_save_needed_0;
4774
TALLOC_CTX *_mem_save_services_returned_0;
4775
if (flags & NDR_IN) {
4776
ZERO_STRUCT(r->out);
4777
4778
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4779
NDR_PULL_ALLOC(ndr, r->in.service);
4780
}
4781
_mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);
4782
NDR_PULL_SET_MEM_CTX(ndr, r->in.service, LIBNDR_FLAG_REF_ALLOC);
4783
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.service));
4784
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, LIBNDR_FLAG_REF_ALLOC);
4785
NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
4786
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
4787
NDR_PULL_ALLOC(ndr, r->out.needed);
4788
ZERO_STRUCTP(r->out.needed);
4789
NDR_PULL_ALLOC(ndr, r->out.services_returned);
4790
ZERO_STRUCTP(r->out.services_returned);
4791
}
4792
if (flags & NDR_OUT) {
4793
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_status));
4794
if (_ptr_service_status) {
4795
NDR_PULL_ALLOC(ndr, r->out.service_status);
4796
} else {
4797
r->out.service_status = NULL;
4798
}
4799
if (r->out.service_status) {
4800
_mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4801
NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, 0);
4802
NDR_CHECK(ndr_pull_ENUM_SERVICE_STATUSA(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
4803
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, 0);
4804
}
4805
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4806
NDR_PULL_ALLOC(ndr, r->out.needed);
4807
}
4808
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
4809
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
4810
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
4811
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
4812
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4813
NDR_PULL_ALLOC(ndr, r->out.services_returned);
4814
}
4815
_mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
4816
NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
4817
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
4818
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
4819
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4820
}
4821
return NDR_ERR_SUCCESS;
4822
}
4823
4824
_PUBLIC_ void ndr_print_svcctl_EnumDependentServicesA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumDependentServicesA *r)
4825
{
4826
ndr_print_struct(ndr, name, "svcctl_EnumDependentServicesA");
4827
if (r == NULL) { ndr_print_null(ndr); return; }
4828
ndr->depth++;
4829
if (flags & NDR_SET_VALUES) {
4830
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4831
}
4832
if (flags & NDR_IN) {
4833
ndr_print_struct(ndr, "in", "svcctl_EnumDependentServicesA");
4834
ndr->depth++;
4835
ndr_print_ptr(ndr, "service", r->in.service);
4836
ndr->depth++;
4837
ndr_print_policy_handle(ndr, "service", r->in.service);
4838
ndr->depth--;
4839
ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
4840
ndr_print_uint32(ndr, "offered", r->in.offered);
4841
ndr->depth--;
4842
}
4843
if (flags & NDR_OUT) {
4844
ndr_print_struct(ndr, "out", "svcctl_EnumDependentServicesA");
4845
ndr->depth++;
4846
ndr_print_ptr(ndr, "service_status", r->out.service_status);
4847
ndr->depth++;
4848
if (r->out.service_status) {
4849
ndr_print_ENUM_SERVICE_STATUSA(ndr, "service_status", r->out.service_status);
4850
}
4851
ndr->depth--;
4852
ndr_print_ptr(ndr, "needed", r->out.needed);
4853
ndr->depth++;
4854
ndr_print_uint32(ndr, "needed", *r->out.needed);
4855
ndr->depth--;
4856
ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
4857
ndr->depth++;
4858
ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
4859
ndr->depth--;
4860
ndr_print_WERROR(ndr, "result", r->out.result);
4861
ndr->depth--;
4862
}
4863
ndr->depth--;
4864
}
4865
4866
static enum ndr_err_code ndr_push_svcctl_EnumServicesStatusA(struct ndr_push *ndr, int flags, const struct svcctl_EnumServicesStatusA *r)
4867
{
4868
if (flags & NDR_IN) {
4869
if (r->in.handle == NULL) {
4870
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4871
}
4872
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4873
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
4874
NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
4875
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
4876
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
4877
if (r->in.resume_handle) {
4878
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
4879
}
4880
}
4881
if (flags & NDR_OUT) {
4882
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
4883
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service, r->in.offered));
4884
if (r->out.needed == NULL) {
4885
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4886
}
4887
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
4888
if (r->out.services_returned == NULL) {
4889
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4890
}
4891
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
4892
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
4893
if (r->out.resume_handle) {
4894
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
4895
}
4896
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4897
}
4898
return NDR_ERR_SUCCESS;
4899
}
4900
4901
static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusA(struct ndr_pull *ndr, int flags, struct svcctl_EnumServicesStatusA *r)
4902
{
4903
uint32_t _ptr_resume_handle;
4904
TALLOC_CTX *_mem_save_handle_0;
4905
TALLOC_CTX *_mem_save_needed_0;
4906
TALLOC_CTX *_mem_save_services_returned_0;
4907
TALLOC_CTX *_mem_save_resume_handle_0;
4908
if (flags & NDR_IN) {
4909
ZERO_STRUCT(r->out);
4910
4911
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4912
NDR_PULL_ALLOC(ndr, r->in.handle);
4913
}
4914
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4915
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4916
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4917
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4918
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
4919
NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
4920
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
4921
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
4922
if (_ptr_resume_handle) {
4923
NDR_PULL_ALLOC(ndr, r->in.resume_handle);
4924
} else {
4925
r->in.resume_handle = NULL;
4926
}
4927
if (r->in.resume_handle) {
4928
_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4929
NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
4930
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
4931
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
4932
}
4933
NDR_PULL_ALLOC(ndr, r->out.needed);
4934
ZERO_STRUCTP(r->out.needed);
4935
NDR_PULL_ALLOC(ndr, r->out.services_returned);
4936
ZERO_STRUCTP(r->out.services_returned);
4937
}
4938
if (flags & NDR_OUT) {
4939
NDR_CHECK(ndr_pull_array_size(ndr, &r->out.service));
4940
NDR_PULL_ALLOC_N(ndr, r->out.service, ndr_get_array_size(ndr, &r->out.service));
4941
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service, ndr_get_array_size(ndr, &r->out.service)));
4942
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4943
NDR_PULL_ALLOC(ndr, r->out.needed);
4944
}
4945
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
4946
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
4947
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
4948
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
4949
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4950
NDR_PULL_ALLOC(ndr, r->out.services_returned);
4951
}
4952
_mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
4953
NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
4954
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
4955
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
4956
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
4957
if (_ptr_resume_handle) {
4958
NDR_PULL_ALLOC(ndr, r->out.resume_handle);
4959
} else {
4960
r->out.resume_handle = NULL;
4961
}
4962
if (r->out.resume_handle) {
4963
_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4964
NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
4965
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
4966
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
4967
}
4968
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4969
if (r->out.service) {
4970
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.offered));
4971
}
4972
}
4973
return NDR_ERR_SUCCESS;
4974
}
4975
4976
_PUBLIC_ void ndr_print_svcctl_EnumServicesStatusA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServicesStatusA *r)
4977
{
4978
ndr_print_struct(ndr, name, "svcctl_EnumServicesStatusA");
4979
if (r == NULL) { ndr_print_null(ndr); return; }
4980
ndr->depth++;
4981
if (flags & NDR_SET_VALUES) {
4982
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4983
}
4984
if (flags & NDR_IN) {
4985
ndr_print_struct(ndr, "in", "svcctl_EnumServicesStatusA");
4986
ndr->depth++;
4987
ndr_print_ptr(ndr, "handle", r->in.handle);
4988
ndr->depth++;
4989
ndr_print_policy_handle(ndr, "handle", r->in.handle);
4990
ndr->depth--;
4991
ndr_print_uint32(ndr, "type", r->in.type);
4992
ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
4993
ndr_print_uint32(ndr, "offered", r->in.offered);
4994
ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
4995
ndr->depth++;
4996
if (r->in.resume_handle) {
4997
ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
4998
}
4999
ndr->depth--;
5000
ndr->depth--;
5001
}
5002
if (flags & NDR_OUT) {
5003
ndr_print_struct(ndr, "out", "svcctl_EnumServicesStatusA");
5004
ndr->depth++;
5005
ndr_print_array_uint8(ndr, "service", r->out.service, r->in.offered);
5006
ndr_print_ptr(ndr, "needed", r->out.needed);
5007
ndr->depth++;
5008
ndr_print_uint32(ndr, "needed", *r->out.needed);
5009
ndr->depth--;
5010
ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
5011
ndr->depth++;
5012
ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
5013
ndr->depth--;
5014
ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5015
ndr->depth++;
5016
if (r->out.resume_handle) {
5017
ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5018
}
5019
ndr->depth--;
5020
ndr_print_WERROR(ndr, "result", r->out.result);
5021
ndr->depth--;
5022
}
5023
ndr->depth--;
5024
}
5025
5026
static enum ndr_err_code ndr_push_svcctl_OpenSCManagerA(struct ndr_push *ndr, int flags, const struct svcctl_OpenSCManagerA *r)
5027
{
5028
if (flags & NDR_IN) {
5029
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.MachineName));
5030
if (r->in.MachineName) {
5031
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
5032
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5033
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
5034
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.MachineName, ndr_charset_length(r->in.MachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5035
}
5036
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DatabaseName));
5037
if (r->in.DatabaseName) {
5038
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
5039
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5040
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
5041
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DatabaseName, ndr_charset_length(r->in.DatabaseName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5042
}
5043
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
5044
}
5045
if (flags & NDR_OUT) {
5046
if (r->out.handle == NULL) {
5047
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5048
}
5049
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5050
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5051
}
5052
return NDR_ERR_SUCCESS;
5053
}
5054
5055
static enum ndr_err_code ndr_pull_svcctl_OpenSCManagerA(struct ndr_pull *ndr, int flags, struct svcctl_OpenSCManagerA *r)
5056
{
5057
uint32_t _ptr_MachineName;
5058
uint32_t _ptr_DatabaseName;
5059
TALLOC_CTX *_mem_save_MachineName_0;
5060
TALLOC_CTX *_mem_save_DatabaseName_0;
5061
TALLOC_CTX *_mem_save_handle_0;
5062
if (flags & NDR_IN) {
5063
ZERO_STRUCT(r->out);
5064
5065
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_MachineName));
5066
if (_ptr_MachineName) {
5067
NDR_PULL_ALLOC(ndr, r->in.MachineName);
5068
} else {
5069
r->in.MachineName = NULL;
5070
}
5071
if (r->in.MachineName) {
5072
_mem_save_MachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
5073
NDR_PULL_SET_MEM_CTX(ndr, r->in.MachineName, 0);
5074
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.MachineName));
5075
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.MachineName));
5076
if (ndr_get_array_length(ndr, &r->in.MachineName) > ndr_get_array_size(ndr, &r->in.MachineName)) {
5077
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.MachineName), ndr_get_array_length(ndr, &r->in.MachineName));
5078
}
5079
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.MachineName), sizeof(uint16_t)));
5080
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.MachineName, ndr_get_array_length(ndr, &r->in.MachineName), sizeof(uint16_t), CH_UTF16));
5081
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_MachineName_0, 0);
5082
}
5083
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DatabaseName));
5084
if (_ptr_DatabaseName) {
5085
NDR_PULL_ALLOC(ndr, r->in.DatabaseName);
5086
} else {
5087
r->in.DatabaseName = NULL;
5088
}
5089
if (r->in.DatabaseName) {
5090
_mem_save_DatabaseName_0 = NDR_PULL_GET_MEM_CTX(ndr);
5091
NDR_PULL_SET_MEM_CTX(ndr, r->in.DatabaseName, 0);
5092
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DatabaseName));
5093
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DatabaseName));
5094
if (ndr_get_array_length(ndr, &r->in.DatabaseName) > ndr_get_array_size(ndr, &r->in.DatabaseName)) {
5095
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.DatabaseName), ndr_get_array_length(ndr, &r->in.DatabaseName));
5096
}
5097
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DatabaseName), sizeof(uint16_t)));
5098
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DatabaseName, ndr_get_array_length(ndr, &r->in.DatabaseName), sizeof(uint16_t), CH_UTF16));
5099
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DatabaseName_0, 0);
5100
}
5101
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
5102
NDR_PULL_ALLOC(ndr, r->out.handle);
5103
ZERO_STRUCTP(r->out.handle);
5104
}
5105
if (flags & NDR_OUT) {
5106
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5107
NDR_PULL_ALLOC(ndr, r->out.handle);
5108
}
5109
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5110
NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5111
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5112
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5113
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5114
}
5115
return NDR_ERR_SUCCESS;
5116
}
5117
5118
_PUBLIC_ void ndr_print_svcctl_OpenSCManagerA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenSCManagerA *r)
5119
{
5120
ndr_print_struct(ndr, name, "svcctl_OpenSCManagerA");
5121
if (r == NULL) { ndr_print_null(ndr); return; }
5122
ndr->depth++;
5123
if (flags & NDR_SET_VALUES) {
5124
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5125
}
5126
if (flags & NDR_IN) {
5127
ndr_print_struct(ndr, "in", "svcctl_OpenSCManagerA");
5128
ndr->depth++;
5129
ndr_print_ptr(ndr, "MachineName", r->in.MachineName);
5130
ndr->depth++;
5131
if (r->in.MachineName) {
5132
ndr_print_string(ndr, "MachineName", r->in.MachineName);
5133
}
5134
ndr->depth--;
5135
ndr_print_ptr(ndr, "DatabaseName", r->in.DatabaseName);
5136
ndr->depth++;
5137
if (r->in.DatabaseName) {
5138
ndr_print_string(ndr, "DatabaseName", r->in.DatabaseName);
5139
}
5140
ndr->depth--;
5141
ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
5142
ndr->depth--;
5143
}
5144
if (flags & NDR_OUT) {
5145
ndr_print_struct(ndr, "out", "svcctl_OpenSCManagerA");
5146
ndr->depth++;
5147
ndr_print_ptr(ndr, "handle", r->out.handle);
5148
ndr->depth++;
5149
ndr_print_policy_handle(ndr, "handle", r->out.handle);
5150
ndr->depth--;
5151
ndr_print_WERROR(ndr, "result", r->out.result);
5152
ndr->depth--;
5153
}
5154
ndr->depth--;
5155
}
5156
5157
static enum ndr_err_code ndr_push_svcctl_OpenServiceA(struct ndr_push *ndr, int flags, const struct svcctl_OpenServiceA *r)
5158
{
5159
if (flags & NDR_IN) {
5160
if (r->in.scmanager_handle == NULL) {
5161
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5162
}
5163
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
5164
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ServiceName));
5165
if (r->in.ServiceName) {
5166
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
5167
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5168
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
5169
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5170
}
5171
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
5172
}
5173
if (flags & NDR_OUT) {
5174
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5175
}
5176
return NDR_ERR_SUCCESS;
5177
}
5178
5179
static enum ndr_err_code ndr_pull_svcctl_OpenServiceA(struct ndr_pull *ndr, int flags, struct svcctl_OpenServiceA *r)
5180
{
5181
uint32_t _ptr_ServiceName;
5182
TALLOC_CTX *_mem_save_scmanager_handle_0;
5183
TALLOC_CTX *_mem_save_ServiceName_0;
5184
if (flags & NDR_IN) {
5185
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5186
NDR_PULL_ALLOC(ndr, r->in.scmanager_handle);
5187
}
5188
_mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5189
NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager_handle, LIBNDR_FLAG_REF_ALLOC);
5190
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
5191
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);
5192
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ServiceName));
5193
if (_ptr_ServiceName) {
5194
NDR_PULL_ALLOC(ndr, r->in.ServiceName);
5195
} else {
5196
r->in.ServiceName = NULL;
5197
}
5198
if (r->in.ServiceName) {
5199
_mem_save_ServiceName_0 = NDR_PULL_GET_MEM_CTX(ndr);
5200
NDR_PULL_SET_MEM_CTX(ndr, r->in.ServiceName, 0);
5201
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
5202
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
5203
if (ndr_get_array_length(ndr, &r->in.ServiceName) > ndr_get_array_size(ndr, &r->in.ServiceName)) {
5204
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.ServiceName), ndr_get_array_length(ndr, &r->in.ServiceName));
5205
}
5206
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));
5207
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t), CH_UTF16));
5208
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ServiceName_0, 0);
5209
}
5210
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
5211
}
5212
if (flags & NDR_OUT) {
5213
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5214
}
5215
return NDR_ERR_SUCCESS;
5216
}
5217
5218
_PUBLIC_ void ndr_print_svcctl_OpenServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenServiceA *r)
5219
{
5220
ndr_print_struct(ndr, name, "svcctl_OpenServiceA");
5221
if (r == NULL) { ndr_print_null(ndr); return; }
5222
ndr->depth++;
5223
if (flags & NDR_SET_VALUES) {
5224
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5225
}
5226
if (flags & NDR_IN) {
5227
ndr_print_struct(ndr, "in", "svcctl_OpenServiceA");
5228
ndr->depth++;
5229
ndr_print_ptr(ndr, "scmanager_handle", r->in.scmanager_handle);
5230
ndr->depth++;
5231
ndr_print_policy_handle(ndr, "scmanager_handle", r->in.scmanager_handle);
5232
ndr->depth--;
5233
ndr_print_ptr(ndr, "ServiceName", r->in.ServiceName);
5234
ndr->depth++;
5235
if (r->in.ServiceName) {
5236
ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
5237
}
5238
ndr->depth--;
5239
ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
5240
ndr->depth--;
5241
}
5242
if (flags & NDR_OUT) {
5243
ndr_print_struct(ndr, "out", "svcctl_OpenServiceA");
5244
ndr->depth++;
5245
ndr_print_WERROR(ndr, "result", r->out.result);
5246
ndr->depth--;
5247
}
5248
ndr->depth--;
5249
}
5250
5251
static enum ndr_err_code ndr_push_svcctl_QueryServiceConfigA(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfigA *r)
5252
{
5253
if (flags & NDR_IN) {
5254
if (r->in.handle == NULL) {
5255
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5256
}
5257
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5258
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
5259
}
5260
if (flags & NDR_OUT) {
5261
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.offered));
5262
if (r->out.needed == NULL) {
5263
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5264
}
5265
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
5266
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5267
}
5268
return NDR_ERR_SUCCESS;
5269
}
5270
5271
static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfigA(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfigA *r)
5272
{
5273
TALLOC_CTX *_mem_save_handle_0;
5274
TALLOC_CTX *_mem_save_needed_0;
5275
if (flags & NDR_IN) {
5276
ZERO_STRUCT(r->out);
5277
5278
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5279
NDR_PULL_ALLOC(ndr, r->in.handle);
5280
}
5281
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5282
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5283
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5284
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5285
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
5286
NDR_PULL_ALLOC(ndr, r->out.needed);
5287
ZERO_STRUCTP(r->out.needed);
5288
}
5289
if (flags & NDR_OUT) {
5290
NDR_PULL_ALLOC_N(ndr, r->out.query, r->in.offered);
5291
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.offered));
5292
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5293
NDR_PULL_ALLOC(ndr, r->out.needed);
5294
}
5295
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
5296
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
5297
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
5298
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
5299
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5300
}
5301
return NDR_ERR_SUCCESS;
5302
}
5303
5304
_PUBLIC_ void ndr_print_svcctl_QueryServiceConfigA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfigA *r)
5305
{
5306
ndr_print_struct(ndr, name, "svcctl_QueryServiceConfigA");
5307
if (r == NULL) { ndr_print_null(ndr); return; }
5308
ndr->depth++;
5309
if (flags & NDR_SET_VALUES) {
5310
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5311
}
5312
if (flags & NDR_IN) {
5313
ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfigA");
5314
ndr->depth++;
5315
ndr_print_ptr(ndr, "handle", r->in.handle);
5316
ndr->depth++;
5317
ndr_print_policy_handle(ndr, "handle", r->in.handle);
5318
ndr->depth--;
5319
ndr_print_uint32(ndr, "offered", r->in.offered);
5320
ndr->depth--;
5321
}
5322
if (flags & NDR_OUT) {
5323
ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfigA");
5324
ndr->depth++;
5325
ndr_print_array_uint8(ndr, "query", r->out.query, r->in.offered);
5326
ndr_print_ptr(ndr, "needed", r->out.needed);
5327
ndr->depth++;
5328
ndr_print_uint32(ndr, "needed", *r->out.needed);
5329
ndr->depth--;
5330
ndr_print_WERROR(ndr, "result", r->out.result);
5331
ndr->depth--;
5332
}
5333
ndr->depth--;
5334
}
5335
5336
static enum ndr_err_code ndr_push_svcctl_QueryServiceLockStatusA(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceLockStatusA *r)
5337
{
5338
if (flags & NDR_IN) {
5339
if (r->in.handle == NULL) {
5340
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5341
}
5342
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5343
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
5344
}
5345
if (flags & NDR_OUT) {
5346
if (r->out.lock_status == NULL) {
5347
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5348
}
5349
NDR_CHECK(ndr_push_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
5350
if (r->out.needed == NULL) {
5351
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5352
}
5353
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
5354
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5355
}
5356
return NDR_ERR_SUCCESS;
5357
}
5358
5359
static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusA(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceLockStatusA *r)
5360
{
5361
TALLOC_CTX *_mem_save_handle_0;
5362
TALLOC_CTX *_mem_save_lock_status_0;
5363
TALLOC_CTX *_mem_save_needed_0;
5364
if (flags & NDR_IN) {
5365
ZERO_STRUCT(r->out);
5366
5367
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5368
NDR_PULL_ALLOC(ndr, r->in.handle);
5369
}
5370
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5371
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5372
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5373
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5374
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
5375
NDR_PULL_ALLOC(ndr, r->out.lock_status);
5376
ZERO_STRUCTP(r->out.lock_status);
5377
NDR_PULL_ALLOC(ndr, r->out.needed);
5378
ZERO_STRUCTP(r->out.needed);
5379
}
5380
if (flags & NDR_OUT) {
5381
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5382
NDR_PULL_ALLOC(ndr, r->out.lock_status);
5383
}
5384
_mem_save_lock_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5385
NDR_PULL_SET_MEM_CTX(ndr, r->out.lock_status, LIBNDR_FLAG_REF_ALLOC);
5386
NDR_CHECK(ndr_pull_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
5387
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_status_0, LIBNDR_FLAG_REF_ALLOC);
5388
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5389
NDR_PULL_ALLOC(ndr, r->out.needed);
5390
}
5391
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
5392
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
5393
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
5394
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
5395
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5396
}
5397
return NDR_ERR_SUCCESS;
5398
}
5399
5400
_PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceLockStatusA *r)
5401
{
5402
ndr_print_struct(ndr, name, "svcctl_QueryServiceLockStatusA");
5403
if (r == NULL) { ndr_print_null(ndr); return; }
5404
ndr->depth++;
5405
if (flags & NDR_SET_VALUES) {
5406
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5407
}
5408
if (flags & NDR_IN) {
5409
ndr_print_struct(ndr, "in", "svcctl_QueryServiceLockStatusA");
5410
ndr->depth++;
5411
ndr_print_ptr(ndr, "handle", r->in.handle);
5412
ndr->depth++;
5413
ndr_print_policy_handle(ndr, "handle", r->in.handle);
5414
ndr->depth--;
5415
ndr_print_uint32(ndr, "offered", r->in.offered);
5416
ndr->depth--;
5417
}
5418
if (flags & NDR_OUT) {
5419
ndr_print_struct(ndr, "out", "svcctl_QueryServiceLockStatusA");
5420
ndr->depth++;
5421
ndr_print_ptr(ndr, "lock_status", r->out.lock_status);
5422
ndr->depth++;
5423
ndr_print_SERVICE_LOCK_STATUS(ndr, "lock_status", r->out.lock_status);
5424
ndr->depth--;
5425
ndr_print_ptr(ndr, "needed", r->out.needed);
5426
ndr->depth++;
5427
ndr_print_uint32(ndr, "needed", *r->out.needed);
5428
ndr->depth--;
5429
ndr_print_WERROR(ndr, "result", r->out.result);
5430
ndr->depth--;
5431
}
5432
ndr->depth--;
5433
}
5434
5435
static enum ndr_err_code ndr_push_svcctl_StartServiceA(struct ndr_push *ndr, int flags, const struct svcctl_StartServiceA *r)
5436
{
5437
if (flags & NDR_IN) {
5438
if (r->in.handle == NULL) {
5439
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5440
}
5441
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5442
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.NumArgs));
5443
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Arguments));
5444
if (r->in.Arguments) {
5445
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
5446
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5447
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
5448
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Arguments, ndr_charset_length(r->in.Arguments, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5449
}
5450
}
5451
if (flags & NDR_OUT) {
5452
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5453
}
5454
return NDR_ERR_SUCCESS;
5455
}
5456
5457
static enum ndr_err_code ndr_pull_svcctl_StartServiceA(struct ndr_pull *ndr, int flags, struct svcctl_StartServiceA *r)
5458
{
5459
uint32_t _ptr_Arguments;
5460
TALLOC_CTX *_mem_save_handle_0;
5461
TALLOC_CTX *_mem_save_Arguments_0;
5462
if (flags & NDR_IN) {
5463
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5464
NDR_PULL_ALLOC(ndr, r->in.handle);
5465
}
5466
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5467
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5468
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5469
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5470
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.NumArgs));
5471
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Arguments));
5472
if (_ptr_Arguments) {
5473
NDR_PULL_ALLOC(ndr, r->in.Arguments);
5474
} else {
5475
r->in.Arguments = NULL;
5476
}
5477
if (r->in.Arguments) {
5478
_mem_save_Arguments_0 = NDR_PULL_GET_MEM_CTX(ndr);
5479
NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);
5480
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Arguments));
5481
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Arguments));
5482
if (ndr_get_array_length(ndr, &r->in.Arguments) > ndr_get_array_size(ndr, &r->in.Arguments)) {
5483
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.Arguments), ndr_get_array_length(ndr, &r->in.Arguments));
5484
}
5485
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Arguments), sizeof(uint16_t)));
5486
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Arguments, ndr_get_array_length(ndr, &r->in.Arguments), sizeof(uint16_t), CH_UTF16));
5487
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_0, 0);
5488
}
5489
}
5490
if (flags & NDR_OUT) {
5491
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5492
}
5493
return NDR_ERR_SUCCESS;
5494
}
5495
5496
_PUBLIC_ void ndr_print_svcctl_StartServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_StartServiceA *r)
5497
{
5498
ndr_print_struct(ndr, name, "svcctl_StartServiceA");
5499
if (r == NULL) { ndr_print_null(ndr); return; }
5500
ndr->depth++;
5501
if (flags & NDR_SET_VALUES) {
5502
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5503
}
5504
if (flags & NDR_IN) {
5505
ndr_print_struct(ndr, "in", "svcctl_StartServiceA");
5506
ndr->depth++;
5507
ndr_print_ptr(ndr, "handle", r->in.handle);
5508
ndr->depth++;
5509
ndr_print_policy_handle(ndr, "handle", r->in.handle);
5510
ndr->depth--;
5511
ndr_print_uint32(ndr, "NumArgs", r->in.NumArgs);
5512
ndr_print_ptr(ndr, "Arguments", r->in.Arguments);
5513
ndr->depth++;
5514
if (r->in.Arguments) {
5515
ndr_print_string(ndr, "Arguments", r->in.Arguments);
5516
}
5517
ndr->depth--;
5518
ndr->depth--;
5519
}
5520
if (flags & NDR_OUT) {
5521
ndr_print_struct(ndr, "out", "svcctl_StartServiceA");
5522
ndr->depth++;
5523
ndr_print_WERROR(ndr, "result", r->out.result);
5524
ndr->depth--;
5525
}
5526
ndr->depth--;
5527
}
5528
5529
static enum ndr_err_code ndr_push_svcctl_GetServiceDisplayNameA(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceDisplayNameA *r)
5530
{
5531
if (flags & NDR_IN) {
5532
if (r->in.handle == NULL) {
5533
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5534
}
5535
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5536
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
5537
if (r->in.service_name) {
5538
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
5539
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5540
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
5541
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5542
}
5543
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
5544
if (r->in.display_name_length) {
5545
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
5546
}
5547
}
5548
if (flags & NDR_OUT) {
5549
if (r->out.display_name == NULL) {
5550
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5551
}
5552
NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.display_name));
5553
if (*r->out.display_name) {
5554
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
5555
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5556
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
5557
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.display_name, ndr_charset_length(*r->out.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5558
}
5559
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
5560
if (r->out.display_name_length) {
5561
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
5562
}
5563
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5564
}
5565
return NDR_ERR_SUCCESS;
5566
}
5567
5568
static enum ndr_err_code ndr_pull_svcctl_GetServiceDisplayNameA(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceDisplayNameA *r)
5569
{
5570
uint32_t _ptr_service_name;
5571
uint32_t _ptr_display_name;
5572
uint32_t _ptr_display_name_length;
5573
TALLOC_CTX *_mem_save_handle_0;
5574
TALLOC_CTX *_mem_save_service_name_0;
5575
TALLOC_CTX *_mem_save_display_name_0;
5576
TALLOC_CTX *_mem_save_display_name_1;
5577
TALLOC_CTX *_mem_save_display_name_length_0;
5578
if (flags & NDR_IN) {
5579
ZERO_STRUCT(r->out);
5580
5581
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5582
NDR_PULL_ALLOC(ndr, r->in.handle);
5583
}
5584
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5585
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5586
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5587
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5588
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
5589
if (_ptr_service_name) {
5590
NDR_PULL_ALLOC(ndr, r->in.service_name);
5591
} else {
5592
r->in.service_name = NULL;
5593
}
5594
if (r->in.service_name) {
5595
_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5596
NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
5597
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
5598
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
5599
if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {
5600
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.service_name), ndr_get_array_length(ndr, &r->in.service_name));
5601
}
5602
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));
5603
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));
5604
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
5605
}
5606
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
5607
if (_ptr_display_name_length) {
5608
NDR_PULL_ALLOC(ndr, r->in.display_name_length);
5609
} else {
5610
r->in.display_name_length = NULL;
5611
}
5612
if (r->in.display_name_length) {
5613
_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
5614
NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
5615
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
5616
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
5617
}
5618
NDR_PULL_ALLOC(ndr, r->out.display_name);
5619
ZERO_STRUCTP(r->out.display_name);
5620
}
5621
if (flags & NDR_OUT) {
5622
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5623
NDR_PULL_ALLOC(ndr, r->out.display_name);
5624
}
5625
_mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5626
NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name, LIBNDR_FLAG_REF_ALLOC);
5627
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
5628
if (_ptr_display_name) {
5629
NDR_PULL_ALLOC(ndr, *r->out.display_name);
5630
} else {
5631
*r->out.display_name = NULL;
5632
}
5633
if (*r->out.display_name) {
5634
_mem_save_display_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
5635
NDR_PULL_SET_MEM_CTX(ndr, *r->out.display_name, 0);
5636
NDR_CHECK(ndr_pull_array_size(ndr, r->out.display_name));
5637
NDR_CHECK(ndr_pull_array_length(ndr, r->out.display_name));
5638
if (ndr_get_array_length(ndr, r->out.display_name) > ndr_get_array_size(ndr, r->out.display_name)) {
5639
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.display_name), ndr_get_array_length(ndr, r->out.display_name));
5640
}
5641
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t)));
5642
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.display_name, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t), CH_UTF16));
5643
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_1, 0);
5644
}
5645
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, LIBNDR_FLAG_REF_ALLOC);
5646
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
5647
if (_ptr_display_name_length) {
5648
NDR_PULL_ALLOC(ndr, r->out.display_name_length);
5649
} else {
5650
r->out.display_name_length = NULL;
5651
}
5652
if (r->out.display_name_length) {
5653
_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
5654
NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
5655
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
5656
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
5657
}
5658
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5659
}
5660
return NDR_ERR_SUCCESS;
5661
}
5662
5663
_PUBLIC_ void ndr_print_svcctl_GetServiceDisplayNameA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceDisplayNameA *r)
5664
{
5665
ndr_print_struct(ndr, name, "svcctl_GetServiceDisplayNameA");
5666
if (r == NULL) { ndr_print_null(ndr); return; }
5667
ndr->depth++;
5668
if (flags & NDR_SET_VALUES) {
5669
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5670
}
5671
if (flags & NDR_IN) {
5672
ndr_print_struct(ndr, "in", "svcctl_GetServiceDisplayNameA");
5673
ndr->depth++;
5674
ndr_print_ptr(ndr, "handle", r->in.handle);
5675
ndr->depth++;
5676
ndr_print_policy_handle(ndr, "handle", r->in.handle);
5677
ndr->depth--;
5678
ndr_print_ptr(ndr, "service_name", r->in.service_name);
5679
ndr->depth++;
5680
if (r->in.service_name) {
5681
ndr_print_string(ndr, "service_name", r->in.service_name);
5682
}
5683
ndr->depth--;
5684
ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
5685
ndr->depth++;
5686
if (r->in.display_name_length) {
5687
ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
5688
}
5689
ndr->depth--;
5690
ndr->depth--;
5691
}
5692
if (flags & NDR_OUT) {
5693
ndr_print_struct(ndr, "out", "svcctl_GetServiceDisplayNameA");
5694
ndr->depth++;
5695
ndr_print_ptr(ndr, "display_name", r->out.display_name);
5696
ndr->depth++;
5697
ndr_print_ptr(ndr, "display_name", *r->out.display_name);
5698
ndr->depth++;
5699
if (*r->out.display_name) {
5700
ndr_print_string(ndr, "display_name", *r->out.display_name);
5701
}
5702
ndr->depth--;
5703
ndr->depth--;
5704
ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
5705
ndr->depth++;
5706
if (r->out.display_name_length) {
5707
ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
5708
}
5709
ndr->depth--;
5710
ndr_print_WERROR(ndr, "result", r->out.result);
5711
ndr->depth--;
5712
}
5713
ndr->depth--;
5714
}
5715
5716
static enum ndr_err_code ndr_push_svcctl_GetServiceKeyNameA(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceKeyNameA *r)
5717
{
5718
if (flags & NDR_IN) {
5719
if (r->in.handle == NULL) {
5720
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5721
}
5722
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5723
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
5724
if (r->in.service_name) {
5725
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
5726
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5727
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
5728
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5729
}
5730
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
5731
if (r->in.display_name_length) {
5732
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
5733
}
5734
}
5735
if (flags & NDR_OUT) {
5736
if (r->out.key_name == NULL) {
5737
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5738
}
5739
NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_name));
5740
if (*r->out.key_name) {
5741
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
5742
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5743
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
5744
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.key_name, ndr_charset_length(*r->out.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5745
}
5746
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
5747
if (r->out.display_name_length) {
5748
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
5749
}
5750
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5751
}
5752
return NDR_ERR_SUCCESS;
5753
}
5754
5755
static enum ndr_err_code ndr_pull_svcctl_GetServiceKeyNameA(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceKeyNameA *r)
5756
{
5757
uint32_t _ptr_service_name;
5758
uint32_t _ptr_key_name;
5759
uint32_t _ptr_display_name_length;
5760
TALLOC_CTX *_mem_save_handle_0;
5761
TALLOC_CTX *_mem_save_service_name_0;
5762
TALLOC_CTX *_mem_save_key_name_0;
5763
TALLOC_CTX *_mem_save_key_name_1;
5764
TALLOC_CTX *_mem_save_display_name_length_0;
5765
if (flags & NDR_IN) {
5766
ZERO_STRUCT(r->out);
5767
5768
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5769
NDR_PULL_ALLOC(ndr, r->in.handle);
5770
}
5771
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5772
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5773
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5774
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5775
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
5776
if (_ptr_service_name) {
5777
NDR_PULL_ALLOC(ndr, r->in.service_name);
5778
} else {
5779
r->in.service_name = NULL;
5780
}
5781
if (r->in.service_name) {
5782
_mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5783
NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
5784
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
5785
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
5786
if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {
5787
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.service_name), ndr_get_array_length(ndr, &r->in.service_name));
5788
}
5789
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));
5790
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));
5791
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
5792
}
5793
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
5794
if (_ptr_display_name_length) {
5795
NDR_PULL_ALLOC(ndr, r->in.display_name_length);
5796
} else {
5797
r->in.display_name_length = NULL;
5798
}
5799
if (r->in.display_name_length) {
5800
_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
5801
NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
5802
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
5803
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
5804
}
5805
NDR_PULL_ALLOC(ndr, r->out.key_name);
5806
ZERO_STRUCTP(r->out.key_name);
5807
}
5808
if (flags & NDR_OUT) {
5809
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5810
NDR_PULL_ALLOC(ndr, r->out.key_name);
5811
}
5812
_mem_save_key_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5813
NDR_PULL_SET_MEM_CTX(ndr, r->out.key_name, LIBNDR_FLAG_REF_ALLOC);
5814
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_name));
5815
if (_ptr_key_name) {
5816
NDR_PULL_ALLOC(ndr, *r->out.key_name);
5817
} else {
5818
*r->out.key_name = NULL;
5819
}
5820
if (*r->out.key_name) {
5821
_mem_save_key_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
5822
NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_name, 0);
5823
NDR_CHECK(ndr_pull_array_size(ndr, r->out.key_name));
5824
NDR_CHECK(ndr_pull_array_length(ndr, r->out.key_name));
5825
if (ndr_get_array_length(ndr, r->out.key_name) > ndr_get_array_size(ndr, r->out.key_name)) {
5826
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.key_name), ndr_get_array_length(ndr, r->out.key_name));
5827
}
5828
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t)));
5829
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.key_name, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t), CH_UTF16));
5830
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_1, 0);
5831
}
5832
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_0, LIBNDR_FLAG_REF_ALLOC);
5833
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
5834
if (_ptr_display_name_length) {
5835
NDR_PULL_ALLOC(ndr, r->out.display_name_length);
5836
} else {
5837
r->out.display_name_length = NULL;
5838
}
5839
if (r->out.display_name_length) {
5840
_mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
5841
NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
5842
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
5843
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
5844
}
5845
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5846
}
5847
return NDR_ERR_SUCCESS;
5848
}
5849
5850
_PUBLIC_ void ndr_print_svcctl_GetServiceKeyNameA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceKeyNameA *r)
5851
{
5852
ndr_print_struct(ndr, name, "svcctl_GetServiceKeyNameA");
5853
if (r == NULL) { ndr_print_null(ndr); return; }
5854
ndr->depth++;
5855
if (flags & NDR_SET_VALUES) {
5856
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5857
}
5858
if (flags & NDR_IN) {
5859
ndr_print_struct(ndr, "in", "svcctl_GetServiceKeyNameA");
5860
ndr->depth++;
5861
ndr_print_ptr(ndr, "handle", r->in.handle);
5862
ndr->depth++;
5863
ndr_print_policy_handle(ndr, "handle", r->in.handle);
5864
ndr->depth--;
5865
ndr_print_ptr(ndr, "service_name", r->in.service_name);
5866
ndr->depth++;
5867
if (r->in.service_name) {
5868
ndr_print_string(ndr, "service_name", r->in.service_name);
5869
}
5870
ndr->depth--;
5871
ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
5872
ndr->depth++;
5873
if (r->in.display_name_length) {
5874
ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
5875
}
5876
ndr->depth--;
5877
ndr->depth--;
5878
}
5879
if (flags & NDR_OUT) {
5880
ndr_print_struct(ndr, "out", "svcctl_GetServiceKeyNameA");
5881
ndr->depth++;
5882
ndr_print_ptr(ndr, "key_name", r->out.key_name);
5883
ndr->depth++;
5884
ndr_print_ptr(ndr, "key_name", *r->out.key_name);
5885
ndr->depth++;
5886
if (*r->out.key_name) {
5887
ndr_print_string(ndr, "key_name", *r->out.key_name);
5888
}
5889
ndr->depth--;
5890
ndr->depth--;
5891
ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
5892
ndr->depth++;
5893
if (r->out.display_name_length) {
5894
ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
5895
}
5896
ndr->depth--;
5897
ndr_print_WERROR(ndr, "result", r->out.result);
5898
ndr->depth--;
5899
}
5900
ndr->depth--;
5901
}
5902
5903
static enum ndr_err_code ndr_push_svcctl_GetCurrentGroupeStateW(struct ndr_push *ndr, int flags, const struct svcctl_GetCurrentGroupeStateW *r)
5904
{
5905
if (flags & NDR_IN) {
5906
}
5907
if (flags & NDR_OUT) {
5908
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5909
}
5910
return NDR_ERR_SUCCESS;
5911
}
5912
5913
static enum ndr_err_code ndr_pull_svcctl_GetCurrentGroupeStateW(struct ndr_pull *ndr, int flags, struct svcctl_GetCurrentGroupeStateW *r)
5914
{
5915
if (flags & NDR_IN) {
5916
}
5917
if (flags & NDR_OUT) {
5918
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5919
}
5920
return NDR_ERR_SUCCESS;
5921
}
5922
5923
_PUBLIC_ void ndr_print_svcctl_GetCurrentGroupeStateW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetCurrentGroupeStateW *r)
5924
{
5925
ndr_print_struct(ndr, name, "svcctl_GetCurrentGroupeStateW");
5926
if (r == NULL) { ndr_print_null(ndr); return; }
5927
ndr->depth++;
5928
if (flags & NDR_SET_VALUES) {
5929
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5930
}
5931
if (flags & NDR_IN) {
5932
ndr_print_struct(ndr, "in", "svcctl_GetCurrentGroupeStateW");
5933
ndr->depth++;
5934
ndr->depth--;
5935
}
5936
if (flags & NDR_OUT) {
5937
ndr_print_struct(ndr, "out", "svcctl_GetCurrentGroupeStateW");
5938
ndr->depth++;
5939
ndr_print_WERROR(ndr, "result", r->out.result);
5940
ndr->depth--;
5941
}
5942
ndr->depth--;
5943
}
5944
5945
static enum ndr_err_code ndr_push_svcctl_EnumServiceGroupW(struct ndr_push *ndr, int flags, const struct svcctl_EnumServiceGroupW *r)
5946
{
5947
if (flags & NDR_IN) {
5948
}
5949
if (flags & NDR_OUT) {
5950
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5951
}
5952
return NDR_ERR_SUCCESS;
5953
}
5954
5955
static enum ndr_err_code ndr_pull_svcctl_EnumServiceGroupW(struct ndr_pull *ndr, int flags, struct svcctl_EnumServiceGroupW *r)
5956
{
5957
if (flags & NDR_IN) {
5958
}
5959
if (flags & NDR_OUT) {
5960
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5961
}
5962
return NDR_ERR_SUCCESS;
5963
}
5964
5965
_PUBLIC_ void ndr_print_svcctl_EnumServiceGroupW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServiceGroupW *r)
5966
{
5967
ndr_print_struct(ndr, name, "svcctl_EnumServiceGroupW");
5968
if (r == NULL) { ndr_print_null(ndr); return; }
5969
ndr->depth++;
5970
if (flags & NDR_SET_VALUES) {
5971
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5972
}
5973
if (flags & NDR_IN) {
5974
ndr_print_struct(ndr, "in", "svcctl_EnumServiceGroupW");
5975
ndr->depth++;
5976
ndr->depth--;
5977
}
5978
if (flags & NDR_OUT) {
5979
ndr_print_struct(ndr, "out", "svcctl_EnumServiceGroupW");
5980
ndr->depth++;
5981
ndr_print_WERROR(ndr, "result", r->out.result);
5982
ndr->depth--;
5983
}
5984
ndr->depth--;
5985
}
5986
5987
static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfig2A(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfig2A *r)
5988
{
5989
if (flags & NDR_IN) {
5990
if (r->in.handle == NULL) {
5991
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5992
}
5993
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5994
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
5995
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
5996
if (r->in.info) {
5997
NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->in.info));
5998
}
5999
}
6000
if (flags & NDR_OUT) {
6001
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6002
}
6003
return NDR_ERR_SUCCESS;
6004
}
6005
6006
static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfig2A(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfig2A *r)
6007
{
6008
uint32_t _ptr_info;
6009
TALLOC_CTX *_mem_save_handle_0;
6010
TALLOC_CTX *_mem_save_info_0;
6011
if (flags & NDR_IN) {
6012
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6013
NDR_PULL_ALLOC(ndr, r->in.handle);
6014
}
6015
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6016
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6017
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6018
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6019
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
6020
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6021
if (_ptr_info) {
6022
NDR_PULL_ALLOC(ndr, r->in.info);
6023
} else {
6024
r->in.info = NULL;
6025
}
6026
if (r->in.info) {
6027
_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6028
NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
6029
NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->in.info));
6030
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
6031
}
6032
}
6033
if (flags & NDR_OUT) {
6034
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6035
}
6036
return NDR_ERR_SUCCESS;
6037
}
6038
6039
_PUBLIC_ void ndr_print_svcctl_ChangeServiceConfig2A(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfig2A *r)
6040
{
6041
ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfig2A");
6042
if (r == NULL) { ndr_print_null(ndr); return; }
6043
ndr->depth++;
6044
if (flags & NDR_SET_VALUES) {
6045
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6046
}
6047
if (flags & NDR_IN) {
6048
ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfig2A");
6049
ndr->depth++;
6050
ndr_print_ptr(ndr, "handle", r->in.handle);
6051
ndr->depth++;
6052
ndr_print_policy_handle(ndr, "handle", r->in.handle);
6053
ndr->depth--;
6054
ndr_print_uint32(ndr, "info_level", r->in.info_level);
6055
ndr_print_ptr(ndr, "info", r->in.info);
6056
ndr->depth++;
6057
if (r->in.info) {
6058
ndr_print_uint8(ndr, "info", *r->in.info);
6059
}
6060
ndr->depth--;
6061
ndr->depth--;
6062
}
6063
if (flags & NDR_OUT) {
6064
ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfig2A");
6065
ndr->depth++;
6066
ndr_print_WERROR(ndr, "result", r->out.result);
6067
ndr->depth--;
6068
}
6069
ndr->depth--;
6070
}
6071
6072
static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfig2W(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfig2W *r)
6073
{
6074
if (flags & NDR_IN) {
6075
if (r->in.handle == NULL) {
6076
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6077
}
6078
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6079
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
6080
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
6081
if (r->in.info) {
6082
NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->in.info));
6083
}
6084
}
6085
if (flags & NDR_OUT) {
6086
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6087
}
6088
return NDR_ERR_SUCCESS;
6089
}
6090
6091
static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfig2W(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfig2W *r)
6092
{
6093
uint32_t _ptr_info;
6094
TALLOC_CTX *_mem_save_handle_0;
6095
TALLOC_CTX *_mem_save_info_0;
6096
if (flags & NDR_IN) {
6097
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6098
NDR_PULL_ALLOC(ndr, r->in.handle);
6099
}
6100
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6101
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6102
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6103
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6104
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
6105
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6106
if (_ptr_info) {
6107
NDR_PULL_ALLOC(ndr, r->in.info);
6108
} else {
6109
r->in.info = NULL;
6110
}
6111
if (r->in.info) {
6112
_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6113
NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
6114
NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->in.info));
6115
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
6116
}
6117
}
6118
if (flags & NDR_OUT) {
6119
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6120
}
6121
return NDR_ERR_SUCCESS;
6122
}
6123
6124
_PUBLIC_ void ndr_print_svcctl_ChangeServiceConfig2W(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfig2W *r)
6125
{
6126
ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfig2W");
6127
if (r == NULL) { ndr_print_null(ndr); return; }
6128
ndr->depth++;
6129
if (flags & NDR_SET_VALUES) {
6130
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6131
}
6132
if (flags & NDR_IN) {
6133
ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfig2W");
6134
ndr->depth++;
6135
ndr_print_ptr(ndr, "handle", r->in.handle);
6136
ndr->depth++;
6137
ndr_print_policy_handle(ndr, "handle", r->in.handle);
6138
ndr->depth--;
6139
ndr_print_uint32(ndr, "info_level", r->in.info_level);
6140
ndr_print_ptr(ndr, "info", r->in.info);
6141
ndr->depth++;
6142
if (r->in.info) {
6143
ndr_print_uint8(ndr, "info", *r->in.info);
6144
}
6145
ndr->depth--;
6146
ndr->depth--;
6147
}
6148
if (flags & NDR_OUT) {
6149
ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfig2W");
6150
ndr->depth++;
6151
ndr_print_WERROR(ndr, "result", r->out.result);
6152
ndr->depth--;
6153
}
6154
ndr->depth--;
6155
}
6156
6157
static enum ndr_err_code ndr_push_svcctl_QueryServiceConfig2A(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfig2A *r)
6158
{
6159
if (flags & NDR_IN) {
6160
if (r->in.handle == NULL) {
6161
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6162
}
6163
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6164
NDR_CHECK(ndr_push_svcctl_ConfigLevel(ndr, NDR_SCALARS, r->in.info_level));
6165
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
6166
}
6167
if (flags & NDR_OUT) {
6168
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
6169
if (r->out.needed == NULL) {
6170
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6171
}
6172
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
6173
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6174
}
6175
return NDR_ERR_SUCCESS;
6176
}
6177
6178
static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfig2A(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfig2A *r)
6179
{
6180
TALLOC_CTX *_mem_save_handle_0;
6181
TALLOC_CTX *_mem_save_needed_0;
6182
if (flags & NDR_IN) {
6183
ZERO_STRUCT(r->out);
6184
6185
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6186
NDR_PULL_ALLOC(ndr, r->in.handle);
6187
}
6188
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6189
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6190
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6191
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6192
NDR_CHECK(ndr_pull_svcctl_ConfigLevel(ndr, NDR_SCALARS, &r->in.info_level));
6193
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
6194
NDR_PULL_ALLOC(ndr, r->out.needed);
6195
ZERO_STRUCTP(r->out.needed);
6196
}
6197
if (flags & NDR_OUT) {
6198
NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
6199
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
6200
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6201
NDR_PULL_ALLOC(ndr, r->out.needed);
6202
}
6203
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
6204
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
6205
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
6206
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
6207
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6208
}
6209
return NDR_ERR_SUCCESS;
6210
}
6211
6212
_PUBLIC_ void ndr_print_svcctl_QueryServiceConfig2A(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfig2A *r)
6213
{
6214
ndr_print_struct(ndr, name, "svcctl_QueryServiceConfig2A");
6215
if (r == NULL) { ndr_print_null(ndr); return; }
6216
ndr->depth++;
6217
if (flags & NDR_SET_VALUES) {
6218
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6219
}
6220
if (flags & NDR_IN) {
6221
ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfig2A");
6222
ndr->depth++;
6223
ndr_print_ptr(ndr, "handle", r->in.handle);
6224
ndr->depth++;
6225
ndr_print_policy_handle(ndr, "handle", r->in.handle);
6226
ndr->depth--;
6227
ndr_print_svcctl_ConfigLevel(ndr, "info_level", r->in.info_level);
6228
ndr_print_uint32(ndr, "offered", r->in.offered);
6229
ndr->depth--;
6230
}
6231
if (flags & NDR_OUT) {
6232
ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfig2A");
6233
ndr->depth++;
6234
ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
6235
ndr_print_ptr(ndr, "needed", r->out.needed);
6236
ndr->depth++;
6237
ndr_print_uint32(ndr, "needed", *r->out.needed);
6238
ndr->depth--;
6239
ndr_print_WERROR(ndr, "result", r->out.result);
6240
ndr->depth--;
6241
}
6242
ndr->depth--;
6243
}
6244
6245
static enum ndr_err_code ndr_push_svcctl_QueryServiceConfig2W(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfig2W *r)
6246
{
6247
if (flags & NDR_IN) {
6248
if (r->in.handle == NULL) {
6249
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6250
}
6251
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6252
NDR_CHECK(ndr_push_svcctl_ConfigLevel(ndr, NDR_SCALARS, r->in.info_level));
6253
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
6254
}
6255
if (flags & NDR_OUT) {
6256
if (r->out.buffer == NULL) {
6257
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6258
}
6259
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
6260
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
6261
if (r->out.needed == NULL) {
6262
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6263
}
6264
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
6265
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6266
}
6267
return NDR_ERR_SUCCESS;
6268
}
6269
6270
static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfig2W(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfig2W *r)
6271
{
6272
TALLOC_CTX *_mem_save_handle_0;
6273
TALLOC_CTX *_mem_save_needed_0;
6274
if (flags & NDR_IN) {
6275
ZERO_STRUCT(r->out);
6276
6277
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6278
NDR_PULL_ALLOC(ndr, r->in.handle);
6279
}
6280
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6281
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6282
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6283
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6284
NDR_CHECK(ndr_pull_svcctl_ConfigLevel(ndr, NDR_SCALARS, &r->in.info_level));
6285
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
6286
if (r->in.offered > 8192) {
6287
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6288
}
6289
NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
6290
memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
6291
NDR_PULL_ALLOC(ndr, r->out.needed);
6292
ZERO_STRUCTP(r->out.needed);
6293
}
6294
if (flags & NDR_OUT) {
6295
NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
6296
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6297
NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
6298
}
6299
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
6300
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6301
NDR_PULL_ALLOC(ndr, r->out.needed);
6302
}
6303
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
6304
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
6305
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
6306
if (*r->out.needed > 8192) {
6307
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6308
}
6309
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
6310
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6311
if (r->out.buffer) {
6312
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
6313
}
6314
}
6315
return NDR_ERR_SUCCESS;
6316
}
6317
6318
_PUBLIC_ void ndr_print_svcctl_QueryServiceConfig2W(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfig2W *r)
6319
{
6320
ndr_print_struct(ndr, name, "svcctl_QueryServiceConfig2W");
6321
if (r == NULL) { ndr_print_null(ndr); return; }
6322
ndr->depth++;
6323
if (flags & NDR_SET_VALUES) {
6324
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6325
}
6326
if (flags & NDR_IN) {
6327
ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfig2W");
6328
ndr->depth++;
6329
ndr_print_ptr(ndr, "handle", r->in.handle);
6330
ndr->depth++;
6331
ndr_print_policy_handle(ndr, "handle", r->in.handle);
6332
ndr->depth--;
6333
ndr_print_svcctl_ConfigLevel(ndr, "info_level", r->in.info_level);
6334
ndr_print_uint32(ndr, "offered", r->in.offered);
6335
ndr->depth--;
6336
}
6337
if (flags & NDR_OUT) {
6338
ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfig2W");
6339
ndr->depth++;
6340
ndr_print_ptr(ndr, "buffer", r->out.buffer);
6341
ndr->depth++;
6342
ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
6343
ndr->depth--;
6344
ndr_print_ptr(ndr, "needed", r->out.needed);
6345
ndr->depth++;
6346
ndr_print_uint32(ndr, "needed", *r->out.needed);
6347
ndr->depth--;
6348
ndr_print_WERROR(ndr, "result", r->out.result);
6349
ndr->depth--;
6350
}
6351
ndr->depth--;
6352
}
6353
6354
static enum ndr_err_code ndr_push_svcctl_QueryServiceStatusEx(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceStatusEx *r)
6355
{
6356
if (flags & NDR_IN) {
6357
if (r->in.handle == NULL) {
6358
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6359
}
6360
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6361
NDR_CHECK(ndr_push_svcctl_StatusLevel(ndr, NDR_SCALARS, r->in.info_level));
6362
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
6363
}
6364
if (flags & NDR_OUT) {
6365
if (r->out.buffer == NULL) {
6366
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6367
}
6368
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
6369
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
6370
if (r->out.needed == NULL) {
6371
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6372
}
6373
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
6374
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6375
}
6376
return NDR_ERR_SUCCESS;
6377
}
6378
6379
static enum ndr_err_code ndr_pull_svcctl_QueryServiceStatusEx(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceStatusEx *r)
6380
{
6381
TALLOC_CTX *_mem_save_handle_0;
6382
TALLOC_CTX *_mem_save_needed_0;
6383
if (flags & NDR_IN) {
6384
ZERO_STRUCT(r->out);
6385
6386
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6387
NDR_PULL_ALLOC(ndr, r->in.handle);
6388
}
6389
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6390
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6391
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6392
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6393
NDR_CHECK(ndr_pull_svcctl_StatusLevel(ndr, NDR_SCALARS, &r->in.info_level));
6394
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
6395
if (r->in.offered > 8192) {
6396
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6397
}
6398
NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
6399
memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
6400
NDR_PULL_ALLOC(ndr, r->out.needed);
6401
ZERO_STRUCTP(r->out.needed);
6402
}
6403
if (flags & NDR_OUT) {
6404
NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
6405
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6406
NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
6407
}
6408
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
6409
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6410
NDR_PULL_ALLOC(ndr, r->out.needed);
6411
}
6412
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
6413
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
6414
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
6415
if (*r->out.needed > 8192) {
6416
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6417
}
6418
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
6419
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6420
if (r->out.buffer) {
6421
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
6422
}
6423
}
6424
return NDR_ERR_SUCCESS;
6425
}
6426
6427
_PUBLIC_ void ndr_print_svcctl_QueryServiceStatusEx(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceStatusEx *r)
6428
{
6429
ndr_print_struct(ndr, name, "svcctl_QueryServiceStatusEx");
6430
if (r == NULL) { ndr_print_null(ndr); return; }
6431
ndr->depth++;
6432
if (flags & NDR_SET_VALUES) {
6433
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6434
}
6435
if (flags & NDR_IN) {
6436
ndr_print_struct(ndr, "in", "svcctl_QueryServiceStatusEx");
6437
ndr->depth++;
6438
ndr_print_ptr(ndr, "handle", r->in.handle);
6439
ndr->depth++;
6440
ndr_print_policy_handle(ndr, "handle", r->in.handle);
6441
ndr->depth--;
6442
ndr_print_svcctl_StatusLevel(ndr, "info_level", r->in.info_level);
6443
ndr_print_uint32(ndr, "offered", r->in.offered);
6444
ndr->depth--;
6445
}
6446
if (flags & NDR_OUT) {
6447
ndr_print_struct(ndr, "out", "svcctl_QueryServiceStatusEx");
6448
ndr->depth++;
6449
ndr_print_ptr(ndr, "buffer", r->out.buffer);
6450
ndr->depth++;
6451
ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
6452
ndr->depth--;
6453
ndr_print_ptr(ndr, "needed", r->out.needed);
6454
ndr->depth++;
6455
ndr_print_uint32(ndr, "needed", *r->out.needed);
6456
ndr->depth--;
6457
ndr_print_WERROR(ndr, "result", r->out.result);
6458
ndr->depth--;
6459
}
6460
ndr->depth--;
6461
}
6462
6463
static enum ndr_err_code ndr_push_EnumServicesStatusExA(struct ndr_push *ndr, int flags, const struct EnumServicesStatusExA *r)
6464
{
6465
if (flags & NDR_IN) {
6466
if (r->in.scmanager == NULL) {
6467
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6468
}
6469
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));
6470
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
6471
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
6472
NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
6473
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
6474
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
6475
if (r->in.resume_handle) {
6476
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6477
}
6478
}
6479
if (flags & NDR_OUT) {
6480
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.offered));
6481
if (r->out.needed == NULL) {
6482
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6483
}
6484
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
6485
if (r->out.service_returned == NULL) {
6486
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6487
}
6488
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.service_returned));
6489
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
6490
if (r->out.resume_handle) {
6491
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6492
}
6493
if (r->out.group_name == NULL) {
6494
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6495
}
6496
NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.group_name));
6497
if (*r->out.group_name) {
6498
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
6499
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6500
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
6501
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.group_name, ndr_charset_length(*r->out.group_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6502
}
6503
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6504
}
6505
return NDR_ERR_SUCCESS;
6506
}
6507
6508
static enum ndr_err_code ndr_pull_EnumServicesStatusExA(struct ndr_pull *ndr, int flags, struct EnumServicesStatusExA *r)
6509
{
6510
uint32_t _ptr_resume_handle;
6511
uint32_t _ptr_group_name;
6512
TALLOC_CTX *_mem_save_scmanager_0;
6513
TALLOC_CTX *_mem_save_needed_0;
6514
TALLOC_CTX *_mem_save_service_returned_0;
6515
TALLOC_CTX *_mem_save_resume_handle_0;
6516
TALLOC_CTX *_mem_save_group_name_0;
6517
TALLOC_CTX *_mem_save_group_name_1;
6518
if (flags & NDR_IN) {
6519
ZERO_STRUCT(r->out);
6520
6521
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6522
NDR_PULL_ALLOC(ndr, r->in.scmanager);
6523
}
6524
_mem_save_scmanager_0 = NDR_PULL_GET_MEM_CTX(ndr);
6525
NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager, LIBNDR_FLAG_REF_ALLOC);
6526
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));
6527
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_0, LIBNDR_FLAG_REF_ALLOC);
6528
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
6529
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
6530
NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
6531
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
6532
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6533
if (_ptr_resume_handle) {
6534
NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6535
} else {
6536
r->in.resume_handle = NULL;
6537
}
6538
if (r->in.resume_handle) {
6539
_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6540
NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
6541
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6542
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6543
}
6544
NDR_PULL_ALLOC(ndr, r->out.needed);
6545
ZERO_STRUCTP(r->out.needed);
6546
NDR_PULL_ALLOC(ndr, r->out.service_returned);
6547
ZERO_STRUCTP(r->out.service_returned);
6548
NDR_PULL_ALLOC(ndr, r->out.group_name);
6549
ZERO_STRUCTP(r->out.group_name);
6550
}
6551
if (flags & NDR_OUT) {
6552
NDR_PULL_ALLOC_N(ndr, r->out.services, r->in.offered);
6553
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.offered));
6554
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6555
NDR_PULL_ALLOC(ndr, r->out.needed);
6556
}
6557
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
6558
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
6559
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
6560
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
6561
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6562
NDR_PULL_ALLOC(ndr, r->out.service_returned);
6563
}
6564
_mem_save_service_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
6565
NDR_PULL_SET_MEM_CTX(ndr, r->out.service_returned, LIBNDR_FLAG_REF_ALLOC);
6566
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.service_returned));
6567
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_returned_0, LIBNDR_FLAG_REF_ALLOC);
6568
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6569
if (_ptr_resume_handle) {
6570
NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6571
} else {
6572
r->out.resume_handle = NULL;
6573
}
6574
if (r->out.resume_handle) {
6575
_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6576
NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6577
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6578
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6579
}
6580
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6581
NDR_PULL_ALLOC(ndr, r->out.group_name);
6582
}
6583
_mem_save_group_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6584
NDR_PULL_SET_MEM_CTX(ndr, r->out.group_name, LIBNDR_FLAG_REF_ALLOC);
6585
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_name));
6586
if (_ptr_group_name) {
6587
NDR_PULL_ALLOC(ndr, *r->out.group_name);
6588
} else {
6589
*r->out.group_name = NULL;
6590
}
6591
if (*r->out.group_name) {
6592
_mem_save_group_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
6593
NDR_PULL_SET_MEM_CTX(ndr, *r->out.group_name, 0);
6594
NDR_CHECK(ndr_pull_array_size(ndr, r->out.group_name));
6595
NDR_CHECK(ndr_pull_array_length(ndr, r->out.group_name));
6596
if (ndr_get_array_length(ndr, r->out.group_name) > ndr_get_array_size(ndr, r->out.group_name)) {
6597
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.group_name), ndr_get_array_length(ndr, r->out.group_name));
6598
}
6599
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.group_name), sizeof(uint16_t)));
6600
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.group_name, ndr_get_array_length(ndr, r->out.group_name), sizeof(uint16_t), CH_UTF16));
6601
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_1, 0);
6602
}
6603
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_0, LIBNDR_FLAG_REF_ALLOC);
6604
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6605
}
6606
return NDR_ERR_SUCCESS;
6607
}
6608
6609
_PUBLIC_ void ndr_print_EnumServicesStatusExA(struct ndr_print *ndr, const char *name, int flags, const struct EnumServicesStatusExA *r)
6610
{
6611
ndr_print_struct(ndr, name, "EnumServicesStatusExA");
6612
if (r == NULL) { ndr_print_null(ndr); return; }
6613
ndr->depth++;
6614
if (flags & NDR_SET_VALUES) {
6615
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6616
}
6617
if (flags & NDR_IN) {
6618
ndr_print_struct(ndr, "in", "EnumServicesStatusExA");
6619
ndr->depth++;
6620
ndr_print_ptr(ndr, "scmanager", r->in.scmanager);
6621
ndr->depth++;
6622
ndr_print_policy_handle(ndr, "scmanager", r->in.scmanager);
6623
ndr->depth--;
6624
ndr_print_uint32(ndr, "info_level", r->in.info_level);
6625
ndr_print_uint32(ndr, "type", r->in.type);
6626
ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
6627
ndr_print_uint32(ndr, "offered", r->in.offered);
6628
ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6629
ndr->depth++;
6630
if (r->in.resume_handle) {
6631
ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6632
}
6633
ndr->depth--;
6634
ndr->depth--;
6635
}
6636
if (flags & NDR_OUT) {
6637
ndr_print_struct(ndr, "out", "EnumServicesStatusExA");
6638
ndr->depth++;
6639
ndr_print_array_uint8(ndr, "services", r->out.services, r->in.offered);
6640
ndr_print_ptr(ndr, "needed", r->out.needed);
6641
ndr->depth++;
6642
ndr_print_uint32(ndr, "needed", *r->out.needed);
6643
ndr->depth--;
6644
ndr_print_ptr(ndr, "service_returned", r->out.service_returned);
6645
ndr->depth++;
6646
ndr_print_uint32(ndr, "service_returned", *r->out.service_returned);
6647
ndr->depth--;
6648
ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6649
ndr->depth++;
6650
if (r->out.resume_handle) {
6651
ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6652
}
6653
ndr->depth--;
6654
ndr_print_ptr(ndr, "group_name", r->out.group_name);
6655
ndr->depth++;
6656
ndr_print_ptr(ndr, "group_name", *r->out.group_name);
6657
ndr->depth++;
6658
if (*r->out.group_name) {
6659
ndr_print_string(ndr, "group_name", *r->out.group_name);
6660
}
6661
ndr->depth--;
6662
ndr->depth--;
6663
ndr_print_WERROR(ndr, "result", r->out.result);
6664
ndr->depth--;
6665
}
6666
ndr->depth--;
6667
}
6668
6669
static enum ndr_err_code ndr_push_EnumServicesStatusExW(struct ndr_push *ndr, int flags, const struct EnumServicesStatusExW *r)
6670
{
6671
if (flags & NDR_IN) {
6672
if (r->in.scmanager == NULL) {
6673
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6674
}
6675
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));
6676
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
6677
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
6678
NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
6679
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
6680
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
6681
if (r->in.resume_handle) {
6682
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6683
}
6684
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.group_name));
6685
if (r->in.group_name) {
6686
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.group_name, CH_UTF16)));
6687
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6688
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.group_name, CH_UTF16)));
6689
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.group_name, ndr_charset_length(r->in.group_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6690
}
6691
}
6692
if (flags & NDR_OUT) {
6693
if (r->out.services == NULL) {
6694
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6695
}
6696
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
6697
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.offered));
6698
if (r->out.needed == NULL) {
6699
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6700
}
6701
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
6702
if (r->out.service_returned == NULL) {
6703
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6704
}
6705
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.service_returned));
6706
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
6707
if (r->out.resume_handle) {
6708
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6709
}
6710
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6711
}
6712
return NDR_ERR_SUCCESS;
6713
}
6714
6715
static enum ndr_err_code ndr_pull_EnumServicesStatusExW(struct ndr_pull *ndr, int flags, struct EnumServicesStatusExW *r)
6716
{
6717
uint32_t _ptr_resume_handle;
6718
uint32_t _ptr_group_name;
6719
TALLOC_CTX *_mem_save_scmanager_0;
6720
TALLOC_CTX *_mem_save_needed_0;
6721
TALLOC_CTX *_mem_save_service_returned_0;
6722
TALLOC_CTX *_mem_save_resume_handle_0;
6723
TALLOC_CTX *_mem_save_group_name_0;
6724
if (flags & NDR_IN) {
6725
ZERO_STRUCT(r->out);
6726
6727
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6728
NDR_PULL_ALLOC(ndr, r->in.scmanager);
6729
}
6730
_mem_save_scmanager_0 = NDR_PULL_GET_MEM_CTX(ndr);
6731
NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager, LIBNDR_FLAG_REF_ALLOC);
6732
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));
6733
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_0, LIBNDR_FLAG_REF_ALLOC);
6734
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
6735
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
6736
NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
6737
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
6738
if (r->in.offered > 0x40000) {
6739
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6740
}
6741
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6742
if (_ptr_resume_handle) {
6743
NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6744
} else {
6745
r->in.resume_handle = NULL;
6746
}
6747
if (r->in.resume_handle) {
6748
_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6749
NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
6750
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6751
if (*r->in.resume_handle > 0x40000) {
6752
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6753
}
6754
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6755
}
6756
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_name));
6757
if (_ptr_group_name) {
6758
NDR_PULL_ALLOC(ndr, r->in.group_name);
6759
} else {
6760
r->in.group_name = NULL;
6761
}
6762
if (r->in.group_name) {
6763
_mem_save_group_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6764
NDR_PULL_SET_MEM_CTX(ndr, r->in.group_name, 0);
6765
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.group_name));
6766
NDR_CHECK(ndr_pull_array_length(ndr, &r->in.group_name));
6767
if (ndr_get_array_length(ndr, &r->in.group_name) > ndr_get_array_size(ndr, &r->in.group_name)) {
6768
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.group_name), ndr_get_array_length(ndr, &r->in.group_name));
6769
}
6770
NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.group_name), sizeof(uint16_t)));
6771
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.group_name, ndr_get_array_length(ndr, &r->in.group_name), sizeof(uint16_t), CH_UTF16));
6772
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_0, 0);
6773
}
6774
NDR_PULL_ALLOC_N(ndr, r->out.services, r->in.offered);
6775
memset(r->out.services, 0, (r->in.offered) * sizeof(*r->out.services));
6776
NDR_PULL_ALLOC(ndr, r->out.needed);
6777
ZERO_STRUCTP(r->out.needed);
6778
NDR_PULL_ALLOC(ndr, r->out.service_returned);
6779
ZERO_STRUCTP(r->out.service_returned);
6780
}
6781
if (flags & NDR_OUT) {
6782
NDR_CHECK(ndr_pull_array_size(ndr, &r->out.services));
6783
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6784
NDR_PULL_ALLOC_N(ndr, r->out.services, ndr_get_array_size(ndr, &r->out.services));
6785
}
6786
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.services, ndr_get_array_size(ndr, &r->out.services)));
6787
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6788
NDR_PULL_ALLOC(ndr, r->out.needed);
6789
}
6790
_mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
6791
NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
6792
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
6793
if (*r->out.needed > 0x40000) {
6794
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6795
}
6796
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
6797
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6798
NDR_PULL_ALLOC(ndr, r->out.service_returned);
6799
}
6800
_mem_save_service_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
6801
NDR_PULL_SET_MEM_CTX(ndr, r->out.service_returned, LIBNDR_FLAG_REF_ALLOC);
6802
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.service_returned));
6803
if (*r->out.service_returned > 0x40000) {
6804
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6805
}
6806
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_returned_0, LIBNDR_FLAG_REF_ALLOC);
6807
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6808
if (_ptr_resume_handle) {
6809
NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6810
} else {
6811
r->out.resume_handle = NULL;
6812
}
6813
if (r->out.resume_handle) {
6814
_mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6815
NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6816
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6817
if (*r->out.resume_handle > 0x40000) {
6818
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6819
}
6820
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6821
}
6822
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6823
if (r->out.services) {
6824
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.services, r->in.offered));
6825
}
6826
}
6827
return NDR_ERR_SUCCESS;
6828
}
6829
6830
_PUBLIC_ void ndr_print_EnumServicesStatusExW(struct ndr_print *ndr, const char *name, int flags, const struct EnumServicesStatusExW *r)
6831
{
6832
ndr_print_struct(ndr, name, "EnumServicesStatusExW");
6833
if (r == NULL) { ndr_print_null(ndr); return; }
6834
ndr->depth++;
6835
if (flags & NDR_SET_VALUES) {
6836
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6837
}
6838
if (flags & NDR_IN) {
6839
ndr_print_struct(ndr, "in", "EnumServicesStatusExW");
6840
ndr->depth++;
6841
ndr_print_ptr(ndr, "scmanager", r->in.scmanager);
6842
ndr->depth++;
6843
ndr_print_policy_handle(ndr, "scmanager", r->in.scmanager);
6844
ndr->depth--;
6845
ndr_print_uint32(ndr, "info_level", r->in.info_level);
6846
ndr_print_uint32(ndr, "type", r->in.type);
6847
ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
6848
ndr_print_uint32(ndr, "offered", r->in.offered);
6849
ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6850
ndr->depth++;
6851
if (r->in.resume_handle) {
6852
ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6853
}
6854
ndr->depth--;
6855
ndr_print_ptr(ndr, "group_name", r->in.group_name);
6856
ndr->depth++;
6857
if (r->in.group_name) {
6858
ndr_print_string(ndr, "group_name", r->in.group_name);
6859
}
6860
ndr->depth--;
6861
ndr->depth--;
6862
}
6863
if (flags & NDR_OUT) {
6864
ndr_print_struct(ndr, "out", "EnumServicesStatusExW");
6865
ndr->depth++;
6866
ndr_print_ptr(ndr, "services", r->out.services);
6867
ndr->depth++;
6868
ndr_print_array_uint8(ndr, "services", r->out.services, r->in.offered);
6869
ndr->depth--;
6870
ndr_print_ptr(ndr, "needed", r->out.needed);
6871
ndr->depth++;
6872
ndr_print_uint32(ndr, "needed", *r->out.needed);
6873
ndr->depth--;
6874
ndr_print_ptr(ndr, "service_returned", r->out.service_returned);
6875
ndr->depth++;
6876
ndr_print_uint32(ndr, "service_returned", *r->out.service_returned);
6877
ndr->depth--;
6878
ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6879
ndr->depth++;
6880
if (r->out.resume_handle) {
6881
ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6882
}
6883
ndr->depth--;
6884
ndr_print_WERROR(ndr, "result", r->out.result);
6885
ndr->depth--;
6886
}
6887
ndr->depth--;
6888
}
6889
6890
static enum ndr_err_code ndr_push_svcctl_SCSendTSMessage(struct ndr_push *ndr, int flags, const struct svcctl_SCSendTSMessage *r)
6891
{
6892
if (flags & NDR_IN) {
6893
}
6894
if (flags & NDR_OUT) {
6895
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6896
}
6897
return NDR_ERR_SUCCESS;
6898
}
6899
6900
static enum ndr_err_code ndr_pull_svcctl_SCSendTSMessage(struct ndr_pull *ndr, int flags, struct svcctl_SCSendTSMessage *r)
6901
{
6902
if (flags & NDR_IN) {
6903
}
6904
if (flags & NDR_OUT) {
6905
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6906
}
6907
return NDR_ERR_SUCCESS;
6908
}
6909
6910
_PUBLIC_ void ndr_print_svcctl_SCSendTSMessage(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSendTSMessage *r)
6911
{
6912
ndr_print_struct(ndr, name, "svcctl_SCSendTSMessage");
6913
if (r == NULL) { ndr_print_null(ndr); return; }
6914
ndr->depth++;
6915
if (flags & NDR_SET_VALUES) {
6916
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6917
}
6918
if (flags & NDR_IN) {
6919
ndr_print_struct(ndr, "in", "svcctl_SCSendTSMessage");
6920
ndr->depth++;
6921
ndr->depth--;
6922
}
6923
if (flags & NDR_OUT) {
6924
ndr_print_struct(ndr, "out", "svcctl_SCSendTSMessage");
6925
ndr->depth++;
6926
ndr_print_WERROR(ndr, "result", r->out.result);
6927
ndr->depth--;
6928
}
6929
ndr->depth--;
6930
}
6931
6932
static const struct ndr_interface_call svcctl_calls[] = {
6933
{
6934
"svcctl_CloseServiceHandle",
6935
sizeof(struct svcctl_CloseServiceHandle),
6936
(ndr_push_flags_fn_t) ndr_push_svcctl_CloseServiceHandle,
6937
(ndr_pull_flags_fn_t) ndr_pull_svcctl_CloseServiceHandle,
6938
(ndr_print_function_t) ndr_print_svcctl_CloseServiceHandle,
6939
{ 0, NULL },
6940
{ 0, NULL },
6941
},
6942
{
6943
"svcctl_ControlService",
6944
sizeof(struct svcctl_ControlService),
6945
(ndr_push_flags_fn_t) ndr_push_svcctl_ControlService,
6946
(ndr_pull_flags_fn_t) ndr_pull_svcctl_ControlService,
6947
(ndr_print_function_t) ndr_print_svcctl_ControlService,
6948
{ 0, NULL },
6949
{ 0, NULL },
6950
},
6951
{
6952
"svcctl_DeleteService",
6953
sizeof(struct svcctl_DeleteService),
6954
(ndr_push_flags_fn_t) ndr_push_svcctl_DeleteService,
6955
(ndr_pull_flags_fn_t) ndr_pull_svcctl_DeleteService,
6956
(ndr_print_function_t) ndr_print_svcctl_DeleteService,
6957
{ 0, NULL },
6958
{ 0, NULL },
6959
},
6960
{
6961
"svcctl_LockServiceDatabase",
6962
sizeof(struct svcctl_LockServiceDatabase),
6963
(ndr_push_flags_fn_t) ndr_push_svcctl_LockServiceDatabase,
6964
(ndr_pull_flags_fn_t) ndr_pull_svcctl_LockServiceDatabase,
6965
(ndr_print_function_t) ndr_print_svcctl_LockServiceDatabase,
6966
{ 0, NULL },
6967
{ 0, NULL },
6968
},
6969
{
6970
"svcctl_QueryServiceObjectSecurity",
6971
sizeof(struct svcctl_QueryServiceObjectSecurity),
6972
(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceObjectSecurity,
6973
(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceObjectSecurity,
6974
(ndr_print_function_t) ndr_print_svcctl_QueryServiceObjectSecurity,
6975
{ 0, NULL },
6976
{ 0, NULL },
6977
},
6978
{
6979
"svcctl_SetServiceObjectSecurity",
6980
sizeof(struct svcctl_SetServiceObjectSecurity),
6981
(ndr_push_flags_fn_t) ndr_push_svcctl_SetServiceObjectSecurity,
6982
(ndr_pull_flags_fn_t) ndr_pull_svcctl_SetServiceObjectSecurity,
6983
(ndr_print_function_t) ndr_print_svcctl_SetServiceObjectSecurity,
6984
{ 0, NULL },
6985
{ 0, NULL },
6986
},
6987
{
6988
"svcctl_QueryServiceStatus",
6989
sizeof(struct svcctl_QueryServiceStatus),
6990
(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceStatus,
6991
(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceStatus,
6992
(ndr_print_function_t) ndr_print_svcctl_QueryServiceStatus,
6993
{ 0, NULL },
6994
{ 0, NULL },
6995
},
6996
{
6997
"svcctl_SetServiceStatus",
6998
sizeof(struct svcctl_SetServiceStatus),
6999
(ndr_push_flags_fn_t) ndr_push_svcctl_SetServiceStatus,
7000
(ndr_pull_flags_fn_t) ndr_pull_svcctl_SetServiceStatus,
7001
(ndr_print_function_t) ndr_print_svcctl_SetServiceStatus,
7002
{ 0, NULL },
7003
{ 0, NULL },
7004
},
7005
{
7006
"svcctl_UnlockServiceDatabase",
7007
sizeof(struct svcctl_UnlockServiceDatabase),
7008
(ndr_push_flags_fn_t) ndr_push_svcctl_UnlockServiceDatabase,
7009
(ndr_pull_flags_fn_t) ndr_pull_svcctl_UnlockServiceDatabase,
7010
(ndr_print_function_t) ndr_print_svcctl_UnlockServiceDatabase,
7011
{ 0, NULL },
7012
{ 0, NULL },
7013
},
7014
{
7015
"svcctl_NotifyBootConfigStatus",
7016
sizeof(struct svcctl_NotifyBootConfigStatus),
7017
(ndr_push_flags_fn_t) ndr_push_svcctl_NotifyBootConfigStatus,
7018
(ndr_pull_flags_fn_t) ndr_pull_svcctl_NotifyBootConfigStatus,
7019
(ndr_print_function_t) ndr_print_svcctl_NotifyBootConfigStatus,
7020
{ 0, NULL },
7021
{ 0, NULL },
7022
},
7023
{
7024
"svcctl_SCSetServiceBitsW",
7025
sizeof(struct svcctl_SCSetServiceBitsW),
7026
(ndr_push_flags_fn_t) ndr_push_svcctl_SCSetServiceBitsW,
7027
(ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSetServiceBitsW,
7028
(ndr_print_function_t) ndr_print_svcctl_SCSetServiceBitsW,
7029
{ 0, NULL },
7030
{ 0, NULL },
7031
},
7032
{
7033
"svcctl_ChangeServiceConfigW",
7034
sizeof(struct svcctl_ChangeServiceConfigW),
7035
(ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfigW,
7036
(ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfigW,
7037
(ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfigW,
7038
{ 0, NULL },
7039
{ 0, NULL },
7040
},
7041
{
7042
"svcctl_CreateServiceW",
7043
sizeof(struct svcctl_CreateServiceW),
7044
(ndr_push_flags_fn_t) ndr_push_svcctl_CreateServiceW,
7045
(ndr_pull_flags_fn_t) ndr_pull_svcctl_CreateServiceW,
7046
(ndr_print_function_t) ndr_print_svcctl_CreateServiceW,
7047
{ 0, NULL },
7048
{ 0, NULL },
7049
},
7050
{
7051
"svcctl_EnumDependentServicesW",
7052
sizeof(struct svcctl_EnumDependentServicesW),
7053
(ndr_push_flags_fn_t) ndr_push_svcctl_EnumDependentServicesW,
7054
(ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumDependentServicesW,
7055
(ndr_print_function_t) ndr_print_svcctl_EnumDependentServicesW,
7056
{ 0, NULL },
7057
{ 0, NULL },
7058
},
7059
{
7060
"svcctl_EnumServicesStatusW",
7061
sizeof(struct svcctl_EnumServicesStatusW),
7062
(ndr_push_flags_fn_t) ndr_push_svcctl_EnumServicesStatusW,
7063
(ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServicesStatusW,
7064
(ndr_print_function_t) ndr_print_svcctl_EnumServicesStatusW,
7065
{ 0, NULL },
7066
{ 0, NULL },
7067
},
7068
{
7069
"svcctl_OpenSCManagerW",
7070
sizeof(struct svcctl_OpenSCManagerW),
7071
(ndr_push_flags_fn_t) ndr_push_svcctl_OpenSCManagerW,
7072
(ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenSCManagerW,
7073
(ndr_print_function_t) ndr_print_svcctl_OpenSCManagerW,
7074
{ 0, NULL },
7075
{ 0, NULL },
7076
},
7077
{
7078
"svcctl_OpenServiceW",
7079
sizeof(struct svcctl_OpenServiceW),
7080
(ndr_push_flags_fn_t) ndr_push_svcctl_OpenServiceW,
7081
(ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenServiceW,
7082
(ndr_print_function_t) ndr_print_svcctl_OpenServiceW,
7083
{ 0, NULL },
7084
{ 0, NULL },
7085
},
7086
{
7087
"svcctl_QueryServiceConfigW",
7088
sizeof(struct svcctl_QueryServiceConfigW),
7089
(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfigW,
7090
(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfigW,
7091
(ndr_print_function_t) ndr_print_svcctl_QueryServiceConfigW,
7092
{ 0, NULL },
7093
{ 0, NULL },
7094
},
7095
{
7096
"svcctl_QueryServiceLockStatusW",
7097
sizeof(struct svcctl_QueryServiceLockStatusW),
7098
(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceLockStatusW,
7099
(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceLockStatusW,
7100
(ndr_print_function_t) ndr_print_svcctl_QueryServiceLockStatusW,
7101
{ 0, NULL },
7102
{ 0, NULL },
7103
},
7104
{
7105
"svcctl_StartServiceW",
7106
sizeof(struct svcctl_StartServiceW),
7107
(ndr_push_flags_fn_t) ndr_push_svcctl_StartServiceW,
7108
(ndr_pull_flags_fn_t) ndr_pull_svcctl_StartServiceW,
7109
(ndr_print_function_t) ndr_print_svcctl_StartServiceW,
7110
{ 0, NULL },
7111
{ 0, NULL },
7112
},
7113
{
7114
"svcctl_GetServiceDisplayNameW",
7115
sizeof(struct svcctl_GetServiceDisplayNameW),
7116
(ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceDisplayNameW,
7117
(ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceDisplayNameW,
7118
(ndr_print_function_t) ndr_print_svcctl_GetServiceDisplayNameW,
7119
{ 0, NULL },
7120
{ 0, NULL },
7121
},
7122
{
7123
"svcctl_GetServiceKeyNameW",
7124
sizeof(struct svcctl_GetServiceKeyNameW),
7125
(ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceKeyNameW,
7126
(ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceKeyNameW,
7127
(ndr_print_function_t) ndr_print_svcctl_GetServiceKeyNameW,
7128
{ 0, NULL },
7129
{ 0, NULL },
7130
},
7131
{
7132
"svcctl_SCSetServiceBitsA",
7133
sizeof(struct svcctl_SCSetServiceBitsA),
7134
(ndr_push_flags_fn_t) ndr_push_svcctl_SCSetServiceBitsA,
7135
(ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSetServiceBitsA,
7136
(ndr_print_function_t) ndr_print_svcctl_SCSetServiceBitsA,
7137
{ 0, NULL },
7138
{ 0, NULL },
7139
},
7140
{
7141
"svcctl_ChangeServiceConfigA",
7142
sizeof(struct svcctl_ChangeServiceConfigA),
7143
(ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfigA,
7144
(ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfigA,
7145
(ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfigA,
7146
{ 0, NULL },
7147
{ 0, NULL },
7148
},
7149
{
7150
"svcctl_CreateServiceA",
7151
sizeof(struct svcctl_CreateServiceA),
7152
(ndr_push_flags_fn_t) ndr_push_svcctl_CreateServiceA,
7153
(ndr_pull_flags_fn_t) ndr_pull_svcctl_CreateServiceA,
7154
(ndr_print_function_t) ndr_print_svcctl_CreateServiceA,
7155
{ 0, NULL },
7156
{ 0, NULL },
7157
},
7158
{
7159
"svcctl_EnumDependentServicesA",
7160
sizeof(struct svcctl_EnumDependentServicesA),
7161
(ndr_push_flags_fn_t) ndr_push_svcctl_EnumDependentServicesA,
7162
(ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumDependentServicesA,
7163
(ndr_print_function_t) ndr_print_svcctl_EnumDependentServicesA,
7164
{ 0, NULL },
7165
{ 0, NULL },
7166
},
7167
{
7168
"svcctl_EnumServicesStatusA",
7169
sizeof(struct svcctl_EnumServicesStatusA),
7170
(ndr_push_flags_fn_t) ndr_push_svcctl_EnumServicesStatusA,
7171
(ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServicesStatusA,
7172
(ndr_print_function_t) ndr_print_svcctl_EnumServicesStatusA,
7173
{ 0, NULL },
7174
{ 0, NULL },
7175
},
7176
{
7177
"svcctl_OpenSCManagerA",
7178
sizeof(struct svcctl_OpenSCManagerA),
7179
(ndr_push_flags_fn_t) ndr_push_svcctl_OpenSCManagerA,
7180
(ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenSCManagerA,
7181
(ndr_print_function_t) ndr_print_svcctl_OpenSCManagerA,
7182
{ 0, NULL },
7183
{ 0, NULL },
7184
},
7185
{
7186
"svcctl_OpenServiceA",
7187
sizeof(struct svcctl_OpenServiceA),
7188
(ndr_push_flags_fn_t) ndr_push_svcctl_OpenServiceA,
7189
(ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenServiceA,
7190
(ndr_print_function_t) ndr_print_svcctl_OpenServiceA,
7191
{ 0, NULL },
7192
{ 0, NULL },
7193
},
7194
{
7195
"svcctl_QueryServiceConfigA",
7196
sizeof(struct svcctl_QueryServiceConfigA),
7197
(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfigA,
7198
(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfigA,
7199
(ndr_print_function_t) ndr_print_svcctl_QueryServiceConfigA,
7200
{ 0, NULL },
7201
{ 0, NULL },
7202
},
7203
{
7204
"svcctl_QueryServiceLockStatusA",
7205
sizeof(struct svcctl_QueryServiceLockStatusA),
7206
(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceLockStatusA,
7207
(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceLockStatusA,
7208
(ndr_print_function_t) ndr_print_svcctl_QueryServiceLockStatusA,
7209
{ 0, NULL },
7210
{ 0, NULL },
7211
},
7212
{
7213
"svcctl_StartServiceA",
7214
sizeof(struct svcctl_StartServiceA),
7215
(ndr_push_flags_fn_t) ndr_push_svcctl_StartServiceA,
7216
(ndr_pull_flags_fn_t) ndr_pull_svcctl_StartServiceA,
7217
(ndr_print_function_t) ndr_print_svcctl_StartServiceA,
7218
{ 0, NULL },
7219
{ 0, NULL },
7220
},
7221
{
7222
"svcctl_GetServiceDisplayNameA",
7223
sizeof(struct svcctl_GetServiceDisplayNameA),
7224
(ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceDisplayNameA,
7225
(ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceDisplayNameA,
7226
(ndr_print_function_t) ndr_print_svcctl_GetServiceDisplayNameA,
7227
{ 0, NULL },
7228
{ 0, NULL },
7229
},
7230
{
7231
"svcctl_GetServiceKeyNameA",
7232
sizeof(struct svcctl_GetServiceKeyNameA),
7233
(ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceKeyNameA,
7234
(ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceKeyNameA,
7235
(ndr_print_function_t) ndr_print_svcctl_GetServiceKeyNameA,
7236
{ 0, NULL },
7237
{ 0, NULL },
7238
},
7239
{
7240
"svcctl_GetCurrentGroupeStateW",
7241
sizeof(struct svcctl_GetCurrentGroupeStateW),
7242
(ndr_push_flags_fn_t) ndr_push_svcctl_GetCurrentGroupeStateW,
7243
(ndr_pull_flags_fn_t) ndr_pull_svcctl_GetCurrentGroupeStateW,
7244
(ndr_print_function_t) ndr_print_svcctl_GetCurrentGroupeStateW,
7245
{ 0, NULL },
7246
{ 0, NULL },
7247
},
7248
{
7249
"svcctl_EnumServiceGroupW",
7250
sizeof(struct svcctl_EnumServiceGroupW),
7251
(ndr_push_flags_fn_t) ndr_push_svcctl_EnumServiceGroupW,
7252
(ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServiceGroupW,
7253
(ndr_print_function_t) ndr_print_svcctl_EnumServiceGroupW,
7254
{ 0, NULL },
7255
{ 0, NULL },
7256
},
7257
{
7258
"svcctl_ChangeServiceConfig2A",
7259
sizeof(struct svcctl_ChangeServiceConfig2A),
7260
(ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfig2A,
7261
(ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfig2A,
7262
(ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfig2A,
7263
{ 0, NULL },
7264
{ 0, NULL },
7265
},
7266
{
7267
"svcctl_ChangeServiceConfig2W",
7268
sizeof(struct svcctl_ChangeServiceConfig2W),
7269
(ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfig2W,
7270
(ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfig2W,
7271
(ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfig2W,
7272
{ 0, NULL },
7273
{ 0, NULL },
7274
},
7275
{
7276
"svcctl_QueryServiceConfig2A",
7277
sizeof(struct svcctl_QueryServiceConfig2A),
7278
(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfig2A,
7279
(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfig2A,
7280
(ndr_print_function_t) ndr_print_svcctl_QueryServiceConfig2A,
7281
{ 0, NULL },
7282
{ 0, NULL },
7283
},
7284
{
7285
"svcctl_QueryServiceConfig2W",
7286
sizeof(struct svcctl_QueryServiceConfig2W),
7287
(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfig2W,
7288
(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfig2W,
7289
(ndr_print_function_t) ndr_print_svcctl_QueryServiceConfig2W,
7290
{ 0, NULL },
7291
{ 0, NULL },
7292
},
7293
{
7294
"svcctl_QueryServiceStatusEx",
7295
sizeof(struct svcctl_QueryServiceStatusEx),
7296
(ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceStatusEx,
7297
(ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceStatusEx,
7298
(ndr_print_function_t) ndr_print_svcctl_QueryServiceStatusEx,
7299
{ 0, NULL },
7300
{ 0, NULL },
7301
},
7302
{
7303
"EnumServicesStatusExA",
7304
sizeof(struct EnumServicesStatusExA),
7305
(ndr_push_flags_fn_t) ndr_push_EnumServicesStatusExA,
7306
(ndr_pull_flags_fn_t) ndr_pull_EnumServicesStatusExA,
7307
(ndr_print_function_t) ndr_print_EnumServicesStatusExA,
7308
{ 0, NULL },
7309
{ 0, NULL },
7310
},
7311
{
7312
"EnumServicesStatusExW",
7313
sizeof(struct EnumServicesStatusExW),
7314
(ndr_push_flags_fn_t) ndr_push_EnumServicesStatusExW,
7315
(ndr_pull_flags_fn_t) ndr_pull_EnumServicesStatusExW,
7316
(ndr_print_function_t) ndr_print_EnumServicesStatusExW,
7317
{ 0, NULL },
7318
{ 0, NULL },
7319
},
7320
{
7321
"svcctl_SCSendTSMessage",
7322
sizeof(struct svcctl_SCSendTSMessage),
7323
(ndr_push_flags_fn_t) ndr_push_svcctl_SCSendTSMessage,
7324
(ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSendTSMessage,
7325
(ndr_print_function_t) ndr_print_svcctl_SCSendTSMessage,
7326
{ 0, NULL },
7327
{ 0, NULL },
7328
},
7329
{ NULL, 0, NULL, NULL, NULL }
7330
};
7331
7332
static const char * const svcctl_endpoint_strings[] = {
7333
"ncacn_np:[\\pipe\\svcctl]",
7334
"ncalrpc:",
7335
};
7336
7337
static const struct ndr_interface_string_array svcctl_endpoints = {
7338
.count = 2,
7339
.names = svcctl_endpoint_strings
7340
};
7341
7342
static const char * const svcctl_authservice_strings[] = {
7343
"host",
7344
};
7345
7346
static const struct ndr_interface_string_array svcctl_authservices = {
7347
.count = 1,
7348
.names = svcctl_authservice_strings
7349
};
7350
7351
7352
const struct ndr_interface_table ndr_table_svcctl = {
7353
.name = "svcctl",
7354
.syntax_id = {
7355
{0x367abb81,0x9844,0x35f1,{0xad,0x32},{0x98,0xf0,0x38,0x00,0x10,0x03}},
7356
NDR_SVCCTL_VERSION
7357
},
7358
.helpstring = NDR_SVCCTL_HELPSTRING,
7359
.num_calls = 44,
7360
.calls = svcctl_calls,
7361
.endpoints = &svcctl_endpoints,
7362
.authservices = &svcctl_authservices
7363
};
7364
Loggerhead is a web-based interface for Breezy
Version: 2.0.1