~ubuntu-branches/ubuntu/wily/samba/wily
» Revision
179
: .pc/CVE-2012-1182-2.patch/source3/librpc/gen_ndr/ndr_eventlog.c
« back to all changes in this revision
Viewing changes to .pc/CVE-2012-1182-2.patch/source3/librpc/gen_ndr/ndr_eventlog.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_eventlog.c
1
/* parser auto-generated by pidl */
2
3
#include "includes.h"
4
#include "librpc/gen_ndr/ndr_eventlog.h"
5
6
#include "librpc/gen_ndr/ndr_lsa.h"
7
#include "librpc/gen_ndr/ndr_security.h"
8
static enum ndr_err_code ndr_push_eventlogReadFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9
{
10
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11
return NDR_ERR_SUCCESS;
12
}
13
14
static enum ndr_err_code ndr_pull_eventlogReadFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15
{
16
uint32_t v;
17
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18
*r = v;
19
return NDR_ERR_SUCCESS;
20
}
21
22
_PUBLIC_ void ndr_print_eventlogReadFlags(struct ndr_print *ndr, const char *name, uint32_t r)
23
{
24
ndr_print_uint32(ndr, name, r);
25
ndr->depth++;
26
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "EVENTLOG_SEQUENTIAL_READ", EVENTLOG_SEQUENTIAL_READ, r);
27
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "EVENTLOG_SEEK_READ", EVENTLOG_SEEK_READ, r);
28
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "EVENTLOG_FORWARDS_READ", EVENTLOG_FORWARDS_READ, r);
29
ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "EVENTLOG_BACKWARDS_READ", EVENTLOG_BACKWARDS_READ, r);
30
ndr->depth--;
31
}
32
33
_PUBLIC_ enum ndr_err_code ndr_push_eventlogEventTypes(struct ndr_push *ndr, int ndr_flags, enum eventlogEventTypes r)
34
{
35
NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
36
return NDR_ERR_SUCCESS;
37
}
38
39
_PUBLIC_ enum ndr_err_code ndr_pull_eventlogEventTypes(struct ndr_pull *ndr, int ndr_flags, enum eventlogEventTypes *r)
40
{
41
uint16_t v;
42
NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
43
*r = v;
44
return NDR_ERR_SUCCESS;
45
}
46
47
_PUBLIC_ void ndr_print_eventlogEventTypes(struct ndr_print *ndr, const char *name, enum eventlogEventTypes r)
48
{
49
const char *val = NULL;
50
51
switch (r) {
52
case EVENTLOG_SUCCESS: val = "EVENTLOG_SUCCESS"; break;
53
case EVENTLOG_ERROR_TYPE: val = "EVENTLOG_ERROR_TYPE"; break;
54
case EVENTLOG_WARNING_TYPE: val = "EVENTLOG_WARNING_TYPE"; break;
55
case EVENTLOG_INFORMATION_TYPE: val = "EVENTLOG_INFORMATION_TYPE"; break;
56
case EVENTLOG_AUDIT_SUCCESS: val = "EVENTLOG_AUDIT_SUCCESS"; break;
57
case EVENTLOG_AUDIT_FAILURE: val = "EVENTLOG_AUDIT_FAILURE"; break;
58
}
59
ndr_print_enum(ndr, name, "ENUM", val, r);
60
}
61
62
static enum ndr_err_code ndr_push_eventlog_OpenUnknown0(struct ndr_push *ndr, int ndr_flags, const struct eventlog_OpenUnknown0 *r)
63
{
64
if (ndr_flags & NDR_SCALARS) {
65
NDR_CHECK(ndr_push_align(ndr, 2));
66
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown0));
67
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown1));
68
NDR_CHECK(ndr_push_trailer_align(ndr, 2));
69
}
70
if (ndr_flags & NDR_BUFFERS) {
71
}
72
return NDR_ERR_SUCCESS;
73
}
74
75
static enum ndr_err_code ndr_pull_eventlog_OpenUnknown0(struct ndr_pull *ndr, int ndr_flags, struct eventlog_OpenUnknown0 *r)
76
{
77
if (ndr_flags & NDR_SCALARS) {
78
NDR_CHECK(ndr_pull_align(ndr, 2));
79
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown0));
80
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown1));
81
NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
82
}
83
if (ndr_flags & NDR_BUFFERS) {
84
}
85
return NDR_ERR_SUCCESS;
86
}
87
88
_PUBLIC_ void ndr_print_eventlog_OpenUnknown0(struct ndr_print *ndr, const char *name, const struct eventlog_OpenUnknown0 *r)
89
{
90
ndr_print_struct(ndr, name, "eventlog_OpenUnknown0");
91
if (r == NULL) { ndr_print_null(ndr); return; }
92
ndr->depth++;
93
ndr_print_uint16(ndr, "unknown0", r->unknown0);
94
ndr_print_uint16(ndr, "unknown1", r->unknown1);
95
ndr->depth--;
96
}
97
98
_PUBLIC_ enum ndr_err_code ndr_push_eventlog_Record_tdb(struct ndr_push *ndr, int ndr_flags, const struct eventlog_Record_tdb *r)
99
{
100
uint32_t cntr_strings_0;
101
{
102
uint32_t _flags_save_STRUCT = ndr->flags;
103
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_PRINT_ARRAY_HEX);
104
if (ndr_flags & NDR_SCALARS) {
105
NDR_CHECK(ndr_push_align(ndr, 4));
106
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
107
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "eLfL", 4, sizeof(uint8_t), CH_DOS));
108
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->record_number));
109
NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->time_generated));
110
NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->time_written));
111
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->event_id));
112
NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->event_type));
113
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_of_strings));
114
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->event_category));
115
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reserved_flags));
116
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->closing_record_number));
117
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->stringoffset));
118
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid.length));
119
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_offset));
120
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->data.length));
121
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->data_offset));
122
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->source_name)));
123
{
124
uint32_t _flags_save_string = ndr->flags;
125
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
126
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->source_name));
127
ndr->flags = _flags_save_string;
128
}
129
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->computer_name)));
130
{
131
uint32_t _flags_save_string = ndr->flags;
132
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
133
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->computer_name));
134
ndr->flags = _flags_save_string;
135
}
136
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sid_padding));
137
NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->sid));
138
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * ndr_size_string_array(r->strings, r->num_of_strings, LIBNDR_FLAG_STR_NULLTERM)));
139
{
140
uint32_t _flags_save_string = ndr->flags;
141
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
142
for (cntr_strings_0 = 0; cntr_strings_0 < r->num_of_strings; cntr_strings_0++) {
143
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->strings[cntr_strings_0]));
144
}
145
ndr->flags = _flags_save_string;
146
}
147
NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
148
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->padding));
149
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
150
}
151
if (ndr_flags & NDR_BUFFERS) {
152
}
153
ndr->flags = _flags_save_STRUCT;
154
}
155
return NDR_ERR_SUCCESS;
156
}
157
158
_PUBLIC_ enum ndr_err_code ndr_pull_eventlog_Record_tdb(struct ndr_pull *ndr, int ndr_flags, struct eventlog_Record_tdb *r)
159
{
160
uint32_t cntr_strings_0;
161
TALLOC_CTX *_mem_save_strings_0;
162
{
163
uint32_t _flags_save_STRUCT = ndr->flags;
164
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_PRINT_ARRAY_HEX);
165
if (ndr_flags & NDR_SCALARS) {
166
NDR_CHECK(ndr_pull_align(ndr, 4));
167
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
168
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->reserved, 4, sizeof(uint8_t), CH_DOS));
169
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->record_number));
170
NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->time_generated));
171
NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->time_written));
172
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->event_id));
173
NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->event_type));
174
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_of_strings));
175
if (r->num_of_strings > 256) {
176
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
177
}
178
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->event_category));
179
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved_flags));
180
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->closing_record_number));
181
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->stringoffset));
182
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_length));
183
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_offset));
184
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
185
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_offset));
186
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->source_name_len));
187
{
188
uint32_t _flags_save_string = ndr->flags;
189
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
190
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->source_name));
191
ndr->flags = _flags_save_string;
192
}
193
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->computer_name_len));
194
{
195
uint32_t _flags_save_string = ndr->flags;
196
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
197
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->computer_name));
198
ndr->flags = _flags_save_string;
199
}
200
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_padding));
201
NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->sid));
202
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->strings_len));
203
{
204
uint32_t _flags_save_string = ndr->flags;
205
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
206
NDR_PULL_ALLOC_N(ndr, r->strings, r->num_of_strings);
207
_mem_save_strings_0 = NDR_PULL_GET_MEM_CTX(ndr);
208
NDR_PULL_SET_MEM_CTX(ndr, r->strings, 0);
209
for (cntr_strings_0 = 0; cntr_strings_0 < r->num_of_strings; cntr_strings_0++) {
210
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->strings[cntr_strings_0]));
211
}
212
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_0, 0);
213
ndr->flags = _flags_save_string;
214
}
215
NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
216
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding));
217
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
218
}
219
if (ndr_flags & NDR_BUFFERS) {
220
}
221
ndr->flags = _flags_save_STRUCT;
222
}
223
return NDR_ERR_SUCCESS;
224
}
225
226
_PUBLIC_ void ndr_print_eventlog_Record_tdb(struct ndr_print *ndr, const char *name, const struct eventlog_Record_tdb *r)
227
{
228
uint32_t cntr_strings_0;
229
ndr_print_struct(ndr, name, "eventlog_Record_tdb");
230
if (r == NULL) { ndr_print_null(ndr); return; }
231
{
232
uint32_t _flags_save_STRUCT = ndr->flags;
233
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_PRINT_ARRAY_HEX);
234
ndr->depth++;
235
ndr_print_uint32(ndr, "size", r->size);
236
ndr_print_string(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"eLfL":r->reserved);
237
ndr_print_uint32(ndr, "record_number", r->record_number);
238
ndr_print_time_t(ndr, "time_generated", r->time_generated);
239
ndr_print_time_t(ndr, "time_written", r->time_written);
240
ndr_print_uint32(ndr, "event_id", r->event_id);
241
ndr_print_eventlogEventTypes(ndr, "event_type", r->event_type);
242
ndr_print_uint16(ndr, "num_of_strings", r->num_of_strings);
243
ndr_print_uint16(ndr, "event_category", r->event_category);
244
ndr_print_uint16(ndr, "reserved_flags", r->reserved_flags);
245
ndr_print_uint32(ndr, "closing_record_number", r->closing_record_number);
246
ndr_print_uint32(ndr, "stringoffset", r->stringoffset);
247
ndr_print_uint32(ndr, "sid_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->sid.length:r->sid_length);
248
ndr_print_uint32(ndr, "sid_offset", r->sid_offset);
249
ndr_print_uint32(ndr, "data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->data.length:r->data_length);
250
ndr_print_uint32(ndr, "data_offset", r->data_offset);
251
ndr_print_uint32(ndr, "source_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->source_name):r->source_name_len);
252
ndr_print_string(ndr, "source_name", r->source_name);
253
ndr_print_uint32(ndr, "computer_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->computer_name):r->computer_name_len);
254
ndr_print_string(ndr, "computer_name", r->computer_name);
255
ndr_print_uint32(ndr, "sid_padding", r->sid_padding);
256
ndr_print_DATA_BLOB(ndr, "sid", r->sid);
257
ndr_print_uint32(ndr, "strings_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * ndr_size_string_array(r->strings, r->num_of_strings, LIBNDR_FLAG_STR_NULLTERM):r->strings_len);
258
ndr->print(ndr, "%s: ARRAY(%d)", "strings", (int)r->num_of_strings);
259
ndr->depth++;
260
for (cntr_strings_0=0;cntr_strings_0<r->num_of_strings;cntr_strings_0++) {
261
ndr_print_string(ndr, "strings", r->strings[cntr_strings_0]);
262
}
263
ndr->depth--;
264
ndr_print_DATA_BLOB(ndr, "data", r->data);
265
ndr_print_uint32(ndr, "padding", r->padding);
266
ndr->depth--;
267
ndr->flags = _flags_save_STRUCT;
268
}
269
}
270
271
static enum ndr_err_code ndr_push_EVENTLOG_HEADER_FLAGS(struct ndr_push *ndr, int ndr_flags, enum EVENTLOG_HEADER_FLAGS r)
272
{
273
NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
274
return NDR_ERR_SUCCESS;
275
}
276
277
static enum ndr_err_code ndr_pull_EVENTLOG_HEADER_FLAGS(struct ndr_pull *ndr, int ndr_flags, enum EVENTLOG_HEADER_FLAGS *r)
278
{
279
uint32_t v;
280
NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
281
*r = v;
282
return NDR_ERR_SUCCESS;
283
}
284
285
_PUBLIC_ void ndr_print_EVENTLOG_HEADER_FLAGS(struct ndr_print *ndr, const char *name, enum EVENTLOG_HEADER_FLAGS r)
286
{
287
const char *val = NULL;
288
289
switch (r) {
290
case ELF_LOGFILE_HEADER_DIRTY: val = "ELF_LOGFILE_HEADER_DIRTY"; break;
291
case ELF_LOGFILE_HEADER_WRAP: val = "ELF_LOGFILE_HEADER_WRAP"; break;
292
case ELF_LOGFILE_LOGFULL_WRITTEN: val = "ELF_LOGFILE_LOGFULL_WRITTEN"; break;
293
case ELF_LOGFILE_ARCHIVE_SET: val = "ELF_LOGFILE_ARCHIVE_SET"; break;
294
}
295
ndr_print_enum(ndr, name, "ENUM", val, r);
296
}
297
298
_PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGHEADER(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOGHEADER *r)
299
{
300
if (ndr_flags & NDR_SCALARS) {
301
NDR_CHECK(ndr_push_align(ndr, 4));
302
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x30));
303
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "LfLe", 4, sizeof(uint8_t), CH_DOS));
304
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
305
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
306
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->StartOffset));
307
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EndOffset));
308
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CurrentRecordNumber));
309
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->OldestRecordNumber));
310
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->MaxSize));
311
NDR_CHECK(ndr_push_EVENTLOG_HEADER_FLAGS(ndr, NDR_SCALARS, r->Flags));
312
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Retention));
313
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x30));
314
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
315
}
316
if (ndr_flags & NDR_BUFFERS) {
317
}
318
return NDR_ERR_SUCCESS;
319
}
320
321
_PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGHEADER(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOGHEADER *r)
322
{
323
if (ndr_flags & NDR_SCALARS) {
324
NDR_CHECK(ndr_pull_align(ndr, 4));
325
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->HeaderSize));
326
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Signature, 4, sizeof(uint8_t), CH_DOS));
327
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MajorVersion));
328
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MinorVersion));
329
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->StartOffset));
330
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EndOffset));
331
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CurrentRecordNumber));
332
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->OldestRecordNumber));
333
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MaxSize));
334
NDR_CHECK(ndr_pull_EVENTLOG_HEADER_FLAGS(ndr, NDR_SCALARS, &r->Flags));
335
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Retention));
336
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EndHeaderSize));
337
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
338
}
339
if (ndr_flags & NDR_BUFFERS) {
340
}
341
return NDR_ERR_SUCCESS;
342
}
343
344
_PUBLIC_ void ndr_print_EVENTLOGHEADER(struct ndr_print *ndr, const char *name, const struct EVENTLOGHEADER *r)
345
{
346
ndr_print_struct(ndr, name, "EVENTLOGHEADER");
347
if (r == NULL) { ndr_print_null(ndr); return; }
348
ndr->depth++;
349
ndr_print_uint32(ndr, "HeaderSize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x30:r->HeaderSize);
350
ndr_print_string(ndr, "Signature", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"LfLe":r->Signature);
351
ndr_print_uint32(ndr, "MajorVersion", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->MajorVersion);
352
ndr_print_uint32(ndr, "MinorVersion", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->MinorVersion);
353
ndr_print_uint32(ndr, "StartOffset", r->StartOffset);
354
ndr_print_uint32(ndr, "EndOffset", r->EndOffset);
355
ndr_print_uint32(ndr, "CurrentRecordNumber", r->CurrentRecordNumber);
356
ndr_print_uint32(ndr, "OldestRecordNumber", r->OldestRecordNumber);
357
ndr_print_uint32(ndr, "MaxSize", r->MaxSize);
358
ndr_print_EVENTLOG_HEADER_FLAGS(ndr, "Flags", r->Flags);
359
ndr_print_uint32(ndr, "Retention", r->Retention);
360
ndr_print_uint32(ndr, "EndHeaderSize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x30:r->EndHeaderSize);
361
ndr->depth--;
362
}
363
364
_PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGRECORD(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOGRECORD *r)
365
{
366
uint32_t cntr_Strings_0;
367
if (ndr_flags & NDR_SCALARS) {
368
NDR_CHECK(ndr_push_align(ndr, 4));
369
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Length));
370
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "LfLe", 4, sizeof(uint8_t), CH_DOS));
371
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->RecordNumber));
372
NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->TimeGenerated));
373
NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->TimeWritten));
374
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EventID));
375
NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->EventType));
376
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->NumStrings));
377
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->EventCategory));
378
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ReservedFlags));
379
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ClosingRecordNumber));
380
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + ndr_size_dom_sid0(&r->UserSid, ndr->flags)));
381
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid0(&r->UserSid, ndr->flags)));
382
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername))));
383
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DataLength));
384
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + ndr_size_dom_sid0(&r->UserSid, ndr->flags) + (2 * ndr_size_string_array(r->Strings, r->NumStrings, LIBNDR_FLAG_STR_NULLTERM))));
385
{
386
uint32_t _flags_save_string = ndr->flags;
387
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
388
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->SourceName));
389
ndr->flags = _flags_save_string;
390
}
391
{
392
uint32_t _flags_save_string = ndr->flags;
393
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
394
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Computername));
395
ndr->flags = _flags_save_string;
396
}
397
{
398
uint32_t _flags_save_dom_sid0 = ndr->flags;
399
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
400
{
401
struct ndr_push *_ndr_UserSid;
402
NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_UserSid, 0, ndr_size_dom_sid0(&r->UserSid, ndr->flags)));
403
NDR_CHECK(ndr_push_dom_sid0(_ndr_UserSid, NDR_SCALARS|NDR_BUFFERS, &r->UserSid));
404
NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_UserSid, 0, ndr_size_dom_sid0(&r->UserSid, ndr->flags)));
405
}
406
ndr->flags = _flags_save_dom_sid0;
407
}
408
{
409
uint32_t _flags_save_string = ndr->flags;
410
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
411
for (cntr_Strings_0 = 0; cntr_Strings_0 < r->NumStrings; cntr_Strings_0++) {
412
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Strings[cntr_Strings_0]));
413
}
414
ndr->flags = _flags_save_string;
415
}
416
{
417
uint32_t _flags_save_uint8 = ndr->flags;
418
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
419
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Data, r->DataLength));
420
ndr->flags = _flags_save_uint8;
421
}
422
{
423
uint32_t _flags_save_string = ndr->flags;
424
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
425
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Pad));
426
ndr->flags = _flags_save_string;
427
}
428
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Length));
429
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
430
}
431
if (ndr_flags & NDR_BUFFERS) {
432
{
433
uint32_t _flags_save_dom_sid0 = ndr->flags;
434
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
435
ndr->flags = _flags_save_dom_sid0;
436
}
437
}
438
return NDR_ERR_SUCCESS;
439
}
440
441
_PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGRECORD(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOGRECORD *r)
442
{
443
uint32_t cntr_Strings_0;
444
TALLOC_CTX *_mem_save_Strings_0;
445
if (ndr_flags & NDR_SCALARS) {
446
NDR_CHECK(ndr_pull_align(ndr, 4));
447
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Length));
448
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Reserved, 4, sizeof(uint8_t), CH_DOS));
449
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RecordNumber));
450
NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->TimeGenerated));
451
NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->TimeWritten));
452
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EventID));
453
NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->EventType));
454
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->NumStrings));
455
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->EventCategory));
456
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ReservedFlags));
457
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ClosingRecordNumber));
458
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->StringOffset));
459
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->UserSidLength));
460
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->UserSidOffset));
461
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DataLength));
462
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DataOffset));
463
{
464
uint32_t _flags_save_string = ndr->flags;
465
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
466
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->SourceName));
467
ndr->flags = _flags_save_string;
468
}
469
{
470
uint32_t _flags_save_string = ndr->flags;
471
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
472
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Computername));
473
ndr->flags = _flags_save_string;
474
}
475
{
476
uint32_t _flags_save_dom_sid0 = ndr->flags;
477
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
478
{
479
struct ndr_pull *_ndr_UserSid;
480
NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_UserSid, 0, r->UserSidLength));
481
NDR_CHECK(ndr_pull_dom_sid0(_ndr_UserSid, NDR_SCALARS|NDR_BUFFERS, &r->UserSid));
482
NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_UserSid, 0, r->UserSidLength));
483
}
484
ndr->flags = _flags_save_dom_sid0;
485
}
486
{
487
uint32_t _flags_save_string = ndr->flags;
488
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
489
NDR_PULL_ALLOC_N(ndr, r->Strings, r->NumStrings);
490
_mem_save_Strings_0 = NDR_PULL_GET_MEM_CTX(ndr);
491
NDR_PULL_SET_MEM_CTX(ndr, r->Strings, 0);
492
for (cntr_Strings_0 = 0; cntr_Strings_0 < r->NumStrings; cntr_Strings_0++) {
493
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Strings[cntr_Strings_0]));
494
}
495
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Strings_0, 0);
496
ndr->flags = _flags_save_string;
497
}
498
{
499
uint32_t _flags_save_uint8 = ndr->flags;
500
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
501
NDR_PULL_ALLOC_N(ndr, r->Data, r->DataLength);
502
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Data, r->DataLength));
503
ndr->flags = _flags_save_uint8;
504
}
505
{
506
uint32_t _flags_save_string = ndr->flags;
507
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
508
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Pad));
509
ndr->flags = _flags_save_string;
510
}
511
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Length2));
512
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
513
}
514
if (ndr_flags & NDR_BUFFERS) {
515
{
516
uint32_t _flags_save_dom_sid0 = ndr->flags;
517
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
518
ndr->flags = _flags_save_dom_sid0;
519
}
520
}
521
return NDR_ERR_SUCCESS;
522
}
523
524
_PUBLIC_ void ndr_print_EVENTLOGRECORD(struct ndr_print *ndr, const char *name, const struct EVENTLOGRECORD *r)
525
{
526
uint32_t cntr_Strings_0;
527
ndr_print_struct(ndr, name, "EVENTLOGRECORD");
528
if (r == NULL) { ndr_print_null(ndr); return; }
529
ndr->depth++;
530
ndr_print_uint32(ndr, "Length", r->Length);
531
ndr_print_string(ndr, "Reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"LfLe":r->Reserved);
532
ndr_print_uint32(ndr, "RecordNumber", r->RecordNumber);
533
ndr_print_time_t(ndr, "TimeGenerated", r->TimeGenerated);
534
ndr_print_time_t(ndr, "TimeWritten", r->TimeWritten);
535
ndr_print_uint32(ndr, "EventID", r->EventID);
536
ndr_print_eventlogEventTypes(ndr, "EventType", r->EventType);
537
ndr_print_uint16(ndr, "NumStrings", r->NumStrings);
538
ndr_print_uint16(ndr, "EventCategory", r->EventCategory);
539
ndr_print_uint16(ndr, "ReservedFlags", r->ReservedFlags);
540
ndr_print_uint32(ndr, "ClosingRecordNumber", r->ClosingRecordNumber);
541
ndr_print_uint32(ndr, "StringOffset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + r->UserSidLength:r->StringOffset);
542
ndr_print_uint32(ndr, "UserSidLength", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid0(&r->UserSid, ndr->flags):r->UserSidLength);
543
ndr_print_uint32(ndr, "UserSidOffset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)):r->UserSidOffset);
544
ndr_print_uint32(ndr, "DataLength", r->DataLength);
545
ndr_print_uint32(ndr, "DataOffset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + r->UserSidLength + (2 * ndr_size_string_array(r->Strings, r->NumStrings, LIBNDR_FLAG_STR_NULLTERM)):r->DataOffset);
546
ndr_print_string(ndr, "SourceName", r->SourceName);
547
ndr_print_string(ndr, "Computername", r->Computername);
548
ndr_print_dom_sid0(ndr, "UserSid", &r->UserSid);
549
ndr->print(ndr, "%s: ARRAY(%d)", "Strings", (int)r->NumStrings);
550
ndr->depth++;
551
for (cntr_Strings_0=0;cntr_Strings_0<r->NumStrings;cntr_Strings_0++) {
552
ndr_print_string(ndr, "Strings", r->Strings[cntr_Strings_0]);
553
}
554
ndr->depth--;
555
ndr_print_array_uint8(ndr, "Data", r->Data, r->DataLength);
556
ndr_print_string(ndr, "Pad", r->Pad);
557
ndr_print_uint32(ndr, "Length2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->Length:r->Length2);
558
ndr->depth--;
559
}
560
561
_PUBLIC_ size_t ndr_size_EVENTLOGRECORD(const struct EVENTLOGRECORD *r, int flags)
562
{
563
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_EVENTLOGRECORD);
564
}
565
566
_PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGEOF(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOGEOF *r)
567
{
568
if (ndr_flags & NDR_SCALARS) {
569
NDR_CHECK(ndr_push_align(ndr, 4));
570
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x28));
571
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x11111111));
572
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x22222222));
573
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x33333333));
574
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x44444444));
575
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->BeginRecord));
576
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EndRecord));
577
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CurrentRecordNumber));
578
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->OldestRecordNumber));
579
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x28));
580
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
581
}
582
if (ndr_flags & NDR_BUFFERS) {
583
}
584
return NDR_ERR_SUCCESS;
585
}
586
587
_PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGEOF(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOGEOF *r)
588
{
589
if (ndr_flags & NDR_SCALARS) {
590
NDR_CHECK(ndr_pull_align(ndr, 4));
591
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RecordSizeBeginning));
592
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->One));
593
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Two));
594
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Three));
595
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Four));
596
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->BeginRecord));
597
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EndRecord));
598
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CurrentRecordNumber));
599
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->OldestRecordNumber));
600
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RecordSizeEnd));
601
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
602
}
603
if (ndr_flags & NDR_BUFFERS) {
604
}
605
return NDR_ERR_SUCCESS;
606
}
607
608
_PUBLIC_ void ndr_print_EVENTLOGEOF(struct ndr_print *ndr, const char *name, const struct EVENTLOGEOF *r)
609
{
610
ndr_print_struct(ndr, name, "EVENTLOGEOF");
611
if (r == NULL) { ndr_print_null(ndr); return; }
612
ndr->depth++;
613
ndr_print_uint32(ndr, "RecordSizeBeginning", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x28:r->RecordSizeBeginning);
614
ndr_print_uint32(ndr, "One", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x11111111:r->One);
615
ndr_print_uint32(ndr, "Two", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x22222222:r->Two);
616
ndr_print_uint32(ndr, "Three", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x33333333:r->Three);
617
ndr_print_uint32(ndr, "Four", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x44444444:r->Four);
618
ndr_print_uint32(ndr, "BeginRecord", r->BeginRecord);
619
ndr_print_uint32(ndr, "EndRecord", r->EndRecord);
620
ndr_print_uint32(ndr, "CurrentRecordNumber", r->CurrentRecordNumber);
621
ndr_print_uint32(ndr, "OldestRecordNumber", r->OldestRecordNumber);
622
ndr_print_uint32(ndr, "RecordSizeEnd", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x28:r->RecordSizeEnd);
623
ndr->depth--;
624
}
625
626
_PUBLIC_ enum ndr_err_code ndr_push_EVENTLOG_EVT_FILE(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOG_EVT_FILE *r)
627
{
628
uint32_t cntr_records_0;
629
if (ndr_flags & NDR_SCALARS) {
630
NDR_CHECK(ndr_push_align(ndr, 4));
631
NDR_CHECK(ndr_push_EVENTLOGHEADER(ndr, NDR_SCALARS, &r->hdr));
632
for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {
633
NDR_CHECK(ndr_push_EVENTLOGRECORD(ndr, NDR_SCALARS, &r->records[cntr_records_0]));
634
}
635
NDR_CHECK(ndr_push_EVENTLOGEOF(ndr, NDR_SCALARS, &r->eof));
636
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
637
}
638
if (ndr_flags & NDR_BUFFERS) {
639
for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {
640
NDR_CHECK(ndr_push_EVENTLOGRECORD(ndr, NDR_BUFFERS, &r->records[cntr_records_0]));
641
}
642
}
643
return NDR_ERR_SUCCESS;
644
}
645
646
_PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOG_EVT_FILE(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOG_EVT_FILE *r)
647
{
648
uint32_t cntr_records_0;
649
TALLOC_CTX *_mem_save_records_0;
650
if (ndr_flags & NDR_SCALARS) {
651
NDR_CHECK(ndr_pull_align(ndr, 4));
652
NDR_CHECK(ndr_pull_EVENTLOGHEADER(ndr, NDR_SCALARS, &r->hdr));
653
NDR_PULL_ALLOC_N(ndr, r->records, r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber);
654
_mem_save_records_0 = NDR_PULL_GET_MEM_CTX(ndr);
655
NDR_PULL_SET_MEM_CTX(ndr, r->records, 0);
656
for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {
657
NDR_CHECK(ndr_pull_EVENTLOGRECORD(ndr, NDR_SCALARS, &r->records[cntr_records_0]));
658
}
659
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_records_0, 0);
660
NDR_CHECK(ndr_pull_EVENTLOGEOF(ndr, NDR_SCALARS, &r->eof));
661
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
662
}
663
if (ndr_flags & NDR_BUFFERS) {
664
_mem_save_records_0 = NDR_PULL_GET_MEM_CTX(ndr);
665
NDR_PULL_SET_MEM_CTX(ndr, r->records, 0);
666
for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {
667
NDR_CHECK(ndr_pull_EVENTLOGRECORD(ndr, NDR_BUFFERS, &r->records[cntr_records_0]));
668
}
669
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_records_0, 0);
670
}
671
return NDR_ERR_SUCCESS;
672
}
673
674
_PUBLIC_ void ndr_print_EVENTLOG_EVT_FILE(struct ndr_print *ndr, const char *name, const struct EVENTLOG_EVT_FILE *r)
675
{
676
uint32_t cntr_records_0;
677
ndr_print_struct(ndr, name, "EVENTLOG_EVT_FILE");
678
if (r == NULL) { ndr_print_null(ndr); return; }
679
ndr->depth++;
680
ndr_print_EVENTLOGHEADER(ndr, "hdr", &r->hdr);
681
ndr->print(ndr, "%s: ARRAY(%d)", "records", (int)r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber);
682
ndr->depth++;
683
for (cntr_records_0=0;cntr_records_0<r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber;cntr_records_0++) {
684
ndr_print_EVENTLOGRECORD(ndr, "records", &r->records[cntr_records_0]);
685
}
686
ndr->depth--;
687
ndr_print_EVENTLOGEOF(ndr, "eof", &r->eof);
688
ndr->depth--;
689
}
690
691
_PUBLIC_ enum ndr_err_code ndr_push_EVENTLOG_FULL_INFORMATION(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOG_FULL_INFORMATION *r)
692
{
693
if (ndr_flags & NDR_SCALARS) {
694
NDR_CHECK(ndr_push_align(ndr, 4));
695
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->full));
696
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
697
}
698
if (ndr_flags & NDR_BUFFERS) {
699
}
700
return NDR_ERR_SUCCESS;
701
}
702
703
_PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOG_FULL_INFORMATION(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOG_FULL_INFORMATION *r)
704
{
705
if (ndr_flags & NDR_SCALARS) {
706
NDR_CHECK(ndr_pull_align(ndr, 4));
707
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->full));
708
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
709
}
710
if (ndr_flags & NDR_BUFFERS) {
711
}
712
return NDR_ERR_SUCCESS;
713
}
714
715
_PUBLIC_ void ndr_print_EVENTLOG_FULL_INFORMATION(struct ndr_print *ndr, const char *name, const struct EVENTLOG_FULL_INFORMATION *r)
716
{
717
ndr_print_struct(ndr, name, "EVENTLOG_FULL_INFORMATION");
718
if (r == NULL) { ndr_print_null(ndr); return; }
719
ndr->depth++;
720
ndr_print_uint32(ndr, "full", r->full);
721
ndr->depth--;
722
}
723
724
static enum ndr_err_code ndr_push_eventlog_ClearEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_ClearEventLogW *r)
725
{
726
if (flags & NDR_IN) {
727
if (r->in.handle == NULL) {
728
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
729
}
730
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
731
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.backupfile));
732
if (r->in.backupfile) {
733
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backupfile));
734
}
735
}
736
if (flags & NDR_OUT) {
737
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
738
}
739
return NDR_ERR_SUCCESS;
740
}
741
742
static enum ndr_err_code ndr_pull_eventlog_ClearEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_ClearEventLogW *r)
743
{
744
uint32_t _ptr_backupfile;
745
TALLOC_CTX *_mem_save_handle_0;
746
TALLOC_CTX *_mem_save_backupfile_0;
747
if (flags & NDR_IN) {
748
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
749
NDR_PULL_ALLOC(ndr, r->in.handle);
750
}
751
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
752
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
753
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
754
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
755
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_backupfile));
756
if (_ptr_backupfile) {
757
NDR_PULL_ALLOC(ndr, r->in.backupfile);
758
} else {
759
r->in.backupfile = NULL;
760
}
761
if (r->in.backupfile) {
762
_mem_save_backupfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
763
NDR_PULL_SET_MEM_CTX(ndr, r->in.backupfile, 0);
764
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backupfile));
765
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backupfile_0, 0);
766
}
767
}
768
if (flags & NDR_OUT) {
769
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
770
}
771
return NDR_ERR_SUCCESS;
772
}
773
774
_PUBLIC_ void ndr_print_eventlog_ClearEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ClearEventLogW *r)
775
{
776
ndr_print_struct(ndr, name, "eventlog_ClearEventLogW");
777
if (r == NULL) { ndr_print_null(ndr); return; }
778
ndr->depth++;
779
if (flags & NDR_SET_VALUES) {
780
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
781
}
782
if (flags & NDR_IN) {
783
ndr_print_struct(ndr, "in", "eventlog_ClearEventLogW");
784
ndr->depth++;
785
ndr_print_ptr(ndr, "handle", r->in.handle);
786
ndr->depth++;
787
ndr_print_policy_handle(ndr, "handle", r->in.handle);
788
ndr->depth--;
789
ndr_print_ptr(ndr, "backupfile", r->in.backupfile);
790
ndr->depth++;
791
if (r->in.backupfile) {
792
ndr_print_lsa_String(ndr, "backupfile", r->in.backupfile);
793
}
794
ndr->depth--;
795
ndr->depth--;
796
}
797
if (flags & NDR_OUT) {
798
ndr_print_struct(ndr, "out", "eventlog_ClearEventLogW");
799
ndr->depth++;
800
ndr_print_NTSTATUS(ndr, "result", r->out.result);
801
ndr->depth--;
802
}
803
ndr->depth--;
804
}
805
806
static enum ndr_err_code ndr_push_eventlog_BackupEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_BackupEventLogW *r)
807
{
808
if (flags & NDR_IN) {
809
if (r->in.handle == NULL) {
810
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
811
}
812
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
813
if (r->in.backup_filename == NULL) {
814
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
815
}
816
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_filename));
817
}
818
if (flags & NDR_OUT) {
819
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
820
}
821
return NDR_ERR_SUCCESS;
822
}
823
824
static enum ndr_err_code ndr_pull_eventlog_BackupEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_BackupEventLogW *r)
825
{
826
TALLOC_CTX *_mem_save_handle_0;
827
TALLOC_CTX *_mem_save_backup_filename_0;
828
if (flags & NDR_IN) {
829
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
830
NDR_PULL_ALLOC(ndr, r->in.handle);
831
}
832
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
833
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
834
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
835
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
836
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
837
NDR_PULL_ALLOC(ndr, r->in.backup_filename);
838
}
839
_mem_save_backup_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
840
NDR_PULL_SET_MEM_CTX(ndr, r->in.backup_filename, LIBNDR_FLAG_REF_ALLOC);
841
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_filename));
842
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backup_filename_0, LIBNDR_FLAG_REF_ALLOC);
843
}
844
if (flags & NDR_OUT) {
845
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
846
}
847
return NDR_ERR_SUCCESS;
848
}
849
850
_PUBLIC_ void ndr_print_eventlog_BackupEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_BackupEventLogW *r)
851
{
852
ndr_print_struct(ndr, name, "eventlog_BackupEventLogW");
853
if (r == NULL) { ndr_print_null(ndr); return; }
854
ndr->depth++;
855
if (flags & NDR_SET_VALUES) {
856
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
857
}
858
if (flags & NDR_IN) {
859
ndr_print_struct(ndr, "in", "eventlog_BackupEventLogW");
860
ndr->depth++;
861
ndr_print_ptr(ndr, "handle", r->in.handle);
862
ndr->depth++;
863
ndr_print_policy_handle(ndr, "handle", r->in.handle);
864
ndr->depth--;
865
ndr_print_ptr(ndr, "backup_filename", r->in.backup_filename);
866
ndr->depth++;
867
ndr_print_lsa_String(ndr, "backup_filename", r->in.backup_filename);
868
ndr->depth--;
869
ndr->depth--;
870
}
871
if (flags & NDR_OUT) {
872
ndr_print_struct(ndr, "out", "eventlog_BackupEventLogW");
873
ndr->depth++;
874
ndr_print_NTSTATUS(ndr, "result", r->out.result);
875
ndr->depth--;
876
}
877
ndr->depth--;
878
}
879
880
static enum ndr_err_code ndr_push_eventlog_CloseEventLog(struct ndr_push *ndr, int flags, const struct eventlog_CloseEventLog *r)
881
{
882
if (flags & NDR_IN) {
883
if (r->in.handle == NULL) {
884
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
885
}
886
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
887
}
888
if (flags & NDR_OUT) {
889
if (r->out.handle == NULL) {
890
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
891
}
892
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
893
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
894
}
895
return NDR_ERR_SUCCESS;
896
}
897
898
static enum ndr_err_code ndr_pull_eventlog_CloseEventLog(struct ndr_pull *ndr, int flags, struct eventlog_CloseEventLog *r)
899
{
900
TALLOC_CTX *_mem_save_handle_0;
901
if (flags & NDR_IN) {
902
ZERO_STRUCT(r->out);
903
904
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
905
NDR_PULL_ALLOC(ndr, r->in.handle);
906
}
907
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
908
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
909
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
910
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
911
NDR_PULL_ALLOC(ndr, r->out.handle);
912
*r->out.handle = *r->in.handle;
913
}
914
if (flags & NDR_OUT) {
915
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
916
NDR_PULL_ALLOC(ndr, r->out.handle);
917
}
918
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
919
NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
920
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
921
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
922
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
923
}
924
return NDR_ERR_SUCCESS;
925
}
926
927
_PUBLIC_ void ndr_print_eventlog_CloseEventLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_CloseEventLog *r)
928
{
929
ndr_print_struct(ndr, name, "eventlog_CloseEventLog");
930
if (r == NULL) { ndr_print_null(ndr); return; }
931
ndr->depth++;
932
if (flags & NDR_SET_VALUES) {
933
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
934
}
935
if (flags & NDR_IN) {
936
ndr_print_struct(ndr, "in", "eventlog_CloseEventLog");
937
ndr->depth++;
938
ndr_print_ptr(ndr, "handle", r->in.handle);
939
ndr->depth++;
940
ndr_print_policy_handle(ndr, "handle", r->in.handle);
941
ndr->depth--;
942
ndr->depth--;
943
}
944
if (flags & NDR_OUT) {
945
ndr_print_struct(ndr, "out", "eventlog_CloseEventLog");
946
ndr->depth++;
947
ndr_print_ptr(ndr, "handle", r->out.handle);
948
ndr->depth++;
949
ndr_print_policy_handle(ndr, "handle", r->out.handle);
950
ndr->depth--;
951
ndr_print_NTSTATUS(ndr, "result", r->out.result);
952
ndr->depth--;
953
}
954
ndr->depth--;
955
}
956
957
static enum ndr_err_code ndr_push_eventlog_DeregisterEventSource(struct ndr_push *ndr, int flags, const struct eventlog_DeregisterEventSource *r)
958
{
959
if (flags & NDR_IN) {
960
if (r->in.handle == NULL) {
961
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
962
}
963
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
964
}
965
if (flags & NDR_OUT) {
966
if (r->out.handle == NULL) {
967
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
968
}
969
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
970
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
971
}
972
return NDR_ERR_SUCCESS;
973
}
974
975
static enum ndr_err_code ndr_pull_eventlog_DeregisterEventSource(struct ndr_pull *ndr, int flags, struct eventlog_DeregisterEventSource *r)
976
{
977
TALLOC_CTX *_mem_save_handle_0;
978
if (flags & NDR_IN) {
979
ZERO_STRUCT(r->out);
980
981
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
982
NDR_PULL_ALLOC(ndr, r->in.handle);
983
}
984
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
985
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
986
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
987
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
988
NDR_PULL_ALLOC(ndr, r->out.handle);
989
*r->out.handle = *r->in.handle;
990
}
991
if (flags & NDR_OUT) {
992
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
993
NDR_PULL_ALLOC(ndr, r->out.handle);
994
}
995
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
996
NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
997
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
998
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
999
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1000
}
1001
return NDR_ERR_SUCCESS;
1002
}
1003
1004
_PUBLIC_ void ndr_print_eventlog_DeregisterEventSource(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_DeregisterEventSource *r)
1005
{
1006
ndr_print_struct(ndr, name, "eventlog_DeregisterEventSource");
1007
if (r == NULL) { ndr_print_null(ndr); return; }
1008
ndr->depth++;
1009
if (flags & NDR_SET_VALUES) {
1010
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1011
}
1012
if (flags & NDR_IN) {
1013
ndr_print_struct(ndr, "in", "eventlog_DeregisterEventSource");
1014
ndr->depth++;
1015
ndr_print_ptr(ndr, "handle", r->in.handle);
1016
ndr->depth++;
1017
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1018
ndr->depth--;
1019
ndr->depth--;
1020
}
1021
if (flags & NDR_OUT) {
1022
ndr_print_struct(ndr, "out", "eventlog_DeregisterEventSource");
1023
ndr->depth++;
1024
ndr_print_ptr(ndr, "handle", r->out.handle);
1025
ndr->depth++;
1026
ndr_print_policy_handle(ndr, "handle", r->out.handle);
1027
ndr->depth--;
1028
ndr_print_NTSTATUS(ndr, "result", r->out.result);
1029
ndr->depth--;
1030
}
1031
ndr->depth--;
1032
}
1033
1034
static enum ndr_err_code ndr_push_eventlog_GetNumRecords(struct ndr_push *ndr, int flags, const struct eventlog_GetNumRecords *r)
1035
{
1036
if (flags & NDR_IN) {
1037
if (r->in.handle == NULL) {
1038
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1039
}
1040
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1041
}
1042
if (flags & NDR_OUT) {
1043
if (r->out.number == NULL) {
1044
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1045
}
1046
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.number));
1047
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1048
}
1049
return NDR_ERR_SUCCESS;
1050
}
1051
1052
static enum ndr_err_code ndr_pull_eventlog_GetNumRecords(struct ndr_pull *ndr, int flags, struct eventlog_GetNumRecords *r)
1053
{
1054
TALLOC_CTX *_mem_save_handle_0;
1055
TALLOC_CTX *_mem_save_number_0;
1056
if (flags & NDR_IN) {
1057
ZERO_STRUCT(r->out);
1058
1059
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1060
NDR_PULL_ALLOC(ndr, r->in.handle);
1061
}
1062
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1063
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1064
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1065
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1066
NDR_PULL_ALLOC(ndr, r->out.number);
1067
ZERO_STRUCTP(r->out.number);
1068
}
1069
if (flags & NDR_OUT) {
1070
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1071
NDR_PULL_ALLOC(ndr, r->out.number);
1072
}
1073
_mem_save_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
1074
NDR_PULL_SET_MEM_CTX(ndr, r->out.number, LIBNDR_FLAG_REF_ALLOC);
1075
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.number));
1076
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_number_0, LIBNDR_FLAG_REF_ALLOC);
1077
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1078
}
1079
return NDR_ERR_SUCCESS;
1080
}
1081
1082
_PUBLIC_ void ndr_print_eventlog_GetNumRecords(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetNumRecords *r)
1083
{
1084
ndr_print_struct(ndr, name, "eventlog_GetNumRecords");
1085
if (r == NULL) { ndr_print_null(ndr); return; }
1086
ndr->depth++;
1087
if (flags & NDR_SET_VALUES) {
1088
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1089
}
1090
if (flags & NDR_IN) {
1091
ndr_print_struct(ndr, "in", "eventlog_GetNumRecords");
1092
ndr->depth++;
1093
ndr_print_ptr(ndr, "handle", r->in.handle);
1094
ndr->depth++;
1095
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1096
ndr->depth--;
1097
ndr->depth--;
1098
}
1099
if (flags & NDR_OUT) {
1100
ndr_print_struct(ndr, "out", "eventlog_GetNumRecords");
1101
ndr->depth++;
1102
ndr_print_ptr(ndr, "number", r->out.number);
1103
ndr->depth++;
1104
ndr_print_uint32(ndr, "number", *r->out.number);
1105
ndr->depth--;
1106
ndr_print_NTSTATUS(ndr, "result", r->out.result);
1107
ndr->depth--;
1108
}
1109
ndr->depth--;
1110
}
1111
1112
static enum ndr_err_code ndr_push_eventlog_GetOldestRecord(struct ndr_push *ndr, int flags, const struct eventlog_GetOldestRecord *r)
1113
{
1114
if (flags & NDR_IN) {
1115
if (r->in.handle == NULL) {
1116
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1117
}
1118
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1119
}
1120
if (flags & NDR_OUT) {
1121
if (r->out.oldest_entry == NULL) {
1122
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1123
}
1124
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.oldest_entry));
1125
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1126
}
1127
return NDR_ERR_SUCCESS;
1128
}
1129
1130
static enum ndr_err_code ndr_pull_eventlog_GetOldestRecord(struct ndr_pull *ndr, int flags, struct eventlog_GetOldestRecord *r)
1131
{
1132
TALLOC_CTX *_mem_save_handle_0;
1133
TALLOC_CTX *_mem_save_oldest_entry_0;
1134
if (flags & NDR_IN) {
1135
ZERO_STRUCT(r->out);
1136
1137
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1138
NDR_PULL_ALLOC(ndr, r->in.handle);
1139
}
1140
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1141
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1142
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1143
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1144
NDR_PULL_ALLOC(ndr, r->out.oldest_entry);
1145
ZERO_STRUCTP(r->out.oldest_entry);
1146
}
1147
if (flags & NDR_OUT) {
1148
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1149
NDR_PULL_ALLOC(ndr, r->out.oldest_entry);
1150
}
1151
_mem_save_oldest_entry_0 = NDR_PULL_GET_MEM_CTX(ndr);
1152
NDR_PULL_SET_MEM_CTX(ndr, r->out.oldest_entry, LIBNDR_FLAG_REF_ALLOC);
1153
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.oldest_entry));
1154
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_oldest_entry_0, LIBNDR_FLAG_REF_ALLOC);
1155
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1156
}
1157
return NDR_ERR_SUCCESS;
1158
}
1159
1160
_PUBLIC_ void ndr_print_eventlog_GetOldestRecord(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetOldestRecord *r)
1161
{
1162
ndr_print_struct(ndr, name, "eventlog_GetOldestRecord");
1163
if (r == NULL) { ndr_print_null(ndr); return; }
1164
ndr->depth++;
1165
if (flags & NDR_SET_VALUES) {
1166
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1167
}
1168
if (flags & NDR_IN) {
1169
ndr_print_struct(ndr, "in", "eventlog_GetOldestRecord");
1170
ndr->depth++;
1171
ndr_print_ptr(ndr, "handle", r->in.handle);
1172
ndr->depth++;
1173
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1174
ndr->depth--;
1175
ndr->depth--;
1176
}
1177
if (flags & NDR_OUT) {
1178
ndr_print_struct(ndr, "out", "eventlog_GetOldestRecord");
1179
ndr->depth++;
1180
ndr_print_ptr(ndr, "oldest_entry", r->out.oldest_entry);
1181
ndr->depth++;
1182
ndr_print_uint32(ndr, "oldest_entry", *r->out.oldest_entry);
1183
ndr->depth--;
1184
ndr_print_NTSTATUS(ndr, "result", r->out.result);
1185
ndr->depth--;
1186
}
1187
ndr->depth--;
1188
}
1189
1190
static enum ndr_err_code ndr_push_eventlog_ChangeNotify(struct ndr_push *ndr, int flags, const struct eventlog_ChangeNotify *r)
1191
{
1192
if (flags & NDR_IN) {
1193
}
1194
if (flags & NDR_OUT) {
1195
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1196
}
1197
return NDR_ERR_SUCCESS;
1198
}
1199
1200
static enum ndr_err_code ndr_pull_eventlog_ChangeNotify(struct ndr_pull *ndr, int flags, struct eventlog_ChangeNotify *r)
1201
{
1202
if (flags & NDR_IN) {
1203
}
1204
if (flags & NDR_OUT) {
1205
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1206
}
1207
return NDR_ERR_SUCCESS;
1208
}
1209
1210
_PUBLIC_ void ndr_print_eventlog_ChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ChangeNotify *r)
1211
{
1212
ndr_print_struct(ndr, name, "eventlog_ChangeNotify");
1213
if (r == NULL) { ndr_print_null(ndr); return; }
1214
ndr->depth++;
1215
if (flags & NDR_SET_VALUES) {
1216
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1217
}
1218
if (flags & NDR_IN) {
1219
ndr_print_struct(ndr, "in", "eventlog_ChangeNotify");
1220
ndr->depth++;
1221
ndr->depth--;
1222
}
1223
if (flags & NDR_OUT) {
1224
ndr_print_struct(ndr, "out", "eventlog_ChangeNotify");
1225
ndr->depth++;
1226
ndr_print_NTSTATUS(ndr, "result", r->out.result);
1227
ndr->depth--;
1228
}
1229
ndr->depth--;
1230
}
1231
1232
static enum ndr_err_code ndr_push_eventlog_OpenEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_OpenEventLogW *r)
1233
{
1234
if (flags & NDR_IN) {
1235
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));
1236
if (r->in.unknown0) {
1237
NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1238
}
1239
if (r->in.logname == NULL) {
1240
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1241
}
1242
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.logname));
1243
if (r->in.servername == NULL) {
1244
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1245
}
1246
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
1247
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.major_version));
1248
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.minor_version));
1249
}
1250
if (flags & NDR_OUT) {
1251
if (r->out.handle == NULL) {
1252
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1253
}
1254
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1255
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1256
}
1257
return NDR_ERR_SUCCESS;
1258
}
1259
1260
static enum ndr_err_code ndr_pull_eventlog_OpenEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_OpenEventLogW *r)
1261
{
1262
uint32_t _ptr_unknown0;
1263
TALLOC_CTX *_mem_save_unknown0_0;
1264
TALLOC_CTX *_mem_save_logname_0;
1265
TALLOC_CTX *_mem_save_servername_0;
1266
TALLOC_CTX *_mem_save_handle_0;
1267
if (flags & NDR_IN) {
1268
ZERO_STRUCT(r->out);
1269
1270
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));
1271
if (_ptr_unknown0) {
1272
NDR_PULL_ALLOC(ndr, r->in.unknown0);
1273
} else {
1274
r->in.unknown0 = NULL;
1275
}
1276
if (r->in.unknown0) {
1277
_mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1278
NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);
1279
NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1280
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);
1281
}
1282
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1283
NDR_PULL_ALLOC(ndr, r->in.logname);
1284
}
1285
_mem_save_logname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1286
NDR_PULL_SET_MEM_CTX(ndr, r->in.logname, LIBNDR_FLAG_REF_ALLOC);
1287
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.logname));
1288
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logname_0, LIBNDR_FLAG_REF_ALLOC);
1289
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1290
NDR_PULL_ALLOC(ndr, r->in.servername);
1291
}
1292
_mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1293
NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, LIBNDR_FLAG_REF_ALLOC);
1294
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
1295
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, LIBNDR_FLAG_REF_ALLOC);
1296
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.major_version));
1297
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.minor_version));
1298
NDR_PULL_ALLOC(ndr, r->out.handle);
1299
ZERO_STRUCTP(r->out.handle);
1300
}
1301
if (flags & NDR_OUT) {
1302
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1303
NDR_PULL_ALLOC(ndr, r->out.handle);
1304
}
1305
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1306
NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
1307
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1308
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1309
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1310
}
1311
return NDR_ERR_SUCCESS;
1312
}
1313
1314
_PUBLIC_ void ndr_print_eventlog_OpenEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenEventLogW *r)
1315
{
1316
ndr_print_struct(ndr, name, "eventlog_OpenEventLogW");
1317
if (r == NULL) { ndr_print_null(ndr); return; }
1318
ndr->depth++;
1319
if (flags & NDR_SET_VALUES) {
1320
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1321
}
1322
if (flags & NDR_IN) {
1323
ndr_print_struct(ndr, "in", "eventlog_OpenEventLogW");
1324
ndr->depth++;
1325
ndr_print_ptr(ndr, "unknown0", r->in.unknown0);
1326
ndr->depth++;
1327
if (r->in.unknown0) {
1328
ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);
1329
}
1330
ndr->depth--;
1331
ndr_print_ptr(ndr, "logname", r->in.logname);
1332
ndr->depth++;
1333
ndr_print_lsa_String(ndr, "logname", r->in.logname);
1334
ndr->depth--;
1335
ndr_print_ptr(ndr, "servername", r->in.servername);
1336
ndr->depth++;
1337
ndr_print_lsa_String(ndr, "servername", r->in.servername);
1338
ndr->depth--;
1339
ndr_print_uint32(ndr, "major_version", r->in.major_version);
1340
ndr_print_uint32(ndr, "minor_version", r->in.minor_version);
1341
ndr->depth--;
1342
}
1343
if (flags & NDR_OUT) {
1344
ndr_print_struct(ndr, "out", "eventlog_OpenEventLogW");
1345
ndr->depth++;
1346
ndr_print_ptr(ndr, "handle", r->out.handle);
1347
ndr->depth++;
1348
ndr_print_policy_handle(ndr, "handle", r->out.handle);
1349
ndr->depth--;
1350
ndr_print_NTSTATUS(ndr, "result", r->out.result);
1351
ndr->depth--;
1352
}
1353
ndr->depth--;
1354
}
1355
1356
static enum ndr_err_code ndr_push_eventlog_RegisterEventSourceW(struct ndr_push *ndr, int flags, const struct eventlog_RegisterEventSourceW *r)
1357
{
1358
if (flags & NDR_IN) {
1359
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));
1360
if (r->in.unknown0) {
1361
NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1362
}
1363
if (r->in.module_name == NULL) {
1364
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1365
}
1366
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.module_name));
1367
if (r->in.reg_module_name == NULL) {
1368
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1369
}
1370
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.reg_module_name));
1371
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.major_version));
1372
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.minor_version));
1373
}
1374
if (flags & NDR_OUT) {
1375
if (r->out.log_handle == NULL) {
1376
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1377
}
1378
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.log_handle));
1379
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1380
}
1381
return NDR_ERR_SUCCESS;
1382
}
1383
1384
static enum ndr_err_code ndr_pull_eventlog_RegisterEventSourceW(struct ndr_pull *ndr, int flags, struct eventlog_RegisterEventSourceW *r)
1385
{
1386
uint32_t _ptr_unknown0;
1387
TALLOC_CTX *_mem_save_unknown0_0;
1388
TALLOC_CTX *_mem_save_module_name_0;
1389
TALLOC_CTX *_mem_save_reg_module_name_0;
1390
TALLOC_CTX *_mem_save_log_handle_0;
1391
if (flags & NDR_IN) {
1392
ZERO_STRUCT(r->out);
1393
1394
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));
1395
if (_ptr_unknown0) {
1396
NDR_PULL_ALLOC(ndr, r->in.unknown0);
1397
} else {
1398
r->in.unknown0 = NULL;
1399
}
1400
if (r->in.unknown0) {
1401
_mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1402
NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);
1403
NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1404
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);
1405
}
1406
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1407
NDR_PULL_ALLOC(ndr, r->in.module_name);
1408
}
1409
_mem_save_module_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1410
NDR_PULL_SET_MEM_CTX(ndr, r->in.module_name, LIBNDR_FLAG_REF_ALLOC);
1411
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.module_name));
1412
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_module_name_0, LIBNDR_FLAG_REF_ALLOC);
1413
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1414
NDR_PULL_ALLOC(ndr, r->in.reg_module_name);
1415
}
1416
_mem_save_reg_module_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1417
NDR_PULL_SET_MEM_CTX(ndr, r->in.reg_module_name, LIBNDR_FLAG_REF_ALLOC);
1418
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.reg_module_name));
1419
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reg_module_name_0, LIBNDR_FLAG_REF_ALLOC);
1420
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.major_version));
1421
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.minor_version));
1422
NDR_PULL_ALLOC(ndr, r->out.log_handle);
1423
ZERO_STRUCTP(r->out.log_handle);
1424
}
1425
if (flags & NDR_OUT) {
1426
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1427
NDR_PULL_ALLOC(ndr, r->out.log_handle);
1428
}
1429
_mem_save_log_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1430
NDR_PULL_SET_MEM_CTX(ndr, r->out.log_handle, LIBNDR_FLAG_REF_ALLOC);
1431
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.log_handle));
1432
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_log_handle_0, LIBNDR_FLAG_REF_ALLOC);
1433
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1434
}
1435
return NDR_ERR_SUCCESS;
1436
}
1437
1438
_PUBLIC_ void ndr_print_eventlog_RegisterEventSourceW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterEventSourceW *r)
1439
{
1440
ndr_print_struct(ndr, name, "eventlog_RegisterEventSourceW");
1441
if (r == NULL) { ndr_print_null(ndr); return; }
1442
ndr->depth++;
1443
if (flags & NDR_SET_VALUES) {
1444
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1445
}
1446
if (flags & NDR_IN) {
1447
ndr_print_struct(ndr, "in", "eventlog_RegisterEventSourceW");
1448
ndr->depth++;
1449
ndr_print_ptr(ndr, "unknown0", r->in.unknown0);
1450
ndr->depth++;
1451
if (r->in.unknown0) {
1452
ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);
1453
}
1454
ndr->depth--;
1455
ndr_print_ptr(ndr, "module_name", r->in.module_name);
1456
ndr->depth++;
1457
ndr_print_lsa_String(ndr, "module_name", r->in.module_name);
1458
ndr->depth--;
1459
ndr_print_ptr(ndr, "reg_module_name", r->in.reg_module_name);
1460
ndr->depth++;
1461
ndr_print_lsa_String(ndr, "reg_module_name", r->in.reg_module_name);
1462
ndr->depth--;
1463
ndr_print_uint32(ndr, "major_version", r->in.major_version);
1464
ndr_print_uint32(ndr, "minor_version", r->in.minor_version);
1465
ndr->depth--;
1466
}
1467
if (flags & NDR_OUT) {
1468
ndr_print_struct(ndr, "out", "eventlog_RegisterEventSourceW");
1469
ndr->depth++;
1470
ndr_print_ptr(ndr, "log_handle", r->out.log_handle);
1471
ndr->depth++;
1472
ndr_print_policy_handle(ndr, "log_handle", r->out.log_handle);
1473
ndr->depth--;
1474
ndr_print_NTSTATUS(ndr, "result", r->out.result);
1475
ndr->depth--;
1476
}
1477
ndr->depth--;
1478
}
1479
1480
static enum ndr_err_code ndr_push_eventlog_OpenBackupEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_OpenBackupEventLogW *r)
1481
{
1482
if (flags & NDR_IN) {
1483
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));
1484
if (r->in.unknown0) {
1485
NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1486
}
1487
if (r->in.backup_logname == NULL) {
1488
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1489
}
1490
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_logname));
1491
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.major_version));
1492
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.minor_version));
1493
}
1494
if (flags & NDR_OUT) {
1495
if (r->out.handle == NULL) {
1496
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1497
}
1498
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1499
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1500
}
1501
return NDR_ERR_SUCCESS;
1502
}
1503
1504
static enum ndr_err_code ndr_pull_eventlog_OpenBackupEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_OpenBackupEventLogW *r)
1505
{
1506
uint32_t _ptr_unknown0;
1507
TALLOC_CTX *_mem_save_unknown0_0;
1508
TALLOC_CTX *_mem_save_backup_logname_0;
1509
TALLOC_CTX *_mem_save_handle_0;
1510
if (flags & NDR_IN) {
1511
ZERO_STRUCT(r->out);
1512
1513
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));
1514
if (_ptr_unknown0) {
1515
NDR_PULL_ALLOC(ndr, r->in.unknown0);
1516
} else {
1517
r->in.unknown0 = NULL;
1518
}
1519
if (r->in.unknown0) {
1520
_mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);
1521
NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);
1522
NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
1523
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);
1524
}
1525
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1526
NDR_PULL_ALLOC(ndr, r->in.backup_logname);
1527
}
1528
_mem_save_backup_logname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1529
NDR_PULL_SET_MEM_CTX(ndr, r->in.backup_logname, LIBNDR_FLAG_REF_ALLOC);
1530
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_logname));
1531
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backup_logname_0, LIBNDR_FLAG_REF_ALLOC);
1532
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.major_version));
1533
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.minor_version));
1534
NDR_PULL_ALLOC(ndr, r->out.handle);
1535
ZERO_STRUCTP(r->out.handle);
1536
}
1537
if (flags & NDR_OUT) {
1538
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1539
NDR_PULL_ALLOC(ndr, r->out.handle);
1540
}
1541
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1542
NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
1543
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1544
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1545
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1546
}
1547
return NDR_ERR_SUCCESS;
1548
}
1549
1550
_PUBLIC_ void ndr_print_eventlog_OpenBackupEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenBackupEventLogW *r)
1551
{
1552
ndr_print_struct(ndr, name, "eventlog_OpenBackupEventLogW");
1553
if (r == NULL) { ndr_print_null(ndr); return; }
1554
ndr->depth++;
1555
if (flags & NDR_SET_VALUES) {
1556
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1557
}
1558
if (flags & NDR_IN) {
1559
ndr_print_struct(ndr, "in", "eventlog_OpenBackupEventLogW");
1560
ndr->depth++;
1561
ndr_print_ptr(ndr, "unknown0", r->in.unknown0);
1562
ndr->depth++;
1563
if (r->in.unknown0) {
1564
ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);
1565
}
1566
ndr->depth--;
1567
ndr_print_ptr(ndr, "backup_logname", r->in.backup_logname);
1568
ndr->depth++;
1569
ndr_print_lsa_String(ndr, "backup_logname", r->in.backup_logname);
1570
ndr->depth--;
1571
ndr_print_uint32(ndr, "major_version", r->in.major_version);
1572
ndr_print_uint32(ndr, "minor_version", r->in.minor_version);
1573
ndr->depth--;
1574
}
1575
if (flags & NDR_OUT) {
1576
ndr_print_struct(ndr, "out", "eventlog_OpenBackupEventLogW");
1577
ndr->depth++;
1578
ndr_print_ptr(ndr, "handle", r->out.handle);
1579
ndr->depth++;
1580
ndr_print_policy_handle(ndr, "handle", r->out.handle);
1581
ndr->depth--;
1582
ndr_print_NTSTATUS(ndr, "result", r->out.result);
1583
ndr->depth--;
1584
}
1585
ndr->depth--;
1586
}
1587
1588
static enum ndr_err_code ndr_push_eventlog_ReadEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_ReadEventLogW *r)
1589
{
1590
if (flags & NDR_IN) {
1591
if (r->in.handle == NULL) {
1592
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1593
}
1594
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1595
NDR_CHECK(ndr_push_eventlogReadFlags(ndr, NDR_SCALARS, r->in.flags));
1596
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offset));
1597
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.number_of_bytes));
1598
}
1599
if (flags & NDR_OUT) {
1600
if (r->out.data == NULL) {
1601
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1602
}
1603
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.number_of_bytes));
1604
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.number_of_bytes));
1605
if (r->out.sent_size == NULL) {
1606
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1607
}
1608
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.sent_size));
1609
if (r->out.real_size == NULL) {
1610
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1611
}
1612
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.real_size));
1613
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1614
}
1615
return NDR_ERR_SUCCESS;
1616
}
1617
1618
static enum ndr_err_code ndr_pull_eventlog_ReadEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_ReadEventLogW *r)
1619
{
1620
TALLOC_CTX *_mem_save_handle_0;
1621
TALLOC_CTX *_mem_save_sent_size_0;
1622
TALLOC_CTX *_mem_save_real_size_0;
1623
if (flags & NDR_IN) {
1624
ZERO_STRUCT(r->out);
1625
1626
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1627
NDR_PULL_ALLOC(ndr, r->in.handle);
1628
}
1629
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1630
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1631
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1632
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1633
NDR_CHECK(ndr_pull_eventlogReadFlags(ndr, NDR_SCALARS, &r->in.flags));
1634
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offset));
1635
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.number_of_bytes));
1636
if (r->in.number_of_bytes > 0x7FFFF) {
1637
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1638
}
1639
NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.number_of_bytes);
1640
memset(r->out.data, 0, (r->in.number_of_bytes) * sizeof(*r->out.data));
1641
NDR_PULL_ALLOC(ndr, r->out.sent_size);
1642
ZERO_STRUCTP(r->out.sent_size);
1643
NDR_PULL_ALLOC(ndr, r->out.real_size);
1644
ZERO_STRUCTP(r->out.real_size);
1645
}
1646
if (flags & NDR_OUT) {
1647
NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
1648
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1649
NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
1650
}
1651
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
1652
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1653
NDR_PULL_ALLOC(ndr, r->out.sent_size);
1654
}
1655
_mem_save_sent_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
1656
NDR_PULL_SET_MEM_CTX(ndr, r->out.sent_size, LIBNDR_FLAG_REF_ALLOC);
1657
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.sent_size));
1658
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sent_size_0, LIBNDR_FLAG_REF_ALLOC);
1659
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1660
NDR_PULL_ALLOC(ndr, r->out.real_size);
1661
}
1662
_mem_save_real_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
1663
NDR_PULL_SET_MEM_CTX(ndr, r->out.real_size, LIBNDR_FLAG_REF_ALLOC);
1664
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.real_size));
1665
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_real_size_0, LIBNDR_FLAG_REF_ALLOC);
1666
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1667
if (r->out.data) {
1668
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.number_of_bytes));
1669
}
1670
}
1671
return NDR_ERR_SUCCESS;
1672
}
1673
1674
_PUBLIC_ void ndr_print_eventlog_ReadEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReadEventLogW *r)
1675
{
1676
ndr_print_struct(ndr, name, "eventlog_ReadEventLogW");
1677
if (r == NULL) { ndr_print_null(ndr); return; }
1678
ndr->depth++;
1679
if (flags & NDR_SET_VALUES) {
1680
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1681
}
1682
if (flags & NDR_IN) {
1683
ndr_print_struct(ndr, "in", "eventlog_ReadEventLogW");
1684
ndr->depth++;
1685
ndr_print_ptr(ndr, "handle", r->in.handle);
1686
ndr->depth++;
1687
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1688
ndr->depth--;
1689
ndr_print_eventlogReadFlags(ndr, "flags", r->in.flags);
1690
ndr_print_uint32(ndr, "offset", r->in.offset);
1691
ndr_print_uint32(ndr, "number_of_bytes", r->in.number_of_bytes);
1692
ndr->depth--;
1693
}
1694
if (flags & NDR_OUT) {
1695
ndr_print_struct(ndr, "out", "eventlog_ReadEventLogW");
1696
ndr->depth++;
1697
ndr_print_ptr(ndr, "data", r->out.data);
1698
ndr->depth++;
1699
ndr_print_array_uint8(ndr, "data", r->out.data, r->in.number_of_bytes);
1700
ndr->depth--;
1701
ndr_print_ptr(ndr, "sent_size", r->out.sent_size);
1702
ndr->depth++;
1703
ndr_print_uint32(ndr, "sent_size", *r->out.sent_size);
1704
ndr->depth--;
1705
ndr_print_ptr(ndr, "real_size", r->out.real_size);
1706
ndr->depth++;
1707
ndr_print_uint32(ndr, "real_size", *r->out.real_size);
1708
ndr->depth--;
1709
ndr_print_NTSTATUS(ndr, "result", r->out.result);
1710
ndr->depth--;
1711
}
1712
ndr->depth--;
1713
}
1714
1715
static enum ndr_err_code ndr_push_eventlog_ReportEventW(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventW *r)
1716
{
1717
uint32_t cntr_strings_1;
1718
if (flags & NDR_IN) {
1719
if (r->in.handle == NULL) {
1720
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1721
}
1722
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1723
NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->in.timestamp));
1724
NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->in.event_type));
1725
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.event_category));
1726
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.event_id));
1727
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.num_of_strings));
1728
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
1729
if (r->in.servername == NULL) {
1730
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1731
}
1732
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
1733
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user_sid));
1734
if (r->in.user_sid) {
1735
NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
1736
}
1737
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings));
1738
if (r->in.strings) {
1739
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_of_strings));
1740
for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
1741
}
1742
for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
1743
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings[cntr_strings_1]));
1744
if (r->in.strings[cntr_strings_1]) {
1745
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
1746
}
1747
}
1748
}
1749
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));
1750
if (r->in.data) {
1751
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
1752
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.data_size));
1753
}
1754
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.flags));
1755
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.record_number));
1756
if (r->in.record_number) {
1757
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.record_number));
1758
}
1759
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.time_written));
1760
if (r->in.time_written) {
1761
NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->in.time_written));
1762
}
1763
}
1764
if (flags & NDR_OUT) {
1765
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.record_number));
1766
if (r->out.record_number) {
1767
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.record_number));
1768
}
1769
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.time_written));
1770
if (r->out.time_written) {
1771
NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->out.time_written));
1772
}
1773
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
1774
}
1775
return NDR_ERR_SUCCESS;
1776
}
1777
1778
static enum ndr_err_code ndr_pull_eventlog_ReportEventW(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventW *r)
1779
{
1780
uint32_t _ptr_user_sid;
1781
uint32_t _ptr_strings;
1782
uint32_t cntr_strings_1;
1783
uint32_t _ptr_data;
1784
uint32_t _ptr_record_number;
1785
uint32_t _ptr_time_written;
1786
TALLOC_CTX *_mem_save_handle_0;
1787
TALLOC_CTX *_mem_save_servername_0;
1788
TALLOC_CTX *_mem_save_user_sid_0;
1789
TALLOC_CTX *_mem_save_strings_0;
1790
TALLOC_CTX *_mem_save_strings_1;
1791
TALLOC_CTX *_mem_save_strings_2;
1792
TALLOC_CTX *_mem_save_data_0;
1793
TALLOC_CTX *_mem_save_record_number_0;
1794
TALLOC_CTX *_mem_save_time_written_0;
1795
if (flags & NDR_IN) {
1796
ZERO_STRUCT(r->out);
1797
1798
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1799
NDR_PULL_ALLOC(ndr, r->in.handle);
1800
}
1801
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1802
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1803
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1804
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1805
NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->in.timestamp));
1806
NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->in.event_type));
1807
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.event_category));
1808
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.event_id));
1809
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.num_of_strings));
1810
if (r->in.num_of_strings > 256) {
1811
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1812
}
1813
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
1814
if (r->in.data_size > 0x3FFFF) {
1815
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1816
}
1817
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1818
NDR_PULL_ALLOC(ndr, r->in.servername);
1819
}
1820
_mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1821
NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, LIBNDR_FLAG_REF_ALLOC);
1822
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
1823
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, LIBNDR_FLAG_REF_ALLOC);
1824
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_sid));
1825
if (_ptr_user_sid) {
1826
NDR_PULL_ALLOC(ndr, r->in.user_sid);
1827
} else {
1828
r->in.user_sid = NULL;
1829
}
1830
if (r->in.user_sid) {
1831
_mem_save_user_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1832
NDR_PULL_SET_MEM_CTX(ndr, r->in.user_sid, 0);
1833
NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
1834
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_sid_0, 0);
1835
}
1836
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
1837
if (_ptr_strings) {
1838
NDR_PULL_ALLOC(ndr, r->in.strings);
1839
} else {
1840
r->in.strings = NULL;
1841
}
1842
if (r->in.strings) {
1843
_mem_save_strings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1844
NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
1845
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.strings));
1846
NDR_PULL_ALLOC_N(ndr, r->in.strings, ndr_get_array_size(ndr, &r->in.strings));
1847
_mem_save_strings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1848
NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
1849
for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
1850
}
1851
for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
1852
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
1853
if (_ptr_strings) {
1854
NDR_PULL_ALLOC(ndr, r->in.strings[cntr_strings_1]);
1855
} else {
1856
r->in.strings[cntr_strings_1] = NULL;
1857
}
1858
if (r->in.strings[cntr_strings_1]) {
1859
_mem_save_strings_2 = NDR_PULL_GET_MEM_CTX(ndr);
1860
NDR_PULL_SET_MEM_CTX(ndr, r->in.strings[cntr_strings_1], 0);
1861
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
1862
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_2, 0);
1863
}
1864
}
1865
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_1, 0);
1866
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_0, 0);
1867
}
1868
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
1869
if (_ptr_data) {
1870
NDR_PULL_ALLOC(ndr, r->in.data);
1871
} else {
1872
r->in.data = NULL;
1873
}
1874
if (r->in.data) {
1875
_mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
1876
NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);
1877
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
1878
NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
1879
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
1880
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
1881
}
1882
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.flags));
1883
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
1884
if (_ptr_record_number) {
1885
NDR_PULL_ALLOC(ndr, r->in.record_number);
1886
} else {
1887
r->in.record_number = NULL;
1888
}
1889
if (r->in.record_number) {
1890
_mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
1891
NDR_PULL_SET_MEM_CTX(ndr, r->in.record_number, 0);
1892
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.record_number));
1893
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
1894
}
1895
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
1896
if (_ptr_time_written) {
1897
NDR_PULL_ALLOC(ndr, r->in.time_written);
1898
} else {
1899
r->in.time_written = NULL;
1900
}
1901
if (r->in.time_written) {
1902
_mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
1903
NDR_PULL_SET_MEM_CTX(ndr, r->in.time_written, 0);
1904
NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->in.time_written));
1905
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
1906
}
1907
if (r->in.strings) {
1908
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.strings, r->in.num_of_strings));
1909
}
1910
if (r->in.data) {
1911
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.data_size));
1912
}
1913
}
1914
if (flags & NDR_OUT) {
1915
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
1916
if (_ptr_record_number) {
1917
NDR_PULL_ALLOC(ndr, r->out.record_number);
1918
} else {
1919
r->out.record_number = NULL;
1920
}
1921
if (r->out.record_number) {
1922
_mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
1923
NDR_PULL_SET_MEM_CTX(ndr, r->out.record_number, 0);
1924
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.record_number));
1925
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
1926
}
1927
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
1928
if (_ptr_time_written) {
1929
NDR_PULL_ALLOC(ndr, r->out.time_written);
1930
} else {
1931
r->out.time_written = NULL;
1932
}
1933
if (r->out.time_written) {
1934
_mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
1935
NDR_PULL_SET_MEM_CTX(ndr, r->out.time_written, 0);
1936
NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->out.time_written));
1937
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
1938
}
1939
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
1940
}
1941
return NDR_ERR_SUCCESS;
1942
}
1943
1944
_PUBLIC_ void ndr_print_eventlog_ReportEventW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventW *r)
1945
{
1946
uint32_t cntr_strings_1;
1947
ndr_print_struct(ndr, name, "eventlog_ReportEventW");
1948
if (r == NULL) { ndr_print_null(ndr); return; }
1949
ndr->depth++;
1950
if (flags & NDR_SET_VALUES) {
1951
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1952
}
1953
if (flags & NDR_IN) {
1954
ndr_print_struct(ndr, "in", "eventlog_ReportEventW");
1955
ndr->depth++;
1956
ndr_print_ptr(ndr, "handle", r->in.handle);
1957
ndr->depth++;
1958
ndr_print_policy_handle(ndr, "handle", r->in.handle);
1959
ndr->depth--;
1960
ndr_print_time_t(ndr, "timestamp", r->in.timestamp);
1961
ndr_print_eventlogEventTypes(ndr, "event_type", r->in.event_type);
1962
ndr_print_uint16(ndr, "event_category", r->in.event_category);
1963
ndr_print_uint32(ndr, "event_id", r->in.event_id);
1964
ndr_print_uint16(ndr, "num_of_strings", r->in.num_of_strings);
1965
ndr_print_uint32(ndr, "data_size", r->in.data_size);
1966
ndr_print_ptr(ndr, "servername", r->in.servername);
1967
ndr->depth++;
1968
ndr_print_lsa_String(ndr, "servername", r->in.servername);
1969
ndr->depth--;
1970
ndr_print_ptr(ndr, "user_sid", r->in.user_sid);
1971
ndr->depth++;
1972
if (r->in.user_sid) {
1973
ndr_print_dom_sid(ndr, "user_sid", r->in.user_sid);
1974
}
1975
ndr->depth--;
1976
ndr_print_ptr(ndr, "strings", r->in.strings);
1977
ndr->depth++;
1978
if (r->in.strings) {
1979
ndr->print(ndr, "%s: ARRAY(%d)", "strings", (int)r->in.num_of_strings);
1980
ndr->depth++;
1981
for (cntr_strings_1=0;cntr_strings_1<r->in.num_of_strings;cntr_strings_1++) {
1982
ndr_print_ptr(ndr, "strings", r->in.strings[cntr_strings_1]);
1983
ndr->depth++;
1984
if (r->in.strings[cntr_strings_1]) {
1985
ndr_print_lsa_String(ndr, "strings", r->in.strings[cntr_strings_1]);
1986
}
1987
ndr->depth--;
1988
}
1989
ndr->depth--;
1990
}
1991
ndr->depth--;
1992
ndr_print_ptr(ndr, "data", r->in.data);
1993
ndr->depth++;
1994
if (r->in.data) {
1995
ndr_print_array_uint8(ndr, "data", r->in.data, r->in.data_size);
1996
}
1997
ndr->depth--;
1998
ndr_print_uint16(ndr, "flags", r->in.flags);
1999
ndr_print_ptr(ndr, "record_number", r->in.record_number);
2000
ndr->depth++;
2001
if (r->in.record_number) {
2002
ndr_print_uint32(ndr, "record_number", *r->in.record_number);
2003
}
2004
ndr->depth--;
2005
ndr_print_ptr(ndr, "time_written", r->in.time_written);
2006
ndr->depth++;
2007
if (r->in.time_written) {
2008
ndr_print_time_t(ndr, "time_written", *r->in.time_written);
2009
}
2010
ndr->depth--;
2011
ndr->depth--;
2012
}
2013
if (flags & NDR_OUT) {
2014
ndr_print_struct(ndr, "out", "eventlog_ReportEventW");
2015
ndr->depth++;
2016
ndr_print_ptr(ndr, "record_number", r->out.record_number);
2017
ndr->depth++;
2018
if (r->out.record_number) {
2019
ndr_print_uint32(ndr, "record_number", *r->out.record_number);
2020
}
2021
ndr->depth--;
2022
ndr_print_ptr(ndr, "time_written", r->out.time_written);
2023
ndr->depth++;
2024
if (r->out.time_written) {
2025
ndr_print_time_t(ndr, "time_written", *r->out.time_written);
2026
}
2027
ndr->depth--;
2028
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2029
ndr->depth--;
2030
}
2031
ndr->depth--;
2032
}
2033
2034
static enum ndr_err_code ndr_push_eventlog_ClearEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_ClearEventLogA *r)
2035
{
2036
if (flags & NDR_IN) {
2037
}
2038
if (flags & NDR_OUT) {
2039
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2040
}
2041
return NDR_ERR_SUCCESS;
2042
}
2043
2044
static enum ndr_err_code ndr_pull_eventlog_ClearEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_ClearEventLogA *r)
2045
{
2046
if (flags & NDR_IN) {
2047
}
2048
if (flags & NDR_OUT) {
2049
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2050
}
2051
return NDR_ERR_SUCCESS;
2052
}
2053
2054
_PUBLIC_ void ndr_print_eventlog_ClearEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ClearEventLogA *r)
2055
{
2056
ndr_print_struct(ndr, name, "eventlog_ClearEventLogA");
2057
if (r == NULL) { ndr_print_null(ndr); return; }
2058
ndr->depth++;
2059
if (flags & NDR_SET_VALUES) {
2060
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2061
}
2062
if (flags & NDR_IN) {
2063
ndr_print_struct(ndr, "in", "eventlog_ClearEventLogA");
2064
ndr->depth++;
2065
ndr->depth--;
2066
}
2067
if (flags & NDR_OUT) {
2068
ndr_print_struct(ndr, "out", "eventlog_ClearEventLogA");
2069
ndr->depth++;
2070
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2071
ndr->depth--;
2072
}
2073
ndr->depth--;
2074
}
2075
2076
static enum ndr_err_code ndr_push_eventlog_BackupEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_BackupEventLogA *r)
2077
{
2078
if (flags & NDR_IN) {
2079
}
2080
if (flags & NDR_OUT) {
2081
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2082
}
2083
return NDR_ERR_SUCCESS;
2084
}
2085
2086
static enum ndr_err_code ndr_pull_eventlog_BackupEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_BackupEventLogA *r)
2087
{
2088
if (flags & NDR_IN) {
2089
}
2090
if (flags & NDR_OUT) {
2091
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2092
}
2093
return NDR_ERR_SUCCESS;
2094
}
2095
2096
_PUBLIC_ void ndr_print_eventlog_BackupEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_BackupEventLogA *r)
2097
{
2098
ndr_print_struct(ndr, name, "eventlog_BackupEventLogA");
2099
if (r == NULL) { ndr_print_null(ndr); return; }
2100
ndr->depth++;
2101
if (flags & NDR_SET_VALUES) {
2102
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2103
}
2104
if (flags & NDR_IN) {
2105
ndr_print_struct(ndr, "in", "eventlog_BackupEventLogA");
2106
ndr->depth++;
2107
ndr->depth--;
2108
}
2109
if (flags & NDR_OUT) {
2110
ndr_print_struct(ndr, "out", "eventlog_BackupEventLogA");
2111
ndr->depth++;
2112
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2113
ndr->depth--;
2114
}
2115
ndr->depth--;
2116
}
2117
2118
static enum ndr_err_code ndr_push_eventlog_OpenEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_OpenEventLogA *r)
2119
{
2120
if (flags & NDR_IN) {
2121
}
2122
if (flags & NDR_OUT) {
2123
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2124
}
2125
return NDR_ERR_SUCCESS;
2126
}
2127
2128
static enum ndr_err_code ndr_pull_eventlog_OpenEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_OpenEventLogA *r)
2129
{
2130
if (flags & NDR_IN) {
2131
}
2132
if (flags & NDR_OUT) {
2133
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2134
}
2135
return NDR_ERR_SUCCESS;
2136
}
2137
2138
_PUBLIC_ void ndr_print_eventlog_OpenEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenEventLogA *r)
2139
{
2140
ndr_print_struct(ndr, name, "eventlog_OpenEventLogA");
2141
if (r == NULL) { ndr_print_null(ndr); return; }
2142
ndr->depth++;
2143
if (flags & NDR_SET_VALUES) {
2144
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2145
}
2146
if (flags & NDR_IN) {
2147
ndr_print_struct(ndr, "in", "eventlog_OpenEventLogA");
2148
ndr->depth++;
2149
ndr->depth--;
2150
}
2151
if (flags & NDR_OUT) {
2152
ndr_print_struct(ndr, "out", "eventlog_OpenEventLogA");
2153
ndr->depth++;
2154
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2155
ndr->depth--;
2156
}
2157
ndr->depth--;
2158
}
2159
2160
static enum ndr_err_code ndr_push_eventlog_RegisterEventSourceA(struct ndr_push *ndr, int flags, const struct eventlog_RegisterEventSourceA *r)
2161
{
2162
if (flags & NDR_IN) {
2163
}
2164
if (flags & NDR_OUT) {
2165
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2166
}
2167
return NDR_ERR_SUCCESS;
2168
}
2169
2170
static enum ndr_err_code ndr_pull_eventlog_RegisterEventSourceA(struct ndr_pull *ndr, int flags, struct eventlog_RegisterEventSourceA *r)
2171
{
2172
if (flags & NDR_IN) {
2173
}
2174
if (flags & NDR_OUT) {
2175
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2176
}
2177
return NDR_ERR_SUCCESS;
2178
}
2179
2180
_PUBLIC_ void ndr_print_eventlog_RegisterEventSourceA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterEventSourceA *r)
2181
{
2182
ndr_print_struct(ndr, name, "eventlog_RegisterEventSourceA");
2183
if (r == NULL) { ndr_print_null(ndr); return; }
2184
ndr->depth++;
2185
if (flags & NDR_SET_VALUES) {
2186
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2187
}
2188
if (flags & NDR_IN) {
2189
ndr_print_struct(ndr, "in", "eventlog_RegisterEventSourceA");
2190
ndr->depth++;
2191
ndr->depth--;
2192
}
2193
if (flags & NDR_OUT) {
2194
ndr_print_struct(ndr, "out", "eventlog_RegisterEventSourceA");
2195
ndr->depth++;
2196
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2197
ndr->depth--;
2198
}
2199
ndr->depth--;
2200
}
2201
2202
static enum ndr_err_code ndr_push_eventlog_OpenBackupEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_OpenBackupEventLogA *r)
2203
{
2204
if (flags & NDR_IN) {
2205
}
2206
if (flags & NDR_OUT) {
2207
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2208
}
2209
return NDR_ERR_SUCCESS;
2210
}
2211
2212
static enum ndr_err_code ndr_pull_eventlog_OpenBackupEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_OpenBackupEventLogA *r)
2213
{
2214
if (flags & NDR_IN) {
2215
}
2216
if (flags & NDR_OUT) {
2217
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2218
}
2219
return NDR_ERR_SUCCESS;
2220
}
2221
2222
_PUBLIC_ void ndr_print_eventlog_OpenBackupEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenBackupEventLogA *r)
2223
{
2224
ndr_print_struct(ndr, name, "eventlog_OpenBackupEventLogA");
2225
if (r == NULL) { ndr_print_null(ndr); return; }
2226
ndr->depth++;
2227
if (flags & NDR_SET_VALUES) {
2228
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2229
}
2230
if (flags & NDR_IN) {
2231
ndr_print_struct(ndr, "in", "eventlog_OpenBackupEventLogA");
2232
ndr->depth++;
2233
ndr->depth--;
2234
}
2235
if (flags & NDR_OUT) {
2236
ndr_print_struct(ndr, "out", "eventlog_OpenBackupEventLogA");
2237
ndr->depth++;
2238
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2239
ndr->depth--;
2240
}
2241
ndr->depth--;
2242
}
2243
2244
static enum ndr_err_code ndr_push_eventlog_ReadEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_ReadEventLogA *r)
2245
{
2246
if (flags & NDR_IN) {
2247
}
2248
if (flags & NDR_OUT) {
2249
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2250
}
2251
return NDR_ERR_SUCCESS;
2252
}
2253
2254
static enum ndr_err_code ndr_pull_eventlog_ReadEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_ReadEventLogA *r)
2255
{
2256
if (flags & NDR_IN) {
2257
}
2258
if (flags & NDR_OUT) {
2259
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2260
}
2261
return NDR_ERR_SUCCESS;
2262
}
2263
2264
_PUBLIC_ void ndr_print_eventlog_ReadEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReadEventLogA *r)
2265
{
2266
ndr_print_struct(ndr, name, "eventlog_ReadEventLogA");
2267
if (r == NULL) { ndr_print_null(ndr); return; }
2268
ndr->depth++;
2269
if (flags & NDR_SET_VALUES) {
2270
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2271
}
2272
if (flags & NDR_IN) {
2273
ndr_print_struct(ndr, "in", "eventlog_ReadEventLogA");
2274
ndr->depth++;
2275
ndr->depth--;
2276
}
2277
if (flags & NDR_OUT) {
2278
ndr_print_struct(ndr, "out", "eventlog_ReadEventLogA");
2279
ndr->depth++;
2280
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2281
ndr->depth--;
2282
}
2283
ndr->depth--;
2284
}
2285
2286
static enum ndr_err_code ndr_push_eventlog_ReportEventA(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventA *r)
2287
{
2288
if (flags & NDR_IN) {
2289
}
2290
if (flags & NDR_OUT) {
2291
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2292
}
2293
return NDR_ERR_SUCCESS;
2294
}
2295
2296
static enum ndr_err_code ndr_pull_eventlog_ReportEventA(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventA *r)
2297
{
2298
if (flags & NDR_IN) {
2299
}
2300
if (flags & NDR_OUT) {
2301
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2302
}
2303
return NDR_ERR_SUCCESS;
2304
}
2305
2306
_PUBLIC_ void ndr_print_eventlog_ReportEventA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventA *r)
2307
{
2308
ndr_print_struct(ndr, name, "eventlog_ReportEventA");
2309
if (r == NULL) { ndr_print_null(ndr); return; }
2310
ndr->depth++;
2311
if (flags & NDR_SET_VALUES) {
2312
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2313
}
2314
if (flags & NDR_IN) {
2315
ndr_print_struct(ndr, "in", "eventlog_ReportEventA");
2316
ndr->depth++;
2317
ndr->depth--;
2318
}
2319
if (flags & NDR_OUT) {
2320
ndr_print_struct(ndr, "out", "eventlog_ReportEventA");
2321
ndr->depth++;
2322
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2323
ndr->depth--;
2324
}
2325
ndr->depth--;
2326
}
2327
2328
static enum ndr_err_code ndr_push_eventlog_RegisterClusterSvc(struct ndr_push *ndr, int flags, const struct eventlog_RegisterClusterSvc *r)
2329
{
2330
if (flags & NDR_IN) {
2331
}
2332
if (flags & NDR_OUT) {
2333
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2334
}
2335
return NDR_ERR_SUCCESS;
2336
}
2337
2338
static enum ndr_err_code ndr_pull_eventlog_RegisterClusterSvc(struct ndr_pull *ndr, int flags, struct eventlog_RegisterClusterSvc *r)
2339
{
2340
if (flags & NDR_IN) {
2341
}
2342
if (flags & NDR_OUT) {
2343
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2344
}
2345
return NDR_ERR_SUCCESS;
2346
}
2347
2348
_PUBLIC_ void ndr_print_eventlog_RegisterClusterSvc(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterClusterSvc *r)
2349
{
2350
ndr_print_struct(ndr, name, "eventlog_RegisterClusterSvc");
2351
if (r == NULL) { ndr_print_null(ndr); return; }
2352
ndr->depth++;
2353
if (flags & NDR_SET_VALUES) {
2354
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2355
}
2356
if (flags & NDR_IN) {
2357
ndr_print_struct(ndr, "in", "eventlog_RegisterClusterSvc");
2358
ndr->depth++;
2359
ndr->depth--;
2360
}
2361
if (flags & NDR_OUT) {
2362
ndr_print_struct(ndr, "out", "eventlog_RegisterClusterSvc");
2363
ndr->depth++;
2364
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2365
ndr->depth--;
2366
}
2367
ndr->depth--;
2368
}
2369
2370
static enum ndr_err_code ndr_push_eventlog_DeregisterClusterSvc(struct ndr_push *ndr, int flags, const struct eventlog_DeregisterClusterSvc *r)
2371
{
2372
if (flags & NDR_IN) {
2373
}
2374
if (flags & NDR_OUT) {
2375
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2376
}
2377
return NDR_ERR_SUCCESS;
2378
}
2379
2380
static enum ndr_err_code ndr_pull_eventlog_DeregisterClusterSvc(struct ndr_pull *ndr, int flags, struct eventlog_DeregisterClusterSvc *r)
2381
{
2382
if (flags & NDR_IN) {
2383
}
2384
if (flags & NDR_OUT) {
2385
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2386
}
2387
return NDR_ERR_SUCCESS;
2388
}
2389
2390
_PUBLIC_ void ndr_print_eventlog_DeregisterClusterSvc(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_DeregisterClusterSvc *r)
2391
{
2392
ndr_print_struct(ndr, name, "eventlog_DeregisterClusterSvc");
2393
if (r == NULL) { ndr_print_null(ndr); return; }
2394
ndr->depth++;
2395
if (flags & NDR_SET_VALUES) {
2396
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2397
}
2398
if (flags & NDR_IN) {
2399
ndr_print_struct(ndr, "in", "eventlog_DeregisterClusterSvc");
2400
ndr->depth++;
2401
ndr->depth--;
2402
}
2403
if (flags & NDR_OUT) {
2404
ndr_print_struct(ndr, "out", "eventlog_DeregisterClusterSvc");
2405
ndr->depth++;
2406
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2407
ndr->depth--;
2408
}
2409
ndr->depth--;
2410
}
2411
2412
static enum ndr_err_code ndr_push_eventlog_WriteClusterEvents(struct ndr_push *ndr, int flags, const struct eventlog_WriteClusterEvents *r)
2413
{
2414
if (flags & NDR_IN) {
2415
}
2416
if (flags & NDR_OUT) {
2417
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2418
}
2419
return NDR_ERR_SUCCESS;
2420
}
2421
2422
static enum ndr_err_code ndr_pull_eventlog_WriteClusterEvents(struct ndr_pull *ndr, int flags, struct eventlog_WriteClusterEvents *r)
2423
{
2424
if (flags & NDR_IN) {
2425
}
2426
if (flags & NDR_OUT) {
2427
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2428
}
2429
return NDR_ERR_SUCCESS;
2430
}
2431
2432
_PUBLIC_ void ndr_print_eventlog_WriteClusterEvents(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_WriteClusterEvents *r)
2433
{
2434
ndr_print_struct(ndr, name, "eventlog_WriteClusterEvents");
2435
if (r == NULL) { ndr_print_null(ndr); return; }
2436
ndr->depth++;
2437
if (flags & NDR_SET_VALUES) {
2438
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2439
}
2440
if (flags & NDR_IN) {
2441
ndr_print_struct(ndr, "in", "eventlog_WriteClusterEvents");
2442
ndr->depth++;
2443
ndr->depth--;
2444
}
2445
if (flags & NDR_OUT) {
2446
ndr_print_struct(ndr, "out", "eventlog_WriteClusterEvents");
2447
ndr->depth++;
2448
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2449
ndr->depth--;
2450
}
2451
ndr->depth--;
2452
}
2453
2454
static enum ndr_err_code ndr_push_eventlog_GetLogInformation(struct ndr_push *ndr, int flags, const struct eventlog_GetLogInformation *r)
2455
{
2456
if (flags & NDR_IN) {
2457
if (r->in.handle == NULL) {
2458
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2459
}
2460
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2461
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
2462
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
2463
}
2464
if (flags & NDR_OUT) {
2465
if (r->out.buffer == NULL) {
2466
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2467
}
2468
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.buf_size));
2469
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));
2470
if (r->out.bytes_needed == NULL) {
2471
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2472
}
2473
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
2474
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2475
}
2476
return NDR_ERR_SUCCESS;
2477
}
2478
2479
static enum ndr_err_code ndr_pull_eventlog_GetLogInformation(struct ndr_pull *ndr, int flags, struct eventlog_GetLogInformation *r)
2480
{
2481
TALLOC_CTX *_mem_save_handle_0;
2482
TALLOC_CTX *_mem_save_bytes_needed_0;
2483
if (flags & NDR_IN) {
2484
ZERO_STRUCT(r->out);
2485
2486
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2487
NDR_PULL_ALLOC(ndr, r->in.handle);
2488
}
2489
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2490
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2491
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2492
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2493
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
2494
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
2495
if (r->in.buf_size > 1024) {
2496
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2497
}
2498
NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.buf_size);
2499
memset(r->out.buffer, 0, (r->in.buf_size) * sizeof(*r->out.buffer));
2500
NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
2501
ZERO_STRUCTP(r->out.bytes_needed);
2502
}
2503
if (flags & NDR_OUT) {
2504
NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
2505
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2506
NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
2507
}
2508
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
2509
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2510
NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
2511
}
2512
_mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
2513
NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
2514
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
2515
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
2516
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2517
if (r->out.buffer) {
2518
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.buf_size));
2519
}
2520
}
2521
return NDR_ERR_SUCCESS;
2522
}
2523
2524
_PUBLIC_ void ndr_print_eventlog_GetLogInformation(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetLogInformation *r)
2525
{
2526
ndr_print_struct(ndr, name, "eventlog_GetLogInformation");
2527
if (r == NULL) { ndr_print_null(ndr); return; }
2528
ndr->depth++;
2529
if (flags & NDR_SET_VALUES) {
2530
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2531
}
2532
if (flags & NDR_IN) {
2533
ndr_print_struct(ndr, "in", "eventlog_GetLogInformation");
2534
ndr->depth++;
2535
ndr_print_ptr(ndr, "handle", r->in.handle);
2536
ndr->depth++;
2537
ndr_print_policy_handle(ndr, "handle", r->in.handle);
2538
ndr->depth--;
2539
ndr_print_uint32(ndr, "level", r->in.level);
2540
ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
2541
ndr->depth--;
2542
}
2543
if (flags & NDR_OUT) {
2544
ndr_print_struct(ndr, "out", "eventlog_GetLogInformation");
2545
ndr->depth++;
2546
ndr_print_ptr(ndr, "buffer", r->out.buffer);
2547
ndr->depth++;
2548
ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.buf_size);
2549
ndr->depth--;
2550
ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
2551
ndr->depth++;
2552
ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
2553
ndr->depth--;
2554
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2555
ndr->depth--;
2556
}
2557
ndr->depth--;
2558
}
2559
2560
static enum ndr_err_code ndr_push_eventlog_FlushEventLog(struct ndr_push *ndr, int flags, const struct eventlog_FlushEventLog *r)
2561
{
2562
if (flags & NDR_IN) {
2563
if (r->in.handle == NULL) {
2564
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2565
}
2566
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2567
}
2568
if (flags & NDR_OUT) {
2569
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2570
}
2571
return NDR_ERR_SUCCESS;
2572
}
2573
2574
static enum ndr_err_code ndr_pull_eventlog_FlushEventLog(struct ndr_pull *ndr, int flags, struct eventlog_FlushEventLog *r)
2575
{
2576
TALLOC_CTX *_mem_save_handle_0;
2577
if (flags & NDR_IN) {
2578
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2579
NDR_PULL_ALLOC(ndr, r->in.handle);
2580
}
2581
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2582
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2583
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2584
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2585
}
2586
if (flags & NDR_OUT) {
2587
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2588
}
2589
return NDR_ERR_SUCCESS;
2590
}
2591
2592
_PUBLIC_ void ndr_print_eventlog_FlushEventLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_FlushEventLog *r)
2593
{
2594
ndr_print_struct(ndr, name, "eventlog_FlushEventLog");
2595
if (r == NULL) { ndr_print_null(ndr); return; }
2596
ndr->depth++;
2597
if (flags & NDR_SET_VALUES) {
2598
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2599
}
2600
if (flags & NDR_IN) {
2601
ndr_print_struct(ndr, "in", "eventlog_FlushEventLog");
2602
ndr->depth++;
2603
ndr_print_ptr(ndr, "handle", r->in.handle);
2604
ndr->depth++;
2605
ndr_print_policy_handle(ndr, "handle", r->in.handle);
2606
ndr->depth--;
2607
ndr->depth--;
2608
}
2609
if (flags & NDR_OUT) {
2610
ndr_print_struct(ndr, "out", "eventlog_FlushEventLog");
2611
ndr->depth++;
2612
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2613
ndr->depth--;
2614
}
2615
ndr->depth--;
2616
}
2617
2618
static enum ndr_err_code ndr_push_eventlog_ReportEventAndSourceW(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventAndSourceW *r)
2619
{
2620
uint32_t cntr_strings_1;
2621
if (flags & NDR_IN) {
2622
if (r->in.handle == NULL) {
2623
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2624
}
2625
NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2626
NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->in.timestamp));
2627
NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->in.event_type));
2628
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.event_category));
2629
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.event_id));
2630
if (r->in.sourcename == NULL) {
2631
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2632
}
2633
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sourcename));
2634
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.num_of_strings));
2635
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
2636
if (r->in.servername == NULL) {
2637
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2638
}
2639
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
2640
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user_sid));
2641
if (r->in.user_sid) {
2642
NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
2643
}
2644
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings));
2645
if (r->in.strings) {
2646
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_of_strings));
2647
for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
2648
}
2649
for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
2650
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings[cntr_strings_1]));
2651
if (r->in.strings[cntr_strings_1]) {
2652
NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
2653
}
2654
}
2655
}
2656
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));
2657
if (r->in.data) {
2658
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
2659
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.data_size));
2660
}
2661
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.flags));
2662
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.record_number));
2663
if (r->in.record_number) {
2664
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.record_number));
2665
}
2666
NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.time_written));
2667
if (r->in.time_written) {
2668
NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->in.time_written));
2669
}
2670
}
2671
if (flags & NDR_OUT) {
2672
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.record_number));
2673
if (r->out.record_number) {
2674
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.record_number));
2675
}
2676
NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.time_written));
2677
if (r->out.time_written) {
2678
NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->out.time_written));
2679
}
2680
NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
2681
}
2682
return NDR_ERR_SUCCESS;
2683
}
2684
2685
static enum ndr_err_code ndr_pull_eventlog_ReportEventAndSourceW(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventAndSourceW *r)
2686
{
2687
uint32_t _ptr_user_sid;
2688
uint32_t _ptr_strings;
2689
uint32_t cntr_strings_1;
2690
uint32_t _ptr_data;
2691
uint32_t _ptr_record_number;
2692
uint32_t _ptr_time_written;
2693
TALLOC_CTX *_mem_save_handle_0;
2694
TALLOC_CTX *_mem_save_sourcename_0;
2695
TALLOC_CTX *_mem_save_servername_0;
2696
TALLOC_CTX *_mem_save_user_sid_0;
2697
TALLOC_CTX *_mem_save_strings_0;
2698
TALLOC_CTX *_mem_save_strings_1;
2699
TALLOC_CTX *_mem_save_strings_2;
2700
TALLOC_CTX *_mem_save_data_0;
2701
TALLOC_CTX *_mem_save_record_number_0;
2702
TALLOC_CTX *_mem_save_time_written_0;
2703
if (flags & NDR_IN) {
2704
ZERO_STRUCT(r->out);
2705
2706
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2707
NDR_PULL_ALLOC(ndr, r->in.handle);
2708
}
2709
_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2710
NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2711
NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2712
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2713
NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->in.timestamp));
2714
NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->in.event_type));
2715
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.event_category));
2716
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.event_id));
2717
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2718
NDR_PULL_ALLOC(ndr, r->in.sourcename);
2719
}
2720
_mem_save_sourcename_0 = NDR_PULL_GET_MEM_CTX(ndr);
2721
NDR_PULL_SET_MEM_CTX(ndr, r->in.sourcename, LIBNDR_FLAG_REF_ALLOC);
2722
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sourcename));
2723
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sourcename_0, LIBNDR_FLAG_REF_ALLOC);
2724
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.num_of_strings));
2725
if (r->in.num_of_strings > 256) {
2726
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2727
}
2728
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
2729
if (r->in.data_size > 0x3FFFF) {
2730
return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2731
}
2732
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2733
NDR_PULL_ALLOC(ndr, r->in.servername);
2734
}
2735
_mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2736
NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, LIBNDR_FLAG_REF_ALLOC);
2737
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
2738
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, LIBNDR_FLAG_REF_ALLOC);
2739
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_sid));
2740
if (_ptr_user_sid) {
2741
NDR_PULL_ALLOC(ndr, r->in.user_sid);
2742
} else {
2743
r->in.user_sid = NULL;
2744
}
2745
if (r->in.user_sid) {
2746
_mem_save_user_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2747
NDR_PULL_SET_MEM_CTX(ndr, r->in.user_sid, 0);
2748
NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
2749
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_sid_0, 0);
2750
}
2751
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
2752
if (_ptr_strings) {
2753
NDR_PULL_ALLOC(ndr, r->in.strings);
2754
} else {
2755
r->in.strings = NULL;
2756
}
2757
if (r->in.strings) {
2758
_mem_save_strings_0 = NDR_PULL_GET_MEM_CTX(ndr);
2759
NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
2760
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.strings));
2761
NDR_PULL_ALLOC_N(ndr, r->in.strings, ndr_get_array_size(ndr, &r->in.strings));
2762
_mem_save_strings_1 = NDR_PULL_GET_MEM_CTX(ndr);
2763
NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
2764
for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
2765
}
2766
for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
2767
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
2768
if (_ptr_strings) {
2769
NDR_PULL_ALLOC(ndr, r->in.strings[cntr_strings_1]);
2770
} else {
2771
r->in.strings[cntr_strings_1] = NULL;
2772
}
2773
if (r->in.strings[cntr_strings_1]) {
2774
_mem_save_strings_2 = NDR_PULL_GET_MEM_CTX(ndr);
2775
NDR_PULL_SET_MEM_CTX(ndr, r->in.strings[cntr_strings_1], 0);
2776
NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
2777
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_2, 0);
2778
}
2779
}
2780
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_1, 0);
2781
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_0, 0);
2782
}
2783
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
2784
if (_ptr_data) {
2785
NDR_PULL_ALLOC(ndr, r->in.data);
2786
} else {
2787
r->in.data = NULL;
2788
}
2789
if (r->in.data) {
2790
_mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2791
NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);
2792
NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
2793
NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
2794
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
2795
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
2796
}
2797
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.flags));
2798
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
2799
if (_ptr_record_number) {
2800
NDR_PULL_ALLOC(ndr, r->in.record_number);
2801
} else {
2802
r->in.record_number = NULL;
2803
}
2804
if (r->in.record_number) {
2805
_mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
2806
NDR_PULL_SET_MEM_CTX(ndr, r->in.record_number, 0);
2807
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.record_number));
2808
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
2809
}
2810
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
2811
if (_ptr_time_written) {
2812
NDR_PULL_ALLOC(ndr, r->in.time_written);
2813
} else {
2814
r->in.time_written = NULL;
2815
}
2816
if (r->in.time_written) {
2817
_mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
2818
NDR_PULL_SET_MEM_CTX(ndr, r->in.time_written, 0);
2819
NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->in.time_written));
2820
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
2821
}
2822
if (r->in.strings) {
2823
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.strings, r->in.num_of_strings));
2824
}
2825
if (r->in.data) {
2826
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.data_size));
2827
}
2828
}
2829
if (flags & NDR_OUT) {
2830
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
2831
if (_ptr_record_number) {
2832
NDR_PULL_ALLOC(ndr, r->out.record_number);
2833
} else {
2834
r->out.record_number = NULL;
2835
}
2836
if (r->out.record_number) {
2837
_mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
2838
NDR_PULL_SET_MEM_CTX(ndr, r->out.record_number, 0);
2839
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.record_number));
2840
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
2841
}
2842
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
2843
if (_ptr_time_written) {
2844
NDR_PULL_ALLOC(ndr, r->out.time_written);
2845
} else {
2846
r->out.time_written = NULL;
2847
}
2848
if (r->out.time_written) {
2849
_mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
2850
NDR_PULL_SET_MEM_CTX(ndr, r->out.time_written, 0);
2851
NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->out.time_written));
2852
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
2853
}
2854
NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
2855
}
2856
return NDR_ERR_SUCCESS;
2857
}
2858
2859
_PUBLIC_ void ndr_print_eventlog_ReportEventAndSourceW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventAndSourceW *r)
2860
{
2861
uint32_t cntr_strings_1;
2862
ndr_print_struct(ndr, name, "eventlog_ReportEventAndSourceW");
2863
if (r == NULL) { ndr_print_null(ndr); return; }
2864
ndr->depth++;
2865
if (flags & NDR_SET_VALUES) {
2866
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2867
}
2868
if (flags & NDR_IN) {
2869
ndr_print_struct(ndr, "in", "eventlog_ReportEventAndSourceW");
2870
ndr->depth++;
2871
ndr_print_ptr(ndr, "handle", r->in.handle);
2872
ndr->depth++;
2873
ndr_print_policy_handle(ndr, "handle", r->in.handle);
2874
ndr->depth--;
2875
ndr_print_time_t(ndr, "timestamp", r->in.timestamp);
2876
ndr_print_eventlogEventTypes(ndr, "event_type", r->in.event_type);
2877
ndr_print_uint16(ndr, "event_category", r->in.event_category);
2878
ndr_print_uint32(ndr, "event_id", r->in.event_id);
2879
ndr_print_ptr(ndr, "sourcename", r->in.sourcename);
2880
ndr->depth++;
2881
ndr_print_lsa_String(ndr, "sourcename", r->in.sourcename);
2882
ndr->depth--;
2883
ndr_print_uint16(ndr, "num_of_strings", r->in.num_of_strings);
2884
ndr_print_uint32(ndr, "data_size", r->in.data_size);
2885
ndr_print_ptr(ndr, "servername", r->in.servername);
2886
ndr->depth++;
2887
ndr_print_lsa_String(ndr, "servername", r->in.servername);
2888
ndr->depth--;
2889
ndr_print_ptr(ndr, "user_sid", r->in.user_sid);
2890
ndr->depth++;
2891
if (r->in.user_sid) {
2892
ndr_print_dom_sid(ndr, "user_sid", r->in.user_sid);
2893
}
2894
ndr->depth--;
2895
ndr_print_ptr(ndr, "strings", r->in.strings);
2896
ndr->depth++;
2897
if (r->in.strings) {
2898
ndr->print(ndr, "%s: ARRAY(%d)", "strings", (int)r->in.num_of_strings);
2899
ndr->depth++;
2900
for (cntr_strings_1=0;cntr_strings_1<r->in.num_of_strings;cntr_strings_1++) {
2901
ndr_print_ptr(ndr, "strings", r->in.strings[cntr_strings_1]);
2902
ndr->depth++;
2903
if (r->in.strings[cntr_strings_1]) {
2904
ndr_print_lsa_String(ndr, "strings", r->in.strings[cntr_strings_1]);
2905
}
2906
ndr->depth--;
2907
}
2908
ndr->depth--;
2909
}
2910
ndr->depth--;
2911
ndr_print_ptr(ndr, "data", r->in.data);
2912
ndr->depth++;
2913
if (r->in.data) {
2914
ndr_print_array_uint8(ndr, "data", r->in.data, r->in.data_size);
2915
}
2916
ndr->depth--;
2917
ndr_print_uint16(ndr, "flags", r->in.flags);
2918
ndr_print_ptr(ndr, "record_number", r->in.record_number);
2919
ndr->depth++;
2920
if (r->in.record_number) {
2921
ndr_print_uint32(ndr, "record_number", *r->in.record_number);
2922
}
2923
ndr->depth--;
2924
ndr_print_ptr(ndr, "time_written", r->in.time_written);
2925
ndr->depth++;
2926
if (r->in.time_written) {
2927
ndr_print_time_t(ndr, "time_written", *r->in.time_written);
2928
}
2929
ndr->depth--;
2930
ndr->depth--;
2931
}
2932
if (flags & NDR_OUT) {
2933
ndr_print_struct(ndr, "out", "eventlog_ReportEventAndSourceW");
2934
ndr->depth++;
2935
ndr_print_ptr(ndr, "record_number", r->out.record_number);
2936
ndr->depth++;
2937
if (r->out.record_number) {
2938
ndr_print_uint32(ndr, "record_number", *r->out.record_number);
2939
}
2940
ndr->depth--;
2941
ndr_print_ptr(ndr, "time_written", r->out.time_written);
2942
ndr->depth++;
2943
if (r->out.time_written) {
2944
ndr_print_time_t(ndr, "time_written", *r->out.time_written);
2945
}
2946
ndr->depth--;
2947
ndr_print_NTSTATUS(ndr, "result", r->out.result);
2948
ndr->depth--;
2949
}
2950
ndr->depth--;
2951
}
2952
2953
static const struct ndr_interface_call eventlog_calls[] = {
2954
{
2955
"eventlog_ClearEventLogW",
2956
sizeof(struct eventlog_ClearEventLogW),
2957
(ndr_push_flags_fn_t) ndr_push_eventlog_ClearEventLogW,
2958
(ndr_pull_flags_fn_t) ndr_pull_eventlog_ClearEventLogW,
2959
(ndr_print_function_t) ndr_print_eventlog_ClearEventLogW,
2960
{ 0, NULL },
2961
{ 0, NULL },
2962
},
2963
{
2964
"eventlog_BackupEventLogW",
2965
sizeof(struct eventlog_BackupEventLogW),
2966
(ndr_push_flags_fn_t) ndr_push_eventlog_BackupEventLogW,
2967
(ndr_pull_flags_fn_t) ndr_pull_eventlog_BackupEventLogW,
2968
(ndr_print_function_t) ndr_print_eventlog_BackupEventLogW,
2969
{ 0, NULL },
2970
{ 0, NULL },
2971
},
2972
{
2973
"eventlog_CloseEventLog",
2974
sizeof(struct eventlog_CloseEventLog),
2975
(ndr_push_flags_fn_t) ndr_push_eventlog_CloseEventLog,
2976
(ndr_pull_flags_fn_t) ndr_pull_eventlog_CloseEventLog,
2977
(ndr_print_function_t) ndr_print_eventlog_CloseEventLog,
2978
{ 0, NULL },
2979
{ 0, NULL },
2980
},
2981
{
2982
"eventlog_DeregisterEventSource",
2983
sizeof(struct eventlog_DeregisterEventSource),
2984
(ndr_push_flags_fn_t) ndr_push_eventlog_DeregisterEventSource,
2985
(ndr_pull_flags_fn_t) ndr_pull_eventlog_DeregisterEventSource,
2986
(ndr_print_function_t) ndr_print_eventlog_DeregisterEventSource,
2987
{ 0, NULL },
2988
{ 0, NULL },
2989
},
2990
{
2991
"eventlog_GetNumRecords",
2992
sizeof(struct eventlog_GetNumRecords),
2993
(ndr_push_flags_fn_t) ndr_push_eventlog_GetNumRecords,
2994
(ndr_pull_flags_fn_t) ndr_pull_eventlog_GetNumRecords,
2995
(ndr_print_function_t) ndr_print_eventlog_GetNumRecords,
2996
{ 0, NULL },
2997
{ 0, NULL },
2998
},
2999
{
3000
"eventlog_GetOldestRecord",
3001
sizeof(struct eventlog_GetOldestRecord),
3002
(ndr_push_flags_fn_t) ndr_push_eventlog_GetOldestRecord,
3003
(ndr_pull_flags_fn_t) ndr_pull_eventlog_GetOldestRecord,
3004
(ndr_print_function_t) ndr_print_eventlog_GetOldestRecord,
3005
{ 0, NULL },
3006
{ 0, NULL },
3007
},
3008
{
3009
"eventlog_ChangeNotify",
3010
sizeof(struct eventlog_ChangeNotify),
3011
(ndr_push_flags_fn_t) ndr_push_eventlog_ChangeNotify,
3012
(ndr_pull_flags_fn_t) ndr_pull_eventlog_ChangeNotify,
3013
(ndr_print_function_t) ndr_print_eventlog_ChangeNotify,
3014
{ 0, NULL },
3015
{ 0, NULL },
3016
},
3017
{
3018
"eventlog_OpenEventLogW",
3019
sizeof(struct eventlog_OpenEventLogW),
3020
(ndr_push_flags_fn_t) ndr_push_eventlog_OpenEventLogW,
3021
(ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenEventLogW,
3022
(ndr_print_function_t) ndr_print_eventlog_OpenEventLogW,
3023
{ 0, NULL },
3024
{ 0, NULL },
3025
},
3026
{
3027
"eventlog_RegisterEventSourceW",
3028
sizeof(struct eventlog_RegisterEventSourceW),
3029
(ndr_push_flags_fn_t) ndr_push_eventlog_RegisterEventSourceW,
3030
(ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterEventSourceW,
3031
(ndr_print_function_t) ndr_print_eventlog_RegisterEventSourceW,
3032
{ 0, NULL },
3033
{ 0, NULL },
3034
},
3035
{
3036
"eventlog_OpenBackupEventLogW",
3037
sizeof(struct eventlog_OpenBackupEventLogW),
3038
(ndr_push_flags_fn_t) ndr_push_eventlog_OpenBackupEventLogW,
3039
(ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenBackupEventLogW,
3040
(ndr_print_function_t) ndr_print_eventlog_OpenBackupEventLogW,
3041
{ 0, NULL },
3042
{ 0, NULL },
3043
},
3044
{
3045
"eventlog_ReadEventLogW",
3046
sizeof(struct eventlog_ReadEventLogW),
3047
(ndr_push_flags_fn_t) ndr_push_eventlog_ReadEventLogW,
3048
(ndr_pull_flags_fn_t) ndr_pull_eventlog_ReadEventLogW,
3049
(ndr_print_function_t) ndr_print_eventlog_ReadEventLogW,
3050
{ 0, NULL },
3051
{ 0, NULL },
3052
},
3053
{
3054
"eventlog_ReportEventW",
3055
sizeof(struct eventlog_ReportEventW),
3056
(ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventW,
3057
(ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventW,
3058
(ndr_print_function_t) ndr_print_eventlog_ReportEventW,
3059
{ 0, NULL },
3060
{ 0, NULL },
3061
},
3062
{
3063
"eventlog_ClearEventLogA",
3064
sizeof(struct eventlog_ClearEventLogA),
3065
(ndr_push_flags_fn_t) ndr_push_eventlog_ClearEventLogA,
3066
(ndr_pull_flags_fn_t) ndr_pull_eventlog_ClearEventLogA,
3067
(ndr_print_function_t) ndr_print_eventlog_ClearEventLogA,
3068
{ 0, NULL },
3069
{ 0, NULL },
3070
},
3071
{
3072
"eventlog_BackupEventLogA",
3073
sizeof(struct eventlog_BackupEventLogA),
3074
(ndr_push_flags_fn_t) ndr_push_eventlog_BackupEventLogA,
3075
(ndr_pull_flags_fn_t) ndr_pull_eventlog_BackupEventLogA,
3076
(ndr_print_function_t) ndr_print_eventlog_BackupEventLogA,
3077
{ 0, NULL },
3078
{ 0, NULL },
3079
},
3080
{
3081
"eventlog_OpenEventLogA",
3082
sizeof(struct eventlog_OpenEventLogA),
3083
(ndr_push_flags_fn_t) ndr_push_eventlog_OpenEventLogA,
3084
(ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenEventLogA,
3085
(ndr_print_function_t) ndr_print_eventlog_OpenEventLogA,
3086
{ 0, NULL },
3087
{ 0, NULL },
3088
},
3089
{
3090
"eventlog_RegisterEventSourceA",
3091
sizeof(struct eventlog_RegisterEventSourceA),
3092
(ndr_push_flags_fn_t) ndr_push_eventlog_RegisterEventSourceA,
3093
(ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterEventSourceA,
3094
(ndr_print_function_t) ndr_print_eventlog_RegisterEventSourceA,
3095
{ 0, NULL },
3096
{ 0, NULL },
3097
},
3098
{
3099
"eventlog_OpenBackupEventLogA",
3100
sizeof(struct eventlog_OpenBackupEventLogA),
3101
(ndr_push_flags_fn_t) ndr_push_eventlog_OpenBackupEventLogA,
3102
(ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenBackupEventLogA,
3103
(ndr_print_function_t) ndr_print_eventlog_OpenBackupEventLogA,
3104
{ 0, NULL },
3105
{ 0, NULL },
3106
},
3107
{
3108
"eventlog_ReadEventLogA",
3109
sizeof(struct eventlog_ReadEventLogA),
3110
(ndr_push_flags_fn_t) ndr_push_eventlog_ReadEventLogA,
3111
(ndr_pull_flags_fn_t) ndr_pull_eventlog_ReadEventLogA,
3112
(ndr_print_function_t) ndr_print_eventlog_ReadEventLogA,
3113
{ 0, NULL },
3114
{ 0, NULL },
3115
},
3116
{
3117
"eventlog_ReportEventA",
3118
sizeof(struct eventlog_ReportEventA),
3119
(ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventA,
3120
(ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventA,
3121
(ndr_print_function_t) ndr_print_eventlog_ReportEventA,
3122
{ 0, NULL },
3123
{ 0, NULL },
3124
},
3125
{
3126
"eventlog_RegisterClusterSvc",
3127
sizeof(struct eventlog_RegisterClusterSvc),
3128
(ndr_push_flags_fn_t) ndr_push_eventlog_RegisterClusterSvc,
3129
(ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterClusterSvc,
3130
(ndr_print_function_t) ndr_print_eventlog_RegisterClusterSvc,
3131
{ 0, NULL },
3132
{ 0, NULL },
3133
},
3134
{
3135
"eventlog_DeregisterClusterSvc",
3136
sizeof(struct eventlog_DeregisterClusterSvc),
3137
(ndr_push_flags_fn_t) ndr_push_eventlog_DeregisterClusterSvc,
3138
(ndr_pull_flags_fn_t) ndr_pull_eventlog_DeregisterClusterSvc,
3139
(ndr_print_function_t) ndr_print_eventlog_DeregisterClusterSvc,
3140
{ 0, NULL },
3141
{ 0, NULL },
3142
},
3143
{
3144
"eventlog_WriteClusterEvents",
3145
sizeof(struct eventlog_WriteClusterEvents),
3146
(ndr_push_flags_fn_t) ndr_push_eventlog_WriteClusterEvents,
3147
(ndr_pull_flags_fn_t) ndr_pull_eventlog_WriteClusterEvents,
3148
(ndr_print_function_t) ndr_print_eventlog_WriteClusterEvents,
3149
{ 0, NULL },
3150
{ 0, NULL },
3151
},
3152
{
3153
"eventlog_GetLogInformation",
3154
sizeof(struct eventlog_GetLogInformation),
3155
(ndr_push_flags_fn_t) ndr_push_eventlog_GetLogInformation,
3156
(ndr_pull_flags_fn_t) ndr_pull_eventlog_GetLogInformation,
3157
(ndr_print_function_t) ndr_print_eventlog_GetLogInformation,
3158
{ 0, NULL },
3159
{ 0, NULL },
3160
},
3161
{
3162
"eventlog_FlushEventLog",
3163
sizeof(struct eventlog_FlushEventLog),
3164
(ndr_push_flags_fn_t) ndr_push_eventlog_FlushEventLog,
3165
(ndr_pull_flags_fn_t) ndr_pull_eventlog_FlushEventLog,
3166
(ndr_print_function_t) ndr_print_eventlog_FlushEventLog,
3167
{ 0, NULL },
3168
{ 0, NULL },
3169
},
3170
{
3171
"eventlog_ReportEventAndSourceW",
3172
sizeof(struct eventlog_ReportEventAndSourceW),
3173
(ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventAndSourceW,
3174
(ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventAndSourceW,
3175
(ndr_print_function_t) ndr_print_eventlog_ReportEventAndSourceW,
3176
{ 0, NULL },
3177
{ 0, NULL },
3178
},
3179
{ NULL, 0, NULL, NULL, NULL }
3180
};
3181
3182
static const char * const eventlog_endpoint_strings[] = {
3183
"ncacn_np:[\\pipe\\eventlog]",
3184
};
3185
3186
static const struct ndr_interface_string_array eventlog_endpoints = {
3187
.count = 1,
3188
.names = eventlog_endpoint_strings
3189
};
3190
3191
static const char * const eventlog_authservice_strings[] = {
3192
"host",
3193
};
3194
3195
static const struct ndr_interface_string_array eventlog_authservices = {
3196
.count = 1,
3197
.names = eventlog_authservice_strings
3198
};
3199
3200
3201
const struct ndr_interface_table ndr_table_eventlog = {
3202
.name = "eventlog",
3203
.syntax_id = {
3204
{0x82273fdc,0xe32a,0x18c3,{0x3f,0x78},{0x82,0x79,0x29,0xdc,0x23,0xea}},
3205
NDR_EVENTLOG_VERSION
3206
},
3207
.helpstring = NDR_EVENTLOG_HELPSTRING,
3208
.num_calls = 25,
3209
.calls = eventlog_calls,
3210
.endpoints = &eventlog_endpoints,
3211
.authservices = &eventlog_authservices
3212
};
3213
Loggerhead is a web-based interface for Breezy
Version: 2.0.1