← Back to branch summary

~lefteris-nikoltsios/+junk/samba-lp1016895

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/ndr_spoolss.c

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
librpc/gen_ndr/ndr_spoolss.c
1
 
/* parser auto-generated by pidl */
2
 
 
3
 
#include "includes.h"
4
 
#include "../librpc/gen_ndr/ndr_spoolss.h"
5
 
 
6
 
#include "librpc/gen_ndr/ndr_misc.h"
7
 
#include "librpc/gen_ndr/ndr_security.h"
8
 
#include "librpc/gen_ndr/ndr_winreg.h"
9
 
static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
10
 
{
11
 
        if (ndr_flags & NDR_SCALARS) {
12
 
                NDR_CHECK(ndr_push_align(ndr, 2));
13
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
14
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
15
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
16
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
17
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
18
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
19
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
20
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
21
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 2));
22
 
        }
23
 
        if (ndr_flags & NDR_BUFFERS) {
24
 
        }
25
 
        return NDR_ERR_SUCCESS;
26
 
}
27
 
 
28
 
static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
29
 
{
30
 
        if (ndr_flags & NDR_SCALARS) {
31
 
                NDR_CHECK(ndr_pull_align(ndr, 2));
32
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
33
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
34
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
35
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
36
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
37
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
38
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
39
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
40
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
41
 
        }
42
 
        if (ndr_flags & NDR_BUFFERS) {
43
 
        }
44
 
        return NDR_ERR_SUCCESS;
45
 
}
46
 
 
47
 
static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
48
 
{
49
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
50
 
}
51
 
 
52
 
static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
53
 
{
54
 
        if (ndr_flags & NDR_SCALARS) {
55
 
                NDR_CHECK(ndr_push_align(ndr, 5));
56
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
57
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
58
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
59
 
        }
60
 
        if (ndr_flags & NDR_BUFFERS) {
61
 
                if (r->time) {
62
 
                        NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
63
 
                }
64
 
        }
65
 
        return NDR_ERR_SUCCESS;
66
 
}
67
 
 
68
 
static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
69
 
{
70
 
        uint32_t _ptr_time;
71
 
        TALLOC_CTX *_mem_save_time_0;
72
 
        if (ndr_flags & NDR_SCALARS) {
73
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
74
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
75
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
76
 
                if (_ptr_time) {
77
 
                        NDR_PULL_ALLOC(ndr, r->time);
78
 
                } else {
79
 
                        r->time = NULL;
80
 
                }
81
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
82
 
        }
83
 
        if (ndr_flags & NDR_BUFFERS) {
84
 
                if (r->time) {
85
 
                        _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
86
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
87
 
                        NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
88
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
89
 
                }
90
 
        }
91
 
        return NDR_ERR_SUCCESS;
92
 
}
93
 
 
94
 
_PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
95
 
{
96
 
        ndr_print_struct(ndr, name, "spoolss_TimeCtr");
97
 
        ndr->depth++;
98
 
        ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
99
 
        ndr_print_ptr(ndr, "time", r->time);
100
 
        ndr->depth++;
101
 
        if (r->time) {
102
 
                ndr_print_spoolss_Time(ndr, "time", r->time);
103
 
        }
104
 
        ndr->depth--;
105
 
        ndr->depth--;
106
 
}
107
 
 
108
 
static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
109
 
{
110
 
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
111
 
        return NDR_ERR_SUCCESS;
112
 
}
113
 
 
114
 
static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
115
 
{
116
 
        uint16_t v;
117
 
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
118
 
        *r = v;
119
 
        return NDR_ERR_SUCCESS;
120
 
}
121
 
 
122
 
_PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
123
 
{
124
 
        const char *val = NULL;
125
 
 
126
 
        switch (r) {
127
 
                case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
128
 
                case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
129
 
                case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
130
 
        }
131
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
132
 
}
133
 
 
134
 
static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
135
 
{
136
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
137
 
        return NDR_ERR_SUCCESS;
138
 
}
139
 
 
140
 
static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
141
 
{
142
 
        uint32_t v;
143
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
144
 
        *r = v;
145
 
        return NDR_ERR_SUCCESS;
146
 
}
147
 
 
148
 
_PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
149
 
{
150
 
        const char *val = NULL;
151
 
 
152
 
        switch (r) {
153
 
                case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
154
 
                case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
155
 
                case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
156
 
                case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
157
 
                case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
158
 
        }
159
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
160
 
}
161
 
 
162
 
static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
163
 
{
164
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
165
 
        return NDR_ERR_SUCCESS;
166
 
}
167
 
 
168
 
static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
169
 
{
170
 
        uint32_t v;
171
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
172
 
        *r = v;
173
 
        return NDR_ERR_SUCCESS;
174
 
}
175
 
 
176
 
_PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
177
 
{
178
 
        const char *val = NULL;
179
 
 
180
 
        switch (r) {
181
 
                case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
182
 
                case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
183
 
                case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
184
 
        }
185
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
186
 
}
187
 
 
188
 
static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
189
 
{
190
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
191
 
        return NDR_ERR_SUCCESS;
192
 
}
193
 
 
194
 
static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
195
 
{
196
 
        uint32_t v;
197
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
198
 
        *r = v;
199
 
        return NDR_ERR_SUCCESS;
200
 
}
201
 
 
202
 
_PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
203
 
{
204
 
        const char *val = NULL;
205
 
 
206
 
        switch (r) {
207
 
                case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
208
 
                case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
209
 
                case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
210
 
                case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
211
 
                case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
212
 
        }
213
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
214
 
}
215
 
 
216
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
217
 
{
218
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
219
 
        return NDR_ERR_SUCCESS;
220
 
}
221
 
 
222
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
223
 
{
224
 
        uint32_t v;
225
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
226
 
        *r = v;
227
 
        return NDR_ERR_SUCCESS;
228
 
}
229
 
 
230
 
_PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
231
 
{
232
 
        ndr_print_uint32(ndr, name, r);
233
 
        ndr->depth++;
234
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
235
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
236
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
237
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
238
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
239
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
240
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
241
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
242
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
243
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
244
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
245
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
246
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
247
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
248
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
249
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
250
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
251
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
252
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
253
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
254
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
255
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
256
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
257
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
258
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
259
 
        ndr->depth--;
260
 
}
261
 
 
262
 
static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
263
 
{
264
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
265
 
        return NDR_ERR_SUCCESS;
266
 
}
267
 
 
268
 
static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
269
 
{
270
 
        uint32_t v;
271
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
272
 
        *r = v;
273
 
        return NDR_ERR_SUCCESS;
274
 
}
275
 
 
276
 
_PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
277
 
{
278
 
        ndr_print_uint32(ndr, name, r);
279
 
        ndr->depth++;
280
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
281
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
282
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
283
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
284
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
285
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
286
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
287
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
288
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
289
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
290
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
291
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
292
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
293
 
        ndr->depth--;
294
 
}
295
 
 
296
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
297
 
{
298
 
        if (ndr_flags & NDR_SCALARS) {
299
 
                NDR_CHECK(ndr_push_align(ndr, 5));
300
 
                {
301
 
                        uint32_t _flags_save_string = ndr->flags;
302
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
303
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
304
 
                        ndr->flags = _flags_save_string;
305
 
                }
306
 
                {
307
 
                        uint32_t _flags_save_string = ndr->flags;
308
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
309
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
310
 
                        ndr->flags = _flags_save_string;
311
 
                }
312
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
313
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
314
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
315
 
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
316
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
317
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
318
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
319
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
320
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
321
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
322
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
323
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
324
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
325
 
                NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
326
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
327
 
                NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
328
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
329
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
330
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
331
 
                NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
332
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
333
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
334
 
                NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
335
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
336
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
337
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
338
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
339
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
340
 
        }
341
 
        if (ndr_flags & NDR_BUFFERS) {
342
 
                {
343
 
                        uint32_t _flags_save_string = ndr->flags;
344
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
345
 
                        if (r->printername) {
346
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
347
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
348
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
349
 
                        }
350
 
                        ndr->flags = _flags_save_string;
351
 
                }
352
 
                {
353
 
                        uint32_t _flags_save_string = ndr->flags;
354
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
355
 
                        if (r->servername) {
356
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
357
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
358
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
359
 
                        }
360
 
                        ndr->flags = _flags_save_string;
361
 
                }
362
 
        }
363
 
        return NDR_ERR_SUCCESS;
364
 
}
365
 
 
366
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
367
 
{
368
 
        uint32_t _ptr_printername;
369
 
        TALLOC_CTX *_mem_save_printername_0;
370
 
        uint32_t _ptr_servername;
371
 
        TALLOC_CTX *_mem_save_servername_0;
372
 
        if (ndr_flags & NDR_SCALARS) {
373
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
374
 
                {
375
 
                        uint32_t _flags_save_string = ndr->flags;
376
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
377
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
378
 
                        if (_ptr_printername) {
379
 
                                NDR_PULL_ALLOC(ndr, r->printername);
380
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
381
 
                        } else {
382
 
                                r->printername = NULL;
383
 
                        }
384
 
                        ndr->flags = _flags_save_string;
385
 
                }
386
 
                {
387
 
                        uint32_t _flags_save_string = ndr->flags;
388
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
389
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
390
 
                        if (_ptr_servername) {
391
 
                                NDR_PULL_ALLOC(ndr, r->servername);
392
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
393
 
                        } else {
394
 
                                r->servername = NULL;
395
 
                        }
396
 
                        ndr->flags = _flags_save_string;
397
 
                }
398
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
399
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
400
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
401
 
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
402
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
403
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
404
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
405
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
406
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
407
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
408
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
409
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
410
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
411
 
                NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
412
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
413
 
                NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
414
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
415
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
416
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
417
 
                NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
418
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
419
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
420
 
                NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
421
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
422
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
423
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
424
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
425
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
426
 
        }
427
 
        if (ndr_flags & NDR_BUFFERS) {
428
 
                {
429
 
                        uint32_t _flags_save_string = ndr->flags;
430
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
431
 
                        if (r->printername) {
432
 
                                uint32_t _relative_save_offset;
433
 
                                _relative_save_offset = ndr->offset;
434
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
435
 
                                _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
436
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
437
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
438
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
439
 
                                ndr->offset = _relative_save_offset;
440
 
                        }
441
 
                        ndr->flags = _flags_save_string;
442
 
                }
443
 
                {
444
 
                        uint32_t _flags_save_string = ndr->flags;
445
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
446
 
                        if (r->servername) {
447
 
                                uint32_t _relative_save_offset;
448
 
                                _relative_save_offset = ndr->offset;
449
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
450
 
                                _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
451
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
452
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
453
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
454
 
                                ndr->offset = _relative_save_offset;
455
 
                        }
456
 
                        ndr->flags = _flags_save_string;
457
 
                }
458
 
        }
459
 
        return NDR_ERR_SUCCESS;
460
 
}
461
 
 
462
 
_PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
463
 
{
464
 
        ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
465
 
        ndr->depth++;
466
 
        ndr_print_ptr(ndr, "printername", r->printername);
467
 
        ndr->depth++;
468
 
        if (r->printername) {
469
 
                ndr_print_string(ndr, "printername", r->printername);
470
 
        }
471
 
        ndr->depth--;
472
 
        ndr_print_ptr(ndr, "servername", r->servername);
473
 
        ndr->depth++;
474
 
        if (r->servername) {
475
 
                ndr_print_string(ndr, "servername", r->servername);
476
 
        }
477
 
        ndr->depth--;
478
 
        ndr_print_uint32(ndr, "cjobs", r->cjobs);
479
 
        ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
480
 
        ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
481
 
        ndr_print_spoolss_Time(ndr, "time", &r->time);
482
 
        ndr_print_uint32(ndr, "global_counter", r->global_counter);
483
 
        ndr_print_uint32(ndr, "total_pages", r->total_pages);
484
 
        ndr_print_uint32(ndr, "version", r->version);
485
 
        ndr_print_uint32(ndr, "free_build", r->free_build);
486
 
        ndr_print_uint32(ndr, "spooling", r->spooling);
487
 
        ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
488
 
        ndr_print_uint32(ndr, "session_counter", r->session_counter);
489
 
        ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
490
 
        ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
491
 
        ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
492
 
        ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
493
 
        ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
494
 
        ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
495
 
        ndr_print_uint32(ndr, "change_id", r->change_id);
496
 
        ndr_print_WERROR(ndr, "last_error", r->last_error);
497
 
        ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
498
 
        ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
499
 
        ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
500
 
        ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
501
 
        ndr_print_uint16(ndr, "processor_level", r->processor_level);
502
 
        ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
503
 
        ndr_print_uint32(ndr, "reserved2", r->reserved2);
504
 
        ndr_print_uint32(ndr, "reserved3", r->reserved3);
505
 
        ndr->depth--;
506
 
}
507
 
 
508
 
_PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
509
 
{
510
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
511
 
}
512
 
 
513
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
514
 
{
515
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
516
 
        return NDR_ERR_SUCCESS;
517
 
}
518
 
 
519
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
520
 
{
521
 
        uint32_t v;
522
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
523
 
        *r = v;
524
 
        return NDR_ERR_SUCCESS;
525
 
}
526
 
 
527
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
528
 
{
529
 
        ndr_print_uint32(ndr, name, r);
530
 
        ndr->depth++;
531
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
532
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
533
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
534
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
535
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
536
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
537
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
538
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
539
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
540
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
541
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
542
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
543
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
544
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
545
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
546
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
547
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
548
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
549
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
550
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
551
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
552
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
553
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
554
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
555
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
556
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
557
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
558
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
559
 
        ndr->depth--;
560
 
}
561
 
 
562
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
563
 
{
564
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
565
 
        return NDR_ERR_SUCCESS;
566
 
}
567
 
 
568
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
569
 
{
570
 
        uint16_t v;
571
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
572
 
        *r = v;
573
 
        return NDR_ERR_SUCCESS;
574
 
}
575
 
 
576
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
577
 
{
578
 
        const char *val = NULL;
579
 
 
580
 
        switch (r) {
581
 
                case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
582
 
                case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
583
 
                case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
584
 
        }
585
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
586
 
}
587
 
 
588
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
589
 
{
590
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
591
 
        return NDR_ERR_SUCCESS;
592
 
}
593
 
 
594
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
595
 
{
596
 
        uint16_t v;
597
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
598
 
        *r = v;
599
 
        return NDR_ERR_SUCCESS;
600
 
}
601
 
 
602
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
603
 
{
604
 
        const char *val = NULL;
605
 
 
606
 
        switch (r) {
607
 
                case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
608
 
                case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
609
 
        }
610
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
611
 
}
612
 
 
613
 
static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
614
 
{
615
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
616
 
        return NDR_ERR_SUCCESS;
617
 
}
618
 
 
619
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
620
 
{
621
 
        uint16_t v;
622
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
623
 
        *r = v;
624
 
        return NDR_ERR_SUCCESS;
625
 
}
626
 
 
627
 
_PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
628
 
{
629
 
        const char *val = NULL;
630
 
 
631
 
        switch (r) {
632
 
                case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
633
 
                case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
634
 
                case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
635
 
                case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
636
 
                case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
637
 
                case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
638
 
                case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
639
 
                case DMPAPER_A3: val = "DMPAPER_A3"; break;
640
 
                case DMPAPER_A4: val = "DMPAPER_A4"; break;
641
 
                case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
642
 
                case DMPAPER_A5: val = "DMPAPER_A5"; break;
643
 
                case DMPAPER_B4: val = "DMPAPER_B4"; break;
644
 
                case DMPAPER_B5: val = "DMPAPER_B5"; break;
645
 
                case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
646
 
                case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
647
 
                case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
648
 
                case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
649
 
                case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
650
 
                case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
651
 
                case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
652
 
                case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
653
 
                case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
654
 
                case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
655
 
                case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
656
 
                case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
657
 
                case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
658
 
                case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
659
 
                case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
660
 
                case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
661
 
                case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
662
 
                case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
663
 
                case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
664
 
                case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
665
 
                case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
666
 
                case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
667
 
                case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
668
 
                case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
669
 
                case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
670
 
                case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
671
 
                case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
672
 
                case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
673
 
                case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
674
 
                case DMPAPER_A6: val = "DMPAPER_A6"; break;
675
 
                case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
676
 
                case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
677
 
                case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
678
 
                case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
679
 
                case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
680
 
                case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
681
 
                case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
682
 
                case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
683
 
                case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
684
 
                case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
685
 
                case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
686
 
                case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
687
 
                case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
688
 
                case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
689
 
                case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
690
 
                case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
691
 
                case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
692
 
                case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
693
 
                case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
694
 
                case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
695
 
                case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
696
 
                case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
697
 
                case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
698
 
                case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
699
 
                case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
700
 
                case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
701
 
                case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
702
 
                case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
703
 
                case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
704
 
                case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
705
 
                case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
706
 
                case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
707
 
                case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
708
 
                case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
709
 
                case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
710
 
                case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
711
 
                case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
712
 
                case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
713
 
                case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
714
 
                case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
715
 
                case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
716
 
                case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
717
 
                case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
718
 
                case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
719
 
                case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
720
 
                case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
721
 
                case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
722
 
                case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
723
 
        }
724
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
725
 
}
726
 
 
727
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
728
 
{
729
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
730
 
        return NDR_ERR_SUCCESS;
731
 
}
732
 
 
733
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
734
 
{
735
 
        uint16_t v;
736
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
737
 
        *r = v;
738
 
        return NDR_ERR_SUCCESS;
739
 
}
740
 
 
741
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
742
 
{
743
 
        const char *val = NULL;
744
 
 
745
 
        switch (r) {
746
 
                case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
747
 
                case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
748
 
                case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
749
 
                case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
750
 
                case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
751
 
                case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
752
 
                case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
753
 
                case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
754
 
                case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
755
 
                case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
756
 
                case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
757
 
                case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
758
 
                case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
759
 
        }
760
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
761
 
}
762
 
 
763
 
static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
764
 
{
765
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
766
 
        return NDR_ERR_SUCCESS;
767
 
}
768
 
 
769
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
770
 
{
771
 
        uint16_t v;
772
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
773
 
        *r = v;
774
 
        return NDR_ERR_SUCCESS;
775
 
}
776
 
 
777
 
_PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
778
 
{
779
 
        const char *val = NULL;
780
 
 
781
 
        switch (r) {
782
 
                case DMRES_HIGH: val = "DMRES_HIGH"; break;
783
 
                case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
784
 
                case DMRES_LOW: val = "DMRES_LOW"; break;
785
 
                case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
786
 
        }
787
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
788
 
}
789
 
 
790
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
791
 
{
792
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
793
 
        return NDR_ERR_SUCCESS;
794
 
}
795
 
 
796
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
797
 
{
798
 
        uint16_t v;
799
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
800
 
        *r = v;
801
 
        return NDR_ERR_SUCCESS;
802
 
}
803
 
 
804
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
805
 
{
806
 
        const char *val = NULL;
807
 
 
808
 
        switch (r) {
809
 
                case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
810
 
                case DMRES_COLOR: val = "DMRES_COLOR"; break;
811
 
        }
812
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
813
 
}
814
 
 
815
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
816
 
{
817
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
818
 
        return NDR_ERR_SUCCESS;
819
 
}
820
 
 
821
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
822
 
{
823
 
        uint16_t v;
824
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
825
 
        *r = v;
826
 
        return NDR_ERR_SUCCESS;
827
 
}
828
 
 
829
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
830
 
{
831
 
        const char *val = NULL;
832
 
 
833
 
        switch (r) {
834
 
                case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
835
 
                case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
836
 
                case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
837
 
        }
838
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
839
 
}
840
 
 
841
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
842
 
{
843
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
844
 
        return NDR_ERR_SUCCESS;
845
 
}
846
 
 
847
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
848
 
{
849
 
        uint16_t v;
850
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
851
 
        *r = v;
852
 
        return NDR_ERR_SUCCESS;
853
 
}
854
 
 
855
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
856
 
{
857
 
        const char *val = NULL;
858
 
 
859
 
        switch (r) {
860
 
                case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
861
 
                case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
862
 
                case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
863
 
                case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
864
 
        }
865
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
866
 
}
867
 
 
868
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
869
 
{
870
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
871
 
        return NDR_ERR_SUCCESS;
872
 
}
873
 
 
874
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
875
 
{
876
 
        uint16_t v;
877
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
878
 
        *r = v;
879
 
        return NDR_ERR_SUCCESS;
880
 
}
881
 
 
882
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
883
 
{
884
 
        const char *val = NULL;
885
 
 
886
 
        switch (r) {
887
 
                case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
888
 
                case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
889
 
        }
890
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
891
 
}
892
 
 
893
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
894
 
{
895
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
896
 
        return NDR_ERR_SUCCESS;
897
 
}
898
 
 
899
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
900
 
{
901
 
        uint32_t v;
902
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
903
 
        *r = v;
904
 
        return NDR_ERR_SUCCESS;
905
 
}
906
 
 
907
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
908
 
{
909
 
        const char *val = NULL;
910
 
 
911
 
        switch (r) {
912
 
                case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
913
 
                case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
914
 
        }
915
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
916
 
}
917
 
 
918
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
919
 
{
920
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
921
 
        return NDR_ERR_SUCCESS;
922
 
}
923
 
 
924
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
925
 
{
926
 
        uint32_t v;
927
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
928
 
        *r = v;
929
 
        return NDR_ERR_SUCCESS;
930
 
}
931
 
 
932
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
933
 
{
934
 
        const char *val = NULL;
935
 
 
936
 
        switch (r) {
937
 
                case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
938
 
                case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
939
 
                case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
940
 
                case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
941
 
        }
942
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
943
 
}
944
 
 
945
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
946
 
{
947
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
948
 
        return NDR_ERR_SUCCESS;
949
 
}
950
 
 
951
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
952
 
{
953
 
        uint32_t v;
954
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
955
 
        *r = v;
956
 
        return NDR_ERR_SUCCESS;
957
 
}
958
 
 
959
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
960
 
{
961
 
        const char *val = NULL;
962
 
 
963
 
        switch (r) {
964
 
                case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
965
 
                case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
966
 
                case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
967
 
                case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
968
 
        }
969
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
970
 
}
971
 
 
972
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
973
 
{
974
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
975
 
        return NDR_ERR_SUCCESS;
976
 
}
977
 
 
978
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
979
 
{
980
 
        uint32_t v;
981
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
982
 
        *r = v;
983
 
        return NDR_ERR_SUCCESS;
984
 
}
985
 
 
986
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
987
 
{
988
 
        const char *val = NULL;
989
 
 
990
 
        switch (r) {
991
 
                case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
992
 
                case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
993
 
                case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
994
 
        }
995
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
996
 
}
997
 
 
998
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
999
 
{
1000
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1001
 
        return NDR_ERR_SUCCESS;
1002
 
}
1003
 
 
1004
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1005
 
{
1006
 
        uint32_t v;
1007
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1008
 
        *r = v;
1009
 
        return NDR_ERR_SUCCESS;
1010
 
}
1011
 
 
1012
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1013
 
{
1014
 
        const char *val = NULL;
1015
 
 
1016
 
        switch (r) {
1017
 
                case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1018
 
                case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1019
 
                case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1020
 
                case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1021
 
                case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1022
 
                case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1023
 
                case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1024
 
                case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1025
 
                case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1026
 
                case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1027
 
        }
1028
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
1029
 
}
1030
 
 
1031
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1032
 
{
1033
 
        if (ndr_flags & NDR_SCALARS) {
1034
 
                NDR_CHECK(ndr_push_align(ndr, 4));
1035
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1036
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1037
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1038
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1039
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1040
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1041
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1042
 
                NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1043
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1044
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1045
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1046
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1047
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1048
 
                NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1049
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1050
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1051
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1052
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1053
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1054
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1055
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1056
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1057
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1058
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1059
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1060
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1061
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1062
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1063
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1064
 
                NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1065
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1066
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1067
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1068
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1069
 
                {
1070
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
1071
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1072
 
                        {
1073
 
                                struct ndr_push *_ndr_driverextra_data;
1074
 
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1075
 
                                NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1076
 
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1077
 
                        }
1078
 
                        ndr->flags = _flags_save_DATA_BLOB;
1079
 
                }
1080
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1081
 
        }
1082
 
        if (ndr_flags & NDR_BUFFERS) {
1083
 
        }
1084
 
        return NDR_ERR_SUCCESS;
1085
 
}
1086
 
 
1087
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1088
 
{
1089
 
        if (ndr_flags & NDR_SCALARS) {
1090
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
1091
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1092
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1093
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1094
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1095
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1096
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1097
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1098
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1099
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1100
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1101
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1102
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1103
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1104
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1105
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1106
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1107
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1108
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1109
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1110
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1111
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1112
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1113
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1114
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1115
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1116
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1117
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1118
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1119
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1120
 
                NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1121
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1122
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1123
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1124
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1125
 
                {
1126
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
1127
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1128
 
                        {
1129
 
                                struct ndr_pull *_ndr_driverextra_data;
1130
 
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1131
 
                                NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1132
 
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1133
 
                        }
1134
 
                        ndr->flags = _flags_save_DATA_BLOB;
1135
 
                }
1136
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1137
 
        }
1138
 
        if (ndr_flags & NDR_BUFFERS) {
1139
 
        }
1140
 
        return NDR_ERR_SUCCESS;
1141
 
}
1142
 
 
1143
 
_PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1144
 
{
1145
 
        ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1146
 
        ndr->depth++;
1147
 
        ndr_print_string(ndr, "devicename", r->devicename);
1148
 
        ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1149
 
        ndr_print_uint16(ndr, "driverversion", r->driverversion);
1150
 
        ndr_print_uint16(ndr, "size", r->size);
1151
 
        ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1152
 
        ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1153
 
        ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1154
 
        ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1155
 
        ndr_print_uint16(ndr, "paperlength", r->paperlength);
1156
 
        ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1157
 
        ndr_print_uint16(ndr, "scale", r->scale);
1158
 
        ndr_print_uint16(ndr, "copies", r->copies);
1159
 
        ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1160
 
        ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1161
 
        ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1162
 
        ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1163
 
        ndr_print_uint16(ndr, "yresolution", r->yresolution);
1164
 
        ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1165
 
        ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1166
 
        ndr_print_string(ndr, "formname", r->formname);
1167
 
        ndr_print_uint16(ndr, "logpixels", r->logpixels);
1168
 
        ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1169
 
        ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1170
 
        ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1171
 
        ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1172
 
        ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1173
 
        ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1174
 
        ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1175
 
        ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1176
 
        ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1177
 
        ndr_print_uint32(ndr, "reserved1", r->reserved1);
1178
 
        ndr_print_uint32(ndr, "reserved2", r->reserved2);
1179
 
        ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1180
 
        ndr_print_uint32(ndr, "panningheight", r->panningheight);
1181
 
        ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1182
 
        ndr->depth--;
1183
 
}
1184
 
 
1185
 
_PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1186
 
{
1187
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1188
 
}
1189
 
 
1190
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1191
 
{
1192
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1193
 
        return NDR_ERR_SUCCESS;
1194
 
}
1195
 
 
1196
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1197
 
{
1198
 
        uint32_t v;
1199
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1200
 
        *r = v;
1201
 
        return NDR_ERR_SUCCESS;
1202
 
}
1203
 
 
1204
 
_PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1205
 
{
1206
 
        ndr_print_uint32(ndr, name, r);
1207
 
        ndr->depth++;
1208
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1209
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1210
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1211
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1212
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1213
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1214
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1215
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1216
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1217
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1218
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1219
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1220
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1221
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1222
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1223
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1224
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1225
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1226
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1227
 
        ndr->depth--;
1228
 
}
1229
 
 
1230
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1231
 
{
1232
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1233
 
        return NDR_ERR_SUCCESS;
1234
 
}
1235
 
 
1236
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1237
 
{
1238
 
        uint32_t v;
1239
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1240
 
        *r = v;
1241
 
        return NDR_ERR_SUCCESS;
1242
 
}
1243
 
 
1244
 
_PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1245
 
{
1246
 
        ndr_print_uint32(ndr, name, r);
1247
 
        ndr->depth++;
1248
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1249
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1250
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1251
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1252
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1253
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1254
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1255
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1256
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1257
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1258
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1259
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1260
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1261
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1262
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1263
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1264
 
        ndr->depth--;
1265
 
}
1266
 
 
1267
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1268
 
{
1269
 
        if (ndr_flags & NDR_SCALARS) {
1270
 
                NDR_CHECK(ndr_push_align(ndr, 5));
1271
 
                NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1272
 
                {
1273
 
                        uint32_t _flags_save_string = ndr->flags;
1274
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1275
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1276
 
                        ndr->flags = _flags_save_string;
1277
 
                }
1278
 
                {
1279
 
                        uint32_t _flags_save_string = ndr->flags;
1280
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1281
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
1282
 
                        ndr->flags = _flags_save_string;
1283
 
                }
1284
 
                {
1285
 
                        uint32_t _flags_save_string = ndr->flags;
1286
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1287
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1288
 
                        ndr->flags = _flags_save_string;
1289
 
                }
1290
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1291
 
        }
1292
 
        if (ndr_flags & NDR_BUFFERS) {
1293
 
                {
1294
 
                        uint32_t _flags_save_string = ndr->flags;
1295
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1296
 
                        if (r->description) {
1297
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
1298
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1299
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
1300
 
                        }
1301
 
                        ndr->flags = _flags_save_string;
1302
 
                }
1303
 
                {
1304
 
                        uint32_t _flags_save_string = ndr->flags;
1305
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1306
 
                        if (r->name) {
1307
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name));
1308
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1309
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name));
1310
 
                        }
1311
 
                        ndr->flags = _flags_save_string;
1312
 
                }
1313
 
                {
1314
 
                        uint32_t _flags_save_string = ndr->flags;
1315
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1316
 
                        if (r->comment) {
1317
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
1318
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1319
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
1320
 
                        }
1321
 
                        ndr->flags = _flags_save_string;
1322
 
                }
1323
 
        }
1324
 
        return NDR_ERR_SUCCESS;
1325
 
}
1326
 
 
1327
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1328
 
{
1329
 
        uint32_t _ptr_description;
1330
 
        TALLOC_CTX *_mem_save_description_0;
1331
 
        uint32_t _ptr_name;
1332
 
        TALLOC_CTX *_mem_save_name_0;
1333
 
        uint32_t _ptr_comment;
1334
 
        TALLOC_CTX *_mem_save_comment_0;
1335
 
        if (ndr_flags & NDR_SCALARS) {
1336
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
1337
 
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1338
 
                {
1339
 
                        uint32_t _flags_save_string = ndr->flags;
1340
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1341
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1342
 
                        if (_ptr_description) {
1343
 
                                NDR_PULL_ALLOC(ndr, r->description);
1344
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1345
 
                        } else {
1346
 
                                r->description = NULL;
1347
 
                        }
1348
 
                        ndr->flags = _flags_save_string;
1349
 
                }
1350
 
                {
1351
 
                        uint32_t _flags_save_string = ndr->flags;
1352
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1353
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1354
 
                        if (_ptr_name) {
1355
 
                                NDR_PULL_ALLOC(ndr, r->name);
1356
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1357
 
                        } else {
1358
 
                                r->name = NULL;
1359
 
                        }
1360
 
                        ndr->flags = _flags_save_string;
1361
 
                }
1362
 
                {
1363
 
                        uint32_t _flags_save_string = ndr->flags;
1364
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1365
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1366
 
                        if (_ptr_comment) {
1367
 
                                NDR_PULL_ALLOC(ndr, r->comment);
1368
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1369
 
                        } else {
1370
 
                                r->comment = NULL;
1371
 
                        }
1372
 
                        ndr->flags = _flags_save_string;
1373
 
                }
1374
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1375
 
        }
1376
 
        if (ndr_flags & NDR_BUFFERS) {
1377
 
                {
1378
 
                        uint32_t _flags_save_string = ndr->flags;
1379
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1380
 
                        if (r->description) {
1381
 
                                uint32_t _relative_save_offset;
1382
 
                                _relative_save_offset = ndr->offset;
1383
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1384
 
                                _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1385
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1386
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1387
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1388
 
                                ndr->offset = _relative_save_offset;
1389
 
                        }
1390
 
                        ndr->flags = _flags_save_string;
1391
 
                }
1392
 
                {
1393
 
                        uint32_t _flags_save_string = ndr->flags;
1394
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1395
 
                        if (r->name) {
1396
 
                                uint32_t _relative_save_offset;
1397
 
                                _relative_save_offset = ndr->offset;
1398
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1399
 
                                _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1400
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1401
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1402
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1403
 
                                ndr->offset = _relative_save_offset;
1404
 
                        }
1405
 
                        ndr->flags = _flags_save_string;
1406
 
                }
1407
 
                {
1408
 
                        uint32_t _flags_save_string = ndr->flags;
1409
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1410
 
                        if (r->comment) {
1411
 
                                uint32_t _relative_save_offset;
1412
 
                                _relative_save_offset = ndr->offset;
1413
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1414
 
                                _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1415
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1416
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1417
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1418
 
                                ndr->offset = _relative_save_offset;
1419
 
                        }
1420
 
                        ndr->flags = _flags_save_string;
1421
 
                }
1422
 
        }
1423
 
        return NDR_ERR_SUCCESS;
1424
 
}
1425
 
 
1426
 
_PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1427
 
{
1428
 
        ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1429
 
        ndr->depth++;
1430
 
        ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1431
 
        ndr_print_ptr(ndr, "description", r->description);
1432
 
        ndr->depth++;
1433
 
        if (r->description) {
1434
 
                ndr_print_string(ndr, "description", r->description);
1435
 
        }
1436
 
        ndr->depth--;
1437
 
        ndr_print_ptr(ndr, "name", r->name);
1438
 
        ndr->depth++;
1439
 
        if (r->name) {
1440
 
                ndr_print_string(ndr, "name", r->name);
1441
 
        }
1442
 
        ndr->depth--;
1443
 
        ndr_print_ptr(ndr, "comment", r->comment);
1444
 
        ndr->depth++;
1445
 
        if (r->comment) {
1446
 
                ndr_print_string(ndr, "comment", r->comment);
1447
 
        }
1448
 
        ndr->depth--;
1449
 
        ndr->depth--;
1450
 
}
1451
 
 
1452
 
_PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1453
 
{
1454
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1455
 
}
1456
 
 
1457
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1458
 
{
1459
 
        uint32_t _ptr_servername;
1460
 
        TALLOC_CTX *_mem_save_servername_0;
1461
 
        uint32_t _ptr_printername;
1462
 
        TALLOC_CTX *_mem_save_printername_0;
1463
 
        uint32_t _ptr_sharename;
1464
 
        TALLOC_CTX *_mem_save_sharename_0;
1465
 
        uint32_t _ptr_portname;
1466
 
        TALLOC_CTX *_mem_save_portname_0;
1467
 
        uint32_t _ptr_drivername;
1468
 
        TALLOC_CTX *_mem_save_drivername_0;
1469
 
        uint32_t _ptr_comment;
1470
 
        TALLOC_CTX *_mem_save_comment_0;
1471
 
        uint32_t _ptr_location;
1472
 
        TALLOC_CTX *_mem_save_location_0;
1473
 
        uint32_t _ptr_devmode;
1474
 
        TALLOC_CTX *_mem_save_devmode_0;
1475
 
        uint32_t _ptr_sepfile;
1476
 
        TALLOC_CTX *_mem_save_sepfile_0;
1477
 
        uint32_t _ptr_printprocessor;
1478
 
        TALLOC_CTX *_mem_save_printprocessor_0;
1479
 
        uint32_t _ptr_datatype;
1480
 
        TALLOC_CTX *_mem_save_datatype_0;
1481
 
        uint32_t _ptr_parameters;
1482
 
        TALLOC_CTX *_mem_save_parameters_0;
1483
 
        uint32_t _ptr_secdesc;
1484
 
        TALLOC_CTX *_mem_save_secdesc_0;
1485
 
        if (ndr_flags & NDR_SCALARS) {
1486
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
1487
 
                {
1488
 
                        uint32_t _flags_save_string = ndr->flags;
1489
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1490
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1491
 
                        if (_ptr_servername) {
1492
 
                                NDR_PULL_ALLOC(ndr, r->servername);
1493
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1494
 
                        } else {
1495
 
                                r->servername = NULL;
1496
 
                        }
1497
 
                        ndr->flags = _flags_save_string;
1498
 
                }
1499
 
                {
1500
 
                        uint32_t _flags_save_string = ndr->flags;
1501
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1502
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1503
 
                        if (_ptr_printername) {
1504
 
                                NDR_PULL_ALLOC(ndr, r->printername);
1505
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1506
 
                        } else {
1507
 
                                r->printername = NULL;
1508
 
                        }
1509
 
                        ndr->flags = _flags_save_string;
1510
 
                }
1511
 
                {
1512
 
                        uint32_t _flags_save_string = ndr->flags;
1513
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1514
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1515
 
                        if (_ptr_sharename) {
1516
 
                                NDR_PULL_ALLOC(ndr, r->sharename);
1517
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1518
 
                        } else {
1519
 
                                r->sharename = NULL;
1520
 
                        }
1521
 
                        ndr->flags = _flags_save_string;
1522
 
                }
1523
 
                {
1524
 
                        uint32_t _flags_save_string = ndr->flags;
1525
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1526
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1527
 
                        if (_ptr_portname) {
1528
 
                                NDR_PULL_ALLOC(ndr, r->portname);
1529
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1530
 
                        } else {
1531
 
                                r->portname = NULL;
1532
 
                        }
1533
 
                        ndr->flags = _flags_save_string;
1534
 
                }
1535
 
                {
1536
 
                        uint32_t _flags_save_string = ndr->flags;
1537
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1538
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1539
 
                        if (_ptr_drivername) {
1540
 
                                NDR_PULL_ALLOC(ndr, r->drivername);
1541
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1542
 
                        } else {
1543
 
                                r->drivername = NULL;
1544
 
                        }
1545
 
                        ndr->flags = _flags_save_string;
1546
 
                }
1547
 
                {
1548
 
                        uint32_t _flags_save_string = ndr->flags;
1549
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1550
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1551
 
                        if (_ptr_comment) {
1552
 
                                NDR_PULL_ALLOC(ndr, r->comment);
1553
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1554
 
                        } else {
1555
 
                                r->comment = NULL;
1556
 
                        }
1557
 
                        ndr->flags = _flags_save_string;
1558
 
                }
1559
 
                {
1560
 
                        uint32_t _flags_save_string = ndr->flags;
1561
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1562
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1563
 
                        if (_ptr_location) {
1564
 
                                NDR_PULL_ALLOC(ndr, r->location);
1565
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1566
 
                        } else {
1567
 
                                r->location = NULL;
1568
 
                        }
1569
 
                        ndr->flags = _flags_save_string;
1570
 
                }
1571
 
                {
1572
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1573
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1574
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1575
 
                        if (_ptr_devmode) {
1576
 
                                NDR_PULL_ALLOC(ndr, r->devmode);
1577
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1578
 
                        } else {
1579
 
                                r->devmode = NULL;
1580
 
                        }
1581
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
1582
 
                }
1583
 
                {
1584
 
                        uint32_t _flags_save_string = ndr->flags;
1585
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1586
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1587
 
                        if (_ptr_sepfile) {
1588
 
                                NDR_PULL_ALLOC(ndr, r->sepfile);
1589
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1590
 
                        } else {
1591
 
                                r->sepfile = NULL;
1592
 
                        }
1593
 
                        ndr->flags = _flags_save_string;
1594
 
                }
1595
 
                {
1596
 
                        uint32_t _flags_save_string = ndr->flags;
1597
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1598
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1599
 
                        if (_ptr_printprocessor) {
1600
 
                                NDR_PULL_ALLOC(ndr, r->printprocessor);
1601
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1602
 
                        } else {
1603
 
                                r->printprocessor = NULL;
1604
 
                        }
1605
 
                        ndr->flags = _flags_save_string;
1606
 
                }
1607
 
                {
1608
 
                        uint32_t _flags_save_string = ndr->flags;
1609
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1610
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1611
 
                        if (_ptr_datatype) {
1612
 
                                NDR_PULL_ALLOC(ndr, r->datatype);
1613
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1614
 
                        } else {
1615
 
                                r->datatype = NULL;
1616
 
                        }
1617
 
                        ndr->flags = _flags_save_string;
1618
 
                }
1619
 
                {
1620
 
                        uint32_t _flags_save_string = ndr->flags;
1621
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1622
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1623
 
                        if (_ptr_parameters) {
1624
 
                                NDR_PULL_ALLOC(ndr, r->parameters);
1625
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1626
 
                        } else {
1627
 
                                r->parameters = NULL;
1628
 
                        }
1629
 
                        ndr->flags = _flags_save_string;
1630
 
                }
1631
 
                {
1632
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1633
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1634
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1635
 
                        if (_ptr_secdesc) {
1636
 
                                NDR_PULL_ALLOC(ndr, r->secdesc);
1637
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1638
 
                        } else {
1639
 
                                r->secdesc = NULL;
1640
 
                        }
1641
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
1642
 
                }
1643
 
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1644
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1645
 
                if (r->priority > 99) {
1646
 
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1647
 
                }
1648
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1649
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1650
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1651
 
                NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1652
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1653
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1654
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1655
 
        }
1656
 
        if (ndr_flags & NDR_BUFFERS) {
1657
 
                {
1658
 
                        uint32_t _flags_save_string = ndr->flags;
1659
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1660
 
                        if (r->servername) {
1661
 
                                uint32_t _relative_save_offset;
1662
 
                                _relative_save_offset = ndr->offset;
1663
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1664
 
                                _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1665
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1666
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1667
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1668
 
                                ndr->offset = _relative_save_offset;
1669
 
                        }
1670
 
                        ndr->flags = _flags_save_string;
1671
 
                }
1672
 
                {
1673
 
                        uint32_t _flags_save_string = ndr->flags;
1674
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1675
 
                        if (r->printername) {
1676
 
                                uint32_t _relative_save_offset;
1677
 
                                _relative_save_offset = ndr->offset;
1678
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1679
 
                                _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1680
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1681
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1682
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1683
 
                                ndr->offset = _relative_save_offset;
1684
 
                        }
1685
 
                        ndr->flags = _flags_save_string;
1686
 
                }
1687
 
                {
1688
 
                        uint32_t _flags_save_string = ndr->flags;
1689
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1690
 
                        if (r->sharename) {
1691
 
                                uint32_t _relative_save_offset;
1692
 
                                _relative_save_offset = ndr->offset;
1693
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1694
 
                                _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1695
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1696
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1697
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1698
 
                                ndr->offset = _relative_save_offset;
1699
 
                        }
1700
 
                        ndr->flags = _flags_save_string;
1701
 
                }
1702
 
                {
1703
 
                        uint32_t _flags_save_string = ndr->flags;
1704
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1705
 
                        if (r->portname) {
1706
 
                                uint32_t _relative_save_offset;
1707
 
                                _relative_save_offset = ndr->offset;
1708
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1709
 
                                _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1710
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1711
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1712
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1713
 
                                ndr->offset = _relative_save_offset;
1714
 
                        }
1715
 
                        ndr->flags = _flags_save_string;
1716
 
                }
1717
 
                {
1718
 
                        uint32_t _flags_save_string = ndr->flags;
1719
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1720
 
                        if (r->drivername) {
1721
 
                                uint32_t _relative_save_offset;
1722
 
                                _relative_save_offset = ndr->offset;
1723
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1724
 
                                _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1725
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1726
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1727
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1728
 
                                ndr->offset = _relative_save_offset;
1729
 
                        }
1730
 
                        ndr->flags = _flags_save_string;
1731
 
                }
1732
 
                {
1733
 
                        uint32_t _flags_save_string = ndr->flags;
1734
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1735
 
                        if (r->comment) {
1736
 
                                uint32_t _relative_save_offset;
1737
 
                                _relative_save_offset = ndr->offset;
1738
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1739
 
                                _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1740
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1741
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1742
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1743
 
                                ndr->offset = _relative_save_offset;
1744
 
                        }
1745
 
                        ndr->flags = _flags_save_string;
1746
 
                }
1747
 
                {
1748
 
                        uint32_t _flags_save_string = ndr->flags;
1749
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1750
 
                        if (r->location) {
1751
 
                                uint32_t _relative_save_offset;
1752
 
                                _relative_save_offset = ndr->offset;
1753
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1754
 
                                _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1755
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1756
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1757
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1758
 
                                ndr->offset = _relative_save_offset;
1759
 
                        }
1760
 
                        ndr->flags = _flags_save_string;
1761
 
                }
1762
 
                {
1763
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1764
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1765
 
                        if (r->devmode) {
1766
 
                                uint32_t _relative_save_offset;
1767
 
                                _relative_save_offset = ndr->offset;
1768
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1769
 
                                _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1770
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1771
 
                                {
1772
 
                                        struct ndr_pull *_ndr_devmode;
1773
 
                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1774
 
                                        NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1775
 
                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1776
 
                                }
1777
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1778
 
                                ndr->offset = _relative_save_offset;
1779
 
                        }
1780
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
1781
 
                }
1782
 
                {
1783
 
                        uint32_t _flags_save_string = ndr->flags;
1784
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1785
 
                        if (r->sepfile) {
1786
 
                                uint32_t _relative_save_offset;
1787
 
                                _relative_save_offset = ndr->offset;
1788
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1789
 
                                _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1790
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1791
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1792
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1793
 
                                ndr->offset = _relative_save_offset;
1794
 
                        }
1795
 
                        ndr->flags = _flags_save_string;
1796
 
                }
1797
 
                {
1798
 
                        uint32_t _flags_save_string = ndr->flags;
1799
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1800
 
                        if (r->printprocessor) {
1801
 
                                uint32_t _relative_save_offset;
1802
 
                                _relative_save_offset = ndr->offset;
1803
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1804
 
                                _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1805
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1806
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1807
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1808
 
                                ndr->offset = _relative_save_offset;
1809
 
                        }
1810
 
                        ndr->flags = _flags_save_string;
1811
 
                }
1812
 
                {
1813
 
                        uint32_t _flags_save_string = ndr->flags;
1814
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1815
 
                        if (r->datatype) {
1816
 
                                uint32_t _relative_save_offset;
1817
 
                                _relative_save_offset = ndr->offset;
1818
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1819
 
                                _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1820
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1821
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1822
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1823
 
                                ndr->offset = _relative_save_offset;
1824
 
                        }
1825
 
                        ndr->flags = _flags_save_string;
1826
 
                }
1827
 
                {
1828
 
                        uint32_t _flags_save_string = ndr->flags;
1829
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1830
 
                        if (r->parameters) {
1831
 
                                uint32_t _relative_save_offset;
1832
 
                                _relative_save_offset = ndr->offset;
1833
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1834
 
                                _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1835
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1836
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1837
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1838
 
                                ndr->offset = _relative_save_offset;
1839
 
                        }
1840
 
                        ndr->flags = _flags_save_string;
1841
 
                }
1842
 
                {
1843
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1844
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1845
 
                        if (r->secdesc) {
1846
 
                                uint32_t _relative_save_offset;
1847
 
                                _relative_save_offset = ndr->offset;
1848
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1849
 
                                _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1850
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1851
 
                                {
1852
 
                                        struct ndr_pull *_ndr_secdesc;
1853
 
                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1854
 
                                        NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1855
 
                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1856
 
                                }
1857
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1858
 
                                ndr->offset = _relative_save_offset;
1859
 
                        }
1860
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
1861
 
                }
1862
 
        }
1863
 
        return NDR_ERR_SUCCESS;
1864
 
}
1865
 
 
1866
 
_PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1867
 
{
1868
 
        ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1869
 
        ndr->depth++;
1870
 
        ndr_print_ptr(ndr, "servername", r->servername);
1871
 
        ndr->depth++;
1872
 
        if (r->servername) {
1873
 
                ndr_print_string(ndr, "servername", r->servername);
1874
 
        }
1875
 
        ndr->depth--;
1876
 
        ndr_print_ptr(ndr, "printername", r->printername);
1877
 
        ndr->depth++;
1878
 
        if (r->printername) {
1879
 
                ndr_print_string(ndr, "printername", r->printername);
1880
 
        }
1881
 
        ndr->depth--;
1882
 
        ndr_print_ptr(ndr, "sharename", r->sharename);
1883
 
        ndr->depth++;
1884
 
        if (r->sharename) {
1885
 
                ndr_print_string(ndr, "sharename", r->sharename);
1886
 
        }
1887
 
        ndr->depth--;
1888
 
        ndr_print_ptr(ndr, "portname", r->portname);
1889
 
        ndr->depth++;
1890
 
        if (r->portname) {
1891
 
                ndr_print_string(ndr, "portname", r->portname);
1892
 
        }
1893
 
        ndr->depth--;
1894
 
        ndr_print_ptr(ndr, "drivername", r->drivername);
1895
 
        ndr->depth++;
1896
 
        if (r->drivername) {
1897
 
                ndr_print_string(ndr, "drivername", r->drivername);
1898
 
        }
1899
 
        ndr->depth--;
1900
 
        ndr_print_ptr(ndr, "comment", r->comment);
1901
 
        ndr->depth++;
1902
 
        if (r->comment) {
1903
 
                ndr_print_string(ndr, "comment", r->comment);
1904
 
        }
1905
 
        ndr->depth--;
1906
 
        ndr_print_ptr(ndr, "location", r->location);
1907
 
        ndr->depth++;
1908
 
        if (r->location) {
1909
 
                ndr_print_string(ndr, "location", r->location);
1910
 
        }
1911
 
        ndr->depth--;
1912
 
        ndr_print_ptr(ndr, "devmode", r->devmode);
1913
 
        ndr->depth++;
1914
 
        if (r->devmode) {
1915
 
                ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1916
 
        }
1917
 
        ndr->depth--;
1918
 
        ndr_print_ptr(ndr, "sepfile", r->sepfile);
1919
 
        ndr->depth++;
1920
 
        if (r->sepfile) {
1921
 
                ndr_print_string(ndr, "sepfile", r->sepfile);
1922
 
        }
1923
 
        ndr->depth--;
1924
 
        ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1925
 
        ndr->depth++;
1926
 
        if (r->printprocessor) {
1927
 
                ndr_print_string(ndr, "printprocessor", r->printprocessor);
1928
 
        }
1929
 
        ndr->depth--;
1930
 
        ndr_print_ptr(ndr, "datatype", r->datatype);
1931
 
        ndr->depth++;
1932
 
        if (r->datatype) {
1933
 
                ndr_print_string(ndr, "datatype", r->datatype);
1934
 
        }
1935
 
        ndr->depth--;
1936
 
        ndr_print_ptr(ndr, "parameters", r->parameters);
1937
 
        ndr->depth++;
1938
 
        if (r->parameters) {
1939
 
                ndr_print_string(ndr, "parameters", r->parameters);
1940
 
        }
1941
 
        ndr->depth--;
1942
 
        ndr_print_ptr(ndr, "secdesc", r->secdesc);
1943
 
        ndr->depth++;
1944
 
        if (r->secdesc) {
1945
 
                ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
1946
 
        }
1947
 
        ndr->depth--;
1948
 
        ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1949
 
        ndr_print_uint32(ndr, "priority", r->priority);
1950
 
        ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1951
 
        ndr_print_uint32(ndr, "starttime", r->starttime);
1952
 
        ndr_print_uint32(ndr, "untiltime", r->untiltime);
1953
 
        ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1954
 
        ndr_print_uint32(ndr, "cjobs", r->cjobs);
1955
 
        ndr_print_uint32(ndr, "averageppm", r->averageppm);
1956
 
        ndr->depth--;
1957
 
}
1958
 
 
1959
 
_PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
1960
 
{
1961
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
1962
 
}
1963
 
 
1964
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1965
 
{
1966
 
        if (ndr_flags & NDR_SCALARS) {
1967
 
                NDR_CHECK(ndr_push_align(ndr, 5));
1968
 
                {
1969
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1970
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1971
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1972
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
1973
 
                }
1974
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1975
 
        }
1976
 
        if (ndr_flags & NDR_BUFFERS) {
1977
 
                {
1978
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1979
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1980
 
                        if (r->secdesc) {
1981
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
1982
 
                                {
1983
 
                                        struct ndr_push *_ndr_secdesc;
1984
 
                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1985
 
                                        NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1986
 
                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1987
 
                                }
1988
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
1989
 
                        }
1990
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
1991
 
                }
1992
 
        }
1993
 
        return NDR_ERR_SUCCESS;
1994
 
}
1995
 
 
1996
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1997
 
{
1998
 
        uint32_t _ptr_secdesc;
1999
 
        TALLOC_CTX *_mem_save_secdesc_0;
2000
 
        if (ndr_flags & NDR_SCALARS) {
2001
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
2002
 
                {
2003
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2004
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2005
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2006
 
                        if (_ptr_secdesc) {
2007
 
                                NDR_PULL_ALLOC(ndr, r->secdesc);
2008
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2009
 
                        } else {
2010
 
                                r->secdesc = NULL;
2011
 
                        }
2012
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
2013
 
                }
2014
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2015
 
        }
2016
 
        if (ndr_flags & NDR_BUFFERS) {
2017
 
                {
2018
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2019
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2020
 
                        if (r->secdesc) {
2021
 
                                uint32_t _relative_save_offset;
2022
 
                                _relative_save_offset = ndr->offset;
2023
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2024
 
                                _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2025
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2026
 
                                {
2027
 
                                        struct ndr_pull *_ndr_secdesc;
2028
 
                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2029
 
                                        NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2030
 
                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2031
 
                                }
2032
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2033
 
                                ndr->offset = _relative_save_offset;
2034
 
                        }
2035
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
2036
 
                }
2037
 
        }
2038
 
        return NDR_ERR_SUCCESS;
2039
 
}
2040
 
 
2041
 
_PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2042
 
{
2043
 
        ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2044
 
        ndr->depth++;
2045
 
        ndr_print_ptr(ndr, "secdesc", r->secdesc);
2046
 
        ndr->depth++;
2047
 
        if (r->secdesc) {
2048
 
                ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
2049
 
        }
2050
 
        ndr->depth--;
2051
 
        ndr->depth--;
2052
 
}
2053
 
 
2054
 
_PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2055
 
{
2056
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2057
 
}
2058
 
 
2059
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2060
 
{
2061
 
        if (ndr_flags & NDR_SCALARS) {
2062
 
                NDR_CHECK(ndr_push_align(ndr, 5));
2063
 
                {
2064
 
                        uint32_t _flags_save_string = ndr->flags;
2065
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2066
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2067
 
                        ndr->flags = _flags_save_string;
2068
 
                }
2069
 
                {
2070
 
                        uint32_t _flags_save_string = ndr->flags;
2071
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2072
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2073
 
                        ndr->flags = _flags_save_string;
2074
 
                }
2075
 
                NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2076
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2077
 
        }
2078
 
        if (ndr_flags & NDR_BUFFERS) {
2079
 
                {
2080
 
                        uint32_t _flags_save_string = ndr->flags;
2081
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2082
 
                        if (r->printername) {
2083
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2084
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2085
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2086
 
                        }
2087
 
                        ndr->flags = _flags_save_string;
2088
 
                }
2089
 
                {
2090
 
                        uint32_t _flags_save_string = ndr->flags;
2091
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2092
 
                        if (r->servername) {
2093
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
2094
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2095
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
2096
 
                        }
2097
 
                        ndr->flags = _flags_save_string;
2098
 
                }
2099
 
        }
2100
 
        return NDR_ERR_SUCCESS;
2101
 
}
2102
 
 
2103
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2104
 
{
2105
 
        uint32_t _ptr_printername;
2106
 
        TALLOC_CTX *_mem_save_printername_0;
2107
 
        uint32_t _ptr_servername;
2108
 
        TALLOC_CTX *_mem_save_servername_0;
2109
 
        if (ndr_flags & NDR_SCALARS) {
2110
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
2111
 
                {
2112
 
                        uint32_t _flags_save_string = ndr->flags;
2113
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2114
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2115
 
                        if (_ptr_printername) {
2116
 
                                NDR_PULL_ALLOC(ndr, r->printername);
2117
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2118
 
                        } else {
2119
 
                                r->printername = NULL;
2120
 
                        }
2121
 
                        ndr->flags = _flags_save_string;
2122
 
                }
2123
 
                {
2124
 
                        uint32_t _flags_save_string = ndr->flags;
2125
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2126
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2127
 
                        if (_ptr_servername) {
2128
 
                                NDR_PULL_ALLOC(ndr, r->servername);
2129
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2130
 
                        } else {
2131
 
                                r->servername = NULL;
2132
 
                        }
2133
 
                        ndr->flags = _flags_save_string;
2134
 
                }
2135
 
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2136
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2137
 
        }
2138
 
        if (ndr_flags & NDR_BUFFERS) {
2139
 
                {
2140
 
                        uint32_t _flags_save_string = ndr->flags;
2141
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2142
 
                        if (r->printername) {
2143
 
                                uint32_t _relative_save_offset;
2144
 
                                _relative_save_offset = ndr->offset;
2145
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2146
 
                                _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2147
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2148
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2149
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2150
 
                                ndr->offset = _relative_save_offset;
2151
 
                        }
2152
 
                        ndr->flags = _flags_save_string;
2153
 
                }
2154
 
                {
2155
 
                        uint32_t _flags_save_string = ndr->flags;
2156
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2157
 
                        if (r->servername) {
2158
 
                                uint32_t _relative_save_offset;
2159
 
                                _relative_save_offset = ndr->offset;
2160
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2161
 
                                _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2162
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2163
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2164
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2165
 
                                ndr->offset = _relative_save_offset;
2166
 
                        }
2167
 
                        ndr->flags = _flags_save_string;
2168
 
                }
2169
 
        }
2170
 
        return NDR_ERR_SUCCESS;
2171
 
}
2172
 
 
2173
 
_PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2174
 
{
2175
 
        ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2176
 
        ndr->depth++;
2177
 
        ndr_print_ptr(ndr, "printername", r->printername);
2178
 
        ndr->depth++;
2179
 
        if (r->printername) {
2180
 
                ndr_print_string(ndr, "printername", r->printername);
2181
 
        }
2182
 
        ndr->depth--;
2183
 
        ndr_print_ptr(ndr, "servername", r->servername);
2184
 
        ndr->depth++;
2185
 
        if (r->servername) {
2186
 
                ndr_print_string(ndr, "servername", r->servername);
2187
 
        }
2188
 
        ndr->depth--;
2189
 
        ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2190
 
        ndr->depth--;
2191
 
}
2192
 
 
2193
 
_PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2194
 
{
2195
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2196
 
}
2197
 
 
2198
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2199
 
{
2200
 
        if (ndr_flags & NDR_SCALARS) {
2201
 
                NDR_CHECK(ndr_push_align(ndr, 5));
2202
 
                {
2203
 
                        uint32_t _flags_save_string = ndr->flags;
2204
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2205
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2206
 
                        ndr->flags = _flags_save_string;
2207
 
                }
2208
 
                {
2209
 
                        uint32_t _flags_save_string = ndr->flags;
2210
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2211
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2212
 
                        ndr->flags = _flags_save_string;
2213
 
                }
2214
 
                NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2215
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2216
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2217
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2218
 
        }
2219
 
        if (ndr_flags & NDR_BUFFERS) {
2220
 
                {
2221
 
                        uint32_t _flags_save_string = ndr->flags;
2222
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2223
 
                        if (r->printername) {
2224
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2225
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2226
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2227
 
                        }
2228
 
                        ndr->flags = _flags_save_string;
2229
 
                }
2230
 
                {
2231
 
                        uint32_t _flags_save_string = ndr->flags;
2232
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2233
 
                        if (r->portname) {
2234
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
2235
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2236
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
2237
 
                        }
2238
 
                        ndr->flags = _flags_save_string;
2239
 
                }
2240
 
        }
2241
 
        return NDR_ERR_SUCCESS;
2242
 
}
2243
 
 
2244
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2245
 
{
2246
 
        uint32_t _ptr_printername;
2247
 
        TALLOC_CTX *_mem_save_printername_0;
2248
 
        uint32_t _ptr_portname;
2249
 
        TALLOC_CTX *_mem_save_portname_0;
2250
 
        if (ndr_flags & NDR_SCALARS) {
2251
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
2252
 
                {
2253
 
                        uint32_t _flags_save_string = ndr->flags;
2254
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2255
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2256
 
                        if (_ptr_printername) {
2257
 
                                NDR_PULL_ALLOC(ndr, r->printername);
2258
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2259
 
                        } else {
2260
 
                                r->printername = NULL;
2261
 
                        }
2262
 
                        ndr->flags = _flags_save_string;
2263
 
                }
2264
 
                {
2265
 
                        uint32_t _flags_save_string = ndr->flags;
2266
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2267
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2268
 
                        if (_ptr_portname) {
2269
 
                                NDR_PULL_ALLOC(ndr, r->portname);
2270
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2271
 
                        } else {
2272
 
                                r->portname = NULL;
2273
 
                        }
2274
 
                        ndr->flags = _flags_save_string;
2275
 
                }
2276
 
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2277
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2278
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2279
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2280
 
        }
2281
 
        if (ndr_flags & NDR_BUFFERS) {
2282
 
                {
2283
 
                        uint32_t _flags_save_string = ndr->flags;
2284
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2285
 
                        if (r->printername) {
2286
 
                                uint32_t _relative_save_offset;
2287
 
                                _relative_save_offset = ndr->offset;
2288
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2289
 
                                _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2290
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2291
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2292
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2293
 
                                ndr->offset = _relative_save_offset;
2294
 
                        }
2295
 
                        ndr->flags = _flags_save_string;
2296
 
                }
2297
 
                {
2298
 
                        uint32_t _flags_save_string = ndr->flags;
2299
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2300
 
                        if (r->portname) {
2301
 
                                uint32_t _relative_save_offset;
2302
 
                                _relative_save_offset = ndr->offset;
2303
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2304
 
                                _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2305
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2306
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2307
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2308
 
                                ndr->offset = _relative_save_offset;
2309
 
                        }
2310
 
                        ndr->flags = _flags_save_string;
2311
 
                }
2312
 
        }
2313
 
        return NDR_ERR_SUCCESS;
2314
 
}
2315
 
 
2316
 
_PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2317
 
{
2318
 
        ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2319
 
        ndr->depth++;
2320
 
        ndr_print_ptr(ndr, "printername", r->printername);
2321
 
        ndr->depth++;
2322
 
        if (r->printername) {
2323
 
                ndr_print_string(ndr, "printername", r->printername);
2324
 
        }
2325
 
        ndr->depth--;
2326
 
        ndr_print_ptr(ndr, "portname", r->portname);
2327
 
        ndr->depth++;
2328
 
        if (r->portname) {
2329
 
                ndr_print_string(ndr, "portname", r->portname);
2330
 
        }
2331
 
        ndr->depth--;
2332
 
        ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2333
 
        ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2334
 
        ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2335
 
        ndr->depth--;
2336
 
}
2337
 
 
2338
 
_PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2339
 
{
2340
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2341
 
}
2342
 
 
2343
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2344
 
{
2345
 
        if (ndr_flags & NDR_SCALARS) {
2346
 
                NDR_CHECK(ndr_push_align(ndr, 4));
2347
 
                NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2348
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2349
 
        }
2350
 
        if (ndr_flags & NDR_BUFFERS) {
2351
 
        }
2352
 
        return NDR_ERR_SUCCESS;
2353
 
}
2354
 
 
2355
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2356
 
{
2357
 
        if (ndr_flags & NDR_SCALARS) {
2358
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
2359
 
                NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2360
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2361
 
        }
2362
 
        if (ndr_flags & NDR_BUFFERS) {
2363
 
        }
2364
 
        return NDR_ERR_SUCCESS;
2365
 
}
2366
 
 
2367
 
_PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2368
 
{
2369
 
        ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2370
 
        ndr->depth++;
2371
 
        ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2372
 
        ndr->depth--;
2373
 
}
2374
 
 
2375
 
_PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2376
 
{
2377
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2378
 
}
2379
 
 
2380
 
static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2381
 
{
2382
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2383
 
        return NDR_ERR_SUCCESS;
2384
 
}
2385
 
 
2386
 
static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2387
 
{
2388
 
        uint32_t v;
2389
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2390
 
        *r = v;
2391
 
        return NDR_ERR_SUCCESS;
2392
 
}
2393
 
 
2394
 
_PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2395
 
{
2396
 
        ndr_print_uint32(ndr, name, r);
2397
 
        ndr->depth++;
2398
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2399
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2400
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2401
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2402
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2403
 
        ndr->depth--;
2404
 
}
2405
 
 
2406
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2407
 
{
2408
 
        if (ndr_flags & NDR_SCALARS) {
2409
 
                NDR_CHECK(ndr_push_align(ndr, 5));
2410
 
                {
2411
 
                        uint32_t _flags_save_string = ndr->flags;
2412
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2413
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2414
 
                        ndr->flags = _flags_save_string;
2415
 
                }
2416
 
                NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2417
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2418
 
        }
2419
 
        if (ndr_flags & NDR_BUFFERS) {
2420
 
                {
2421
 
                        uint32_t _flags_save_string = ndr->flags;
2422
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2423
 
                        if (r->guid) {
2424
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->guid));
2425
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2426
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->guid));
2427
 
                        }
2428
 
                        ndr->flags = _flags_save_string;
2429
 
                }
2430
 
        }
2431
 
        return NDR_ERR_SUCCESS;
2432
 
}
2433
 
 
2434
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2435
 
{
2436
 
        uint32_t _ptr_guid;
2437
 
        TALLOC_CTX *_mem_save_guid_0;
2438
 
        if (ndr_flags & NDR_SCALARS) {
2439
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
2440
 
                {
2441
 
                        uint32_t _flags_save_string = ndr->flags;
2442
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2443
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2444
 
                        if (_ptr_guid) {
2445
 
                                NDR_PULL_ALLOC(ndr, r->guid);
2446
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2447
 
                        } else {
2448
 
                                r->guid = NULL;
2449
 
                        }
2450
 
                        ndr->flags = _flags_save_string;
2451
 
                }
2452
 
                NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2453
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2454
 
        }
2455
 
        if (ndr_flags & NDR_BUFFERS) {
2456
 
                {
2457
 
                        uint32_t _flags_save_string = ndr->flags;
2458
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2459
 
                        if (r->guid) {
2460
 
                                uint32_t _relative_save_offset;
2461
 
                                _relative_save_offset = ndr->offset;
2462
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2463
 
                                _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2464
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2465
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2466
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2467
 
                                ndr->offset = _relative_save_offset;
2468
 
                        }
2469
 
                        ndr->flags = _flags_save_string;
2470
 
                }
2471
 
        }
2472
 
        return NDR_ERR_SUCCESS;
2473
 
}
2474
 
 
2475
 
_PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2476
 
{
2477
 
        ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2478
 
        ndr->depth++;
2479
 
        ndr_print_ptr(ndr, "guid", r->guid);
2480
 
        ndr->depth++;
2481
 
        if (r->guid) {
2482
 
                ndr_print_string(ndr, "guid", r->guid);
2483
 
        }
2484
 
        ndr->depth--;
2485
 
        ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2486
 
        ndr->depth--;
2487
 
}
2488
 
 
2489
 
_PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2490
 
{
2491
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2492
 
}
2493
 
 
2494
 
static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2495
 
{
2496
 
        if (ndr_flags & NDR_SCALARS) {
2497
 
                NDR_CHECK(ndr_push_align(ndr, 5));
2498
 
                {
2499
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2500
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2501
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2502
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
2503
 
                }
2504
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2505
 
        }
2506
 
        if (ndr_flags & NDR_BUFFERS) {
2507
 
                {
2508
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2509
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2510
 
                        if (r->devmode) {
2511
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
2512
 
                                {
2513
 
                                        struct ndr_push *_ndr_devmode;
2514
 
                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2515
 
                                        NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2516
 
                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2517
 
                                }
2518
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
2519
 
                        }
2520
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
2521
 
                }
2522
 
        }
2523
 
        return NDR_ERR_SUCCESS;
2524
 
}
2525
 
 
2526
 
static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2527
 
{
2528
 
        uint32_t _ptr_devmode;
2529
 
        TALLOC_CTX *_mem_save_devmode_0;
2530
 
        if (ndr_flags & NDR_SCALARS) {
2531
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
2532
 
                {
2533
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2534
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2535
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2536
 
                        if (_ptr_devmode) {
2537
 
                                NDR_PULL_ALLOC(ndr, r->devmode);
2538
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2539
 
                        } else {
2540
 
                                r->devmode = NULL;
2541
 
                        }
2542
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
2543
 
                }
2544
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2545
 
        }
2546
 
        if (ndr_flags & NDR_BUFFERS) {
2547
 
                {
2548
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2549
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2550
 
                        if (r->devmode) {
2551
 
                                uint32_t _relative_save_offset;
2552
 
                                _relative_save_offset = ndr->offset;
2553
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2554
 
                                _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2555
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2556
 
                                {
2557
 
                                        struct ndr_pull *_ndr_devmode;
2558
 
                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2559
 
                                        NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2560
 
                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2561
 
                                }
2562
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2563
 
                                ndr->offset = _relative_save_offset;
2564
 
                        }
2565
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
2566
 
                }
2567
 
        }
2568
 
        return NDR_ERR_SUCCESS;
2569
 
}
2570
 
 
2571
 
_PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2572
 
{
2573
 
        ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2574
 
        ndr->depth++;
2575
 
        ndr_print_ptr(ndr, "devmode", r->devmode);
2576
 
        ndr->depth++;
2577
 
        if (r->devmode) {
2578
 
                ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2579
 
        }
2580
 
        ndr->depth--;
2581
 
        ndr->depth--;
2582
 
}
2583
 
 
2584
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2585
 
{
2586
 
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2587
 
        {
2588
 
                uint32_t _flags_save_UNION = ndr->flags;
2589
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2590
 
                if (ndr_flags & NDR_SCALARS) {
2591
 
                        int level = ndr_push_get_switch_value(ndr, r);
2592
 
                        NDR_CHECK(ndr_push_union_align(ndr, 5));
2593
 
                        switch (level) {
2594
 
                                case 0: {
2595
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
2596
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2597
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2598
 
                                break; }
2599
 
 
2600
 
                                case 1: {
2601
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
2602
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2603
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2604
 
                                break; }
2605
 
 
2606
 
                                case 2: {
2607
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
2608
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2609
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2610
 
                                break; }
2611
 
 
2612
 
                                case 3: {
2613
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
2614
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2615
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2616
 
                                break; }
2617
 
 
2618
 
                                case 4: {
2619
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
2620
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2621
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2622
 
                                break; }
2623
 
 
2624
 
                                case 5: {
2625
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
2626
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2627
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2628
 
                                break; }
2629
 
 
2630
 
                                case 6: {
2631
 
                                        NDR_CHECK(ndr_push_align(ndr, 4));
2632
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2633
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2634
 
                                break; }
2635
 
 
2636
 
                                case 7: {
2637
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
2638
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2639
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2640
 
                                break; }
2641
 
 
2642
 
                                case 8: {
2643
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
2644
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2645
 
                                        NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2646
 
                                break; }
2647
 
 
2648
 
                                case 9: {
2649
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
2650
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2651
 
                                        NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2652
 
                                break; }
2653
 
 
2654
 
                                default: {
2655
 
                                break; }
2656
 
 
2657
 
                        }
2658
 
                }
2659
 
                if (ndr_flags & NDR_BUFFERS) {
2660
 
                        int level = ndr_push_get_switch_value(ndr, r);
2661
 
                        NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2662
 
                        switch (level) {
2663
 
                                case 0:
2664
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2665
 
                                break;
2666
 
 
2667
 
                                case 1:
2668
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2669
 
                                break;
2670
 
 
2671
 
                                case 2:
2672
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2673
 
                                break;
2674
 
 
2675
 
                                case 3:
2676
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2677
 
                                break;
2678
 
 
2679
 
                                case 4:
2680
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2681
 
                                break;
2682
 
 
2683
 
                                case 5:
2684
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2685
 
                                break;
2686
 
 
2687
 
                                case 6:
2688
 
                                break;
2689
 
 
2690
 
                                case 7:
2691
 
                                        NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2692
 
                                break;
2693
 
 
2694
 
                                case 8:
2695
 
                                        NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2696
 
                                break;
2697
 
 
2698
 
                                case 9:
2699
 
                                        NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2700
 
                                break;
2701
 
 
2702
 
                                default:
2703
 
                                break;
2704
 
 
2705
 
                        }
2706
 
                }
2707
 
                ndr->flags = _flags_save_UNION;
2708
 
        }
2709
 
        ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2710
 
        return NDR_ERR_SUCCESS;
2711
 
}
2712
 
 
2713
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2714
 
{
2715
 
        uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2716
 
        int level;
2717
 
        {
2718
 
                uint32_t _flags_save_UNION = ndr->flags;
2719
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2720
 
                level = ndr_pull_get_switch_value(ndr, r);
2721
 
                if (ndr_flags & NDR_SCALARS) {
2722
 
                        NDR_CHECK(ndr_pull_union_align(ndr, 5));
2723
 
                        switch (level) {
2724
 
                                case 0: {
2725
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
2726
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2727
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2728
 
                                break; }
2729
 
 
2730
 
                                case 1: {
2731
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
2732
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2733
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2734
 
                                break; }
2735
 
 
2736
 
                                case 2: {
2737
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
2738
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2739
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2740
 
                                break; }
2741
 
 
2742
 
                                case 3: {
2743
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
2744
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2745
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2746
 
                                break; }
2747
 
 
2748
 
                                case 4: {
2749
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
2750
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2751
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2752
 
                                break; }
2753
 
 
2754
 
                                case 5: {
2755
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
2756
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2757
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2758
 
                                break; }
2759
 
 
2760
 
                                case 6: {
2761
 
                                        NDR_CHECK(ndr_pull_align(ndr, 4));
2762
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2763
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2764
 
                                break; }
2765
 
 
2766
 
                                case 7: {
2767
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
2768
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2769
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2770
 
                                break; }
2771
 
 
2772
 
                                case 8: {
2773
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
2774
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2775
 
                                        NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2776
 
                                break; }
2777
 
 
2778
 
                                case 9: {
2779
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
2780
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2781
 
                                        NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2782
 
                                break; }
2783
 
 
2784
 
                                default: {
2785
 
                                break; }
2786
 
 
2787
 
                        }
2788
 
                }
2789
 
                if (ndr_flags & NDR_BUFFERS) {
2790
 
                        NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2791
 
                        switch (level) {
2792
 
                                case 0:
2793
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2794
 
                                break;
2795
 
 
2796
 
                                case 1:
2797
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2798
 
                                break;
2799
 
 
2800
 
                                case 2:
2801
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2802
 
                                break;
2803
 
 
2804
 
                                case 3:
2805
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2806
 
                                break;
2807
 
 
2808
 
                                case 4:
2809
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2810
 
                                break;
2811
 
 
2812
 
                                case 5:
2813
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2814
 
                                break;
2815
 
 
2816
 
                                case 6:
2817
 
                                break;
2818
 
 
2819
 
                                case 7:
2820
 
                                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2821
 
                                break;
2822
 
 
2823
 
                                case 8:
2824
 
                                        NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2825
 
                                break;
2826
 
 
2827
 
                                case 9:
2828
 
                                        NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2829
 
                                break;
2830
 
 
2831
 
                                default:
2832
 
                                break;
2833
 
 
2834
 
                        }
2835
 
                }
2836
 
                ndr->flags = _flags_save_UNION;
2837
 
        }
2838
 
        ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2839
 
        return NDR_ERR_SUCCESS;
2840
 
}
2841
 
 
2842
 
_PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2843
 
{
2844
 
        int level;
2845
 
        {
2846
 
                uint32_t _flags_save_UNION = ndr->flags;
2847
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2848
 
                level = ndr_print_get_switch_value(ndr, r);
2849
 
                ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2850
 
                switch (level) {
2851
 
                        case 0:
2852
 
                                ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2853
 
                        break;
2854
 
 
2855
 
                        case 1:
2856
 
                                ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2857
 
                        break;
2858
 
 
2859
 
                        case 2:
2860
 
                                ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2861
 
                        break;
2862
 
 
2863
 
                        case 3:
2864
 
                                ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2865
 
                        break;
2866
 
 
2867
 
                        case 4:
2868
 
                                ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2869
 
                        break;
2870
 
 
2871
 
                        case 5:
2872
 
                                ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2873
 
                        break;
2874
 
 
2875
 
                        case 6:
2876
 
                                ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2877
 
                        break;
2878
 
 
2879
 
                        case 7:
2880
 
                                ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2881
 
                        break;
2882
 
 
2883
 
                        case 8:
2884
 
                                ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2885
 
                        break;
2886
 
 
2887
 
                        case 9:
2888
 
                                ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2889
 
                        break;
2890
 
 
2891
 
                        default:
2892
 
                        break;
2893
 
 
2894
 
                }
2895
 
                ndr->flags = _flags_save_UNION;
2896
 
        }
2897
 
}
2898
 
 
2899
 
_PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
2900
 
{
2901
 
        flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
2902
 
        return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
2903
 
}
2904
 
 
2905
 
static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2906
 
{
2907
 
        if (ndr_flags & NDR_SCALARS) {
2908
 
                NDR_CHECK(ndr_push_align(ndr, 5));
2909
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2910
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2911
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2912
 
        }
2913
 
        if (ndr_flags & NDR_BUFFERS) {
2914
 
                if (r->devmode) {
2915
 
                        {
2916
 
                                struct ndr_push *_ndr_devmode;
2917
 
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2918
 
                                NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2919
 
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2920
 
                        }
2921
 
                }
2922
 
        }
2923
 
        return NDR_ERR_SUCCESS;
2924
 
}
2925
 
 
2926
 
static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2927
 
{
2928
 
        uint32_t _ptr_devmode;
2929
 
        TALLOC_CTX *_mem_save_devmode_0;
2930
 
        if (ndr_flags & NDR_SCALARS) {
2931
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
2932
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2933
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2934
 
                if (_ptr_devmode) {
2935
 
                        NDR_PULL_ALLOC(ndr, r->devmode);
2936
 
                } else {
2937
 
                        r->devmode = NULL;
2938
 
                }
2939
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2940
 
        }
2941
 
        if (ndr_flags & NDR_BUFFERS) {
2942
 
                if (r->devmode) {
2943
 
                        _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2944
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2945
 
                        {
2946
 
                                struct ndr_pull *_ndr_devmode;
2947
 
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2948
 
                                NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2949
 
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2950
 
                        }
2951
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2952
 
                }
2953
 
        }
2954
 
        return NDR_ERR_SUCCESS;
2955
 
}
2956
 
 
2957
 
_PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2958
 
{
2959
 
        ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2960
 
        ndr->depth++;
2961
 
        ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
2962
 
        ndr_print_ptr(ndr, "devmode", r->devmode);
2963
 
        ndr->depth++;
2964
 
        if (r->devmode) {
2965
 
                ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2966
 
        }
2967
 
        ndr->depth--;
2968
 
        ndr->depth--;
2969
 
}
2970
 
 
2971
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2972
 
{
2973
 
        if (ndr_flags & NDR_SCALARS) {
2974
 
                NDR_CHECK(ndr_push_align(ndr, 5));
2975
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2976
 
                {
2977
 
                        uint32_t _flags_save_string = ndr->flags;
2978
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2979
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2980
 
                        ndr->flags = _flags_save_string;
2981
 
                }
2982
 
                {
2983
 
                        uint32_t _flags_save_string = ndr->flags;
2984
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2985
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2986
 
                        ndr->flags = _flags_save_string;
2987
 
                }
2988
 
                {
2989
 
                        uint32_t _flags_save_string = ndr->flags;
2990
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2991
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2992
 
                        ndr->flags = _flags_save_string;
2993
 
                }
2994
 
                {
2995
 
                        uint32_t _flags_save_string = ndr->flags;
2996
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
2997
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2998
 
                        ndr->flags = _flags_save_string;
2999
 
                }
3000
 
                {
3001
 
                        uint32_t _flags_save_string = ndr->flags;
3002
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3003
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3004
 
                        ndr->flags = _flags_save_string;
3005
 
                }
3006
 
                {
3007
 
                        uint32_t _flags_save_string = ndr->flags;
3008
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3009
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3010
 
                        ndr->flags = _flags_save_string;
3011
 
                }
3012
 
                NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3013
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3014
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3015
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3016
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3017
 
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3018
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3019
 
        }
3020
 
        if (ndr_flags & NDR_BUFFERS) {
3021
 
                {
3022
 
                        uint32_t _flags_save_string = ndr->flags;
3023
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3024
 
                        if (r->printer_name) {
3025
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3026
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3027
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3028
 
                        }
3029
 
                        ndr->flags = _flags_save_string;
3030
 
                }
3031
 
                {
3032
 
                        uint32_t _flags_save_string = ndr->flags;
3033
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3034
 
                        if (r->server_name) {
3035
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3036
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3037
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3038
 
                        }
3039
 
                        ndr->flags = _flags_save_string;
3040
 
                }
3041
 
                {
3042
 
                        uint32_t _flags_save_string = ndr->flags;
3043
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3044
 
                        if (r->user_name) {
3045
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3046
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3047
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3048
 
                        }
3049
 
                        ndr->flags = _flags_save_string;
3050
 
                }
3051
 
                {
3052
 
                        uint32_t _flags_save_string = ndr->flags;
3053
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3054
 
                        if (r->document_name) {
3055
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3056
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3057
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3058
 
                        }
3059
 
                        ndr->flags = _flags_save_string;
3060
 
                }
3061
 
                {
3062
 
                        uint32_t _flags_save_string = ndr->flags;
3063
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3064
 
                        if (r->data_type) {
3065
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3066
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3067
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3068
 
                        }
3069
 
                        ndr->flags = _flags_save_string;
3070
 
                }
3071
 
                {
3072
 
                        uint32_t _flags_save_string = ndr->flags;
3073
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3074
 
                        if (r->text_status) {
3075
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3076
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3077
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3078
 
                        }
3079
 
                        ndr->flags = _flags_save_string;
3080
 
                }
3081
 
        }
3082
 
        return NDR_ERR_SUCCESS;
3083
 
}
3084
 
 
3085
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3086
 
{
3087
 
        uint32_t _ptr_printer_name;
3088
 
        TALLOC_CTX *_mem_save_printer_name_0;
3089
 
        uint32_t _ptr_server_name;
3090
 
        TALLOC_CTX *_mem_save_server_name_0;
3091
 
        uint32_t _ptr_user_name;
3092
 
        TALLOC_CTX *_mem_save_user_name_0;
3093
 
        uint32_t _ptr_document_name;
3094
 
        TALLOC_CTX *_mem_save_document_name_0;
3095
 
        uint32_t _ptr_data_type;
3096
 
        TALLOC_CTX *_mem_save_data_type_0;
3097
 
        uint32_t _ptr_text_status;
3098
 
        TALLOC_CTX *_mem_save_text_status_0;
3099
 
        if (ndr_flags & NDR_SCALARS) {
3100
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
3101
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3102
 
                {
3103
 
                        uint32_t _flags_save_string = ndr->flags;
3104
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3105
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3106
 
                        if (_ptr_printer_name) {
3107
 
                                NDR_PULL_ALLOC(ndr, r->printer_name);
3108
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3109
 
                        } else {
3110
 
                                r->printer_name = NULL;
3111
 
                        }
3112
 
                        ndr->flags = _flags_save_string;
3113
 
                }
3114
 
                {
3115
 
                        uint32_t _flags_save_string = ndr->flags;
3116
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3117
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3118
 
                        if (_ptr_server_name) {
3119
 
                                NDR_PULL_ALLOC(ndr, r->server_name);
3120
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3121
 
                        } else {
3122
 
                                r->server_name = NULL;
3123
 
                        }
3124
 
                        ndr->flags = _flags_save_string;
3125
 
                }
3126
 
                {
3127
 
                        uint32_t _flags_save_string = ndr->flags;
3128
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3129
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3130
 
                        if (_ptr_user_name) {
3131
 
                                NDR_PULL_ALLOC(ndr, r->user_name);
3132
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3133
 
                        } else {
3134
 
                                r->user_name = NULL;
3135
 
                        }
3136
 
                        ndr->flags = _flags_save_string;
3137
 
                }
3138
 
                {
3139
 
                        uint32_t _flags_save_string = ndr->flags;
3140
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3141
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3142
 
                        if (_ptr_document_name) {
3143
 
                                NDR_PULL_ALLOC(ndr, r->document_name);
3144
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3145
 
                        } else {
3146
 
                                r->document_name = NULL;
3147
 
                        }
3148
 
                        ndr->flags = _flags_save_string;
3149
 
                }
3150
 
                {
3151
 
                        uint32_t _flags_save_string = ndr->flags;
3152
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3153
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3154
 
                        if (_ptr_data_type) {
3155
 
                                NDR_PULL_ALLOC(ndr, r->data_type);
3156
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3157
 
                        } else {
3158
 
                                r->data_type = NULL;
3159
 
                        }
3160
 
                        ndr->flags = _flags_save_string;
3161
 
                }
3162
 
                {
3163
 
                        uint32_t _flags_save_string = ndr->flags;
3164
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3165
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3166
 
                        if (_ptr_text_status) {
3167
 
                                NDR_PULL_ALLOC(ndr, r->text_status);
3168
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3169
 
                        } else {
3170
 
                                r->text_status = NULL;
3171
 
                        }
3172
 
                        ndr->flags = _flags_save_string;
3173
 
                }
3174
 
                NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3175
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3176
 
                if (r->priority > 99) {
3177
 
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3178
 
                }
3179
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3180
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3181
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3182
 
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3183
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3184
 
        }
3185
 
        if (ndr_flags & NDR_BUFFERS) {
3186
 
                {
3187
 
                        uint32_t _flags_save_string = ndr->flags;
3188
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3189
 
                        if (r->printer_name) {
3190
 
                                uint32_t _relative_save_offset;
3191
 
                                _relative_save_offset = ndr->offset;
3192
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3193
 
                                _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3194
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3195
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3196
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3197
 
                                ndr->offset = _relative_save_offset;
3198
 
                        }
3199
 
                        ndr->flags = _flags_save_string;
3200
 
                }
3201
 
                {
3202
 
                        uint32_t _flags_save_string = ndr->flags;
3203
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3204
 
                        if (r->server_name) {
3205
 
                                uint32_t _relative_save_offset;
3206
 
                                _relative_save_offset = ndr->offset;
3207
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3208
 
                                _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3209
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3210
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3211
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3212
 
                                ndr->offset = _relative_save_offset;
3213
 
                        }
3214
 
                        ndr->flags = _flags_save_string;
3215
 
                }
3216
 
                {
3217
 
                        uint32_t _flags_save_string = ndr->flags;
3218
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3219
 
                        if (r->user_name) {
3220
 
                                uint32_t _relative_save_offset;
3221
 
                                _relative_save_offset = ndr->offset;
3222
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3223
 
                                _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3224
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3225
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3226
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3227
 
                                ndr->offset = _relative_save_offset;
3228
 
                        }
3229
 
                        ndr->flags = _flags_save_string;
3230
 
                }
3231
 
                {
3232
 
                        uint32_t _flags_save_string = ndr->flags;
3233
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3234
 
                        if (r->document_name) {
3235
 
                                uint32_t _relative_save_offset;
3236
 
                                _relative_save_offset = ndr->offset;
3237
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3238
 
                                _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3239
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3240
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3241
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3242
 
                                ndr->offset = _relative_save_offset;
3243
 
                        }
3244
 
                        ndr->flags = _flags_save_string;
3245
 
                }
3246
 
                {
3247
 
                        uint32_t _flags_save_string = ndr->flags;
3248
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3249
 
                        if (r->data_type) {
3250
 
                                uint32_t _relative_save_offset;
3251
 
                                _relative_save_offset = ndr->offset;
3252
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3253
 
                                _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3254
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3255
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3256
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3257
 
                                ndr->offset = _relative_save_offset;
3258
 
                        }
3259
 
                        ndr->flags = _flags_save_string;
3260
 
                }
3261
 
                {
3262
 
                        uint32_t _flags_save_string = ndr->flags;
3263
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3264
 
                        if (r->text_status) {
3265
 
                                uint32_t _relative_save_offset;
3266
 
                                _relative_save_offset = ndr->offset;
3267
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3268
 
                                _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3269
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3270
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3271
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3272
 
                                ndr->offset = _relative_save_offset;
3273
 
                        }
3274
 
                        ndr->flags = _flags_save_string;
3275
 
                }
3276
 
        }
3277
 
        return NDR_ERR_SUCCESS;
3278
 
}
3279
 
 
3280
 
_PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3281
 
{
3282
 
        ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3283
 
        ndr->depth++;
3284
 
        ndr_print_uint32(ndr, "job_id", r->job_id);
3285
 
        ndr_print_ptr(ndr, "printer_name", r->printer_name);
3286
 
        ndr->depth++;
3287
 
        if (r->printer_name) {
3288
 
                ndr_print_string(ndr, "printer_name", r->printer_name);
3289
 
        }
3290
 
        ndr->depth--;
3291
 
        ndr_print_ptr(ndr, "server_name", r->server_name);
3292
 
        ndr->depth++;
3293
 
        if (r->server_name) {
3294
 
                ndr_print_string(ndr, "server_name", r->server_name);
3295
 
        }
3296
 
        ndr->depth--;
3297
 
        ndr_print_ptr(ndr, "user_name", r->user_name);
3298
 
        ndr->depth++;
3299
 
        if (r->user_name) {
3300
 
                ndr_print_string(ndr, "user_name", r->user_name);
3301
 
        }
3302
 
        ndr->depth--;
3303
 
        ndr_print_ptr(ndr, "document_name", r->document_name);
3304
 
        ndr->depth++;
3305
 
        if (r->document_name) {
3306
 
                ndr_print_string(ndr, "document_name", r->document_name);
3307
 
        }
3308
 
        ndr->depth--;
3309
 
        ndr_print_ptr(ndr, "data_type", r->data_type);
3310
 
        ndr->depth++;
3311
 
        if (r->data_type) {
3312
 
                ndr_print_string(ndr, "data_type", r->data_type);
3313
 
        }
3314
 
        ndr->depth--;
3315
 
        ndr_print_ptr(ndr, "text_status", r->text_status);
3316
 
        ndr->depth++;
3317
 
        if (r->text_status) {
3318
 
                ndr_print_string(ndr, "text_status", r->text_status);
3319
 
        }
3320
 
        ndr->depth--;
3321
 
        ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3322
 
        ndr_print_uint32(ndr, "priority", r->priority);
3323
 
        ndr_print_uint32(ndr, "position", r->position);
3324
 
        ndr_print_uint32(ndr, "total_pages", r->total_pages);
3325
 
        ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3326
 
        ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3327
 
        ndr->depth--;
3328
 
}
3329
 
 
3330
 
_PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3331
 
{
3332
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3333
 
}
3334
 
 
3335
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3336
 
{
3337
 
        if (ndr_flags & NDR_SCALARS) {
3338
 
                NDR_CHECK(ndr_push_align(ndr, 5));
3339
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3340
 
                {
3341
 
                        uint32_t _flags_save_string = ndr->flags;
3342
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3343
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3344
 
                        ndr->flags = _flags_save_string;
3345
 
                }
3346
 
                {
3347
 
                        uint32_t _flags_save_string = ndr->flags;
3348
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3349
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3350
 
                        ndr->flags = _flags_save_string;
3351
 
                }
3352
 
                {
3353
 
                        uint32_t _flags_save_string = ndr->flags;
3354
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3355
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3356
 
                        ndr->flags = _flags_save_string;
3357
 
                }
3358
 
                {
3359
 
                        uint32_t _flags_save_string = ndr->flags;
3360
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3361
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3362
 
                        ndr->flags = _flags_save_string;
3363
 
                }
3364
 
                {
3365
 
                        uint32_t _flags_save_string = ndr->flags;
3366
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3367
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3368
 
                        ndr->flags = _flags_save_string;
3369
 
                }
3370
 
                {
3371
 
                        uint32_t _flags_save_string = ndr->flags;
3372
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3373
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3374
 
                        ndr->flags = _flags_save_string;
3375
 
                }
3376
 
                {
3377
 
                        uint32_t _flags_save_string = ndr->flags;
3378
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3379
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3380
 
                        ndr->flags = _flags_save_string;
3381
 
                }
3382
 
                {
3383
 
                        uint32_t _flags_save_string = ndr->flags;
3384
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3385
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3386
 
                        ndr->flags = _flags_save_string;
3387
 
                }
3388
 
                {
3389
 
                        uint32_t _flags_save_string = ndr->flags;
3390
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3391
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3392
 
                        ndr->flags = _flags_save_string;
3393
 
                }
3394
 
                {
3395
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3396
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3397
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3398
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
3399
 
                }
3400
 
                {
3401
 
                        uint32_t _flags_save_string = ndr->flags;
3402
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3403
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3404
 
                        ndr->flags = _flags_save_string;
3405
 
                }
3406
 
                {
3407
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3408
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3409
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3410
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
3411
 
                }
3412
 
                NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3413
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3414
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3415
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3416
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3417
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3418
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3419
 
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3420
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3421
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3422
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3423
 
        }
3424
 
        if (ndr_flags & NDR_BUFFERS) {
3425
 
                {
3426
 
                        uint32_t _flags_save_string = ndr->flags;
3427
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3428
 
                        if (r->printer_name) {
3429
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3430
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3431
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3432
 
                        }
3433
 
                        ndr->flags = _flags_save_string;
3434
 
                }
3435
 
                {
3436
 
                        uint32_t _flags_save_string = ndr->flags;
3437
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3438
 
                        if (r->server_name) {
3439
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3440
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3441
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3442
 
                        }
3443
 
                        ndr->flags = _flags_save_string;
3444
 
                }
3445
 
                {
3446
 
                        uint32_t _flags_save_string = ndr->flags;
3447
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3448
 
                        if (r->user_name) {
3449
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3450
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3451
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3452
 
                        }
3453
 
                        ndr->flags = _flags_save_string;
3454
 
                }
3455
 
                {
3456
 
                        uint32_t _flags_save_string = ndr->flags;
3457
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3458
 
                        if (r->document_name) {
3459
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3460
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3461
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3462
 
                        }
3463
 
                        ndr->flags = _flags_save_string;
3464
 
                }
3465
 
                {
3466
 
                        uint32_t _flags_save_string = ndr->flags;
3467
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3468
 
                        if (r->notify_name) {
3469
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
3470
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3471
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
3472
 
                        }
3473
 
                        ndr->flags = _flags_save_string;
3474
 
                }
3475
 
                {
3476
 
                        uint32_t _flags_save_string = ndr->flags;
3477
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3478
 
                        if (r->data_type) {
3479
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3480
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3481
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3482
 
                        }
3483
 
                        ndr->flags = _flags_save_string;
3484
 
                }
3485
 
                {
3486
 
                        uint32_t _flags_save_string = ndr->flags;
3487
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3488
 
                        if (r->print_processor) {
3489
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
3490
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3491
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
3492
 
                        }
3493
 
                        ndr->flags = _flags_save_string;
3494
 
                }
3495
 
                {
3496
 
                        uint32_t _flags_save_string = ndr->flags;
3497
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3498
 
                        if (r->parameters) {
3499
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
3500
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3501
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
3502
 
                        }
3503
 
                        ndr->flags = _flags_save_string;
3504
 
                }
3505
 
                {
3506
 
                        uint32_t _flags_save_string = ndr->flags;
3507
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3508
 
                        if (r->driver_name) {
3509
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
3510
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3511
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
3512
 
                        }
3513
 
                        ndr->flags = _flags_save_string;
3514
 
                }
3515
 
                {
3516
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3517
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3518
 
                        if (r->devmode) {
3519
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
3520
 
                                {
3521
 
                                        struct ndr_push *_ndr_devmode;
3522
 
                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3523
 
                                        NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3524
 
                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
3525
 
                                }
3526
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
3527
 
                        }
3528
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
3529
 
                }
3530
 
                {
3531
 
                        uint32_t _flags_save_string = ndr->flags;
3532
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3533
 
                        if (r->text_status) {
3534
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3535
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3536
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3537
 
                        }
3538
 
                        ndr->flags = _flags_save_string;
3539
 
                }
3540
 
                {
3541
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3542
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3543
 
                        if (r->secdesc) {
3544
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
3545
 
                                {
3546
 
                                        struct ndr_push *_ndr_secdesc;
3547
 
                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3548
 
                                        NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3549
 
                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3550
 
                                }
3551
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
3552
 
                        }
3553
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
3554
 
                }
3555
 
        }
3556
 
        return NDR_ERR_SUCCESS;
3557
 
}
3558
 
 
3559
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3560
 
{
3561
 
        uint32_t _ptr_printer_name;
3562
 
        TALLOC_CTX *_mem_save_printer_name_0;
3563
 
        uint32_t _ptr_server_name;
3564
 
        TALLOC_CTX *_mem_save_server_name_0;
3565
 
        uint32_t _ptr_user_name;
3566
 
        TALLOC_CTX *_mem_save_user_name_0;
3567
 
        uint32_t _ptr_document_name;
3568
 
        TALLOC_CTX *_mem_save_document_name_0;
3569
 
        uint32_t _ptr_notify_name;
3570
 
        TALLOC_CTX *_mem_save_notify_name_0;
3571
 
        uint32_t _ptr_data_type;
3572
 
        TALLOC_CTX *_mem_save_data_type_0;
3573
 
        uint32_t _ptr_print_processor;
3574
 
        TALLOC_CTX *_mem_save_print_processor_0;
3575
 
        uint32_t _ptr_parameters;
3576
 
        TALLOC_CTX *_mem_save_parameters_0;
3577
 
        uint32_t _ptr_driver_name;
3578
 
        TALLOC_CTX *_mem_save_driver_name_0;
3579
 
        uint32_t _ptr_devmode;
3580
 
        TALLOC_CTX *_mem_save_devmode_0;
3581
 
        uint32_t _ptr_text_status;
3582
 
        TALLOC_CTX *_mem_save_text_status_0;
3583
 
        uint32_t _ptr_secdesc;
3584
 
        TALLOC_CTX *_mem_save_secdesc_0;
3585
 
        if (ndr_flags & NDR_SCALARS) {
3586
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
3587
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3588
 
                {
3589
 
                        uint32_t _flags_save_string = ndr->flags;
3590
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3591
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3592
 
                        if (_ptr_printer_name) {
3593
 
                                NDR_PULL_ALLOC(ndr, r->printer_name);
3594
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3595
 
                        } else {
3596
 
                                r->printer_name = NULL;
3597
 
                        }
3598
 
                        ndr->flags = _flags_save_string;
3599
 
                }
3600
 
                {
3601
 
                        uint32_t _flags_save_string = ndr->flags;
3602
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3603
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3604
 
                        if (_ptr_server_name) {
3605
 
                                NDR_PULL_ALLOC(ndr, r->server_name);
3606
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3607
 
                        } else {
3608
 
                                r->server_name = NULL;
3609
 
                        }
3610
 
                        ndr->flags = _flags_save_string;
3611
 
                }
3612
 
                {
3613
 
                        uint32_t _flags_save_string = ndr->flags;
3614
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3615
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3616
 
                        if (_ptr_user_name) {
3617
 
                                NDR_PULL_ALLOC(ndr, r->user_name);
3618
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3619
 
                        } else {
3620
 
                                r->user_name = NULL;
3621
 
                        }
3622
 
                        ndr->flags = _flags_save_string;
3623
 
                }
3624
 
                {
3625
 
                        uint32_t _flags_save_string = ndr->flags;
3626
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3627
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3628
 
                        if (_ptr_document_name) {
3629
 
                                NDR_PULL_ALLOC(ndr, r->document_name);
3630
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3631
 
                        } else {
3632
 
                                r->document_name = NULL;
3633
 
                        }
3634
 
                        ndr->flags = _flags_save_string;
3635
 
                }
3636
 
                {
3637
 
                        uint32_t _flags_save_string = ndr->flags;
3638
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3639
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3640
 
                        if (_ptr_notify_name) {
3641
 
                                NDR_PULL_ALLOC(ndr, r->notify_name);
3642
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3643
 
                        } else {
3644
 
                                r->notify_name = NULL;
3645
 
                        }
3646
 
                        ndr->flags = _flags_save_string;
3647
 
                }
3648
 
                {
3649
 
                        uint32_t _flags_save_string = ndr->flags;
3650
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3651
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3652
 
                        if (_ptr_data_type) {
3653
 
                                NDR_PULL_ALLOC(ndr, r->data_type);
3654
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3655
 
                        } else {
3656
 
                                r->data_type = NULL;
3657
 
                        }
3658
 
                        ndr->flags = _flags_save_string;
3659
 
                }
3660
 
                {
3661
 
                        uint32_t _flags_save_string = ndr->flags;
3662
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3663
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3664
 
                        if (_ptr_print_processor) {
3665
 
                                NDR_PULL_ALLOC(ndr, r->print_processor);
3666
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3667
 
                        } else {
3668
 
                                r->print_processor = NULL;
3669
 
                        }
3670
 
                        ndr->flags = _flags_save_string;
3671
 
                }
3672
 
                {
3673
 
                        uint32_t _flags_save_string = ndr->flags;
3674
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3675
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3676
 
                        if (_ptr_parameters) {
3677
 
                                NDR_PULL_ALLOC(ndr, r->parameters);
3678
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3679
 
                        } else {
3680
 
                                r->parameters = NULL;
3681
 
                        }
3682
 
                        ndr->flags = _flags_save_string;
3683
 
                }
3684
 
                {
3685
 
                        uint32_t _flags_save_string = ndr->flags;
3686
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3687
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3688
 
                        if (_ptr_driver_name) {
3689
 
                                NDR_PULL_ALLOC(ndr, r->driver_name);
3690
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3691
 
                        } else {
3692
 
                                r->driver_name = NULL;
3693
 
                        }
3694
 
                        ndr->flags = _flags_save_string;
3695
 
                }
3696
 
                {
3697
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3698
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3699
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3700
 
                        if (_ptr_devmode) {
3701
 
                                NDR_PULL_ALLOC(ndr, r->devmode);
3702
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3703
 
                        } else {
3704
 
                                r->devmode = NULL;
3705
 
                        }
3706
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
3707
 
                }
3708
 
                {
3709
 
                        uint32_t _flags_save_string = ndr->flags;
3710
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3711
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3712
 
                        if (_ptr_text_status) {
3713
 
                                NDR_PULL_ALLOC(ndr, r->text_status);
3714
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3715
 
                        } else {
3716
 
                                r->text_status = NULL;
3717
 
                        }
3718
 
                        ndr->flags = _flags_save_string;
3719
 
                }
3720
 
                {
3721
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3722
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3723
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3724
 
                        if (_ptr_secdesc) {
3725
 
                                NDR_PULL_ALLOC(ndr, r->secdesc);
3726
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3727
 
                        } else {
3728
 
                                r->secdesc = NULL;
3729
 
                        }
3730
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
3731
 
                }
3732
 
                NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3733
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3734
 
                if (r->priority > 99) {
3735
 
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3736
 
                }
3737
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3738
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3739
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3740
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3741
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3742
 
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3743
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3744
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3745
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3746
 
        }
3747
 
        if (ndr_flags & NDR_BUFFERS) {
3748
 
                {
3749
 
                        uint32_t _flags_save_string = ndr->flags;
3750
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3751
 
                        if (r->printer_name) {
3752
 
                                uint32_t _relative_save_offset;
3753
 
                                _relative_save_offset = ndr->offset;
3754
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3755
 
                                _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3756
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3757
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3758
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3759
 
                                ndr->offset = _relative_save_offset;
3760
 
                        }
3761
 
                        ndr->flags = _flags_save_string;
3762
 
                }
3763
 
                {
3764
 
                        uint32_t _flags_save_string = ndr->flags;
3765
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3766
 
                        if (r->server_name) {
3767
 
                                uint32_t _relative_save_offset;
3768
 
                                _relative_save_offset = ndr->offset;
3769
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3770
 
                                _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3771
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3772
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3773
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3774
 
                                ndr->offset = _relative_save_offset;
3775
 
                        }
3776
 
                        ndr->flags = _flags_save_string;
3777
 
                }
3778
 
                {
3779
 
                        uint32_t _flags_save_string = ndr->flags;
3780
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3781
 
                        if (r->user_name) {
3782
 
                                uint32_t _relative_save_offset;
3783
 
                                _relative_save_offset = ndr->offset;
3784
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3785
 
                                _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3786
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3787
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3788
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3789
 
                                ndr->offset = _relative_save_offset;
3790
 
                        }
3791
 
                        ndr->flags = _flags_save_string;
3792
 
                }
3793
 
                {
3794
 
                        uint32_t _flags_save_string = ndr->flags;
3795
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3796
 
                        if (r->document_name) {
3797
 
                                uint32_t _relative_save_offset;
3798
 
                                _relative_save_offset = ndr->offset;
3799
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3800
 
                                _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3801
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3802
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3803
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3804
 
                                ndr->offset = _relative_save_offset;
3805
 
                        }
3806
 
                        ndr->flags = _flags_save_string;
3807
 
                }
3808
 
                {
3809
 
                        uint32_t _flags_save_string = ndr->flags;
3810
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3811
 
                        if (r->notify_name) {
3812
 
                                uint32_t _relative_save_offset;
3813
 
                                _relative_save_offset = ndr->offset;
3814
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3815
 
                                _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3816
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3817
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3818
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3819
 
                                ndr->offset = _relative_save_offset;
3820
 
                        }
3821
 
                        ndr->flags = _flags_save_string;
3822
 
                }
3823
 
                {
3824
 
                        uint32_t _flags_save_string = ndr->flags;
3825
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3826
 
                        if (r->data_type) {
3827
 
                                uint32_t _relative_save_offset;
3828
 
                                _relative_save_offset = ndr->offset;
3829
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3830
 
                                _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3831
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3832
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3833
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3834
 
                                ndr->offset = _relative_save_offset;
3835
 
                        }
3836
 
                        ndr->flags = _flags_save_string;
3837
 
                }
3838
 
                {
3839
 
                        uint32_t _flags_save_string = ndr->flags;
3840
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3841
 
                        if (r->print_processor) {
3842
 
                                uint32_t _relative_save_offset;
3843
 
                                _relative_save_offset = ndr->offset;
3844
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3845
 
                                _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3846
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3847
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3848
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3849
 
                                ndr->offset = _relative_save_offset;
3850
 
                        }
3851
 
                        ndr->flags = _flags_save_string;
3852
 
                }
3853
 
                {
3854
 
                        uint32_t _flags_save_string = ndr->flags;
3855
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3856
 
                        if (r->parameters) {
3857
 
                                uint32_t _relative_save_offset;
3858
 
                                _relative_save_offset = ndr->offset;
3859
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3860
 
                                _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3861
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3862
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3863
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3864
 
                                ndr->offset = _relative_save_offset;
3865
 
                        }
3866
 
                        ndr->flags = _flags_save_string;
3867
 
                }
3868
 
                {
3869
 
                        uint32_t _flags_save_string = ndr->flags;
3870
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3871
 
                        if (r->driver_name) {
3872
 
                                uint32_t _relative_save_offset;
3873
 
                                _relative_save_offset = ndr->offset;
3874
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3875
 
                                _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3876
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3877
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3878
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3879
 
                                ndr->offset = _relative_save_offset;
3880
 
                        }
3881
 
                        ndr->flags = _flags_save_string;
3882
 
                }
3883
 
                {
3884
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3885
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3886
 
                        if (r->devmode) {
3887
 
                                uint32_t _relative_save_offset;
3888
 
                                _relative_save_offset = ndr->offset;
3889
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3890
 
                                _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3891
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3892
 
                                {
3893
 
                                        struct ndr_pull *_ndr_devmode;
3894
 
                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3895
 
                                        NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3896
 
                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
3897
 
                                }
3898
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3899
 
                                ndr->offset = _relative_save_offset;
3900
 
                        }
3901
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
3902
 
                }
3903
 
                {
3904
 
                        uint32_t _flags_save_string = ndr->flags;
3905
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
3906
 
                        if (r->text_status) {
3907
 
                                uint32_t _relative_save_offset;
3908
 
                                _relative_save_offset = ndr->offset;
3909
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3910
 
                                _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3911
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3912
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3913
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3914
 
                                ndr->offset = _relative_save_offset;
3915
 
                        }
3916
 
                        ndr->flags = _flags_save_string;
3917
 
                }
3918
 
                {
3919
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3920
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3921
 
                        if (r->secdesc) {
3922
 
                                uint32_t _relative_save_offset;
3923
 
                                _relative_save_offset = ndr->offset;
3924
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3925
 
                                _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3926
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3927
 
                                {
3928
 
                                        struct ndr_pull *_ndr_secdesc;
3929
 
                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3930
 
                                        NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3931
 
                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3932
 
                                }
3933
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3934
 
                                ndr->offset = _relative_save_offset;
3935
 
                        }
3936
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
3937
 
                }
3938
 
        }
3939
 
        return NDR_ERR_SUCCESS;
3940
 
}
3941
 
 
3942
 
_PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3943
 
{
3944
 
        ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3945
 
        ndr->depth++;
3946
 
        ndr_print_uint32(ndr, "job_id", r->job_id);
3947
 
        ndr_print_ptr(ndr, "printer_name", r->printer_name);
3948
 
        ndr->depth++;
3949
 
        if (r->printer_name) {
3950
 
                ndr_print_string(ndr, "printer_name", r->printer_name);
3951
 
        }
3952
 
        ndr->depth--;
3953
 
        ndr_print_ptr(ndr, "server_name", r->server_name);
3954
 
        ndr->depth++;
3955
 
        if (r->server_name) {
3956
 
                ndr_print_string(ndr, "server_name", r->server_name);
3957
 
        }
3958
 
        ndr->depth--;
3959
 
        ndr_print_ptr(ndr, "user_name", r->user_name);
3960
 
        ndr->depth++;
3961
 
        if (r->user_name) {
3962
 
                ndr_print_string(ndr, "user_name", r->user_name);
3963
 
        }
3964
 
        ndr->depth--;
3965
 
        ndr_print_ptr(ndr, "document_name", r->document_name);
3966
 
        ndr->depth++;
3967
 
        if (r->document_name) {
3968
 
                ndr_print_string(ndr, "document_name", r->document_name);
3969
 
        }
3970
 
        ndr->depth--;
3971
 
        ndr_print_ptr(ndr, "notify_name", r->notify_name);
3972
 
        ndr->depth++;
3973
 
        if (r->notify_name) {
3974
 
                ndr_print_string(ndr, "notify_name", r->notify_name);
3975
 
        }
3976
 
        ndr->depth--;
3977
 
        ndr_print_ptr(ndr, "data_type", r->data_type);
3978
 
        ndr->depth++;
3979
 
        if (r->data_type) {
3980
 
                ndr_print_string(ndr, "data_type", r->data_type);
3981
 
        }
3982
 
        ndr->depth--;
3983
 
        ndr_print_ptr(ndr, "print_processor", r->print_processor);
3984
 
        ndr->depth++;
3985
 
        if (r->print_processor) {
3986
 
                ndr_print_string(ndr, "print_processor", r->print_processor);
3987
 
        }
3988
 
        ndr->depth--;
3989
 
        ndr_print_ptr(ndr, "parameters", r->parameters);
3990
 
        ndr->depth++;
3991
 
        if (r->parameters) {
3992
 
                ndr_print_string(ndr, "parameters", r->parameters);
3993
 
        }
3994
 
        ndr->depth--;
3995
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
3996
 
        ndr->depth++;
3997
 
        if (r->driver_name) {
3998
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
3999
 
        }
4000
 
        ndr->depth--;
4001
 
        ndr_print_ptr(ndr, "devmode", r->devmode);
4002
 
        ndr->depth++;
4003
 
        if (r->devmode) {
4004
 
                ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4005
 
        }
4006
 
        ndr->depth--;
4007
 
        ndr_print_ptr(ndr, "text_status", r->text_status);
4008
 
        ndr->depth++;
4009
 
        if (r->text_status) {
4010
 
                ndr_print_string(ndr, "text_status", r->text_status);
4011
 
        }
4012
 
        ndr->depth--;
4013
 
        ndr_print_ptr(ndr, "secdesc", r->secdesc);
4014
 
        ndr->depth++;
4015
 
        if (r->secdesc) {
4016
 
                ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
4017
 
        }
4018
 
        ndr->depth--;
4019
 
        ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4020
 
        ndr_print_uint32(ndr, "priority", r->priority);
4021
 
        ndr_print_uint32(ndr, "position", r->position);
4022
 
        ndr_print_uint32(ndr, "start_time", r->start_time);
4023
 
        ndr_print_uint32(ndr, "until_time", r->until_time);
4024
 
        ndr_print_uint32(ndr, "total_pages", r->total_pages);
4025
 
        ndr_print_uint32(ndr, "size", r->size);
4026
 
        ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4027
 
        ndr_print_uint32(ndr, "time", r->time);
4028
 
        ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4029
 
        ndr->depth--;
4030
 
}
4031
 
 
4032
 
_PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4033
 
{
4034
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4035
 
}
4036
 
 
4037
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4038
 
{
4039
 
        if (ndr_flags & NDR_SCALARS) {
4040
 
                NDR_CHECK(ndr_push_align(ndr, 4));
4041
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4042
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4043
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4044
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4045
 
        }
4046
 
        if (ndr_flags & NDR_BUFFERS) {
4047
 
        }
4048
 
        return NDR_ERR_SUCCESS;
4049
 
}
4050
 
 
4051
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4052
 
{
4053
 
        if (ndr_flags & NDR_SCALARS) {
4054
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
4055
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4056
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4057
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4058
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4059
 
        }
4060
 
        if (ndr_flags & NDR_BUFFERS) {
4061
 
        }
4062
 
        return NDR_ERR_SUCCESS;
4063
 
}
4064
 
 
4065
 
_PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4066
 
{
4067
 
        ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4068
 
        ndr->depth++;
4069
 
        ndr_print_uint32(ndr, "job_id", r->job_id);
4070
 
        ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4071
 
        ndr_print_uint32(ndr, "reserved", r->reserved);
4072
 
        ndr->depth--;
4073
 
}
4074
 
 
4075
 
_PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4076
 
{
4077
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4078
 
}
4079
 
 
4080
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4081
 
{
4082
 
        if (ndr_flags & NDR_SCALARS) {
4083
 
                NDR_CHECK(ndr_push_align(ndr, 5));
4084
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4085
 
                {
4086
 
                        uint32_t _flags_save_string = ndr->flags;
4087
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4088
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4089
 
                        ndr->flags = _flags_save_string;
4090
 
                }
4091
 
                {
4092
 
                        uint32_t _flags_save_string = ndr->flags;
4093
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4094
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4095
 
                        ndr->flags = _flags_save_string;
4096
 
                }
4097
 
                {
4098
 
                        uint32_t _flags_save_string = ndr->flags;
4099
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4100
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4101
 
                        ndr->flags = _flags_save_string;
4102
 
                }
4103
 
                {
4104
 
                        uint32_t _flags_save_string = ndr->flags;
4105
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4106
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4107
 
                        ndr->flags = _flags_save_string;
4108
 
                }
4109
 
                {
4110
 
                        uint32_t _flags_save_string = ndr->flags;
4111
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4112
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4113
 
                        ndr->flags = _flags_save_string;
4114
 
                }
4115
 
                {
4116
 
                        uint32_t _flags_save_string = ndr->flags;
4117
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4118
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4119
 
                        ndr->flags = _flags_save_string;
4120
 
                }
4121
 
                {
4122
 
                        uint32_t _flags_save_string = ndr->flags;
4123
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4124
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4125
 
                        ndr->flags = _flags_save_string;
4126
 
                }
4127
 
                {
4128
 
                        uint32_t _flags_save_string = ndr->flags;
4129
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4130
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4131
 
                        ndr->flags = _flags_save_string;
4132
 
                }
4133
 
                {
4134
 
                        uint32_t _flags_save_string = ndr->flags;
4135
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4136
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4137
 
                        ndr->flags = _flags_save_string;
4138
 
                }
4139
 
                {
4140
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4141
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4142
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4143
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
4144
 
                }
4145
 
                {
4146
 
                        uint32_t _flags_save_string = ndr->flags;
4147
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4148
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4149
 
                        ndr->flags = _flags_save_string;
4150
 
                }
4151
 
                {
4152
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4153
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4154
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4155
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
4156
 
                }
4157
 
                NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4158
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4159
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4160
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4161
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4162
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4163
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4164
 
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4165
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4166
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4167
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4168
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4169
 
        }
4170
 
        if (ndr_flags & NDR_BUFFERS) {
4171
 
                {
4172
 
                        uint32_t _flags_save_string = ndr->flags;
4173
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4174
 
                        if (r->printer_name) {
4175
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
4176
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4177
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
4178
 
                        }
4179
 
                        ndr->flags = _flags_save_string;
4180
 
                }
4181
 
                {
4182
 
                        uint32_t _flags_save_string = ndr->flags;
4183
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4184
 
                        if (r->server_name) {
4185
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
4186
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4187
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
4188
 
                        }
4189
 
                        ndr->flags = _flags_save_string;
4190
 
                }
4191
 
                {
4192
 
                        uint32_t _flags_save_string = ndr->flags;
4193
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4194
 
                        if (r->user_name) {
4195
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
4196
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4197
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
4198
 
                        }
4199
 
                        ndr->flags = _flags_save_string;
4200
 
                }
4201
 
                {
4202
 
                        uint32_t _flags_save_string = ndr->flags;
4203
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4204
 
                        if (r->document_name) {
4205
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
4206
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4207
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
4208
 
                        }
4209
 
                        ndr->flags = _flags_save_string;
4210
 
                }
4211
 
                {
4212
 
                        uint32_t _flags_save_string = ndr->flags;
4213
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4214
 
                        if (r->notify_name) {
4215
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
4216
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4217
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
4218
 
                        }
4219
 
                        ndr->flags = _flags_save_string;
4220
 
                }
4221
 
                {
4222
 
                        uint32_t _flags_save_string = ndr->flags;
4223
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4224
 
                        if (r->data_type) {
4225
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
4226
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4227
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
4228
 
                        }
4229
 
                        ndr->flags = _flags_save_string;
4230
 
                }
4231
 
                {
4232
 
                        uint32_t _flags_save_string = ndr->flags;
4233
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4234
 
                        if (r->print_processor) {
4235
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
4236
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4237
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
4238
 
                        }
4239
 
                        ndr->flags = _flags_save_string;
4240
 
                }
4241
 
                {
4242
 
                        uint32_t _flags_save_string = ndr->flags;
4243
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4244
 
                        if (r->parameters) {
4245
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
4246
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4247
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
4248
 
                        }
4249
 
                        ndr->flags = _flags_save_string;
4250
 
                }
4251
 
                {
4252
 
                        uint32_t _flags_save_string = ndr->flags;
4253
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4254
 
                        if (r->driver_name) {
4255
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
4256
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4257
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
4258
 
                        }
4259
 
                        ndr->flags = _flags_save_string;
4260
 
                }
4261
 
                {
4262
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4263
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4264
 
                        if (r->devmode) {
4265
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
4266
 
                                {
4267
 
                                        struct ndr_push *_ndr_devmode;
4268
 
                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4269
 
                                        NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4270
 
                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
4271
 
                                }
4272
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
4273
 
                        }
4274
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
4275
 
                }
4276
 
                {
4277
 
                        uint32_t _flags_save_string = ndr->flags;
4278
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4279
 
                        if (r->text_status) {
4280
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
4281
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4282
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
4283
 
                        }
4284
 
                        ndr->flags = _flags_save_string;
4285
 
                }
4286
 
                {
4287
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4288
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4289
 
                        if (r->secdesc) {
4290
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
4291
 
                                {
4292
 
                                        struct ndr_push *_ndr_secdesc;
4293
 
                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4294
 
                                        NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4295
 
                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4296
 
                                }
4297
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
4298
 
                        }
4299
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
4300
 
                }
4301
 
        }
4302
 
        return NDR_ERR_SUCCESS;
4303
 
}
4304
 
 
4305
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4306
 
{
4307
 
        uint32_t _ptr_printer_name;
4308
 
        TALLOC_CTX *_mem_save_printer_name_0;
4309
 
        uint32_t _ptr_server_name;
4310
 
        TALLOC_CTX *_mem_save_server_name_0;
4311
 
        uint32_t _ptr_user_name;
4312
 
        TALLOC_CTX *_mem_save_user_name_0;
4313
 
        uint32_t _ptr_document_name;
4314
 
        TALLOC_CTX *_mem_save_document_name_0;
4315
 
        uint32_t _ptr_notify_name;
4316
 
        TALLOC_CTX *_mem_save_notify_name_0;
4317
 
        uint32_t _ptr_data_type;
4318
 
        TALLOC_CTX *_mem_save_data_type_0;
4319
 
        uint32_t _ptr_print_processor;
4320
 
        TALLOC_CTX *_mem_save_print_processor_0;
4321
 
        uint32_t _ptr_parameters;
4322
 
        TALLOC_CTX *_mem_save_parameters_0;
4323
 
        uint32_t _ptr_driver_name;
4324
 
        TALLOC_CTX *_mem_save_driver_name_0;
4325
 
        uint32_t _ptr_devmode;
4326
 
        TALLOC_CTX *_mem_save_devmode_0;
4327
 
        uint32_t _ptr_text_status;
4328
 
        TALLOC_CTX *_mem_save_text_status_0;
4329
 
        uint32_t _ptr_secdesc;
4330
 
        TALLOC_CTX *_mem_save_secdesc_0;
4331
 
        if (ndr_flags & NDR_SCALARS) {
4332
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
4333
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4334
 
                {
4335
 
                        uint32_t _flags_save_string = ndr->flags;
4336
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4337
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4338
 
                        if (_ptr_printer_name) {
4339
 
                                NDR_PULL_ALLOC(ndr, r->printer_name);
4340
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4341
 
                        } else {
4342
 
                                r->printer_name = NULL;
4343
 
                        }
4344
 
                        ndr->flags = _flags_save_string;
4345
 
                }
4346
 
                {
4347
 
                        uint32_t _flags_save_string = ndr->flags;
4348
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4349
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4350
 
                        if (_ptr_server_name) {
4351
 
                                NDR_PULL_ALLOC(ndr, r->server_name);
4352
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4353
 
                        } else {
4354
 
                                r->server_name = NULL;
4355
 
                        }
4356
 
                        ndr->flags = _flags_save_string;
4357
 
                }
4358
 
                {
4359
 
                        uint32_t _flags_save_string = ndr->flags;
4360
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4361
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4362
 
                        if (_ptr_user_name) {
4363
 
                                NDR_PULL_ALLOC(ndr, r->user_name);
4364
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4365
 
                        } else {
4366
 
                                r->user_name = NULL;
4367
 
                        }
4368
 
                        ndr->flags = _flags_save_string;
4369
 
                }
4370
 
                {
4371
 
                        uint32_t _flags_save_string = ndr->flags;
4372
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4373
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4374
 
                        if (_ptr_document_name) {
4375
 
                                NDR_PULL_ALLOC(ndr, r->document_name);
4376
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4377
 
                        } else {
4378
 
                                r->document_name = NULL;
4379
 
                        }
4380
 
                        ndr->flags = _flags_save_string;
4381
 
                }
4382
 
                {
4383
 
                        uint32_t _flags_save_string = ndr->flags;
4384
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4385
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4386
 
                        if (_ptr_notify_name) {
4387
 
                                NDR_PULL_ALLOC(ndr, r->notify_name);
4388
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4389
 
                        } else {
4390
 
                                r->notify_name = NULL;
4391
 
                        }
4392
 
                        ndr->flags = _flags_save_string;
4393
 
                }
4394
 
                {
4395
 
                        uint32_t _flags_save_string = ndr->flags;
4396
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4397
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4398
 
                        if (_ptr_data_type) {
4399
 
                                NDR_PULL_ALLOC(ndr, r->data_type);
4400
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4401
 
                        } else {
4402
 
                                r->data_type = NULL;
4403
 
                        }
4404
 
                        ndr->flags = _flags_save_string;
4405
 
                }
4406
 
                {
4407
 
                        uint32_t _flags_save_string = ndr->flags;
4408
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4409
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4410
 
                        if (_ptr_print_processor) {
4411
 
                                NDR_PULL_ALLOC(ndr, r->print_processor);
4412
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4413
 
                        } else {
4414
 
                                r->print_processor = NULL;
4415
 
                        }
4416
 
                        ndr->flags = _flags_save_string;
4417
 
                }
4418
 
                {
4419
 
                        uint32_t _flags_save_string = ndr->flags;
4420
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4421
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4422
 
                        if (_ptr_parameters) {
4423
 
                                NDR_PULL_ALLOC(ndr, r->parameters);
4424
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4425
 
                        } else {
4426
 
                                r->parameters = NULL;
4427
 
                        }
4428
 
                        ndr->flags = _flags_save_string;
4429
 
                }
4430
 
                {
4431
 
                        uint32_t _flags_save_string = ndr->flags;
4432
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4433
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4434
 
                        if (_ptr_driver_name) {
4435
 
                                NDR_PULL_ALLOC(ndr, r->driver_name);
4436
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4437
 
                        } else {
4438
 
                                r->driver_name = NULL;
4439
 
                        }
4440
 
                        ndr->flags = _flags_save_string;
4441
 
                }
4442
 
                {
4443
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4444
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4445
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4446
 
                        if (_ptr_devmode) {
4447
 
                                NDR_PULL_ALLOC(ndr, r->devmode);
4448
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4449
 
                        } else {
4450
 
                                r->devmode = NULL;
4451
 
                        }
4452
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
4453
 
                }
4454
 
                {
4455
 
                        uint32_t _flags_save_string = ndr->flags;
4456
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4457
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4458
 
                        if (_ptr_text_status) {
4459
 
                                NDR_PULL_ALLOC(ndr, r->text_status);
4460
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4461
 
                        } else {
4462
 
                                r->text_status = NULL;
4463
 
                        }
4464
 
                        ndr->flags = _flags_save_string;
4465
 
                }
4466
 
                {
4467
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4468
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4469
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4470
 
                        if (_ptr_secdesc) {
4471
 
                                NDR_PULL_ALLOC(ndr, r->secdesc);
4472
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4473
 
                        } else {
4474
 
                                r->secdesc = NULL;
4475
 
                        }
4476
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
4477
 
                }
4478
 
                NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4479
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4480
 
                if (r->priority > 99) {
4481
 
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4482
 
                }
4483
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4484
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4485
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4486
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4487
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4488
 
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4489
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4490
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4491
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4492
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4493
 
        }
4494
 
        if (ndr_flags & NDR_BUFFERS) {
4495
 
                {
4496
 
                        uint32_t _flags_save_string = ndr->flags;
4497
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4498
 
                        if (r->printer_name) {
4499
 
                                uint32_t _relative_save_offset;
4500
 
                                _relative_save_offset = ndr->offset;
4501
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4502
 
                                _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4503
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4504
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4505
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4506
 
                                ndr->offset = _relative_save_offset;
4507
 
                        }
4508
 
                        ndr->flags = _flags_save_string;
4509
 
                }
4510
 
                {
4511
 
                        uint32_t _flags_save_string = ndr->flags;
4512
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4513
 
                        if (r->server_name) {
4514
 
                                uint32_t _relative_save_offset;
4515
 
                                _relative_save_offset = ndr->offset;
4516
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4517
 
                                _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4518
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4519
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4520
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4521
 
                                ndr->offset = _relative_save_offset;
4522
 
                        }
4523
 
                        ndr->flags = _flags_save_string;
4524
 
                }
4525
 
                {
4526
 
                        uint32_t _flags_save_string = ndr->flags;
4527
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4528
 
                        if (r->user_name) {
4529
 
                                uint32_t _relative_save_offset;
4530
 
                                _relative_save_offset = ndr->offset;
4531
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4532
 
                                _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4533
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4534
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4535
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4536
 
                                ndr->offset = _relative_save_offset;
4537
 
                        }
4538
 
                        ndr->flags = _flags_save_string;
4539
 
                }
4540
 
                {
4541
 
                        uint32_t _flags_save_string = ndr->flags;
4542
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4543
 
                        if (r->document_name) {
4544
 
                                uint32_t _relative_save_offset;
4545
 
                                _relative_save_offset = ndr->offset;
4546
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4547
 
                                _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4548
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4549
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4550
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4551
 
                                ndr->offset = _relative_save_offset;
4552
 
                        }
4553
 
                        ndr->flags = _flags_save_string;
4554
 
                }
4555
 
                {
4556
 
                        uint32_t _flags_save_string = ndr->flags;
4557
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4558
 
                        if (r->notify_name) {
4559
 
                                uint32_t _relative_save_offset;
4560
 
                                _relative_save_offset = ndr->offset;
4561
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4562
 
                                _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4563
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4564
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4565
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4566
 
                                ndr->offset = _relative_save_offset;
4567
 
                        }
4568
 
                        ndr->flags = _flags_save_string;
4569
 
                }
4570
 
                {
4571
 
                        uint32_t _flags_save_string = ndr->flags;
4572
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4573
 
                        if (r->data_type) {
4574
 
                                uint32_t _relative_save_offset;
4575
 
                                _relative_save_offset = ndr->offset;
4576
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4577
 
                                _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4578
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4579
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4580
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4581
 
                                ndr->offset = _relative_save_offset;
4582
 
                        }
4583
 
                        ndr->flags = _flags_save_string;
4584
 
                }
4585
 
                {
4586
 
                        uint32_t _flags_save_string = ndr->flags;
4587
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4588
 
                        if (r->print_processor) {
4589
 
                                uint32_t _relative_save_offset;
4590
 
                                _relative_save_offset = ndr->offset;
4591
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4592
 
                                _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4593
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4594
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4595
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4596
 
                                ndr->offset = _relative_save_offset;
4597
 
                        }
4598
 
                        ndr->flags = _flags_save_string;
4599
 
                }
4600
 
                {
4601
 
                        uint32_t _flags_save_string = ndr->flags;
4602
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4603
 
                        if (r->parameters) {
4604
 
                                uint32_t _relative_save_offset;
4605
 
                                _relative_save_offset = ndr->offset;
4606
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4607
 
                                _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4608
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4609
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4610
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4611
 
                                ndr->offset = _relative_save_offset;
4612
 
                        }
4613
 
                        ndr->flags = _flags_save_string;
4614
 
                }
4615
 
                {
4616
 
                        uint32_t _flags_save_string = ndr->flags;
4617
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4618
 
                        if (r->driver_name) {
4619
 
                                uint32_t _relative_save_offset;
4620
 
                                _relative_save_offset = ndr->offset;
4621
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4622
 
                                _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4623
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4624
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4625
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4626
 
                                ndr->offset = _relative_save_offset;
4627
 
                        }
4628
 
                        ndr->flags = _flags_save_string;
4629
 
                }
4630
 
                {
4631
 
                        uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4632
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4633
 
                        if (r->devmode) {
4634
 
                                uint32_t _relative_save_offset;
4635
 
                                _relative_save_offset = ndr->offset;
4636
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4637
 
                                _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4638
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4639
 
                                {
4640
 
                                        struct ndr_pull *_ndr_devmode;
4641
 
                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4642
 
                                        NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4643
 
                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
4644
 
                                }
4645
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4646
 
                                ndr->offset = _relative_save_offset;
4647
 
                        }
4648
 
                        ndr->flags = _flags_save_spoolss_DeviceMode;
4649
 
                }
4650
 
                {
4651
 
                        uint32_t _flags_save_string = ndr->flags;
4652
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
4653
 
                        if (r->text_status) {
4654
 
                                uint32_t _relative_save_offset;
4655
 
                                _relative_save_offset = ndr->offset;
4656
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4657
 
                                _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4658
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4659
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4660
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4661
 
                                ndr->offset = _relative_save_offset;
4662
 
                        }
4663
 
                        ndr->flags = _flags_save_string;
4664
 
                }
4665
 
                {
4666
 
                        uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4667
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4668
 
                        if (r->secdesc) {
4669
 
                                uint32_t _relative_save_offset;
4670
 
                                _relative_save_offset = ndr->offset;
4671
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4672
 
                                _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4673
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4674
 
                                {
4675
 
                                        struct ndr_pull *_ndr_secdesc;
4676
 
                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4677
 
                                        NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4678
 
                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4679
 
                                }
4680
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4681
 
                                ndr->offset = _relative_save_offset;
4682
 
                        }
4683
 
                        ndr->flags = _flags_save_spoolss_security_descriptor;
4684
 
                }
4685
 
        }
4686
 
        return NDR_ERR_SUCCESS;
4687
 
}
4688
 
 
4689
 
_PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4690
 
{
4691
 
        ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4692
 
        ndr->depth++;
4693
 
        ndr_print_uint32(ndr, "job_id", r->job_id);
4694
 
        ndr_print_ptr(ndr, "printer_name", r->printer_name);
4695
 
        ndr->depth++;
4696
 
        if (r->printer_name) {
4697
 
                ndr_print_string(ndr, "printer_name", r->printer_name);
4698
 
        }
4699
 
        ndr->depth--;
4700
 
        ndr_print_ptr(ndr, "server_name", r->server_name);
4701
 
        ndr->depth++;
4702
 
        if (r->server_name) {
4703
 
                ndr_print_string(ndr, "server_name", r->server_name);
4704
 
        }
4705
 
        ndr->depth--;
4706
 
        ndr_print_ptr(ndr, "user_name", r->user_name);
4707
 
        ndr->depth++;
4708
 
        if (r->user_name) {
4709
 
                ndr_print_string(ndr, "user_name", r->user_name);
4710
 
        }
4711
 
        ndr->depth--;
4712
 
        ndr_print_ptr(ndr, "document_name", r->document_name);
4713
 
        ndr->depth++;
4714
 
        if (r->document_name) {
4715
 
                ndr_print_string(ndr, "document_name", r->document_name);
4716
 
        }
4717
 
        ndr->depth--;
4718
 
        ndr_print_ptr(ndr, "notify_name", r->notify_name);
4719
 
        ndr->depth++;
4720
 
        if (r->notify_name) {
4721
 
                ndr_print_string(ndr, "notify_name", r->notify_name);
4722
 
        }
4723
 
        ndr->depth--;
4724
 
        ndr_print_ptr(ndr, "data_type", r->data_type);
4725
 
        ndr->depth++;
4726
 
        if (r->data_type) {
4727
 
                ndr_print_string(ndr, "data_type", r->data_type);
4728
 
        }
4729
 
        ndr->depth--;
4730
 
        ndr_print_ptr(ndr, "print_processor", r->print_processor);
4731
 
        ndr->depth++;
4732
 
        if (r->print_processor) {
4733
 
                ndr_print_string(ndr, "print_processor", r->print_processor);
4734
 
        }
4735
 
        ndr->depth--;
4736
 
        ndr_print_ptr(ndr, "parameters", r->parameters);
4737
 
        ndr->depth++;
4738
 
        if (r->parameters) {
4739
 
                ndr_print_string(ndr, "parameters", r->parameters);
4740
 
        }
4741
 
        ndr->depth--;
4742
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
4743
 
        ndr->depth++;
4744
 
        if (r->driver_name) {
4745
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
4746
 
        }
4747
 
        ndr->depth--;
4748
 
        ndr_print_ptr(ndr, "devmode", r->devmode);
4749
 
        ndr->depth++;
4750
 
        if (r->devmode) {
4751
 
                ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4752
 
        }
4753
 
        ndr->depth--;
4754
 
        ndr_print_ptr(ndr, "text_status", r->text_status);
4755
 
        ndr->depth++;
4756
 
        if (r->text_status) {
4757
 
                ndr_print_string(ndr, "text_status", r->text_status);
4758
 
        }
4759
 
        ndr->depth--;
4760
 
        ndr_print_ptr(ndr, "secdesc", r->secdesc);
4761
 
        ndr->depth++;
4762
 
        if (r->secdesc) {
4763
 
                ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
4764
 
        }
4765
 
        ndr->depth--;
4766
 
        ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4767
 
        ndr_print_uint32(ndr, "priority", r->priority);
4768
 
        ndr_print_uint32(ndr, "position", r->position);
4769
 
        ndr_print_uint32(ndr, "start_time", r->start_time);
4770
 
        ndr_print_uint32(ndr, "until_time", r->until_time);
4771
 
        ndr_print_uint32(ndr, "total_pages", r->total_pages);
4772
 
        ndr_print_uint32(ndr, "size", r->size);
4773
 
        ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4774
 
        ndr_print_uint32(ndr, "time", r->time);
4775
 
        ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4776
 
        ndr_print_uint32(ndr, "size_high", r->size_high);
4777
 
        ndr->depth--;
4778
 
}
4779
 
 
4780
 
_PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4781
 
{
4782
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4783
 
}
4784
 
 
4785
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4786
 
{
4787
 
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4788
 
        {
4789
 
                uint32_t _flags_save_UNION = ndr->flags;
4790
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
4791
 
                if (ndr_flags & NDR_SCALARS) {
4792
 
                        int level = ndr_push_get_switch_value(ndr, r);
4793
 
                        NDR_CHECK(ndr_push_union_align(ndr, 5));
4794
 
                        switch (level) {
4795
 
                                case 1: {
4796
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
4797
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4798
 
                                        NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4799
 
                                break; }
4800
 
 
4801
 
                                case 2: {
4802
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
4803
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4804
 
                                        NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4805
 
                                break; }
4806
 
 
4807
 
                                case 3: {
4808
 
                                        NDR_CHECK(ndr_push_align(ndr, 4));
4809
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4810
 
                                        NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4811
 
                                break; }
4812
 
 
4813
 
                                case 4: {
4814
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
4815
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4816
 
                                        NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4817
 
                                break; }
4818
 
 
4819
 
                                default: {
4820
 
                                break; }
4821
 
 
4822
 
                        }
4823
 
                }
4824
 
                if (ndr_flags & NDR_BUFFERS) {
4825
 
                        int level = ndr_push_get_switch_value(ndr, r);
4826
 
                        NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4827
 
                        switch (level) {
4828
 
                                case 1:
4829
 
                                        NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4830
 
                                break;
4831
 
 
4832
 
                                case 2:
4833
 
                                        NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4834
 
                                break;
4835
 
 
4836
 
                                case 3:
4837
 
                                break;
4838
 
 
4839
 
                                case 4:
4840
 
                                        NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4841
 
                                break;
4842
 
 
4843
 
                                default:
4844
 
                                break;
4845
 
 
4846
 
                        }
4847
 
                }
4848
 
                ndr->flags = _flags_save_UNION;
4849
 
        }
4850
 
        ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4851
 
        return NDR_ERR_SUCCESS;
4852
 
}
4853
 
 
4854
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4855
 
{
4856
 
        uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4857
 
        int level;
4858
 
        {
4859
 
                uint32_t _flags_save_UNION = ndr->flags;
4860
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
4861
 
                level = ndr_pull_get_switch_value(ndr, r);
4862
 
                if (ndr_flags & NDR_SCALARS) {
4863
 
                        NDR_CHECK(ndr_pull_union_align(ndr, 5));
4864
 
                        switch (level) {
4865
 
                                case 1: {
4866
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
4867
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4868
 
                                        NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4869
 
                                break; }
4870
 
 
4871
 
                                case 2: {
4872
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
4873
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4874
 
                                        NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4875
 
                                break; }
4876
 
 
4877
 
                                case 3: {
4878
 
                                        NDR_CHECK(ndr_pull_align(ndr, 4));
4879
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4880
 
                                        NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4881
 
                                break; }
4882
 
 
4883
 
                                case 4: {
4884
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
4885
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4886
 
                                        NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4887
 
                                break; }
4888
 
 
4889
 
                                default: {
4890
 
                                break; }
4891
 
 
4892
 
                        }
4893
 
                }
4894
 
                if (ndr_flags & NDR_BUFFERS) {
4895
 
                        NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4896
 
                        switch (level) {
4897
 
                                case 1:
4898
 
                                        NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4899
 
                                break;
4900
 
 
4901
 
                                case 2:
4902
 
                                        NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4903
 
                                break;
4904
 
 
4905
 
                                case 3:
4906
 
                                break;
4907
 
 
4908
 
                                case 4:
4909
 
                                        NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4910
 
                                break;
4911
 
 
4912
 
                                default:
4913
 
                                break;
4914
 
 
4915
 
                        }
4916
 
                }
4917
 
                ndr->flags = _flags_save_UNION;
4918
 
        }
4919
 
        ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4920
 
        return NDR_ERR_SUCCESS;
4921
 
}
4922
 
 
4923
 
_PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4924
 
{
4925
 
        int level;
4926
 
        {
4927
 
                uint32_t _flags_save_UNION = ndr->flags;
4928
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
4929
 
                level = ndr_print_get_switch_value(ndr, r);
4930
 
                ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4931
 
                switch (level) {
4932
 
                        case 1:
4933
 
                                ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4934
 
                        break;
4935
 
 
4936
 
                        case 2:
4937
 
                                ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4938
 
                        break;
4939
 
 
4940
 
                        case 3:
4941
 
                                ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4942
 
                        break;
4943
 
 
4944
 
                        case 4:
4945
 
                                ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4946
 
                        break;
4947
 
 
4948
 
                        default:
4949
 
                        break;
4950
 
 
4951
 
                }
4952
 
                ndr->flags = _flags_save_UNION;
4953
 
        }
4954
 
}
4955
 
 
4956
 
_PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4957
 
{
4958
 
        flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
4959
 
        return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4960
 
}
4961
 
 
4962
 
static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4963
 
{
4964
 
        if (ndr_flags & NDR_SCALARS) {
4965
 
                NDR_CHECK(ndr_push_align(ndr, 5));
4966
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4967
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4968
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4969
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4970
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4971
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4972
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4973
 
                NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4974
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4975
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4976
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4977
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4978
 
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4979
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4980
 
        }
4981
 
        if (ndr_flags & NDR_BUFFERS) {
4982
 
                if (r->printer_name) {
4983
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4984
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4985
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4986
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4987
 
                }
4988
 
                if (r->server_name) {
4989
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4990
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4991
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4992
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4993
 
                }
4994
 
                if (r->user_name) {
4995
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4996
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4997
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4998
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4999
 
                }
5000
 
                if (r->document_name) {
5001
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5002
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5003
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5004
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5005
 
                }
5006
 
                if (r->data_type) {
5007
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5008
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5009
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5010
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5011
 
                }
5012
 
                if (r->text_status) {
5013
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5014
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5015
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5016
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5017
 
                }
5018
 
        }
5019
 
        return NDR_ERR_SUCCESS;
5020
 
}
5021
 
 
5022
 
static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
5023
 
{
5024
 
        uint32_t _ptr_printer_name;
5025
 
        TALLOC_CTX *_mem_save_printer_name_0;
5026
 
        uint32_t _ptr_server_name;
5027
 
        TALLOC_CTX *_mem_save_server_name_0;
5028
 
        uint32_t _ptr_user_name;
5029
 
        TALLOC_CTX *_mem_save_user_name_0;
5030
 
        uint32_t _ptr_document_name;
5031
 
        TALLOC_CTX *_mem_save_document_name_0;
5032
 
        uint32_t _ptr_data_type;
5033
 
        TALLOC_CTX *_mem_save_data_type_0;
5034
 
        uint32_t _ptr_text_status;
5035
 
        TALLOC_CTX *_mem_save_text_status_0;
5036
 
        if (ndr_flags & NDR_SCALARS) {
5037
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
5038
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5039
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5040
 
                if (_ptr_printer_name) {
5041
 
                        NDR_PULL_ALLOC(ndr, r->printer_name);
5042
 
                } else {
5043
 
                        r->printer_name = NULL;
5044
 
                }
5045
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5046
 
                if (_ptr_server_name) {
5047
 
                        NDR_PULL_ALLOC(ndr, r->server_name);
5048
 
                } else {
5049
 
                        r->server_name = NULL;
5050
 
                }
5051
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5052
 
                if (_ptr_user_name) {
5053
 
                        NDR_PULL_ALLOC(ndr, r->user_name);
5054
 
                } else {
5055
 
                        r->user_name = NULL;
5056
 
                }
5057
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5058
 
                if (_ptr_document_name) {
5059
 
                        NDR_PULL_ALLOC(ndr, r->document_name);
5060
 
                } else {
5061
 
                        r->document_name = NULL;
5062
 
                }
5063
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5064
 
                if (_ptr_data_type) {
5065
 
                        NDR_PULL_ALLOC(ndr, r->data_type);
5066
 
                } else {
5067
 
                        r->data_type = NULL;
5068
 
                }
5069
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5070
 
                if (_ptr_text_status) {
5071
 
                        NDR_PULL_ALLOC(ndr, r->text_status);
5072
 
                } else {
5073
 
                        r->text_status = NULL;
5074
 
                }
5075
 
                NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5076
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5077
 
                if (r->priority > 99) {
5078
 
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5079
 
                }
5080
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5081
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5082
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5083
 
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5084
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5085
 
        }
5086
 
        if (ndr_flags & NDR_BUFFERS) {
5087
 
                if (r->printer_name) {
5088
 
                        _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5089
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5090
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5091
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5092
 
                        if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5093
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5094
 
                        }
5095
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5096
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5097
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5098
 
                }
5099
 
                if (r->server_name) {
5100
 
                        _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5101
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5102
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5103
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5104
 
                        if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5105
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5106
 
                        }
5107
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5108
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5109
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5110
 
                }
5111
 
                if (r->user_name) {
5112
 
                        _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5113
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5114
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5115
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5116
 
                        if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5117
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5118
 
                        }
5119
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5120
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5121
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5122
 
                }
5123
 
                if (r->document_name) {
5124
 
                        _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5125
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5126
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5127
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5128
 
                        if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5129
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5130
 
                        }
5131
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5132
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5133
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5134
 
                }
5135
 
                if (r->data_type) {
5136
 
                        _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5137
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5138
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5139
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5140
 
                        if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5141
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5142
 
                        }
5143
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5144
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5145
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5146
 
                }
5147
 
                if (r->text_status) {
5148
 
                        _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5149
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5150
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5151
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5152
 
                        if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5153
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5154
 
                        }
5155
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5156
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5157
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5158
 
                }
5159
 
        }
5160
 
        return NDR_ERR_SUCCESS;
5161
 
}
5162
 
 
5163
 
_PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5164
 
{
5165
 
        ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5166
 
        ndr->depth++;
5167
 
        ndr_print_uint32(ndr, "job_id", r->job_id);
5168
 
        ndr_print_ptr(ndr, "printer_name", r->printer_name);
5169
 
        ndr->depth++;
5170
 
        if (r->printer_name) {
5171
 
                ndr_print_string(ndr, "printer_name", r->printer_name);
5172
 
        }
5173
 
        ndr->depth--;
5174
 
        ndr_print_ptr(ndr, "server_name", r->server_name);
5175
 
        ndr->depth++;
5176
 
        if (r->server_name) {
5177
 
                ndr_print_string(ndr, "server_name", r->server_name);
5178
 
        }
5179
 
        ndr->depth--;
5180
 
        ndr_print_ptr(ndr, "user_name", r->user_name);
5181
 
        ndr->depth++;
5182
 
        if (r->user_name) {
5183
 
                ndr_print_string(ndr, "user_name", r->user_name);
5184
 
        }
5185
 
        ndr->depth--;
5186
 
        ndr_print_ptr(ndr, "document_name", r->document_name);
5187
 
        ndr->depth++;
5188
 
        if (r->document_name) {
5189
 
                ndr_print_string(ndr, "document_name", r->document_name);
5190
 
        }
5191
 
        ndr->depth--;
5192
 
        ndr_print_ptr(ndr, "data_type", r->data_type);
5193
 
        ndr->depth++;
5194
 
        if (r->data_type) {
5195
 
                ndr_print_string(ndr, "data_type", r->data_type);
5196
 
        }
5197
 
        ndr->depth--;
5198
 
        ndr_print_ptr(ndr, "text_status", r->text_status);
5199
 
        ndr->depth++;
5200
 
        if (r->text_status) {
5201
 
                ndr_print_string(ndr, "text_status", r->text_status);
5202
 
        }
5203
 
        ndr->depth--;
5204
 
        ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5205
 
        ndr_print_uint32(ndr, "priority", r->priority);
5206
 
        ndr_print_uint32(ndr, "position", r->position);
5207
 
        ndr_print_uint32(ndr, "total_pages", r->total_pages);
5208
 
        ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5209
 
        ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5210
 
        ndr->depth--;
5211
 
}
5212
 
 
5213
 
static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5214
 
{
5215
 
        if (ndr_flags & NDR_SCALARS) {
5216
 
                NDR_CHECK(ndr_push_align(ndr, 5));
5217
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5218
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5219
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5220
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5221
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5222
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5223
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5224
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5225
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5226
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5227
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5228
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5229
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5230
 
                NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5231
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5232
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5233
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5234
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5235
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5236
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5237
 
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5238
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5239
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5240
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5241
 
        }
5242
 
        if (ndr_flags & NDR_BUFFERS) {
5243
 
                if (r->printer_name) {
5244
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5245
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5246
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5247
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5248
 
                }
5249
 
                if (r->server_name) {
5250
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5251
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5252
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5253
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5254
 
                }
5255
 
                if (r->user_name) {
5256
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5257
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5258
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5259
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5260
 
                }
5261
 
                if (r->document_name) {
5262
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5263
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5264
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5265
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5266
 
                }
5267
 
                if (r->notify_name) {
5268
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5269
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5270
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5271
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5272
 
                }
5273
 
                if (r->data_type) {
5274
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5275
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5276
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5277
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5278
 
                }
5279
 
                if (r->print_processor) {
5280
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5281
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5282
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5283
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5284
 
                }
5285
 
                if (r->parameters) {
5286
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5287
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5288
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5289
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5290
 
                }
5291
 
                if (r->driver_name) {
5292
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5293
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5294
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5295
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5296
 
                }
5297
 
                if (r->text_status) {
5298
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5299
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5300
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5301
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5302
 
                }
5303
 
        }
5304
 
        return NDR_ERR_SUCCESS;
5305
 
}
5306
 
 
5307
 
static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5308
 
{
5309
 
        uint32_t _ptr_printer_name;
5310
 
        TALLOC_CTX *_mem_save_printer_name_0;
5311
 
        uint32_t _ptr_server_name;
5312
 
        TALLOC_CTX *_mem_save_server_name_0;
5313
 
        uint32_t _ptr_user_name;
5314
 
        TALLOC_CTX *_mem_save_user_name_0;
5315
 
        uint32_t _ptr_document_name;
5316
 
        TALLOC_CTX *_mem_save_document_name_0;
5317
 
        uint32_t _ptr_notify_name;
5318
 
        TALLOC_CTX *_mem_save_notify_name_0;
5319
 
        uint32_t _ptr_data_type;
5320
 
        TALLOC_CTX *_mem_save_data_type_0;
5321
 
        uint32_t _ptr_print_processor;
5322
 
        TALLOC_CTX *_mem_save_print_processor_0;
5323
 
        uint32_t _ptr_parameters;
5324
 
        TALLOC_CTX *_mem_save_parameters_0;
5325
 
        uint32_t _ptr_driver_name;
5326
 
        TALLOC_CTX *_mem_save_driver_name_0;
5327
 
        uint32_t _ptr_text_status;
5328
 
        TALLOC_CTX *_mem_save_text_status_0;
5329
 
        if (ndr_flags & NDR_SCALARS) {
5330
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
5331
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5332
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5333
 
                if (_ptr_printer_name) {
5334
 
                        NDR_PULL_ALLOC(ndr, r->printer_name);
5335
 
                } else {
5336
 
                        r->printer_name = NULL;
5337
 
                }
5338
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5339
 
                if (_ptr_server_name) {
5340
 
                        NDR_PULL_ALLOC(ndr, r->server_name);
5341
 
                } else {
5342
 
                        r->server_name = NULL;
5343
 
                }
5344
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5345
 
                if (_ptr_user_name) {
5346
 
                        NDR_PULL_ALLOC(ndr, r->user_name);
5347
 
                } else {
5348
 
                        r->user_name = NULL;
5349
 
                }
5350
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5351
 
                if (_ptr_document_name) {
5352
 
                        NDR_PULL_ALLOC(ndr, r->document_name);
5353
 
                } else {
5354
 
                        r->document_name = NULL;
5355
 
                }
5356
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5357
 
                if (_ptr_notify_name) {
5358
 
                        NDR_PULL_ALLOC(ndr, r->notify_name);
5359
 
                } else {
5360
 
                        r->notify_name = NULL;
5361
 
                }
5362
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5363
 
                if (_ptr_data_type) {
5364
 
                        NDR_PULL_ALLOC(ndr, r->data_type);
5365
 
                } else {
5366
 
                        r->data_type = NULL;
5367
 
                }
5368
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5369
 
                if (_ptr_print_processor) {
5370
 
                        NDR_PULL_ALLOC(ndr, r->print_processor);
5371
 
                } else {
5372
 
                        r->print_processor = NULL;
5373
 
                }
5374
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5375
 
                if (_ptr_parameters) {
5376
 
                        NDR_PULL_ALLOC(ndr, r->parameters);
5377
 
                } else {
5378
 
                        r->parameters = NULL;
5379
 
                }
5380
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5381
 
                if (_ptr_driver_name) {
5382
 
                        NDR_PULL_ALLOC(ndr, r->driver_name);
5383
 
                } else {
5384
 
                        r->driver_name = NULL;
5385
 
                }
5386
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5387
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5388
 
                if (_ptr_text_status) {
5389
 
                        NDR_PULL_ALLOC(ndr, r->text_status);
5390
 
                } else {
5391
 
                        r->text_status = NULL;
5392
 
                }
5393
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5394
 
                NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5395
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5396
 
                if (r->priority > 99) {
5397
 
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5398
 
                }
5399
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5400
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5401
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5402
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5403
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5404
 
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5405
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5406
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5407
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5408
 
        }
5409
 
        if (ndr_flags & NDR_BUFFERS) {
5410
 
                if (r->printer_name) {
5411
 
                        _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5412
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5413
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5414
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5415
 
                        if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5416
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5417
 
                        }
5418
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5419
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5420
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5421
 
                }
5422
 
                if (r->server_name) {
5423
 
                        _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5424
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5425
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5426
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5427
 
                        if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5428
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5429
 
                        }
5430
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5431
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5432
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5433
 
                }
5434
 
                if (r->user_name) {
5435
 
                        _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5436
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5437
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5438
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5439
 
                        if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5440
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5441
 
                        }
5442
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5443
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5444
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5445
 
                }
5446
 
                if (r->document_name) {
5447
 
                        _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5448
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5449
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5450
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5451
 
                        if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5452
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5453
 
                        }
5454
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5455
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5456
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5457
 
                }
5458
 
                if (r->notify_name) {
5459
 
                        _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5460
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5461
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5462
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5463
 
                        if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5464
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5465
 
                        }
5466
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5467
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5468
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5469
 
                }
5470
 
                if (r->data_type) {
5471
 
                        _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5472
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5473
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5474
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5475
 
                        if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5476
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5477
 
                        }
5478
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5479
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5480
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5481
 
                }
5482
 
                if (r->print_processor) {
5483
 
                        _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5484
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5485
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5486
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5487
 
                        if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5488
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5489
 
                        }
5490
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5491
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5492
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5493
 
                }
5494
 
                if (r->parameters) {
5495
 
                        _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5496
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5497
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5498
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5499
 
                        if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5500
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
5501
 
                        }
5502
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5503
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5504
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5505
 
                }
5506
 
                if (r->driver_name) {
5507
 
                        _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5508
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5509
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5510
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5511
 
                        if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5512
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5513
 
                        }
5514
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5515
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5516
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5517
 
                }
5518
 
                if (r->text_status) {
5519
 
                        _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5520
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5521
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5522
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5523
 
                        if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5524
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5525
 
                        }
5526
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5527
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5528
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5529
 
                }
5530
 
        }
5531
 
        return NDR_ERR_SUCCESS;
5532
 
}
5533
 
 
5534
 
_PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5535
 
{
5536
 
        ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5537
 
        ndr->depth++;
5538
 
        ndr_print_uint32(ndr, "job_id", r->job_id);
5539
 
        ndr_print_ptr(ndr, "printer_name", r->printer_name);
5540
 
        ndr->depth++;
5541
 
        if (r->printer_name) {
5542
 
                ndr_print_string(ndr, "printer_name", r->printer_name);
5543
 
        }
5544
 
        ndr->depth--;
5545
 
        ndr_print_ptr(ndr, "server_name", r->server_name);
5546
 
        ndr->depth++;
5547
 
        if (r->server_name) {
5548
 
                ndr_print_string(ndr, "server_name", r->server_name);
5549
 
        }
5550
 
        ndr->depth--;
5551
 
        ndr_print_ptr(ndr, "user_name", r->user_name);
5552
 
        ndr->depth++;
5553
 
        if (r->user_name) {
5554
 
                ndr_print_string(ndr, "user_name", r->user_name);
5555
 
        }
5556
 
        ndr->depth--;
5557
 
        ndr_print_ptr(ndr, "document_name", r->document_name);
5558
 
        ndr->depth++;
5559
 
        if (r->document_name) {
5560
 
                ndr_print_string(ndr, "document_name", r->document_name);
5561
 
        }
5562
 
        ndr->depth--;
5563
 
        ndr_print_ptr(ndr, "notify_name", r->notify_name);
5564
 
        ndr->depth++;
5565
 
        if (r->notify_name) {
5566
 
                ndr_print_string(ndr, "notify_name", r->notify_name);
5567
 
        }
5568
 
        ndr->depth--;
5569
 
        ndr_print_ptr(ndr, "data_type", r->data_type);
5570
 
        ndr->depth++;
5571
 
        if (r->data_type) {
5572
 
                ndr_print_string(ndr, "data_type", r->data_type);
5573
 
        }
5574
 
        ndr->depth--;
5575
 
        ndr_print_ptr(ndr, "print_processor", r->print_processor);
5576
 
        ndr->depth++;
5577
 
        if (r->print_processor) {
5578
 
                ndr_print_string(ndr, "print_processor", r->print_processor);
5579
 
        }
5580
 
        ndr->depth--;
5581
 
        ndr_print_ptr(ndr, "parameters", r->parameters);
5582
 
        ndr->depth++;
5583
 
        if (r->parameters) {
5584
 
                ndr_print_string(ndr, "parameters", r->parameters);
5585
 
        }
5586
 
        ndr->depth--;
5587
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
5588
 
        ndr->depth++;
5589
 
        if (r->driver_name) {
5590
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
5591
 
        }
5592
 
        ndr->depth--;
5593
 
        ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5594
 
        ndr_print_ptr(ndr, "text_status", r->text_status);
5595
 
        ndr->depth++;
5596
 
        if (r->text_status) {
5597
 
                ndr_print_string(ndr, "text_status", r->text_status);
5598
 
        }
5599
 
        ndr->depth--;
5600
 
        ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5601
 
        ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5602
 
        ndr_print_uint32(ndr, "priority", r->priority);
5603
 
        ndr_print_uint32(ndr, "position", r->position);
5604
 
        ndr_print_uint32(ndr, "start_time", r->start_time);
5605
 
        ndr_print_uint32(ndr, "until_time", r->until_time);
5606
 
        ndr_print_uint32(ndr, "total_pages", r->total_pages);
5607
 
        ndr_print_uint32(ndr, "size", r->size);
5608
 
        ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5609
 
        ndr_print_uint32(ndr, "time", r->time);
5610
 
        ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5611
 
        ndr->depth--;
5612
 
}
5613
 
 
5614
 
static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5615
 
{
5616
 
        if (ndr_flags & NDR_SCALARS) {
5617
 
                NDR_CHECK(ndr_push_align(ndr, 5));
5618
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5619
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5620
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5621
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5622
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5623
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5624
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5625
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5626
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5627
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5628
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5629
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5630
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5631
 
                NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5632
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5633
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5634
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5635
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5636
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5637
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5638
 
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5639
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5640
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5641
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5642
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5643
 
        }
5644
 
        if (ndr_flags & NDR_BUFFERS) {
5645
 
                if (r->printer_name) {
5646
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5647
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5648
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5649
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5650
 
                }
5651
 
                if (r->server_name) {
5652
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5653
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5654
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5655
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5656
 
                }
5657
 
                if (r->user_name) {
5658
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5659
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5660
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5661
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5662
 
                }
5663
 
                if (r->document_name) {
5664
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5665
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5666
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5667
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5668
 
                }
5669
 
                if (r->notify_name) {
5670
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5671
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5672
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5673
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5674
 
                }
5675
 
                if (r->data_type) {
5676
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5677
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5678
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5679
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5680
 
                }
5681
 
                if (r->print_processor) {
5682
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5683
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5684
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5685
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5686
 
                }
5687
 
                if (r->parameters) {
5688
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5689
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5690
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5691
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5692
 
                }
5693
 
                if (r->driver_name) {
5694
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5695
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5696
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5697
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5698
 
                }
5699
 
                if (r->text_status) {
5700
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5701
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5702
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5703
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5704
 
                }
5705
 
        }
5706
 
        return NDR_ERR_SUCCESS;
5707
 
}
5708
 
 
5709
 
static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5710
 
{
5711
 
        uint32_t _ptr_printer_name;
5712
 
        TALLOC_CTX *_mem_save_printer_name_0;
5713
 
        uint32_t _ptr_server_name;
5714
 
        TALLOC_CTX *_mem_save_server_name_0;
5715
 
        uint32_t _ptr_user_name;
5716
 
        TALLOC_CTX *_mem_save_user_name_0;
5717
 
        uint32_t _ptr_document_name;
5718
 
        TALLOC_CTX *_mem_save_document_name_0;
5719
 
        uint32_t _ptr_notify_name;
5720
 
        TALLOC_CTX *_mem_save_notify_name_0;
5721
 
        uint32_t _ptr_data_type;
5722
 
        TALLOC_CTX *_mem_save_data_type_0;
5723
 
        uint32_t _ptr_print_processor;
5724
 
        TALLOC_CTX *_mem_save_print_processor_0;
5725
 
        uint32_t _ptr_parameters;
5726
 
        TALLOC_CTX *_mem_save_parameters_0;
5727
 
        uint32_t _ptr_driver_name;
5728
 
        TALLOC_CTX *_mem_save_driver_name_0;
5729
 
        uint32_t _ptr_text_status;
5730
 
        TALLOC_CTX *_mem_save_text_status_0;
5731
 
        if (ndr_flags & NDR_SCALARS) {
5732
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
5733
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5734
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5735
 
                if (_ptr_printer_name) {
5736
 
                        NDR_PULL_ALLOC(ndr, r->printer_name);
5737
 
                } else {
5738
 
                        r->printer_name = NULL;
5739
 
                }
5740
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5741
 
                if (_ptr_server_name) {
5742
 
                        NDR_PULL_ALLOC(ndr, r->server_name);
5743
 
                } else {
5744
 
                        r->server_name = NULL;
5745
 
                }
5746
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5747
 
                if (_ptr_user_name) {
5748
 
                        NDR_PULL_ALLOC(ndr, r->user_name);
5749
 
                } else {
5750
 
                        r->user_name = NULL;
5751
 
                }
5752
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5753
 
                if (_ptr_document_name) {
5754
 
                        NDR_PULL_ALLOC(ndr, r->document_name);
5755
 
                } else {
5756
 
                        r->document_name = NULL;
5757
 
                }
5758
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5759
 
                if (_ptr_notify_name) {
5760
 
                        NDR_PULL_ALLOC(ndr, r->notify_name);
5761
 
                } else {
5762
 
                        r->notify_name = NULL;
5763
 
                }
5764
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5765
 
                if (_ptr_data_type) {
5766
 
                        NDR_PULL_ALLOC(ndr, r->data_type);
5767
 
                } else {
5768
 
                        r->data_type = NULL;
5769
 
                }
5770
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5771
 
                if (_ptr_print_processor) {
5772
 
                        NDR_PULL_ALLOC(ndr, r->print_processor);
5773
 
                } else {
5774
 
                        r->print_processor = NULL;
5775
 
                }
5776
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5777
 
                if (_ptr_parameters) {
5778
 
                        NDR_PULL_ALLOC(ndr, r->parameters);
5779
 
                } else {
5780
 
                        r->parameters = NULL;
5781
 
                }
5782
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5783
 
                if (_ptr_driver_name) {
5784
 
                        NDR_PULL_ALLOC(ndr, r->driver_name);
5785
 
                } else {
5786
 
                        r->driver_name = NULL;
5787
 
                }
5788
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5789
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5790
 
                if (_ptr_text_status) {
5791
 
                        NDR_PULL_ALLOC(ndr, r->text_status);
5792
 
                } else {
5793
 
                        r->text_status = NULL;
5794
 
                }
5795
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5796
 
                NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5797
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5798
 
                if (r->priority > 99) {
5799
 
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5800
 
                }
5801
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5802
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5803
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5804
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5805
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5806
 
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5807
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5808
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5809
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5810
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5811
 
        }
5812
 
        if (ndr_flags & NDR_BUFFERS) {
5813
 
                if (r->printer_name) {
5814
 
                        _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5815
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5816
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5817
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5818
 
                        if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5819
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5820
 
                        }
5821
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5822
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5823
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5824
 
                }
5825
 
                if (r->server_name) {
5826
 
                        _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5827
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5828
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5829
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5830
 
                        if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5831
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5832
 
                        }
5833
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5834
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5835
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5836
 
                }
5837
 
                if (r->user_name) {
5838
 
                        _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5839
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5840
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5841
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5842
 
                        if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5843
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5844
 
                        }
5845
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5846
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5847
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5848
 
                }
5849
 
                if (r->document_name) {
5850
 
                        _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5851
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5852
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5853
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5854
 
                        if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5855
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5856
 
                        }
5857
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5858
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5859
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5860
 
                }
5861
 
                if (r->notify_name) {
5862
 
                        _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5863
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5864
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5865
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5866
 
                        if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5867
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5868
 
                        }
5869
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5870
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5871
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5872
 
                }
5873
 
                if (r->data_type) {
5874
 
                        _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5875
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5876
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5877
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5878
 
                        if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5879
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5880
 
                        }
5881
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5882
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5883
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5884
 
                }
5885
 
                if (r->print_processor) {
5886
 
                        _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5887
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5888
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5889
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5890
 
                        if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5891
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5892
 
                        }
5893
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5894
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5895
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5896
 
                }
5897
 
                if (r->parameters) {
5898
 
                        _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5899
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5900
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5901
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5902
 
                        if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5903
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
5904
 
                        }
5905
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5906
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5907
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5908
 
                }
5909
 
                if (r->driver_name) {
5910
 
                        _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5911
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5912
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5913
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5914
 
                        if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5915
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5916
 
                        }
5917
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5918
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5919
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5920
 
                }
5921
 
                if (r->text_status) {
5922
 
                        _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5923
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5924
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5925
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5926
 
                        if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5927
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5928
 
                        }
5929
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5930
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5931
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5932
 
                }
5933
 
        }
5934
 
        return NDR_ERR_SUCCESS;
5935
 
}
5936
 
 
5937
 
_PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5938
 
{
5939
 
        ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5940
 
        ndr->depth++;
5941
 
        ndr_print_uint32(ndr, "job_id", r->job_id);
5942
 
        ndr_print_ptr(ndr, "printer_name", r->printer_name);
5943
 
        ndr->depth++;
5944
 
        if (r->printer_name) {
5945
 
                ndr_print_string(ndr, "printer_name", r->printer_name);
5946
 
        }
5947
 
        ndr->depth--;
5948
 
        ndr_print_ptr(ndr, "server_name", r->server_name);
5949
 
        ndr->depth++;
5950
 
        if (r->server_name) {
5951
 
                ndr_print_string(ndr, "server_name", r->server_name);
5952
 
        }
5953
 
        ndr->depth--;
5954
 
        ndr_print_ptr(ndr, "user_name", r->user_name);
5955
 
        ndr->depth++;
5956
 
        if (r->user_name) {
5957
 
                ndr_print_string(ndr, "user_name", r->user_name);
5958
 
        }
5959
 
        ndr->depth--;
5960
 
        ndr_print_ptr(ndr, "document_name", r->document_name);
5961
 
        ndr->depth++;
5962
 
        if (r->document_name) {
5963
 
                ndr_print_string(ndr, "document_name", r->document_name);
5964
 
        }
5965
 
        ndr->depth--;
5966
 
        ndr_print_ptr(ndr, "notify_name", r->notify_name);
5967
 
        ndr->depth++;
5968
 
        if (r->notify_name) {
5969
 
                ndr_print_string(ndr, "notify_name", r->notify_name);
5970
 
        }
5971
 
        ndr->depth--;
5972
 
        ndr_print_ptr(ndr, "data_type", r->data_type);
5973
 
        ndr->depth++;
5974
 
        if (r->data_type) {
5975
 
                ndr_print_string(ndr, "data_type", r->data_type);
5976
 
        }
5977
 
        ndr->depth--;
5978
 
        ndr_print_ptr(ndr, "print_processor", r->print_processor);
5979
 
        ndr->depth++;
5980
 
        if (r->print_processor) {
5981
 
                ndr_print_string(ndr, "print_processor", r->print_processor);
5982
 
        }
5983
 
        ndr->depth--;
5984
 
        ndr_print_ptr(ndr, "parameters", r->parameters);
5985
 
        ndr->depth++;
5986
 
        if (r->parameters) {
5987
 
                ndr_print_string(ndr, "parameters", r->parameters);
5988
 
        }
5989
 
        ndr->depth--;
5990
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
5991
 
        ndr->depth++;
5992
 
        if (r->driver_name) {
5993
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
5994
 
        }
5995
 
        ndr->depth--;
5996
 
        ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5997
 
        ndr_print_ptr(ndr, "text_status", r->text_status);
5998
 
        ndr->depth++;
5999
 
        if (r->text_status) {
6000
 
                ndr_print_string(ndr, "text_status", r->text_status);
6001
 
        }
6002
 
        ndr->depth--;
6003
 
        ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6004
 
        ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6005
 
        ndr_print_uint32(ndr, "priority", r->priority);
6006
 
        ndr_print_uint32(ndr, "position", r->position);
6007
 
        ndr_print_uint32(ndr, "start_time", r->start_time);
6008
 
        ndr_print_uint32(ndr, "until_time", r->until_time);
6009
 
        ndr_print_uint32(ndr, "total_pages", r->total_pages);
6010
 
        ndr_print_uint32(ndr, "size", r->size);
6011
 
        ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6012
 
        ndr_print_uint32(ndr, "time", r->time);
6013
 
        ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6014
 
        ndr_print_uint32(ndr, "size_high", r->size_high);
6015
 
        ndr->depth--;
6016
 
}
6017
 
 
6018
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
6019
 
{
6020
 
        if (ndr_flags & NDR_SCALARS) {
6021
 
                int level = ndr_push_get_switch_value(ndr, r);
6022
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6023
 
                NDR_CHECK(ndr_push_union_align(ndr, 5));
6024
 
                switch (level) {
6025
 
                        case 1: {
6026
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6027
 
                        break; }
6028
 
 
6029
 
                        case 2: {
6030
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6031
 
                        break; }
6032
 
 
6033
 
                        case 3: {
6034
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6035
 
                        break; }
6036
 
 
6037
 
                        case 4: {
6038
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6039
 
                        break; }
6040
 
 
6041
 
                        default: {
6042
 
                        break; }
6043
 
 
6044
 
                }
6045
 
        }
6046
 
        if (ndr_flags & NDR_BUFFERS) {
6047
 
                int level = ndr_push_get_switch_value(ndr, r);
6048
 
                switch (level) {
6049
 
                        case 1:
6050
 
                                if (r->info1) {
6051
 
                                        NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6052
 
                                }
6053
 
                        break;
6054
 
 
6055
 
                        case 2:
6056
 
                                if (r->info2) {
6057
 
                                        NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6058
 
                                }
6059
 
                        break;
6060
 
 
6061
 
                        case 3:
6062
 
                                if (r->info3) {
6063
 
                                        NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6064
 
                                }
6065
 
                        break;
6066
 
 
6067
 
                        case 4:
6068
 
                                if (r->info4) {
6069
 
                                        NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6070
 
                                }
6071
 
                        break;
6072
 
 
6073
 
                        default:
6074
 
                        break;
6075
 
 
6076
 
                }
6077
 
        }
6078
 
        return NDR_ERR_SUCCESS;
6079
 
}
6080
 
 
6081
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6082
 
{
6083
 
        int level;
6084
 
        uint32_t _level;
6085
 
        TALLOC_CTX *_mem_save_info1_0;
6086
 
        TALLOC_CTX *_mem_save_info2_0;
6087
 
        TALLOC_CTX *_mem_save_info3_0;
6088
 
        TALLOC_CTX *_mem_save_info4_0;
6089
 
        level = ndr_pull_get_switch_value(ndr, r);
6090
 
        if (ndr_flags & NDR_SCALARS) {
6091
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6092
 
                if (_level != level) {
6093
 
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6094
 
                }
6095
 
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
6096
 
                switch (level) {
6097
 
                        case 1: {
6098
 
                                uint32_t _ptr_info1;
6099
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6100
 
                                if (_ptr_info1) {
6101
 
                                        NDR_PULL_ALLOC(ndr, r->info1);
6102
 
                                } else {
6103
 
                                        r->info1 = NULL;
6104
 
                                }
6105
 
                        break; }
6106
 
 
6107
 
                        case 2: {
6108
 
                                uint32_t _ptr_info2;
6109
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6110
 
                                if (_ptr_info2) {
6111
 
                                        NDR_PULL_ALLOC(ndr, r->info2);
6112
 
                                } else {
6113
 
                                        r->info2 = NULL;
6114
 
                                }
6115
 
                        break; }
6116
 
 
6117
 
                        case 3: {
6118
 
                                uint32_t _ptr_info3;
6119
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6120
 
                                if (_ptr_info3) {
6121
 
                                        NDR_PULL_ALLOC(ndr, r->info3);
6122
 
                                } else {
6123
 
                                        r->info3 = NULL;
6124
 
                                }
6125
 
                        break; }
6126
 
 
6127
 
                        case 4: {
6128
 
                                uint32_t _ptr_info4;
6129
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6130
 
                                if (_ptr_info4) {
6131
 
                                        NDR_PULL_ALLOC(ndr, r->info4);
6132
 
                                } else {
6133
 
                                        r->info4 = NULL;
6134
 
                                }
6135
 
                        break; }
6136
 
 
6137
 
                        default: {
6138
 
                        break; }
6139
 
 
6140
 
                }
6141
 
        }
6142
 
        if (ndr_flags & NDR_BUFFERS) {
6143
 
                switch (level) {
6144
 
                        case 1:
6145
 
                                if (r->info1) {
6146
 
                                        _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6147
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6148
 
                                        NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6149
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6150
 
                                }
6151
 
                        break;
6152
 
 
6153
 
                        case 2:
6154
 
                                if (r->info2) {
6155
 
                                        _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6156
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6157
 
                                        NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6158
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6159
 
                                }
6160
 
                        break;
6161
 
 
6162
 
                        case 3:
6163
 
                                if (r->info3) {
6164
 
                                        _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6165
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6166
 
                                        NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6167
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6168
 
                                }
6169
 
                        break;
6170
 
 
6171
 
                        case 4:
6172
 
                                if (r->info4) {
6173
 
                                        _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6174
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6175
 
                                        NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6176
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6177
 
                                }
6178
 
                        break;
6179
 
 
6180
 
                        default:
6181
 
                        break;
6182
 
 
6183
 
                }
6184
 
        }
6185
 
        return NDR_ERR_SUCCESS;
6186
 
}
6187
 
 
6188
 
_PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6189
 
{
6190
 
        int level;
6191
 
        level = ndr_print_get_switch_value(ndr, r);
6192
 
        ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6193
 
        switch (level) {
6194
 
                case 1:
6195
 
                        ndr_print_ptr(ndr, "info1", r->info1);
6196
 
                        ndr->depth++;
6197
 
                        if (r->info1) {
6198
 
                                ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6199
 
                        }
6200
 
                        ndr->depth--;
6201
 
                break;
6202
 
 
6203
 
                case 2:
6204
 
                        ndr_print_ptr(ndr, "info2", r->info2);
6205
 
                        ndr->depth++;
6206
 
                        if (r->info2) {
6207
 
                                ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6208
 
                        }
6209
 
                        ndr->depth--;
6210
 
                break;
6211
 
 
6212
 
                case 3:
6213
 
                        ndr_print_ptr(ndr, "info3", r->info3);
6214
 
                        ndr->depth++;
6215
 
                        if (r->info3) {
6216
 
                                ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6217
 
                        }
6218
 
                        ndr->depth--;
6219
 
                break;
6220
 
 
6221
 
                case 4:
6222
 
                        ndr_print_ptr(ndr, "info4", r->info4);
6223
 
                        ndr->depth++;
6224
 
                        if (r->info4) {
6225
 
                                ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6226
 
                        }
6227
 
                        ndr->depth--;
6228
 
                break;
6229
 
 
6230
 
                default:
6231
 
                break;
6232
 
 
6233
 
        }
6234
 
}
6235
 
 
6236
 
static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6237
 
{
6238
 
        if (ndr_flags & NDR_SCALARS) {
6239
 
                NDR_CHECK(ndr_push_align(ndr, 5));
6240
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6241
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6242
 
                NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6243
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6244
 
        }
6245
 
        if (ndr_flags & NDR_BUFFERS) {
6246
 
                NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6247
 
        }
6248
 
        return NDR_ERR_SUCCESS;
6249
 
}
6250
 
 
6251
 
static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6252
 
{
6253
 
        if (ndr_flags & NDR_SCALARS) {
6254
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
6255
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6256
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6257
 
                NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6258
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6259
 
        }
6260
 
        if (ndr_flags & NDR_BUFFERS) {
6261
 
                NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6262
 
        }
6263
 
        return NDR_ERR_SUCCESS;
6264
 
}
6265
 
 
6266
 
_PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6267
 
{
6268
 
        ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6269
 
        ndr->depth++;
6270
 
        ndr_print_uint32(ndr, "level", r->level);
6271
 
        ndr_print_set_switch_value(ndr, &r->info, r->level);
6272
 
        ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6273
 
        ndr->depth--;
6274
 
}
6275
 
 
6276
 
static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6277
 
{
6278
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6279
 
        return NDR_ERR_SUCCESS;
6280
 
}
6281
 
 
6282
 
static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6283
 
{
6284
 
        uint32_t v;
6285
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6286
 
        *r = v;
6287
 
        return NDR_ERR_SUCCESS;
6288
 
}
6289
 
 
6290
 
_PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6291
 
{
6292
 
        const char *val = NULL;
6293
 
 
6294
 
        switch (r) {
6295
 
                case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6296
 
                case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6297
 
                case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6298
 
                case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6299
 
                case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6300
 
                case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6301
 
                case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6302
 
                case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6303
 
                case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6304
 
        }
6305
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
6306
 
}
6307
 
 
6308
 
static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6309
 
{
6310
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6311
 
        return NDR_ERR_SUCCESS;
6312
 
}
6313
 
 
6314
 
static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6315
 
{
6316
 
        uint32_t v;
6317
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6318
 
        *r = v;
6319
 
        return NDR_ERR_SUCCESS;
6320
 
}
6321
 
 
6322
 
_PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6323
 
{
6324
 
        const char *val = NULL;
6325
 
 
6326
 
        switch (r) {
6327
 
                case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6328
 
                case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6329
 
                case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6330
 
                case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6331
 
                case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6332
 
        }
6333
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
6334
 
}
6335
 
 
6336
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6337
 
{
6338
 
        if (ndr_flags & NDR_SCALARS) {
6339
 
                NDR_CHECK(ndr_push_align(ndr, 5));
6340
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6341
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6342
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6343
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6344
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6345
 
                NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6346
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6347
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6348
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6349
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6350
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6351
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6352
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6353
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6354
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6355
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6356
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6357
 
                NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6358
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6359
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6360
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6361
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6362
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6363
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6364
 
                NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6365
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6366
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6367
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6368
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6369
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6370
 
        }
6371
 
        if (ndr_flags & NDR_BUFFERS) {
6372
 
                if (r->servername) {
6373
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6374
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6375
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6376
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6377
 
                }
6378
 
                if (r->printername) {
6379
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6380
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6381
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6382
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6383
 
                }
6384
 
        }
6385
 
        return NDR_ERR_SUCCESS;
6386
 
}
6387
 
 
6388
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6389
 
{
6390
 
        uint32_t _ptr_servername;
6391
 
        TALLOC_CTX *_mem_save_servername_0;
6392
 
        uint32_t _ptr_printername;
6393
 
        TALLOC_CTX *_mem_save_printername_0;
6394
 
        if (ndr_flags & NDR_SCALARS) {
6395
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
6396
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6397
 
                if (_ptr_servername) {
6398
 
                        NDR_PULL_ALLOC(ndr, r->servername);
6399
 
                } else {
6400
 
                        r->servername = NULL;
6401
 
                }
6402
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6403
 
                if (_ptr_printername) {
6404
 
                        NDR_PULL_ALLOC(ndr, r->printername);
6405
 
                } else {
6406
 
                        r->printername = NULL;
6407
 
                }
6408
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6409
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6410
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6411
 
                NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6412
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6413
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6414
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6415
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6416
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6417
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6418
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6419
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6420
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6421
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6422
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6423
 
                NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6424
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6425
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6426
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6427
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6428
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6429
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6430
 
                NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6431
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6432
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6433
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6434
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6435
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6436
 
        }
6437
 
        if (ndr_flags & NDR_BUFFERS) {
6438
 
                if (r->servername) {
6439
 
                        _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6440
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6441
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6442
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6443
 
                        if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6444
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6445
 
                        }
6446
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6447
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6448
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6449
 
                }
6450
 
                if (r->printername) {
6451
 
                        _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6452
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6453
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6454
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6455
 
                        if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6456
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6457
 
                        }
6458
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6459
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6460
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6461
 
                }
6462
 
        }
6463
 
        return NDR_ERR_SUCCESS;
6464
 
}
6465
 
 
6466
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6467
 
{
6468
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6469
 
        ndr->depth++;
6470
 
        ndr_print_ptr(ndr, "servername", r->servername);
6471
 
        ndr->depth++;
6472
 
        if (r->servername) {
6473
 
                ndr_print_string(ndr, "servername", r->servername);
6474
 
        }
6475
 
        ndr->depth--;
6476
 
        ndr_print_ptr(ndr, "printername", r->printername);
6477
 
        ndr->depth++;
6478
 
        if (r->printername) {
6479
 
                ndr_print_string(ndr, "printername", r->printername);
6480
 
        }
6481
 
        ndr->depth--;
6482
 
        ndr_print_uint32(ndr, "cjobs", r->cjobs);
6483
 
        ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6484
 
        ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6485
 
        ndr_print_spoolss_Time(ndr, "time", &r->time);
6486
 
        ndr_print_uint32(ndr, "global_counter", r->global_counter);
6487
 
        ndr_print_uint32(ndr, "total_pages", r->total_pages);
6488
 
        ndr_print_uint32(ndr, "version", r->version);
6489
 
        ndr_print_uint32(ndr, "free_build", r->free_build);
6490
 
        ndr_print_uint32(ndr, "spooling", r->spooling);
6491
 
        ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6492
 
        ndr_print_uint32(ndr, "session_counter", r->session_counter);
6493
 
        ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6494
 
        ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6495
 
        ndr_print_uint32(ndr, "job_error", r->job_error);
6496
 
        ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6497
 
        ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6498
 
        ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6499
 
        ndr_print_uint32(ndr, "change_id", r->change_id);
6500
 
        ndr_print_WERROR(ndr, "last_error", r->last_error);
6501
 
        ndr_print_uint32(ndr, "status", r->status);
6502
 
        ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6503
 
        ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6504
 
        ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6505
 
        ndr_print_uint16(ndr, "processor_level", r->processor_level);
6506
 
        ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6507
 
        ndr_print_uint32(ndr, "reserved2", r->reserved2);
6508
 
        ndr_print_uint32(ndr, "reserved3", r->reserved3);
6509
 
        ndr->depth--;
6510
 
}
6511
 
 
6512
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6513
 
{
6514
 
        if (ndr_flags & NDR_SCALARS) {
6515
 
                NDR_CHECK(ndr_push_align(ndr, 5));
6516
 
                NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6517
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6518
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6519
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6520
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6521
 
        }
6522
 
        if (ndr_flags & NDR_BUFFERS) {
6523
 
                if (r->description) {
6524
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6525
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6526
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6527
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6528
 
                }
6529
 
                if (r->name) {
6530
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6531
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6532
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6533
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6534
 
                }
6535
 
                if (r->comment) {
6536
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6537
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6538
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6539
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6540
 
                }
6541
 
        }
6542
 
        return NDR_ERR_SUCCESS;
6543
 
}
6544
 
 
6545
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6546
 
{
6547
 
        uint32_t _ptr_description;
6548
 
        TALLOC_CTX *_mem_save_description_0;
6549
 
        uint32_t _ptr_name;
6550
 
        TALLOC_CTX *_mem_save_name_0;
6551
 
        uint32_t _ptr_comment;
6552
 
        TALLOC_CTX *_mem_save_comment_0;
6553
 
        if (ndr_flags & NDR_SCALARS) {
6554
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
6555
 
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6556
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6557
 
                if (_ptr_description) {
6558
 
                        NDR_PULL_ALLOC(ndr, r->description);
6559
 
                } else {
6560
 
                        r->description = NULL;
6561
 
                }
6562
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6563
 
                if (_ptr_name) {
6564
 
                        NDR_PULL_ALLOC(ndr, r->name);
6565
 
                } else {
6566
 
                        r->name = NULL;
6567
 
                }
6568
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6569
 
                if (_ptr_comment) {
6570
 
                        NDR_PULL_ALLOC(ndr, r->comment);
6571
 
                } else {
6572
 
                        r->comment = NULL;
6573
 
                }
6574
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6575
 
        }
6576
 
        if (ndr_flags & NDR_BUFFERS) {
6577
 
                if (r->description) {
6578
 
                        _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6579
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6580
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6581
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6582
 
                        if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6583
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
6584
 
                        }
6585
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6586
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6587
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6588
 
                }
6589
 
                if (r->name) {
6590
 
                        _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6591
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6592
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6593
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6594
 
                        if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6595
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
6596
 
                        }
6597
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6598
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6599
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6600
 
                }
6601
 
                if (r->comment) {
6602
 
                        _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6603
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6604
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6605
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6606
 
                        if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6607
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6608
 
                        }
6609
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6610
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6611
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6612
 
                }
6613
 
        }
6614
 
        return NDR_ERR_SUCCESS;
6615
 
}
6616
 
 
6617
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6618
 
{
6619
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6620
 
        ndr->depth++;
6621
 
        ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
6622
 
        ndr_print_ptr(ndr, "description", r->description);
6623
 
        ndr->depth++;
6624
 
        if (r->description) {
6625
 
                ndr_print_string(ndr, "description", r->description);
6626
 
        }
6627
 
        ndr->depth--;
6628
 
        ndr_print_ptr(ndr, "name", r->name);
6629
 
        ndr->depth++;
6630
 
        if (r->name) {
6631
 
                ndr_print_string(ndr, "name", r->name);
6632
 
        }
6633
 
        ndr->depth--;
6634
 
        ndr_print_ptr(ndr, "comment", r->comment);
6635
 
        ndr->depth++;
6636
 
        if (r->comment) {
6637
 
                ndr_print_string(ndr, "comment", r->comment);
6638
 
        }
6639
 
        ndr->depth--;
6640
 
        ndr->depth--;
6641
 
}
6642
 
 
6643
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6644
 
{
6645
 
        if (ndr_flags & NDR_SCALARS) {
6646
 
                NDR_CHECK(ndr_push_align(ndr, 5));
6647
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6648
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6649
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6650
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6651
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6652
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6653
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6654
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
6655
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6656
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6657
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6658
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6659
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secdesc_ptr));
6660
 
                NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6661
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6662
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6663
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6664
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6665
 
                NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6666
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6667
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6668
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6669
 
        }
6670
 
        if (ndr_flags & NDR_BUFFERS) {
6671
 
                if (r->servername) {
6672
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6673
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6674
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6675
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6676
 
                }
6677
 
                if (r->printername) {
6678
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6679
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6680
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6681
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6682
 
                }
6683
 
                if (r->sharename) {
6684
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6685
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6686
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6687
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6688
 
                }
6689
 
                if (r->portname) {
6690
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6691
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6692
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6693
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6694
 
                }
6695
 
                if (r->drivername) {
6696
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6697
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6698
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6699
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6700
 
                }
6701
 
                if (r->comment) {
6702
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6703
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6704
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6705
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6706
 
                }
6707
 
                if (r->location) {
6708
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6709
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6710
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6711
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6712
 
                }
6713
 
                if (r->sepfile) {
6714
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6715
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6716
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6717
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6718
 
                }
6719
 
                if (r->printprocessor) {
6720
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6721
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6722
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6723
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6724
 
                }
6725
 
                if (r->datatype) {
6726
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6727
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6728
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6729
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6730
 
                }
6731
 
                if (r->parameters) {
6732
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6733
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6734
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6735
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6736
 
                }
6737
 
        }
6738
 
        return NDR_ERR_SUCCESS;
6739
 
}
6740
 
 
6741
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6742
 
{
6743
 
        uint32_t _ptr_servername;
6744
 
        TALLOC_CTX *_mem_save_servername_0;
6745
 
        uint32_t _ptr_printername;
6746
 
        TALLOC_CTX *_mem_save_printername_0;
6747
 
        uint32_t _ptr_sharename;
6748
 
        TALLOC_CTX *_mem_save_sharename_0;
6749
 
        uint32_t _ptr_portname;
6750
 
        TALLOC_CTX *_mem_save_portname_0;
6751
 
        uint32_t _ptr_drivername;
6752
 
        TALLOC_CTX *_mem_save_drivername_0;
6753
 
        uint32_t _ptr_comment;
6754
 
        TALLOC_CTX *_mem_save_comment_0;
6755
 
        uint32_t _ptr_location;
6756
 
        TALLOC_CTX *_mem_save_location_0;
6757
 
        uint32_t _ptr_sepfile;
6758
 
        TALLOC_CTX *_mem_save_sepfile_0;
6759
 
        uint32_t _ptr_printprocessor;
6760
 
        TALLOC_CTX *_mem_save_printprocessor_0;
6761
 
        uint32_t _ptr_datatype;
6762
 
        TALLOC_CTX *_mem_save_datatype_0;
6763
 
        uint32_t _ptr_parameters;
6764
 
        TALLOC_CTX *_mem_save_parameters_0;
6765
 
        if (ndr_flags & NDR_SCALARS) {
6766
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
6767
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6768
 
                if (_ptr_servername) {
6769
 
                        NDR_PULL_ALLOC(ndr, r->servername);
6770
 
                } else {
6771
 
                        r->servername = NULL;
6772
 
                }
6773
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6774
 
                if (_ptr_printername) {
6775
 
                        NDR_PULL_ALLOC(ndr, r->printername);
6776
 
                } else {
6777
 
                        r->printername = NULL;
6778
 
                }
6779
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6780
 
                if (_ptr_sharename) {
6781
 
                        NDR_PULL_ALLOC(ndr, r->sharename);
6782
 
                } else {
6783
 
                        r->sharename = NULL;
6784
 
                }
6785
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6786
 
                if (_ptr_portname) {
6787
 
                        NDR_PULL_ALLOC(ndr, r->portname);
6788
 
                } else {
6789
 
                        r->portname = NULL;
6790
 
                }
6791
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6792
 
                if (_ptr_drivername) {
6793
 
                        NDR_PULL_ALLOC(ndr, r->drivername);
6794
 
                } else {
6795
 
                        r->drivername = NULL;
6796
 
                }
6797
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6798
 
                if (_ptr_comment) {
6799
 
                        NDR_PULL_ALLOC(ndr, r->comment);
6800
 
                } else {
6801
 
                        r->comment = NULL;
6802
 
                }
6803
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6804
 
                if (_ptr_location) {
6805
 
                        NDR_PULL_ALLOC(ndr, r->location);
6806
 
                } else {
6807
 
                        r->location = NULL;
6808
 
                }
6809
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
6810
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6811
 
                if (_ptr_sepfile) {
6812
 
                        NDR_PULL_ALLOC(ndr, r->sepfile);
6813
 
                } else {
6814
 
                        r->sepfile = NULL;
6815
 
                }
6816
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6817
 
                if (_ptr_printprocessor) {
6818
 
                        NDR_PULL_ALLOC(ndr, r->printprocessor);
6819
 
                } else {
6820
 
                        r->printprocessor = NULL;
6821
 
                }
6822
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6823
 
                if (_ptr_datatype) {
6824
 
                        NDR_PULL_ALLOC(ndr, r->datatype);
6825
 
                } else {
6826
 
                        r->datatype = NULL;
6827
 
                }
6828
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6829
 
                if (_ptr_parameters) {
6830
 
                        NDR_PULL_ALLOC(ndr, r->parameters);
6831
 
                } else {
6832
 
                        r->parameters = NULL;
6833
 
                }
6834
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secdesc_ptr));
6835
 
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6836
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6837
 
                if (r->priority > 99) {
6838
 
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6839
 
                }
6840
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6841
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6842
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6843
 
                NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6844
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6845
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6846
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6847
 
        }
6848
 
        if (ndr_flags & NDR_BUFFERS) {
6849
 
                if (r->servername) {
6850
 
                        _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6851
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6852
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6853
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6854
 
                        if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6855
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6856
 
                        }
6857
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6858
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6859
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6860
 
                }
6861
 
                if (r->printername) {
6862
 
                        _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6863
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6864
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6865
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6866
 
                        if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6867
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6868
 
                        }
6869
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6870
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6871
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6872
 
                }
6873
 
                if (r->sharename) {
6874
 
                        _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6875
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6876
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6877
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6878
 
                        if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6879
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
6880
 
                        }
6881
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6882
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6883
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6884
 
                }
6885
 
                if (r->portname) {
6886
 
                        _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6887
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6888
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6889
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6890
 
                        if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6891
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
6892
 
                        }
6893
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6894
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6895
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6896
 
                }
6897
 
                if (r->drivername) {
6898
 
                        _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6899
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6900
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6901
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6902
 
                        if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6903
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
6904
 
                        }
6905
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6906
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6907
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6908
 
                }
6909
 
                if (r->comment) {
6910
 
                        _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6911
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6912
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6913
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6914
 
                        if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6915
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6916
 
                        }
6917
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6918
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6919
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6920
 
                }
6921
 
                if (r->location) {
6922
 
                        _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6923
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6924
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6925
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6926
 
                        if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6927
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
6928
 
                        }
6929
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6930
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6931
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6932
 
                }
6933
 
                if (r->sepfile) {
6934
 
                        _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6935
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6936
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6937
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6938
 
                        if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6939
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
6940
 
                        }
6941
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6942
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6943
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6944
 
                }
6945
 
                if (r->printprocessor) {
6946
 
                        _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6947
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6948
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6949
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6950
 
                        if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6951
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
6952
 
                        }
6953
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6954
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6955
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6956
 
                }
6957
 
                if (r->datatype) {
6958
 
                        _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6959
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6960
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6961
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6962
 
                        if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6963
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
6964
 
                        }
6965
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6966
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6967
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6968
 
                }
6969
 
                if (r->parameters) {
6970
 
                        _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6971
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6972
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6973
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6974
 
                        if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6975
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
6976
 
                        }
6977
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6978
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6979
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6980
 
                }
6981
 
        }
6982
 
        return NDR_ERR_SUCCESS;
6983
 
}
6984
 
 
6985
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6986
 
{
6987
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6988
 
        ndr->depth++;
6989
 
        ndr_print_ptr(ndr, "servername", r->servername);
6990
 
        ndr->depth++;
6991
 
        if (r->servername) {
6992
 
                ndr_print_string(ndr, "servername", r->servername);
6993
 
        }
6994
 
        ndr->depth--;
6995
 
        ndr_print_ptr(ndr, "printername", r->printername);
6996
 
        ndr->depth++;
6997
 
        if (r->printername) {
6998
 
                ndr_print_string(ndr, "printername", r->printername);
6999
 
        }
7000
 
        ndr->depth--;
7001
 
        ndr_print_ptr(ndr, "sharename", r->sharename);
7002
 
        ndr->depth++;
7003
 
        if (r->sharename) {
7004
 
                ndr_print_string(ndr, "sharename", r->sharename);
7005
 
        }
7006
 
        ndr->depth--;
7007
 
        ndr_print_ptr(ndr, "portname", r->portname);
7008
 
        ndr->depth++;
7009
 
        if (r->portname) {
7010
 
                ndr_print_string(ndr, "portname", r->portname);
7011
 
        }
7012
 
        ndr->depth--;
7013
 
        ndr_print_ptr(ndr, "drivername", r->drivername);
7014
 
        ndr->depth++;
7015
 
        if (r->drivername) {
7016
 
                ndr_print_string(ndr, "drivername", r->drivername);
7017
 
        }
7018
 
        ndr->depth--;
7019
 
        ndr_print_ptr(ndr, "comment", r->comment);
7020
 
        ndr->depth++;
7021
 
        if (r->comment) {
7022
 
                ndr_print_string(ndr, "comment", r->comment);
7023
 
        }
7024
 
        ndr->depth--;
7025
 
        ndr_print_ptr(ndr, "location", r->location);
7026
 
        ndr->depth++;
7027
 
        if (r->location) {
7028
 
                ndr_print_string(ndr, "location", r->location);
7029
 
        }
7030
 
        ndr->depth--;
7031
 
        ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7032
 
        ndr_print_ptr(ndr, "sepfile", r->sepfile);
7033
 
        ndr->depth++;
7034
 
        if (r->sepfile) {
7035
 
                ndr_print_string(ndr, "sepfile", r->sepfile);
7036
 
        }
7037
 
        ndr->depth--;
7038
 
        ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7039
 
        ndr->depth++;
7040
 
        if (r->printprocessor) {
7041
 
                ndr_print_string(ndr, "printprocessor", r->printprocessor);
7042
 
        }
7043
 
        ndr->depth--;
7044
 
        ndr_print_ptr(ndr, "datatype", r->datatype);
7045
 
        ndr->depth++;
7046
 
        if (r->datatype) {
7047
 
                ndr_print_string(ndr, "datatype", r->datatype);
7048
 
        }
7049
 
        ndr->depth--;
7050
 
        ndr_print_ptr(ndr, "parameters", r->parameters);
7051
 
        ndr->depth++;
7052
 
        if (r->parameters) {
7053
 
                ndr_print_string(ndr, "parameters", r->parameters);
7054
 
        }
7055
 
        ndr->depth--;
7056
 
        ndr_print_uint32(ndr, "secdesc_ptr", r->secdesc_ptr);
7057
 
        ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7058
 
        ndr_print_uint32(ndr, "priority", r->priority);
7059
 
        ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7060
 
        ndr_print_uint32(ndr, "starttime", r->starttime);
7061
 
        ndr_print_uint32(ndr, "untiltime", r->untiltime);
7062
 
        ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7063
 
        ndr_print_uint32(ndr, "cjobs", r->cjobs);
7064
 
        ndr_print_uint32(ndr, "averageppm", r->averageppm);
7065
 
        ndr->depth--;
7066
 
}
7067
 
 
7068
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7069
 
{
7070
 
        if (ndr_flags & NDR_SCALARS) {
7071
 
                NDR_CHECK(ndr_push_align(ndr, 4));
7072
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7073
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7074
 
        }
7075
 
        if (ndr_flags & NDR_BUFFERS) {
7076
 
        }
7077
 
        return NDR_ERR_SUCCESS;
7078
 
}
7079
 
 
7080
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7081
 
{
7082
 
        if (ndr_flags & NDR_SCALARS) {
7083
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
7084
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7085
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7086
 
        }
7087
 
        if (ndr_flags & NDR_BUFFERS) {
7088
 
        }
7089
 
        return NDR_ERR_SUCCESS;
7090
 
}
7091
 
 
7092
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7093
 
{
7094
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7095
 
        ndr->depth++;
7096
 
        ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7097
 
        ndr->depth--;
7098
 
}
7099
 
 
7100
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7101
 
{
7102
 
        if (ndr_flags & NDR_SCALARS) {
7103
 
                NDR_CHECK(ndr_push_align(ndr, 5));
7104
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7105
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7106
 
                NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7107
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7108
 
        }
7109
 
        if (ndr_flags & NDR_BUFFERS) {
7110
 
                if (r->printername) {
7111
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7112
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7113
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7114
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7115
 
                }
7116
 
                if (r->servername) {
7117
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7118
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7119
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7120
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7121
 
                }
7122
 
        }
7123
 
        return NDR_ERR_SUCCESS;
7124
 
}
7125
 
 
7126
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7127
 
{
7128
 
        uint32_t _ptr_printername;
7129
 
        TALLOC_CTX *_mem_save_printername_0;
7130
 
        uint32_t _ptr_servername;
7131
 
        TALLOC_CTX *_mem_save_servername_0;
7132
 
        if (ndr_flags & NDR_SCALARS) {
7133
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
7134
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7135
 
                if (_ptr_printername) {
7136
 
                        NDR_PULL_ALLOC(ndr, r->printername);
7137
 
                } else {
7138
 
                        r->printername = NULL;
7139
 
                }
7140
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7141
 
                if (_ptr_servername) {
7142
 
                        NDR_PULL_ALLOC(ndr, r->servername);
7143
 
                } else {
7144
 
                        r->servername = NULL;
7145
 
                }
7146
 
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7147
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7148
 
        }
7149
 
        if (ndr_flags & NDR_BUFFERS) {
7150
 
                if (r->printername) {
7151
 
                        _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7152
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7153
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7154
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7155
 
                        if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7156
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7157
 
                        }
7158
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7159
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7160
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7161
 
                }
7162
 
                if (r->servername) {
7163
 
                        _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7164
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7165
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7166
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7167
 
                        if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7168
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
7169
 
                        }
7170
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7171
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7172
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7173
 
                }
7174
 
        }
7175
 
        return NDR_ERR_SUCCESS;
7176
 
}
7177
 
 
7178
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7179
 
{
7180
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7181
 
        ndr->depth++;
7182
 
        ndr_print_ptr(ndr, "printername", r->printername);
7183
 
        ndr->depth++;
7184
 
        if (r->printername) {
7185
 
                ndr_print_string(ndr, "printername", r->printername);
7186
 
        }
7187
 
        ndr->depth--;
7188
 
        ndr_print_ptr(ndr, "servername", r->servername);
7189
 
        ndr->depth++;
7190
 
        if (r->servername) {
7191
 
                ndr_print_string(ndr, "servername", r->servername);
7192
 
        }
7193
 
        ndr->depth--;
7194
 
        ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7195
 
        ndr->depth--;
7196
 
}
7197
 
 
7198
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7199
 
{
7200
 
        if (ndr_flags & NDR_SCALARS) {
7201
 
                NDR_CHECK(ndr_push_align(ndr, 5));
7202
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7203
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7204
 
                NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7205
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7206
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7207
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7208
 
        }
7209
 
        if (ndr_flags & NDR_BUFFERS) {
7210
 
                if (r->printername) {
7211
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7212
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7213
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7214
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7215
 
                }
7216
 
                if (r->portname) {
7217
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7218
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7219
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7220
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7221
 
                }
7222
 
        }
7223
 
        return NDR_ERR_SUCCESS;
7224
 
}
7225
 
 
7226
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7227
 
{
7228
 
        uint32_t _ptr_printername;
7229
 
        TALLOC_CTX *_mem_save_printername_0;
7230
 
        uint32_t _ptr_portname;
7231
 
        TALLOC_CTX *_mem_save_portname_0;
7232
 
        if (ndr_flags & NDR_SCALARS) {
7233
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
7234
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7235
 
                if (_ptr_printername) {
7236
 
                        NDR_PULL_ALLOC(ndr, r->printername);
7237
 
                } else {
7238
 
                        r->printername = NULL;
7239
 
                }
7240
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7241
 
                if (_ptr_portname) {
7242
 
                        NDR_PULL_ALLOC(ndr, r->portname);
7243
 
                } else {
7244
 
                        r->portname = NULL;
7245
 
                }
7246
 
                NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7247
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7248
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7249
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7250
 
        }
7251
 
        if (ndr_flags & NDR_BUFFERS) {
7252
 
                if (r->printername) {
7253
 
                        _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7254
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7255
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7256
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7257
 
                        if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7258
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7259
 
                        }
7260
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7261
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7262
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7263
 
                }
7264
 
                if (r->portname) {
7265
 
                        _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7266
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7267
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7268
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7269
 
                        if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7270
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
7271
 
                        }
7272
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7273
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7274
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7275
 
                }
7276
 
        }
7277
 
        return NDR_ERR_SUCCESS;
7278
 
}
7279
 
 
7280
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7281
 
{
7282
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7283
 
        ndr->depth++;
7284
 
        ndr_print_ptr(ndr, "printername", r->printername);
7285
 
        ndr->depth++;
7286
 
        if (r->printername) {
7287
 
                ndr_print_string(ndr, "printername", r->printername);
7288
 
        }
7289
 
        ndr->depth--;
7290
 
        ndr_print_ptr(ndr, "portname", r->portname);
7291
 
        ndr->depth++;
7292
 
        if (r->portname) {
7293
 
                ndr_print_string(ndr, "portname", r->portname);
7294
 
        }
7295
 
        ndr->depth--;
7296
 
        ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7297
 
        ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7298
 
        ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7299
 
        ndr->depth--;
7300
 
}
7301
 
 
7302
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7303
 
{
7304
 
        if (ndr_flags & NDR_SCALARS) {
7305
 
                NDR_CHECK(ndr_push_align(ndr, 4));
7306
 
                NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7307
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7308
 
        }
7309
 
        if (ndr_flags & NDR_BUFFERS) {
7310
 
        }
7311
 
        return NDR_ERR_SUCCESS;
7312
 
}
7313
 
 
7314
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7315
 
{
7316
 
        if (ndr_flags & NDR_SCALARS) {
7317
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
7318
 
                NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7319
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7320
 
        }
7321
 
        if (ndr_flags & NDR_BUFFERS) {
7322
 
        }
7323
 
        return NDR_ERR_SUCCESS;
7324
 
}
7325
 
 
7326
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7327
 
{
7328
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7329
 
        ndr->depth++;
7330
 
        ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7331
 
        ndr->depth--;
7332
 
}
7333
 
 
7334
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7335
 
{
7336
 
        if (ndr_flags & NDR_SCALARS) {
7337
 
                NDR_CHECK(ndr_push_align(ndr, 5));
7338
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7339
 
                NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7340
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7341
 
        }
7342
 
        if (ndr_flags & NDR_BUFFERS) {
7343
 
                if (r->guid) {
7344
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7345
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7346
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7347
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7348
 
                }
7349
 
        }
7350
 
        return NDR_ERR_SUCCESS;
7351
 
}
7352
 
 
7353
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7354
 
{
7355
 
        uint32_t _ptr_guid;
7356
 
        TALLOC_CTX *_mem_save_guid_0;
7357
 
        if (ndr_flags & NDR_SCALARS) {
7358
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
7359
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7360
 
                if (_ptr_guid) {
7361
 
                        NDR_PULL_ALLOC(ndr, r->guid);
7362
 
                } else {
7363
 
                        r->guid = NULL;
7364
 
                }
7365
 
                NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7366
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7367
 
        }
7368
 
        if (ndr_flags & NDR_BUFFERS) {
7369
 
                if (r->guid) {
7370
 
                        _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7371
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7372
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7373
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7374
 
                        if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7375
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
7376
 
                        }
7377
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7378
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7379
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7380
 
                }
7381
 
        }
7382
 
        return NDR_ERR_SUCCESS;
7383
 
}
7384
 
 
7385
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7386
 
{
7387
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7388
 
        ndr->depth++;
7389
 
        ndr_print_ptr(ndr, "guid", r->guid);
7390
 
        ndr->depth++;
7391
 
        if (r->guid) {
7392
 
                ndr_print_string(ndr, "guid", r->guid);
7393
 
        }
7394
 
        ndr->depth--;
7395
 
        ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7396
 
        ndr->depth--;
7397
 
}
7398
 
 
7399
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo8 *r)
7400
 
{
7401
 
        if (ndr_flags & NDR_SCALARS) {
7402
 
                NDR_CHECK(ndr_push_align(ndr, 4));
7403
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7404
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7405
 
        }
7406
 
        if (ndr_flags & NDR_BUFFERS) {
7407
 
        }
7408
 
        return NDR_ERR_SUCCESS;
7409
 
}
7410
 
 
7411
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo8 *r)
7412
 
{
7413
 
        if (ndr_flags & NDR_SCALARS) {
7414
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
7415
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7416
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7417
 
        }
7418
 
        if (ndr_flags & NDR_BUFFERS) {
7419
 
        }
7420
 
        return NDR_ERR_SUCCESS;
7421
 
}
7422
 
 
7423
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo8 *r)
7424
 
{
7425
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo8");
7426
 
        ndr->depth++;
7427
 
        ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7428
 
        ndr->depth--;
7429
 
}
7430
 
 
7431
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo9(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo9 *r)
7432
 
{
7433
 
        if (ndr_flags & NDR_SCALARS) {
7434
 
                NDR_CHECK(ndr_push_align(ndr, 4));
7435
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7436
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7437
 
        }
7438
 
        if (ndr_flags & NDR_BUFFERS) {
7439
 
        }
7440
 
        return NDR_ERR_SUCCESS;
7441
 
}
7442
 
 
7443
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo9(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo9 *r)
7444
 
{
7445
 
        if (ndr_flags & NDR_SCALARS) {
7446
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
7447
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7448
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7449
 
        }
7450
 
        if (ndr_flags & NDR_BUFFERS) {
7451
 
        }
7452
 
        return NDR_ERR_SUCCESS;
7453
 
}
7454
 
 
7455
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo9(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo9 *r)
7456
 
{
7457
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo9");
7458
 
        ndr->depth++;
7459
 
        ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7460
 
        ndr->depth--;
7461
 
}
7462
 
 
7463
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7464
 
{
7465
 
        if (ndr_flags & NDR_SCALARS) {
7466
 
                int level = ndr_push_get_switch_value(ndr, r);
7467
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7468
 
                NDR_CHECK(ndr_push_union_align(ndr, 5));
7469
 
                switch (level) {
7470
 
                        case 0: {
7471
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7472
 
                        break; }
7473
 
 
7474
 
                        case 1: {
7475
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7476
 
                        break; }
7477
 
 
7478
 
                        case 2: {
7479
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7480
 
                        break; }
7481
 
 
7482
 
                        case 3: {
7483
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7484
 
                        break; }
7485
 
 
7486
 
                        case 4: {
7487
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7488
 
                        break; }
7489
 
 
7490
 
                        case 5: {
7491
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7492
 
                        break; }
7493
 
 
7494
 
                        case 6: {
7495
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7496
 
                        break; }
7497
 
 
7498
 
                        case 7: {
7499
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7500
 
                        break; }
7501
 
 
7502
 
                        case 8: {
7503
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7504
 
                        break; }
7505
 
 
7506
 
                        case 9: {
7507
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7508
 
                        break; }
7509
 
 
7510
 
                        default: {
7511
 
                        break; }
7512
 
 
7513
 
                }
7514
 
        }
7515
 
        if (ndr_flags & NDR_BUFFERS) {
7516
 
                int level = ndr_push_get_switch_value(ndr, r);
7517
 
                switch (level) {
7518
 
                        case 0:
7519
 
                                if (r->info0) {
7520
 
                                        NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7521
 
                                }
7522
 
                        break;
7523
 
 
7524
 
                        case 1:
7525
 
                                if (r->info1) {
7526
 
                                        NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7527
 
                                }
7528
 
                        break;
7529
 
 
7530
 
                        case 2:
7531
 
                                if (r->info2) {
7532
 
                                        NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7533
 
                                }
7534
 
                        break;
7535
 
 
7536
 
                        case 3:
7537
 
                                if (r->info3) {
7538
 
                                        NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7539
 
                                }
7540
 
                        break;
7541
 
 
7542
 
                        case 4:
7543
 
                                if (r->info4) {
7544
 
                                        NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7545
 
                                }
7546
 
                        break;
7547
 
 
7548
 
                        case 5:
7549
 
                                if (r->info5) {
7550
 
                                        NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7551
 
                                }
7552
 
                        break;
7553
 
 
7554
 
                        case 6:
7555
 
                                if (r->info6) {
7556
 
                                        NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7557
 
                                }
7558
 
                        break;
7559
 
 
7560
 
                        case 7:
7561
 
                                if (r->info7) {
7562
 
                                        NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7563
 
                                }
7564
 
                        break;
7565
 
 
7566
 
                        case 8:
7567
 
                                if (r->info8) {
7568
 
                                        NDR_CHECK(ndr_push_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
7569
 
                                }
7570
 
                        break;
7571
 
 
7572
 
                        case 9:
7573
 
                                if (r->info9) {
7574
 
                                        NDR_CHECK(ndr_push_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
7575
 
                                }
7576
 
                        break;
7577
 
 
7578
 
                        default:
7579
 
                        break;
7580
 
 
7581
 
                }
7582
 
        }
7583
 
        return NDR_ERR_SUCCESS;
7584
 
}
7585
 
 
7586
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7587
 
{
7588
 
        int level;
7589
 
        uint32_t _level;
7590
 
        TALLOC_CTX *_mem_save_info0_0;
7591
 
        TALLOC_CTX *_mem_save_info1_0;
7592
 
        TALLOC_CTX *_mem_save_info2_0;
7593
 
        TALLOC_CTX *_mem_save_info3_0;
7594
 
        TALLOC_CTX *_mem_save_info4_0;
7595
 
        TALLOC_CTX *_mem_save_info5_0;
7596
 
        TALLOC_CTX *_mem_save_info6_0;
7597
 
        TALLOC_CTX *_mem_save_info7_0;
7598
 
        TALLOC_CTX *_mem_save_info8_0;
7599
 
        TALLOC_CTX *_mem_save_info9_0;
7600
 
        level = ndr_pull_get_switch_value(ndr, r);
7601
 
        if (ndr_flags & NDR_SCALARS) {
7602
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7603
 
                if (_level != level) {
7604
 
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7605
 
                }
7606
 
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
7607
 
                switch (level) {
7608
 
                        case 0: {
7609
 
                                uint32_t _ptr_info0;
7610
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7611
 
                                if (_ptr_info0) {
7612
 
                                        NDR_PULL_ALLOC(ndr, r->info0);
7613
 
                                } else {
7614
 
                                        r->info0 = NULL;
7615
 
                                }
7616
 
                        break; }
7617
 
 
7618
 
                        case 1: {
7619
 
                                uint32_t _ptr_info1;
7620
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7621
 
                                if (_ptr_info1) {
7622
 
                                        NDR_PULL_ALLOC(ndr, r->info1);
7623
 
                                } else {
7624
 
                                        r->info1 = NULL;
7625
 
                                }
7626
 
                        break; }
7627
 
 
7628
 
                        case 2: {
7629
 
                                uint32_t _ptr_info2;
7630
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7631
 
                                if (_ptr_info2) {
7632
 
                                        NDR_PULL_ALLOC(ndr, r->info2);
7633
 
                                } else {
7634
 
                                        r->info2 = NULL;
7635
 
                                }
7636
 
                        break; }
7637
 
 
7638
 
                        case 3: {
7639
 
                                uint32_t _ptr_info3;
7640
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7641
 
                                if (_ptr_info3) {
7642
 
                                        NDR_PULL_ALLOC(ndr, r->info3);
7643
 
                                } else {
7644
 
                                        r->info3 = NULL;
7645
 
                                }
7646
 
                        break; }
7647
 
 
7648
 
                        case 4: {
7649
 
                                uint32_t _ptr_info4;
7650
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7651
 
                                if (_ptr_info4) {
7652
 
                                        NDR_PULL_ALLOC(ndr, r->info4);
7653
 
                                } else {
7654
 
                                        r->info4 = NULL;
7655
 
                                }
7656
 
                        break; }
7657
 
 
7658
 
                        case 5: {
7659
 
                                uint32_t _ptr_info5;
7660
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7661
 
                                if (_ptr_info5) {
7662
 
                                        NDR_PULL_ALLOC(ndr, r->info5);
7663
 
                                } else {
7664
 
                                        r->info5 = NULL;
7665
 
                                }
7666
 
                        break; }
7667
 
 
7668
 
                        case 6: {
7669
 
                                uint32_t _ptr_info6;
7670
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7671
 
                                if (_ptr_info6) {
7672
 
                                        NDR_PULL_ALLOC(ndr, r->info6);
7673
 
                                } else {
7674
 
                                        r->info6 = NULL;
7675
 
                                }
7676
 
                        break; }
7677
 
 
7678
 
                        case 7: {
7679
 
                                uint32_t _ptr_info7;
7680
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7681
 
                                if (_ptr_info7) {
7682
 
                                        NDR_PULL_ALLOC(ndr, r->info7);
7683
 
                                } else {
7684
 
                                        r->info7 = NULL;
7685
 
                                }
7686
 
                        break; }
7687
 
 
7688
 
                        case 8: {
7689
 
                                uint32_t _ptr_info8;
7690
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7691
 
                                if (_ptr_info8) {
7692
 
                                        NDR_PULL_ALLOC(ndr, r->info8);
7693
 
                                } else {
7694
 
                                        r->info8 = NULL;
7695
 
                                }
7696
 
                        break; }
7697
 
 
7698
 
                        case 9: {
7699
 
                                uint32_t _ptr_info9;
7700
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7701
 
                                if (_ptr_info9) {
7702
 
                                        NDR_PULL_ALLOC(ndr, r->info9);
7703
 
                                } else {
7704
 
                                        r->info9 = NULL;
7705
 
                                }
7706
 
                        break; }
7707
 
 
7708
 
                        default: {
7709
 
                        break; }
7710
 
 
7711
 
                }
7712
 
        }
7713
 
        if (ndr_flags & NDR_BUFFERS) {
7714
 
                switch (level) {
7715
 
                        case 0:
7716
 
                                if (r->info0) {
7717
 
                                        _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7718
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7719
 
                                        NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7720
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7721
 
                                }
7722
 
                        break;
7723
 
 
7724
 
                        case 1:
7725
 
                                if (r->info1) {
7726
 
                                        _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7727
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7728
 
                                        NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7729
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7730
 
                                }
7731
 
                        break;
7732
 
 
7733
 
                        case 2:
7734
 
                                if (r->info2) {
7735
 
                                        _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7736
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7737
 
                                        NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7738
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7739
 
                                }
7740
 
                        break;
7741
 
 
7742
 
                        case 3:
7743
 
                                if (r->info3) {
7744
 
                                        _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7745
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7746
 
                                        NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7747
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7748
 
                                }
7749
 
                        break;
7750
 
 
7751
 
                        case 4:
7752
 
                                if (r->info4) {
7753
 
                                        _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7754
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7755
 
                                        NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7756
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7757
 
                                }
7758
 
                        break;
7759
 
 
7760
 
                        case 5:
7761
 
                                if (r->info5) {
7762
 
                                        _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7763
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7764
 
                                        NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7765
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7766
 
                                }
7767
 
                        break;
7768
 
 
7769
 
                        case 6:
7770
 
                                if (r->info6) {
7771
 
                                        _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7772
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7773
 
                                        NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7774
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7775
 
                                }
7776
 
                        break;
7777
 
 
7778
 
                        case 7:
7779
 
                                if (r->info7) {
7780
 
                                        _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7781
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7782
 
                                        NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7783
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7784
 
                                }
7785
 
                        break;
7786
 
 
7787
 
                        case 8:
7788
 
                                if (r->info8) {
7789
 
                                        _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7790
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7791
 
                                        NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
7792
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7793
 
                                }
7794
 
                        break;
7795
 
 
7796
 
                        case 9:
7797
 
                                if (r->info9) {
7798
 
                                        _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7799
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7800
 
                                        NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
7801
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7802
 
                                }
7803
 
                        break;
7804
 
 
7805
 
                        default:
7806
 
                        break;
7807
 
 
7808
 
                }
7809
 
        }
7810
 
        return NDR_ERR_SUCCESS;
7811
 
}
7812
 
 
7813
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7814
 
{
7815
 
        int level;
7816
 
        level = ndr_print_get_switch_value(ndr, r);
7817
 
        ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7818
 
        switch (level) {
7819
 
                case 0:
7820
 
                        ndr_print_ptr(ndr, "info0", r->info0);
7821
 
                        ndr->depth++;
7822
 
                        if (r->info0) {
7823
 
                                ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7824
 
                        }
7825
 
                        ndr->depth--;
7826
 
                break;
7827
 
 
7828
 
                case 1:
7829
 
                        ndr_print_ptr(ndr, "info1", r->info1);
7830
 
                        ndr->depth++;
7831
 
                        if (r->info1) {
7832
 
                                ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7833
 
                        }
7834
 
                        ndr->depth--;
7835
 
                break;
7836
 
 
7837
 
                case 2:
7838
 
                        ndr_print_ptr(ndr, "info2", r->info2);
7839
 
                        ndr->depth++;
7840
 
                        if (r->info2) {
7841
 
                                ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7842
 
                        }
7843
 
                        ndr->depth--;
7844
 
                break;
7845
 
 
7846
 
                case 3:
7847
 
                        ndr_print_ptr(ndr, "info3", r->info3);
7848
 
                        ndr->depth++;
7849
 
                        if (r->info3) {
7850
 
                                ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7851
 
                        }
7852
 
                        ndr->depth--;
7853
 
                break;
7854
 
 
7855
 
                case 4:
7856
 
                        ndr_print_ptr(ndr, "info4", r->info4);
7857
 
                        ndr->depth++;
7858
 
                        if (r->info4) {
7859
 
                                ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7860
 
                        }
7861
 
                        ndr->depth--;
7862
 
                break;
7863
 
 
7864
 
                case 5:
7865
 
                        ndr_print_ptr(ndr, "info5", r->info5);
7866
 
                        ndr->depth++;
7867
 
                        if (r->info5) {
7868
 
                                ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7869
 
                        }
7870
 
                        ndr->depth--;
7871
 
                break;
7872
 
 
7873
 
                case 6:
7874
 
                        ndr_print_ptr(ndr, "info6", r->info6);
7875
 
                        ndr->depth++;
7876
 
                        if (r->info6) {
7877
 
                                ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7878
 
                        }
7879
 
                        ndr->depth--;
7880
 
                break;
7881
 
 
7882
 
                case 7:
7883
 
                        ndr_print_ptr(ndr, "info7", r->info7);
7884
 
                        ndr->depth++;
7885
 
                        if (r->info7) {
7886
 
                                ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7887
 
                        }
7888
 
                        ndr->depth--;
7889
 
                break;
7890
 
 
7891
 
                case 8:
7892
 
                        ndr_print_ptr(ndr, "info8", r->info8);
7893
 
                        ndr->depth++;
7894
 
                        if (r->info8) {
7895
 
                                ndr_print_spoolss_SetPrinterInfo8(ndr, "info8", r->info8);
7896
 
                        }
7897
 
                        ndr->depth--;
7898
 
                break;
7899
 
 
7900
 
                case 9:
7901
 
                        ndr_print_ptr(ndr, "info9", r->info9);
7902
 
                        ndr->depth++;
7903
 
                        if (r->info9) {
7904
 
                                ndr_print_spoolss_SetPrinterInfo9(ndr, "info9", r->info9);
7905
 
                        }
7906
 
                        ndr->depth--;
7907
 
                break;
7908
 
 
7909
 
                default:
7910
 
                break;
7911
 
 
7912
 
        }
7913
 
}
7914
 
 
7915
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7916
 
{
7917
 
        if (ndr_flags & NDR_SCALARS) {
7918
 
                NDR_CHECK(ndr_push_align(ndr, 5));
7919
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7920
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7921
 
                NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7922
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7923
 
        }
7924
 
        if (ndr_flags & NDR_BUFFERS) {
7925
 
                NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7926
 
        }
7927
 
        return NDR_ERR_SUCCESS;
7928
 
}
7929
 
 
7930
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7931
 
{
7932
 
        if (ndr_flags & NDR_SCALARS) {
7933
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
7934
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7935
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7936
 
                NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7937
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7938
 
        }
7939
 
        if (ndr_flags & NDR_BUFFERS) {
7940
 
                NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7941
 
        }
7942
 
        return NDR_ERR_SUCCESS;
7943
 
}
7944
 
 
7945
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7946
 
{
7947
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7948
 
        ndr->depth++;
7949
 
        ndr_print_uint32(ndr, "level", r->level);
7950
 
        ndr_print_set_switch_value(ndr, &r->info, r->level);
7951
 
        ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7952
 
        ndr->depth--;
7953
 
}
7954
 
 
7955
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7956
 
{
7957
 
        if (ndr_flags & NDR_SCALARS) {
7958
 
                NDR_CHECK(ndr_push_align(ndr, 4));
7959
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7960
 
                {
7961
 
                        uint32_t _flags_save_string_array = ndr->flags;
7962
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
7963
 
                        NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7964
 
                        ndr->flags = _flags_save_string_array;
7965
 
                }
7966
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7967
 
        }
7968
 
        if (ndr_flags & NDR_BUFFERS) {
7969
 
        }
7970
 
        return NDR_ERR_SUCCESS;
7971
 
}
7972
 
 
7973
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7974
 
{
7975
 
        if (ndr_flags & NDR_SCALARS) {
7976
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
7977
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7978
 
                {
7979
 
                        uint32_t _flags_save_string_array = ndr->flags;
7980
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
7981
 
                        NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7982
 
                        ndr->flags = _flags_save_string_array;
7983
 
                }
7984
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7985
 
        }
7986
 
        if (ndr_flags & NDR_BUFFERS) {
7987
 
        }
7988
 
        return NDR_ERR_SUCCESS;
7989
 
}
7990
 
 
7991
 
_PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7992
 
{
7993
 
        ndr_print_struct(ndr, name, "spoolss_StringArray");
7994
 
        ndr->depth++;
7995
 
        ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
7996
 
        ndr_print_string_array(ndr, "string", r->string);
7997
 
        ndr->depth--;
7998
 
}
7999
 
 
8000
 
static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
8001
 
{
8002
 
        if (ndr_flags & NDR_SCALARS) {
8003
 
                NDR_CHECK(ndr_push_align(ndr, 5));
8004
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8005
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8006
 
        }
8007
 
        if (ndr_flags & NDR_BUFFERS) {
8008
 
                if (r->driver_name) {
8009
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8010
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8011
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8012
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8013
 
                }
8014
 
        }
8015
 
        return NDR_ERR_SUCCESS;
8016
 
}
8017
 
 
8018
 
static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
8019
 
{
8020
 
        uint32_t _ptr_driver_name;
8021
 
        TALLOC_CTX *_mem_save_driver_name_0;
8022
 
        if (ndr_flags & NDR_SCALARS) {
8023
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
8024
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8025
 
                if (_ptr_driver_name) {
8026
 
                        NDR_PULL_ALLOC(ndr, r->driver_name);
8027
 
                } else {
8028
 
                        r->driver_name = NULL;
8029
 
                }
8030
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8031
 
        }
8032
 
        if (ndr_flags & NDR_BUFFERS) {
8033
 
                if (r->driver_name) {
8034
 
                        _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8035
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8036
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8037
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8038
 
                        if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8039
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8040
 
                        }
8041
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8042
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8043
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8044
 
                }
8045
 
        }
8046
 
        return NDR_ERR_SUCCESS;
8047
 
}
8048
 
 
8049
 
_PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8050
 
{
8051
 
        ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8052
 
        ndr->depth++;
8053
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
8054
 
        ndr->depth++;
8055
 
        if (r->driver_name) {
8056
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
8057
 
        }
8058
 
        ndr->depth--;
8059
 
        ndr->depth--;
8060
 
}
8061
 
 
8062
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8063
 
{
8064
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8065
 
        return NDR_ERR_SUCCESS;
8066
 
}
8067
 
 
8068
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8069
 
{
8070
 
        uint32_t v;
8071
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8072
 
        *r = v;
8073
 
        return NDR_ERR_SUCCESS;
8074
 
}
8075
 
 
8076
 
_PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8077
 
{
8078
 
        const char *val = NULL;
8079
 
 
8080
 
        switch (r) {
8081
 
                case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8082
 
                case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8083
 
                case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8084
 
                case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8085
 
        }
8086
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
8087
 
}
8088
 
 
8089
 
static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8090
 
{
8091
 
        if (ndr_flags & NDR_SCALARS) {
8092
 
                NDR_CHECK(ndr_push_align(ndr, 5));
8093
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8094
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8095
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8096
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8097
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8098
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8099
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8100
 
        }
8101
 
        if (ndr_flags & NDR_BUFFERS) {
8102
 
                if (r->driver_name) {
8103
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8104
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8105
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8106
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8107
 
                }
8108
 
                if (r->architecture) {
8109
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8110
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8111
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8112
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8113
 
                }
8114
 
                if (r->driver_path) {
8115
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8116
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8117
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8118
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8119
 
                }
8120
 
                if (r->data_file) {
8121
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8122
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8123
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8124
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8125
 
                }
8126
 
                if (r->config_file) {
8127
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8128
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8129
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8130
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8131
 
                }
8132
 
        }
8133
 
        return NDR_ERR_SUCCESS;
8134
 
}
8135
 
 
8136
 
static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8137
 
{
8138
 
        uint32_t _ptr_driver_name;
8139
 
        TALLOC_CTX *_mem_save_driver_name_0;
8140
 
        uint32_t _ptr_architecture;
8141
 
        TALLOC_CTX *_mem_save_architecture_0;
8142
 
        uint32_t _ptr_driver_path;
8143
 
        TALLOC_CTX *_mem_save_driver_path_0;
8144
 
        uint32_t _ptr_data_file;
8145
 
        TALLOC_CTX *_mem_save_data_file_0;
8146
 
        uint32_t _ptr_config_file;
8147
 
        TALLOC_CTX *_mem_save_config_file_0;
8148
 
        if (ndr_flags & NDR_SCALARS) {
8149
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
8150
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8151
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8152
 
                if (_ptr_driver_name) {
8153
 
                        NDR_PULL_ALLOC(ndr, r->driver_name);
8154
 
                } else {
8155
 
                        r->driver_name = NULL;
8156
 
                }
8157
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8158
 
                if (_ptr_architecture) {
8159
 
                        NDR_PULL_ALLOC(ndr, r->architecture);
8160
 
                } else {
8161
 
                        r->architecture = NULL;
8162
 
                }
8163
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8164
 
                if (_ptr_driver_path) {
8165
 
                        NDR_PULL_ALLOC(ndr, r->driver_path);
8166
 
                } else {
8167
 
                        r->driver_path = NULL;
8168
 
                }
8169
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8170
 
                if (_ptr_data_file) {
8171
 
                        NDR_PULL_ALLOC(ndr, r->data_file);
8172
 
                } else {
8173
 
                        r->data_file = NULL;
8174
 
                }
8175
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8176
 
                if (_ptr_config_file) {
8177
 
                        NDR_PULL_ALLOC(ndr, r->config_file);
8178
 
                } else {
8179
 
                        r->config_file = NULL;
8180
 
                }
8181
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8182
 
        }
8183
 
        if (ndr_flags & NDR_BUFFERS) {
8184
 
                if (r->driver_name) {
8185
 
                        _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8186
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8187
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8188
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8189
 
                        if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8190
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8191
 
                        }
8192
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8193
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8194
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8195
 
                }
8196
 
                if (r->architecture) {
8197
 
                        _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8198
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8199
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8200
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8201
 
                        if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8202
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8203
 
                        }
8204
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8205
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8206
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8207
 
                }
8208
 
                if (r->driver_path) {
8209
 
                        _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8210
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8211
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8212
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8213
 
                        if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8214
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8215
 
                        }
8216
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8217
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8218
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8219
 
                }
8220
 
                if (r->data_file) {
8221
 
                        _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8222
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8223
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8224
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8225
 
                        if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8226
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8227
 
                        }
8228
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8229
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8230
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8231
 
                }
8232
 
                if (r->config_file) {
8233
 
                        _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8234
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8235
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8236
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8237
 
                        if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8238
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8239
 
                        }
8240
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8241
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8242
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8243
 
                }
8244
 
        }
8245
 
        return NDR_ERR_SUCCESS;
8246
 
}
8247
 
 
8248
 
_PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8249
 
{
8250
 
        ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8251
 
        ndr->depth++;
8252
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8253
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
8254
 
        ndr->depth++;
8255
 
        if (r->driver_name) {
8256
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
8257
 
        }
8258
 
        ndr->depth--;
8259
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
8260
 
        ndr->depth++;
8261
 
        if (r->architecture) {
8262
 
                ndr_print_string(ndr, "architecture", r->architecture);
8263
 
        }
8264
 
        ndr->depth--;
8265
 
        ndr_print_ptr(ndr, "driver_path", r->driver_path);
8266
 
        ndr->depth++;
8267
 
        if (r->driver_path) {
8268
 
                ndr_print_string(ndr, "driver_path", r->driver_path);
8269
 
        }
8270
 
        ndr->depth--;
8271
 
        ndr_print_ptr(ndr, "data_file", r->data_file);
8272
 
        ndr->depth++;
8273
 
        if (r->data_file) {
8274
 
                ndr_print_string(ndr, "data_file", r->data_file);
8275
 
        }
8276
 
        ndr->depth--;
8277
 
        ndr_print_ptr(ndr, "config_file", r->config_file);
8278
 
        ndr->depth++;
8279
 
        if (r->config_file) {
8280
 
                ndr_print_string(ndr, "config_file", r->config_file);
8281
 
        }
8282
 
        ndr->depth--;
8283
 
        ndr->depth--;
8284
 
}
8285
 
 
8286
 
static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8287
 
{
8288
 
        if (ndr_flags & NDR_SCALARS) {
8289
 
                NDR_CHECK(ndr_push_align(ndr, 5));
8290
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8291
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8292
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8293
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8294
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8295
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8296
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8297
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8298
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8299
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8300
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8301
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8302
 
        }
8303
 
        if (ndr_flags & NDR_BUFFERS) {
8304
 
                if (r->driver_name) {
8305
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8306
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8307
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8308
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8309
 
                }
8310
 
                if (r->architecture) {
8311
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8312
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8313
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8314
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8315
 
                }
8316
 
                if (r->driver_path) {
8317
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8318
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8319
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8320
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8321
 
                }
8322
 
                if (r->data_file) {
8323
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8324
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8325
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8326
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8327
 
                }
8328
 
                if (r->config_file) {
8329
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8330
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8331
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8332
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8333
 
                }
8334
 
                if (r->help_file) {
8335
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8336
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8337
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8338
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8339
 
                }
8340
 
                if (r->monitor_name) {
8341
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8342
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8343
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8344
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8345
 
                }
8346
 
                if (r->default_datatype) {
8347
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8348
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8349
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8350
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8351
 
                }
8352
 
                if (r->dependent_files) {
8353
 
                        NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8354
 
                }
8355
 
        }
8356
 
        return NDR_ERR_SUCCESS;
8357
 
}
8358
 
 
8359
 
static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8360
 
{
8361
 
        uint32_t _ptr_driver_name;
8362
 
        TALLOC_CTX *_mem_save_driver_name_0;
8363
 
        uint32_t _ptr_architecture;
8364
 
        TALLOC_CTX *_mem_save_architecture_0;
8365
 
        uint32_t _ptr_driver_path;
8366
 
        TALLOC_CTX *_mem_save_driver_path_0;
8367
 
        uint32_t _ptr_data_file;
8368
 
        TALLOC_CTX *_mem_save_data_file_0;
8369
 
        uint32_t _ptr_config_file;
8370
 
        TALLOC_CTX *_mem_save_config_file_0;
8371
 
        uint32_t _ptr_help_file;
8372
 
        TALLOC_CTX *_mem_save_help_file_0;
8373
 
        uint32_t _ptr_monitor_name;
8374
 
        TALLOC_CTX *_mem_save_monitor_name_0;
8375
 
        uint32_t _ptr_default_datatype;
8376
 
        TALLOC_CTX *_mem_save_default_datatype_0;
8377
 
        uint32_t _ptr_dependent_files;
8378
 
        TALLOC_CTX *_mem_save_dependent_files_0;
8379
 
        if (ndr_flags & NDR_SCALARS) {
8380
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
8381
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8382
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8383
 
                if (_ptr_driver_name) {
8384
 
                        NDR_PULL_ALLOC(ndr, r->driver_name);
8385
 
                } else {
8386
 
                        r->driver_name = NULL;
8387
 
                }
8388
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8389
 
                if (_ptr_architecture) {
8390
 
                        NDR_PULL_ALLOC(ndr, r->architecture);
8391
 
                } else {
8392
 
                        r->architecture = NULL;
8393
 
                }
8394
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8395
 
                if (_ptr_driver_path) {
8396
 
                        NDR_PULL_ALLOC(ndr, r->driver_path);
8397
 
                } else {
8398
 
                        r->driver_path = NULL;
8399
 
                }
8400
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8401
 
                if (_ptr_data_file) {
8402
 
                        NDR_PULL_ALLOC(ndr, r->data_file);
8403
 
                } else {
8404
 
                        r->data_file = NULL;
8405
 
                }
8406
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8407
 
                if (_ptr_config_file) {
8408
 
                        NDR_PULL_ALLOC(ndr, r->config_file);
8409
 
                } else {
8410
 
                        r->config_file = NULL;
8411
 
                }
8412
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8413
 
                if (_ptr_help_file) {
8414
 
                        NDR_PULL_ALLOC(ndr, r->help_file);
8415
 
                } else {
8416
 
                        r->help_file = NULL;
8417
 
                }
8418
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8419
 
                if (_ptr_monitor_name) {
8420
 
                        NDR_PULL_ALLOC(ndr, r->monitor_name);
8421
 
                } else {
8422
 
                        r->monitor_name = NULL;
8423
 
                }
8424
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8425
 
                if (_ptr_default_datatype) {
8426
 
                        NDR_PULL_ALLOC(ndr, r->default_datatype);
8427
 
                } else {
8428
 
                        r->default_datatype = NULL;
8429
 
                }
8430
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8431
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8432
 
                if (_ptr_dependent_files) {
8433
 
                        NDR_PULL_ALLOC(ndr, r->dependent_files);
8434
 
                } else {
8435
 
                        r->dependent_files = NULL;
8436
 
                }
8437
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8438
 
        }
8439
 
        if (ndr_flags & NDR_BUFFERS) {
8440
 
                if (r->driver_name) {
8441
 
                        _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8442
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8443
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8444
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8445
 
                        if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8446
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8447
 
                        }
8448
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8449
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8450
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8451
 
                }
8452
 
                if (r->architecture) {
8453
 
                        _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8454
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8455
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8456
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8457
 
                        if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8458
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8459
 
                        }
8460
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8461
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8462
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8463
 
                }
8464
 
                if (r->driver_path) {
8465
 
                        _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8466
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8467
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8468
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8469
 
                        if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8470
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8471
 
                        }
8472
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8473
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8474
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8475
 
                }
8476
 
                if (r->data_file) {
8477
 
                        _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8478
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8479
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8480
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8481
 
                        if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8482
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8483
 
                        }
8484
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8485
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8486
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8487
 
                }
8488
 
                if (r->config_file) {
8489
 
                        _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8490
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8491
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8492
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8493
 
                        if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8494
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8495
 
                        }
8496
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8497
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8498
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8499
 
                }
8500
 
                if (r->help_file) {
8501
 
                        _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8502
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8503
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8504
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8505
 
                        if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8506
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8507
 
                        }
8508
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8509
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8510
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8511
 
                }
8512
 
                if (r->monitor_name) {
8513
 
                        _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8514
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8515
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8516
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8517
 
                        if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8518
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8519
 
                        }
8520
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8521
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8522
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8523
 
                }
8524
 
                if (r->default_datatype) {
8525
 
                        _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8526
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8527
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8528
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8529
 
                        if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8530
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8531
 
                        }
8532
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8533
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8534
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8535
 
                }
8536
 
                if (r->dependent_files) {
8537
 
                        _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8538
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8539
 
                        NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8540
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8541
 
                }
8542
 
        }
8543
 
        return NDR_ERR_SUCCESS;
8544
 
}
8545
 
 
8546
 
_PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8547
 
{
8548
 
        ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8549
 
        ndr->depth++;
8550
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8551
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
8552
 
        ndr->depth++;
8553
 
        if (r->driver_name) {
8554
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
8555
 
        }
8556
 
        ndr->depth--;
8557
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
8558
 
        ndr->depth++;
8559
 
        if (r->architecture) {
8560
 
                ndr_print_string(ndr, "architecture", r->architecture);
8561
 
        }
8562
 
        ndr->depth--;
8563
 
        ndr_print_ptr(ndr, "driver_path", r->driver_path);
8564
 
        ndr->depth++;
8565
 
        if (r->driver_path) {
8566
 
                ndr_print_string(ndr, "driver_path", r->driver_path);
8567
 
        }
8568
 
        ndr->depth--;
8569
 
        ndr_print_ptr(ndr, "data_file", r->data_file);
8570
 
        ndr->depth++;
8571
 
        if (r->data_file) {
8572
 
                ndr_print_string(ndr, "data_file", r->data_file);
8573
 
        }
8574
 
        ndr->depth--;
8575
 
        ndr_print_ptr(ndr, "config_file", r->config_file);
8576
 
        ndr->depth++;
8577
 
        if (r->config_file) {
8578
 
                ndr_print_string(ndr, "config_file", r->config_file);
8579
 
        }
8580
 
        ndr->depth--;
8581
 
        ndr_print_ptr(ndr, "help_file", r->help_file);
8582
 
        ndr->depth++;
8583
 
        if (r->help_file) {
8584
 
                ndr_print_string(ndr, "help_file", r->help_file);
8585
 
        }
8586
 
        ndr->depth--;
8587
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8588
 
        ndr->depth++;
8589
 
        if (r->monitor_name) {
8590
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
8591
 
        }
8592
 
        ndr->depth--;
8593
 
        ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8594
 
        ndr->depth++;
8595
 
        if (r->default_datatype) {
8596
 
                ndr_print_string(ndr, "default_datatype", r->default_datatype);
8597
 
        }
8598
 
        ndr->depth--;
8599
 
        ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8600
 
        ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8601
 
        ndr->depth++;
8602
 
        if (r->dependent_files) {
8603
 
                ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8604
 
        }
8605
 
        ndr->depth--;
8606
 
        ndr->depth--;
8607
 
}
8608
 
 
8609
 
static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8610
 
{
8611
 
        if (ndr_flags & NDR_SCALARS) {
8612
 
                NDR_CHECK(ndr_push_align(ndr, 5));
8613
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8614
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8615
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8616
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8617
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8618
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8619
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8620
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8621
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8622
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8623
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8624
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8625
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8626
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8627
 
        }
8628
 
        if (ndr_flags & NDR_BUFFERS) {
8629
 
                if (r->driver_name) {
8630
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8631
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8632
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8633
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8634
 
                }
8635
 
                if (r->architecture) {
8636
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8637
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8638
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8639
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8640
 
                }
8641
 
                if (r->driver_path) {
8642
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8643
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8644
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8645
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8646
 
                }
8647
 
                if (r->data_file) {
8648
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8649
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8650
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8651
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8652
 
                }
8653
 
                if (r->config_file) {
8654
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8655
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8656
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8657
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8658
 
                }
8659
 
                if (r->help_file) {
8660
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8661
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8662
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8663
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8664
 
                }
8665
 
                if (r->monitor_name) {
8666
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8667
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8668
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8669
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8670
 
                }
8671
 
                if (r->default_datatype) {
8672
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8673
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8674
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8675
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8676
 
                }
8677
 
                if (r->dependent_files) {
8678
 
                        NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8679
 
                }
8680
 
                if (r->previous_names) {
8681
 
                        NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8682
 
                }
8683
 
        }
8684
 
        return NDR_ERR_SUCCESS;
8685
 
}
8686
 
 
8687
 
static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8688
 
{
8689
 
        uint32_t _ptr_driver_name;
8690
 
        TALLOC_CTX *_mem_save_driver_name_0;
8691
 
        uint32_t _ptr_architecture;
8692
 
        TALLOC_CTX *_mem_save_architecture_0;
8693
 
        uint32_t _ptr_driver_path;
8694
 
        TALLOC_CTX *_mem_save_driver_path_0;
8695
 
        uint32_t _ptr_data_file;
8696
 
        TALLOC_CTX *_mem_save_data_file_0;
8697
 
        uint32_t _ptr_config_file;
8698
 
        TALLOC_CTX *_mem_save_config_file_0;
8699
 
        uint32_t _ptr_help_file;
8700
 
        TALLOC_CTX *_mem_save_help_file_0;
8701
 
        uint32_t _ptr_monitor_name;
8702
 
        TALLOC_CTX *_mem_save_monitor_name_0;
8703
 
        uint32_t _ptr_default_datatype;
8704
 
        TALLOC_CTX *_mem_save_default_datatype_0;
8705
 
        uint32_t _ptr_dependent_files;
8706
 
        TALLOC_CTX *_mem_save_dependent_files_0;
8707
 
        uint32_t _ptr_previous_names;
8708
 
        TALLOC_CTX *_mem_save_previous_names_0;
8709
 
        if (ndr_flags & NDR_SCALARS) {
8710
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
8711
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8712
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8713
 
                if (_ptr_driver_name) {
8714
 
                        NDR_PULL_ALLOC(ndr, r->driver_name);
8715
 
                } else {
8716
 
                        r->driver_name = NULL;
8717
 
                }
8718
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8719
 
                if (_ptr_architecture) {
8720
 
                        NDR_PULL_ALLOC(ndr, r->architecture);
8721
 
                } else {
8722
 
                        r->architecture = NULL;
8723
 
                }
8724
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8725
 
                if (_ptr_driver_path) {
8726
 
                        NDR_PULL_ALLOC(ndr, r->driver_path);
8727
 
                } else {
8728
 
                        r->driver_path = NULL;
8729
 
                }
8730
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8731
 
                if (_ptr_data_file) {
8732
 
                        NDR_PULL_ALLOC(ndr, r->data_file);
8733
 
                } else {
8734
 
                        r->data_file = NULL;
8735
 
                }
8736
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8737
 
                if (_ptr_config_file) {
8738
 
                        NDR_PULL_ALLOC(ndr, r->config_file);
8739
 
                } else {
8740
 
                        r->config_file = NULL;
8741
 
                }
8742
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8743
 
                if (_ptr_help_file) {
8744
 
                        NDR_PULL_ALLOC(ndr, r->help_file);
8745
 
                } else {
8746
 
                        r->help_file = NULL;
8747
 
                }
8748
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8749
 
                if (_ptr_monitor_name) {
8750
 
                        NDR_PULL_ALLOC(ndr, r->monitor_name);
8751
 
                } else {
8752
 
                        r->monitor_name = NULL;
8753
 
                }
8754
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8755
 
                if (_ptr_default_datatype) {
8756
 
                        NDR_PULL_ALLOC(ndr, r->default_datatype);
8757
 
                } else {
8758
 
                        r->default_datatype = NULL;
8759
 
                }
8760
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8761
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8762
 
                if (_ptr_dependent_files) {
8763
 
                        NDR_PULL_ALLOC(ndr, r->dependent_files);
8764
 
                } else {
8765
 
                        r->dependent_files = NULL;
8766
 
                }
8767
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8768
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8769
 
                if (_ptr_previous_names) {
8770
 
                        NDR_PULL_ALLOC(ndr, r->previous_names);
8771
 
                } else {
8772
 
                        r->previous_names = NULL;
8773
 
                }
8774
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8775
 
        }
8776
 
        if (ndr_flags & NDR_BUFFERS) {
8777
 
                if (r->driver_name) {
8778
 
                        _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8779
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8780
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8781
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8782
 
                        if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8783
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8784
 
                        }
8785
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8786
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8787
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8788
 
                }
8789
 
                if (r->architecture) {
8790
 
                        _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8791
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8792
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8793
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8794
 
                        if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8795
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8796
 
                        }
8797
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8798
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8799
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8800
 
                }
8801
 
                if (r->driver_path) {
8802
 
                        _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8803
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8804
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8805
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8806
 
                        if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8807
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8808
 
                        }
8809
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8810
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8811
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8812
 
                }
8813
 
                if (r->data_file) {
8814
 
                        _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8815
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8816
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8817
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8818
 
                        if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8819
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8820
 
                        }
8821
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8822
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8823
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8824
 
                }
8825
 
                if (r->config_file) {
8826
 
                        _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8827
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8828
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8829
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8830
 
                        if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8831
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8832
 
                        }
8833
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8834
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8835
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8836
 
                }
8837
 
                if (r->help_file) {
8838
 
                        _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8839
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8840
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8841
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8842
 
                        if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8843
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8844
 
                        }
8845
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8846
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8847
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8848
 
                }
8849
 
                if (r->monitor_name) {
8850
 
                        _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8851
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8852
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8853
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8854
 
                        if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8855
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8856
 
                        }
8857
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8858
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8859
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8860
 
                }
8861
 
                if (r->default_datatype) {
8862
 
                        _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8863
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8864
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8865
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8866
 
                        if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8867
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8868
 
                        }
8869
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8870
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8871
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8872
 
                }
8873
 
                if (r->dependent_files) {
8874
 
                        _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8875
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8876
 
                        NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8877
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8878
 
                }
8879
 
                if (r->previous_names) {
8880
 
                        _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8881
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8882
 
                        NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8883
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8884
 
                }
8885
 
        }
8886
 
        return NDR_ERR_SUCCESS;
8887
 
}
8888
 
 
8889
 
_PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8890
 
{
8891
 
        ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8892
 
        ndr->depth++;
8893
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8894
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
8895
 
        ndr->depth++;
8896
 
        if (r->driver_name) {
8897
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
8898
 
        }
8899
 
        ndr->depth--;
8900
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
8901
 
        ndr->depth++;
8902
 
        if (r->architecture) {
8903
 
                ndr_print_string(ndr, "architecture", r->architecture);
8904
 
        }
8905
 
        ndr->depth--;
8906
 
        ndr_print_ptr(ndr, "driver_path", r->driver_path);
8907
 
        ndr->depth++;
8908
 
        if (r->driver_path) {
8909
 
                ndr_print_string(ndr, "driver_path", r->driver_path);
8910
 
        }
8911
 
        ndr->depth--;
8912
 
        ndr_print_ptr(ndr, "data_file", r->data_file);
8913
 
        ndr->depth++;
8914
 
        if (r->data_file) {
8915
 
                ndr_print_string(ndr, "data_file", r->data_file);
8916
 
        }
8917
 
        ndr->depth--;
8918
 
        ndr_print_ptr(ndr, "config_file", r->config_file);
8919
 
        ndr->depth++;
8920
 
        if (r->config_file) {
8921
 
                ndr_print_string(ndr, "config_file", r->config_file);
8922
 
        }
8923
 
        ndr->depth--;
8924
 
        ndr_print_ptr(ndr, "help_file", r->help_file);
8925
 
        ndr->depth++;
8926
 
        if (r->help_file) {
8927
 
                ndr_print_string(ndr, "help_file", r->help_file);
8928
 
        }
8929
 
        ndr->depth--;
8930
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8931
 
        ndr->depth++;
8932
 
        if (r->monitor_name) {
8933
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
8934
 
        }
8935
 
        ndr->depth--;
8936
 
        ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8937
 
        ndr->depth++;
8938
 
        if (r->default_datatype) {
8939
 
                ndr_print_string(ndr, "default_datatype", r->default_datatype);
8940
 
        }
8941
 
        ndr->depth--;
8942
 
        ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8943
 
        ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8944
 
        ndr->depth++;
8945
 
        if (r->dependent_files) {
8946
 
                ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8947
 
        }
8948
 
        ndr->depth--;
8949
 
        ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
8950
 
        ndr_print_ptr(ndr, "previous_names", r->previous_names);
8951
 
        ndr->depth++;
8952
 
        if (r->previous_names) {
8953
 
                ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8954
 
        }
8955
 
        ndr->depth--;
8956
 
        ndr->depth--;
8957
 
}
8958
 
 
8959
 
static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
8960
 
{
8961
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8962
 
        return NDR_ERR_SUCCESS;
8963
 
}
8964
 
 
8965
 
static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
8966
 
{
8967
 
        uint32_t v;
8968
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8969
 
        *r = v;
8970
 
        return NDR_ERR_SUCCESS;
8971
 
}
8972
 
 
8973
 
_PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
8974
 
{
8975
 
        ndr_print_uint32(ndr, name, r);
8976
 
        ndr->depth++;
8977
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
8978
 
        ndr->depth--;
8979
 
}
8980
 
 
8981
 
static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8982
 
{
8983
 
        if (ndr_flags & NDR_SCALARS) {
8984
 
                NDR_CHECK(ndr_push_align(ndr, 8));
8985
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8986
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8987
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8988
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8989
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8990
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8991
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8992
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8993
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8994
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8995
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8996
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8997
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8998
 
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8999
 
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9000
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9001
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9002
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9003
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9004
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9005
 
        }
9006
 
        if (ndr_flags & NDR_BUFFERS) {
9007
 
                if (r->driver_name) {
9008
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9009
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9010
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9011
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9012
 
                }
9013
 
                if (r->architecture) {
9014
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9015
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9016
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9017
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9018
 
                }
9019
 
                if (r->driver_path) {
9020
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9021
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9022
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9023
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9024
 
                }
9025
 
                if (r->data_file) {
9026
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9027
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9028
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9029
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9030
 
                }
9031
 
                if (r->config_file) {
9032
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9033
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9034
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9035
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9036
 
                }
9037
 
                if (r->help_file) {
9038
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9039
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9040
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9041
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9042
 
                }
9043
 
                if (r->monitor_name) {
9044
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9045
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9046
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9047
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9048
 
                }
9049
 
                if (r->default_datatype) {
9050
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9051
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9052
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9053
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9054
 
                }
9055
 
                if (r->dependent_files) {
9056
 
                        NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9057
 
                }
9058
 
                if (r->previous_names) {
9059
 
                        NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9060
 
                }
9061
 
                if (r->manufacturer_name) {
9062
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9063
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9064
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9065
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9066
 
                }
9067
 
                if (r->manufacturer_url) {
9068
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9069
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9070
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9071
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9072
 
                }
9073
 
                if (r->hardware_id) {
9074
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9075
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9076
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9077
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9078
 
                }
9079
 
                if (r->provider) {
9080
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9081
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9082
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9083
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9084
 
                }
9085
 
        }
9086
 
        return NDR_ERR_SUCCESS;
9087
 
}
9088
 
 
9089
 
static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9090
 
{
9091
 
        uint32_t _ptr_driver_name;
9092
 
        TALLOC_CTX *_mem_save_driver_name_0;
9093
 
        uint32_t _ptr_architecture;
9094
 
        TALLOC_CTX *_mem_save_architecture_0;
9095
 
        uint32_t _ptr_driver_path;
9096
 
        TALLOC_CTX *_mem_save_driver_path_0;
9097
 
        uint32_t _ptr_data_file;
9098
 
        TALLOC_CTX *_mem_save_data_file_0;
9099
 
        uint32_t _ptr_config_file;
9100
 
        TALLOC_CTX *_mem_save_config_file_0;
9101
 
        uint32_t _ptr_help_file;
9102
 
        TALLOC_CTX *_mem_save_help_file_0;
9103
 
        uint32_t _ptr_monitor_name;
9104
 
        TALLOC_CTX *_mem_save_monitor_name_0;
9105
 
        uint32_t _ptr_default_datatype;
9106
 
        TALLOC_CTX *_mem_save_default_datatype_0;
9107
 
        uint32_t _ptr_dependent_files;
9108
 
        TALLOC_CTX *_mem_save_dependent_files_0;
9109
 
        uint32_t _ptr_previous_names;
9110
 
        TALLOC_CTX *_mem_save_previous_names_0;
9111
 
        uint32_t _ptr_manufacturer_name;
9112
 
        TALLOC_CTX *_mem_save_manufacturer_name_0;
9113
 
        uint32_t _ptr_manufacturer_url;
9114
 
        TALLOC_CTX *_mem_save_manufacturer_url_0;
9115
 
        uint32_t _ptr_hardware_id;
9116
 
        TALLOC_CTX *_mem_save_hardware_id_0;
9117
 
        uint32_t _ptr_provider;
9118
 
        TALLOC_CTX *_mem_save_provider_0;
9119
 
        if (ndr_flags & NDR_SCALARS) {
9120
 
                NDR_CHECK(ndr_pull_align(ndr, 8));
9121
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9122
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9123
 
                if (_ptr_driver_name) {
9124
 
                        NDR_PULL_ALLOC(ndr, r->driver_name);
9125
 
                } else {
9126
 
                        r->driver_name = NULL;
9127
 
                }
9128
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9129
 
                if (_ptr_architecture) {
9130
 
                        NDR_PULL_ALLOC(ndr, r->architecture);
9131
 
                } else {
9132
 
                        r->architecture = NULL;
9133
 
                }
9134
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9135
 
                if (_ptr_driver_path) {
9136
 
                        NDR_PULL_ALLOC(ndr, r->driver_path);
9137
 
                } else {
9138
 
                        r->driver_path = NULL;
9139
 
                }
9140
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9141
 
                if (_ptr_data_file) {
9142
 
                        NDR_PULL_ALLOC(ndr, r->data_file);
9143
 
                } else {
9144
 
                        r->data_file = NULL;
9145
 
                }
9146
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9147
 
                if (_ptr_config_file) {
9148
 
                        NDR_PULL_ALLOC(ndr, r->config_file);
9149
 
                } else {
9150
 
                        r->config_file = NULL;
9151
 
                }
9152
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9153
 
                if (_ptr_help_file) {
9154
 
                        NDR_PULL_ALLOC(ndr, r->help_file);
9155
 
                } else {
9156
 
                        r->help_file = NULL;
9157
 
                }
9158
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9159
 
                if (_ptr_monitor_name) {
9160
 
                        NDR_PULL_ALLOC(ndr, r->monitor_name);
9161
 
                } else {
9162
 
                        r->monitor_name = NULL;
9163
 
                }
9164
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9165
 
                if (_ptr_default_datatype) {
9166
 
                        NDR_PULL_ALLOC(ndr, r->default_datatype);
9167
 
                } else {
9168
 
                        r->default_datatype = NULL;
9169
 
                }
9170
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9171
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9172
 
                if (_ptr_dependent_files) {
9173
 
                        NDR_PULL_ALLOC(ndr, r->dependent_files);
9174
 
                } else {
9175
 
                        r->dependent_files = NULL;
9176
 
                }
9177
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9178
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9179
 
                if (_ptr_previous_names) {
9180
 
                        NDR_PULL_ALLOC(ndr, r->previous_names);
9181
 
                } else {
9182
 
                        r->previous_names = NULL;
9183
 
                }
9184
 
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9185
 
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9186
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9187
 
                if (_ptr_manufacturer_name) {
9188
 
                        NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9189
 
                } else {
9190
 
                        r->manufacturer_name = NULL;
9191
 
                }
9192
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9193
 
                if (_ptr_manufacturer_url) {
9194
 
                        NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9195
 
                } else {
9196
 
                        r->manufacturer_url = NULL;
9197
 
                }
9198
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9199
 
                if (_ptr_hardware_id) {
9200
 
                        NDR_PULL_ALLOC(ndr, r->hardware_id);
9201
 
                } else {
9202
 
                        r->hardware_id = NULL;
9203
 
                }
9204
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9205
 
                if (_ptr_provider) {
9206
 
                        NDR_PULL_ALLOC(ndr, r->provider);
9207
 
                } else {
9208
 
                        r->provider = NULL;
9209
 
                }
9210
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9211
 
        }
9212
 
        if (ndr_flags & NDR_BUFFERS) {
9213
 
                if (r->driver_name) {
9214
 
                        _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9215
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9216
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9217
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9218
 
                        if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9219
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9220
 
                        }
9221
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9222
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9223
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9224
 
                }
9225
 
                if (r->architecture) {
9226
 
                        _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9227
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9228
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9229
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9230
 
                        if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9231
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9232
 
                        }
9233
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9234
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9235
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9236
 
                }
9237
 
                if (r->driver_path) {
9238
 
                        _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9239
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9240
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9241
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9242
 
                        if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9243
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9244
 
                        }
9245
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9246
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9247
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9248
 
                }
9249
 
                if (r->data_file) {
9250
 
                        _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9251
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9252
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9253
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9254
 
                        if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9255
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9256
 
                        }
9257
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9258
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9259
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9260
 
                }
9261
 
                if (r->config_file) {
9262
 
                        _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9263
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9264
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9265
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9266
 
                        if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9267
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9268
 
                        }
9269
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9270
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9271
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9272
 
                }
9273
 
                if (r->help_file) {
9274
 
                        _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9275
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9276
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9277
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9278
 
                        if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9279
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9280
 
                        }
9281
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9282
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9283
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9284
 
                }
9285
 
                if (r->monitor_name) {
9286
 
                        _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9287
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9288
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9289
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9290
 
                        if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9291
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9292
 
                        }
9293
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9294
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9295
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9296
 
                }
9297
 
                if (r->default_datatype) {
9298
 
                        _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9299
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9300
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9301
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9302
 
                        if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9303
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9304
 
                        }
9305
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9306
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9307
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9308
 
                }
9309
 
                if (r->dependent_files) {
9310
 
                        _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9311
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9312
 
                        NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9313
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9314
 
                }
9315
 
                if (r->previous_names) {
9316
 
                        _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9317
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9318
 
                        NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9319
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9320
 
                }
9321
 
                if (r->manufacturer_name) {
9322
 
                        _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9323
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9324
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9325
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9326
 
                        if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9327
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9328
 
                        }
9329
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9330
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9331
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9332
 
                }
9333
 
                if (r->manufacturer_url) {
9334
 
                        _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9335
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9336
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9337
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9338
 
                        if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9339
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9340
 
                        }
9341
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9342
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9343
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9344
 
                }
9345
 
                if (r->hardware_id) {
9346
 
                        _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9347
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9348
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9349
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9350
 
                        if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9351
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9352
 
                        }
9353
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9354
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9355
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9356
 
                }
9357
 
                if (r->provider) {
9358
 
                        _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9359
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9360
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9361
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9362
 
                        if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9363
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
9364
 
                        }
9365
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9366
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9367
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9368
 
                }
9369
 
        }
9370
 
        return NDR_ERR_SUCCESS;
9371
 
}
9372
 
 
9373
 
_PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9374
 
{
9375
 
        ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9376
 
        ndr->depth++;
9377
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9378
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
9379
 
        ndr->depth++;
9380
 
        if (r->driver_name) {
9381
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
9382
 
        }
9383
 
        ndr->depth--;
9384
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
9385
 
        ndr->depth++;
9386
 
        if (r->architecture) {
9387
 
                ndr_print_string(ndr, "architecture", r->architecture);
9388
 
        }
9389
 
        ndr->depth--;
9390
 
        ndr_print_ptr(ndr, "driver_path", r->driver_path);
9391
 
        ndr->depth++;
9392
 
        if (r->driver_path) {
9393
 
                ndr_print_string(ndr, "driver_path", r->driver_path);
9394
 
        }
9395
 
        ndr->depth--;
9396
 
        ndr_print_ptr(ndr, "data_file", r->data_file);
9397
 
        ndr->depth++;
9398
 
        if (r->data_file) {
9399
 
                ndr_print_string(ndr, "data_file", r->data_file);
9400
 
        }
9401
 
        ndr->depth--;
9402
 
        ndr_print_ptr(ndr, "config_file", r->config_file);
9403
 
        ndr->depth++;
9404
 
        if (r->config_file) {
9405
 
                ndr_print_string(ndr, "config_file", r->config_file);
9406
 
        }
9407
 
        ndr->depth--;
9408
 
        ndr_print_ptr(ndr, "help_file", r->help_file);
9409
 
        ndr->depth++;
9410
 
        if (r->help_file) {
9411
 
                ndr_print_string(ndr, "help_file", r->help_file);
9412
 
        }
9413
 
        ndr->depth--;
9414
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9415
 
        ndr->depth++;
9416
 
        if (r->monitor_name) {
9417
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
9418
 
        }
9419
 
        ndr->depth--;
9420
 
        ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9421
 
        ndr->depth++;
9422
 
        if (r->default_datatype) {
9423
 
                ndr_print_string(ndr, "default_datatype", r->default_datatype);
9424
 
        }
9425
 
        ndr->depth--;
9426
 
        ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
9427
 
        ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9428
 
        ndr->depth++;
9429
 
        if (r->dependent_files) {
9430
 
                ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9431
 
        }
9432
 
        ndr->depth--;
9433
 
        ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
9434
 
        ndr_print_ptr(ndr, "previous_names", r->previous_names);
9435
 
        ndr->depth++;
9436
 
        if (r->previous_names) {
9437
 
                ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9438
 
        }
9439
 
        ndr->depth--;
9440
 
        ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9441
 
        ndr_print_hyper(ndr, "driver_version", r->driver_version);
9442
 
        ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9443
 
        ndr->depth++;
9444
 
        if (r->manufacturer_name) {
9445
 
                ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9446
 
        }
9447
 
        ndr->depth--;
9448
 
        ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9449
 
        ndr->depth++;
9450
 
        if (r->manufacturer_url) {
9451
 
                ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9452
 
        }
9453
 
        ndr->depth--;
9454
 
        ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9455
 
        ndr->depth++;
9456
 
        if (r->hardware_id) {
9457
 
                ndr_print_string(ndr, "hardware_id", r->hardware_id);
9458
 
        }
9459
 
        ndr->depth--;
9460
 
        ndr_print_ptr(ndr, "provider", r->provider);
9461
 
        ndr->depth++;
9462
 
        if (r->provider) {
9463
 
                ndr_print_string(ndr, "provider", r->provider);
9464
 
        }
9465
 
        ndr->depth--;
9466
 
        ndr->depth--;
9467
 
}
9468
 
 
9469
 
static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9470
 
{
9471
 
        if (ndr_flags & NDR_SCALARS) {
9472
 
                NDR_CHECK(ndr_push_align(ndr, 8));
9473
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9474
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9475
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9476
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9477
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9478
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9479
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9480
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9481
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9482
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9483
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9484
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9485
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9486
 
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9487
 
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9488
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9489
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9490
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9491
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9492
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9493
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9494
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9495
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9496
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9497
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9498
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9499
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9500
 
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9501
 
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9502
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9503
 
        }
9504
 
        if (ndr_flags & NDR_BUFFERS) {
9505
 
                if (r->driver_name) {
9506
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9507
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9508
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9509
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9510
 
                }
9511
 
                if (r->architecture) {
9512
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9513
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9514
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9515
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9516
 
                }
9517
 
                if (r->driver_path) {
9518
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9519
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9520
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9521
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9522
 
                }
9523
 
                if (r->data_file) {
9524
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9525
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9526
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9527
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9528
 
                }
9529
 
                if (r->config_file) {
9530
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9531
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9532
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9533
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9534
 
                }
9535
 
                if (r->help_file) {
9536
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9537
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9538
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9539
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9540
 
                }
9541
 
                if (r->monitor_name) {
9542
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9543
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9544
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9545
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9546
 
                }
9547
 
                if (r->default_datatype) {
9548
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9549
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9550
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9551
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9552
 
                }
9553
 
                if (r->dependent_files) {
9554
 
                        NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9555
 
                }
9556
 
                if (r->previous_names) {
9557
 
                        NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9558
 
                }
9559
 
                if (r->manufacturer_name) {
9560
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9561
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9562
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9563
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9564
 
                }
9565
 
                if (r->manufacturer_url) {
9566
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9567
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9568
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9569
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9570
 
                }
9571
 
                if (r->hardware_id) {
9572
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9573
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9574
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9575
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9576
 
                }
9577
 
                if (r->provider) {
9578
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9579
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9580
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9581
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9582
 
                }
9583
 
                if (r->print_processor) {
9584
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9585
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9586
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9587
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9588
 
                }
9589
 
                if (r->vendor_setup) {
9590
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9591
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9592
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9593
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9594
 
                }
9595
 
                if (r->color_profiles) {
9596
 
                        NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9597
 
                }
9598
 
                if (r->inf_path) {
9599
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9600
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9601
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9602
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9603
 
                }
9604
 
                if (r->core_driver_dependencies) {
9605
 
                        NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9606
 
                }
9607
 
        }
9608
 
        return NDR_ERR_SUCCESS;
9609
 
}
9610
 
 
9611
 
static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9612
 
{
9613
 
        uint32_t _ptr_driver_name;
9614
 
        TALLOC_CTX *_mem_save_driver_name_0;
9615
 
        uint32_t _ptr_architecture;
9616
 
        TALLOC_CTX *_mem_save_architecture_0;
9617
 
        uint32_t _ptr_driver_path;
9618
 
        TALLOC_CTX *_mem_save_driver_path_0;
9619
 
        uint32_t _ptr_data_file;
9620
 
        TALLOC_CTX *_mem_save_data_file_0;
9621
 
        uint32_t _ptr_config_file;
9622
 
        TALLOC_CTX *_mem_save_config_file_0;
9623
 
        uint32_t _ptr_help_file;
9624
 
        TALLOC_CTX *_mem_save_help_file_0;
9625
 
        uint32_t _ptr_monitor_name;
9626
 
        TALLOC_CTX *_mem_save_monitor_name_0;
9627
 
        uint32_t _ptr_default_datatype;
9628
 
        TALLOC_CTX *_mem_save_default_datatype_0;
9629
 
        uint32_t _ptr_dependent_files;
9630
 
        TALLOC_CTX *_mem_save_dependent_files_0;
9631
 
        uint32_t _ptr_previous_names;
9632
 
        TALLOC_CTX *_mem_save_previous_names_0;
9633
 
        uint32_t _ptr_manufacturer_name;
9634
 
        TALLOC_CTX *_mem_save_manufacturer_name_0;
9635
 
        uint32_t _ptr_manufacturer_url;
9636
 
        TALLOC_CTX *_mem_save_manufacturer_url_0;
9637
 
        uint32_t _ptr_hardware_id;
9638
 
        TALLOC_CTX *_mem_save_hardware_id_0;
9639
 
        uint32_t _ptr_provider;
9640
 
        TALLOC_CTX *_mem_save_provider_0;
9641
 
        uint32_t _ptr_print_processor;
9642
 
        TALLOC_CTX *_mem_save_print_processor_0;
9643
 
        uint32_t _ptr_vendor_setup;
9644
 
        TALLOC_CTX *_mem_save_vendor_setup_0;
9645
 
        uint32_t _ptr_color_profiles;
9646
 
        TALLOC_CTX *_mem_save_color_profiles_0;
9647
 
        uint32_t _ptr_inf_path;
9648
 
        TALLOC_CTX *_mem_save_inf_path_0;
9649
 
        uint32_t _ptr_core_driver_dependencies;
9650
 
        TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9651
 
        if (ndr_flags & NDR_SCALARS) {
9652
 
                NDR_CHECK(ndr_pull_align(ndr, 8));
9653
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9654
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9655
 
                if (_ptr_driver_name) {
9656
 
                        NDR_PULL_ALLOC(ndr, r->driver_name);
9657
 
                } else {
9658
 
                        r->driver_name = NULL;
9659
 
                }
9660
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9661
 
                if (_ptr_architecture) {
9662
 
                        NDR_PULL_ALLOC(ndr, r->architecture);
9663
 
                } else {
9664
 
                        r->architecture = NULL;
9665
 
                }
9666
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9667
 
                if (_ptr_driver_path) {
9668
 
                        NDR_PULL_ALLOC(ndr, r->driver_path);
9669
 
                } else {
9670
 
                        r->driver_path = NULL;
9671
 
                }
9672
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9673
 
                if (_ptr_data_file) {
9674
 
                        NDR_PULL_ALLOC(ndr, r->data_file);
9675
 
                } else {
9676
 
                        r->data_file = NULL;
9677
 
                }
9678
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9679
 
                if (_ptr_config_file) {
9680
 
                        NDR_PULL_ALLOC(ndr, r->config_file);
9681
 
                } else {
9682
 
                        r->config_file = NULL;
9683
 
                }
9684
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9685
 
                if (_ptr_help_file) {
9686
 
                        NDR_PULL_ALLOC(ndr, r->help_file);
9687
 
                } else {
9688
 
                        r->help_file = NULL;
9689
 
                }
9690
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9691
 
                if (_ptr_monitor_name) {
9692
 
                        NDR_PULL_ALLOC(ndr, r->monitor_name);
9693
 
                } else {
9694
 
                        r->monitor_name = NULL;
9695
 
                }
9696
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9697
 
                if (_ptr_default_datatype) {
9698
 
                        NDR_PULL_ALLOC(ndr, r->default_datatype);
9699
 
                } else {
9700
 
                        r->default_datatype = NULL;
9701
 
                }
9702
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9703
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9704
 
                if (_ptr_dependent_files) {
9705
 
                        NDR_PULL_ALLOC(ndr, r->dependent_files);
9706
 
                } else {
9707
 
                        r->dependent_files = NULL;
9708
 
                }
9709
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9710
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9711
 
                if (_ptr_previous_names) {
9712
 
                        NDR_PULL_ALLOC(ndr, r->previous_names);
9713
 
                } else {
9714
 
                        r->previous_names = NULL;
9715
 
                }
9716
 
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9717
 
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9718
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9719
 
                if (_ptr_manufacturer_name) {
9720
 
                        NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9721
 
                } else {
9722
 
                        r->manufacturer_name = NULL;
9723
 
                }
9724
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9725
 
                if (_ptr_manufacturer_url) {
9726
 
                        NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9727
 
                } else {
9728
 
                        r->manufacturer_url = NULL;
9729
 
                }
9730
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9731
 
                if (_ptr_hardware_id) {
9732
 
                        NDR_PULL_ALLOC(ndr, r->hardware_id);
9733
 
                } else {
9734
 
                        r->hardware_id = NULL;
9735
 
                }
9736
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9737
 
                if (_ptr_provider) {
9738
 
                        NDR_PULL_ALLOC(ndr, r->provider);
9739
 
                } else {
9740
 
                        r->provider = NULL;
9741
 
                }
9742
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9743
 
                if (_ptr_print_processor) {
9744
 
                        NDR_PULL_ALLOC(ndr, r->print_processor);
9745
 
                } else {
9746
 
                        r->print_processor = NULL;
9747
 
                }
9748
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9749
 
                if (_ptr_vendor_setup) {
9750
 
                        NDR_PULL_ALLOC(ndr, r->vendor_setup);
9751
 
                } else {
9752
 
                        r->vendor_setup = NULL;
9753
 
                }
9754
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9755
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9756
 
                if (_ptr_color_profiles) {
9757
 
                        NDR_PULL_ALLOC(ndr, r->color_profiles);
9758
 
                } else {
9759
 
                        r->color_profiles = NULL;
9760
 
                }
9761
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9762
 
                if (_ptr_inf_path) {
9763
 
                        NDR_PULL_ALLOC(ndr, r->inf_path);
9764
 
                } else {
9765
 
                        r->inf_path = NULL;
9766
 
                }
9767
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9768
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9769
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9770
 
                if (_ptr_core_driver_dependencies) {
9771
 
                        NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9772
 
                } else {
9773
 
                        r->core_driver_dependencies = NULL;
9774
 
                }
9775
 
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9776
 
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9777
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9778
 
        }
9779
 
        if (ndr_flags & NDR_BUFFERS) {
9780
 
                if (r->driver_name) {
9781
 
                        _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9782
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9783
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9784
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9785
 
                        if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9786
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9787
 
                        }
9788
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9789
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9790
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9791
 
                }
9792
 
                if (r->architecture) {
9793
 
                        _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9794
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9795
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9796
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9797
 
                        if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9798
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9799
 
                        }
9800
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9801
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9802
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9803
 
                }
9804
 
                if (r->driver_path) {
9805
 
                        _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9806
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9807
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9808
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9809
 
                        if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9810
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9811
 
                        }
9812
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9813
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9814
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9815
 
                }
9816
 
                if (r->data_file) {
9817
 
                        _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9818
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9819
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9820
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9821
 
                        if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9822
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9823
 
                        }
9824
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9825
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9826
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9827
 
                }
9828
 
                if (r->config_file) {
9829
 
                        _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9830
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9831
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9832
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9833
 
                        if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9834
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9835
 
                        }
9836
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9837
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9838
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9839
 
                }
9840
 
                if (r->help_file) {
9841
 
                        _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9842
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9843
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9844
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9845
 
                        if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9846
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9847
 
                        }
9848
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9849
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9850
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9851
 
                }
9852
 
                if (r->monitor_name) {
9853
 
                        _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9854
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9855
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9856
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9857
 
                        if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9858
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9859
 
                        }
9860
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9861
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9862
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9863
 
                }
9864
 
                if (r->default_datatype) {
9865
 
                        _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9866
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9867
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9868
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9869
 
                        if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9870
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9871
 
                        }
9872
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9873
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9874
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9875
 
                }
9876
 
                if (r->dependent_files) {
9877
 
                        _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9878
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9879
 
                        NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9880
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9881
 
                }
9882
 
                if (r->previous_names) {
9883
 
                        _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9884
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9885
 
                        NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9886
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9887
 
                }
9888
 
                if (r->manufacturer_name) {
9889
 
                        _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9890
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9891
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9892
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9893
 
                        if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9894
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9895
 
                        }
9896
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9897
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9898
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9899
 
                }
9900
 
                if (r->manufacturer_url) {
9901
 
                        _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9902
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9903
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9904
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9905
 
                        if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9906
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9907
 
                        }
9908
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9909
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9910
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9911
 
                }
9912
 
                if (r->hardware_id) {
9913
 
                        _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9914
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9915
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9916
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9917
 
                        if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9918
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9919
 
                        }
9920
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9921
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9922
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9923
 
                }
9924
 
                if (r->provider) {
9925
 
                        _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9926
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9927
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9928
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9929
 
                        if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9930
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
9931
 
                        }
9932
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9933
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9934
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9935
 
                }
9936
 
                if (r->print_processor) {
9937
 
                        _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9938
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9939
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9940
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9941
 
                        if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9942
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
9943
 
                        }
9944
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9945
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9946
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9947
 
                }
9948
 
                if (r->vendor_setup) {
9949
 
                        _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9950
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9951
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9952
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9953
 
                        if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9954
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->vendor_setup), ndr_get_array_length(ndr, &r->vendor_setup));
9955
 
                        }
9956
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9957
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9958
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9959
 
                }
9960
 
                if (r->color_profiles) {
9961
 
                        _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9962
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9963
 
                        NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9964
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9965
 
                }
9966
 
                if (r->inf_path) {
9967
 
                        _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9968
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9969
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9970
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9971
 
                        if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9972
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->inf_path), ndr_get_array_length(ndr, &r->inf_path));
9973
 
                        }
9974
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9975
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9976
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9977
 
                }
9978
 
                if (r->core_driver_dependencies) {
9979
 
                        _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9980
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9981
 
                        NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9982
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9983
 
                }
9984
 
        }
9985
 
        return NDR_ERR_SUCCESS;
9986
 
}
9987
 
 
9988
 
_PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9989
 
{
9990
 
        ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9991
 
        ndr->depth++;
9992
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9993
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
9994
 
        ndr->depth++;
9995
 
        if (r->driver_name) {
9996
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
9997
 
        }
9998
 
        ndr->depth--;
9999
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
10000
 
        ndr->depth++;
10001
 
        if (r->architecture) {
10002
 
                ndr_print_string(ndr, "architecture", r->architecture);
10003
 
        }
10004
 
        ndr->depth--;
10005
 
        ndr_print_ptr(ndr, "driver_path", r->driver_path);
10006
 
        ndr->depth++;
10007
 
        if (r->driver_path) {
10008
 
                ndr_print_string(ndr, "driver_path", r->driver_path);
10009
 
        }
10010
 
        ndr->depth--;
10011
 
        ndr_print_ptr(ndr, "data_file", r->data_file);
10012
 
        ndr->depth++;
10013
 
        if (r->data_file) {
10014
 
                ndr_print_string(ndr, "data_file", r->data_file);
10015
 
        }
10016
 
        ndr->depth--;
10017
 
        ndr_print_ptr(ndr, "config_file", r->config_file);
10018
 
        ndr->depth++;
10019
 
        if (r->config_file) {
10020
 
                ndr_print_string(ndr, "config_file", r->config_file);
10021
 
        }
10022
 
        ndr->depth--;
10023
 
        ndr_print_ptr(ndr, "help_file", r->help_file);
10024
 
        ndr->depth++;
10025
 
        if (r->help_file) {
10026
 
                ndr_print_string(ndr, "help_file", r->help_file);
10027
 
        }
10028
 
        ndr->depth--;
10029
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10030
 
        ndr->depth++;
10031
 
        if (r->monitor_name) {
10032
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
10033
 
        }
10034
 
        ndr->depth--;
10035
 
        ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10036
 
        ndr->depth++;
10037
 
        if (r->default_datatype) {
10038
 
                ndr_print_string(ndr, "default_datatype", r->default_datatype);
10039
 
        }
10040
 
        ndr->depth--;
10041
 
        ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
10042
 
        ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10043
 
        ndr->depth++;
10044
 
        if (r->dependent_files) {
10045
 
                ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10046
 
        }
10047
 
        ndr->depth--;
10048
 
        ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
10049
 
        ndr_print_ptr(ndr, "previous_names", r->previous_names);
10050
 
        ndr->depth++;
10051
 
        if (r->previous_names) {
10052
 
                ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10053
 
        }
10054
 
        ndr->depth--;
10055
 
        ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10056
 
        ndr_print_hyper(ndr, "driver_version", r->driver_version);
10057
 
        ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10058
 
        ndr->depth++;
10059
 
        if (r->manufacturer_name) {
10060
 
                ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10061
 
        }
10062
 
        ndr->depth--;
10063
 
        ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10064
 
        ndr->depth++;
10065
 
        if (r->manufacturer_url) {
10066
 
                ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10067
 
        }
10068
 
        ndr->depth--;
10069
 
        ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10070
 
        ndr->depth++;
10071
 
        if (r->hardware_id) {
10072
 
                ndr_print_string(ndr, "hardware_id", r->hardware_id);
10073
 
        }
10074
 
        ndr->depth--;
10075
 
        ndr_print_ptr(ndr, "provider", r->provider);
10076
 
        ndr->depth++;
10077
 
        if (r->provider) {
10078
 
                ndr_print_string(ndr, "provider", r->provider);
10079
 
        }
10080
 
        ndr->depth--;
10081
 
        ndr_print_ptr(ndr, "print_processor", r->print_processor);
10082
 
        ndr->depth++;
10083
 
        if (r->print_processor) {
10084
 
                ndr_print_string(ndr, "print_processor", r->print_processor);
10085
 
        }
10086
 
        ndr->depth--;
10087
 
        ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10088
 
        ndr->depth++;
10089
 
        if (r->vendor_setup) {
10090
 
                ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10091
 
        }
10092
 
        ndr->depth--;
10093
 
        ndr_print_uint32(ndr, "_ndr_size_color_profiles", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_color_profiles);
10094
 
        ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10095
 
        ndr->depth++;
10096
 
        if (r->color_profiles) {
10097
 
                ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10098
 
        }
10099
 
        ndr->depth--;
10100
 
        ndr_print_ptr(ndr, "inf_path", r->inf_path);
10101
 
        ndr->depth++;
10102
 
        if (r->inf_path) {
10103
 
                ndr_print_string(ndr, "inf_path", r->inf_path);
10104
 
        }
10105
 
        ndr->depth--;
10106
 
        ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10107
 
        ndr_print_uint32(ndr, "_ndr_size_core_driver_dependencies", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_core_driver_dependencies);
10108
 
        ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10109
 
        ndr->depth++;
10110
 
        if (r->core_driver_dependencies) {
10111
 
                ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10112
 
        }
10113
 
        ndr->depth--;
10114
 
        ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10115
 
        ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10116
 
        ndr->depth--;
10117
 
}
10118
 
 
10119
 
static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10120
 
{
10121
 
        if (ndr_flags & NDR_SCALARS) {
10122
 
                int level = ndr_push_get_switch_value(ndr, r);
10123
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10124
 
                NDR_CHECK(ndr_push_union_align(ndr, 5));
10125
 
                switch (level) {
10126
 
                        case 1: {
10127
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10128
 
                        break; }
10129
 
 
10130
 
                        case 2: {
10131
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10132
 
                        break; }
10133
 
 
10134
 
                        case 3: {
10135
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10136
 
                        break; }
10137
 
 
10138
 
                        case 4: {
10139
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10140
 
                        break; }
10141
 
 
10142
 
                        case 6: {
10143
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10144
 
                        break; }
10145
 
 
10146
 
                        case 8: {
10147
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10148
 
                        break; }
10149
 
 
10150
 
                        default:
10151
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10152
 
                }
10153
 
        }
10154
 
        if (ndr_flags & NDR_BUFFERS) {
10155
 
                int level = ndr_push_get_switch_value(ndr, r);
10156
 
                switch (level) {
10157
 
                        case 1:
10158
 
                                if (r->info1) {
10159
 
                                        NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10160
 
                                }
10161
 
                        break;
10162
 
 
10163
 
                        case 2:
10164
 
                                if (r->info2) {
10165
 
                                        NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10166
 
                                }
10167
 
                        break;
10168
 
 
10169
 
                        case 3:
10170
 
                                if (r->info3) {
10171
 
                                        NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10172
 
                                }
10173
 
                        break;
10174
 
 
10175
 
                        case 4:
10176
 
                                if (r->info4) {
10177
 
                                        NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10178
 
                                }
10179
 
                        break;
10180
 
 
10181
 
                        case 6:
10182
 
                                if (r->info6) {
10183
 
                                        NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10184
 
                                }
10185
 
                        break;
10186
 
 
10187
 
                        case 8:
10188
 
                                if (r->info8) {
10189
 
                                        NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10190
 
                                }
10191
 
                        break;
10192
 
 
10193
 
                        default:
10194
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10195
 
                }
10196
 
        }
10197
 
        return NDR_ERR_SUCCESS;
10198
 
}
10199
 
 
10200
 
static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10201
 
{
10202
 
        int level;
10203
 
        uint32_t _level;
10204
 
        TALLOC_CTX *_mem_save_info1_0;
10205
 
        TALLOC_CTX *_mem_save_info2_0;
10206
 
        TALLOC_CTX *_mem_save_info3_0;
10207
 
        TALLOC_CTX *_mem_save_info4_0;
10208
 
        TALLOC_CTX *_mem_save_info6_0;
10209
 
        TALLOC_CTX *_mem_save_info8_0;
10210
 
        level = ndr_pull_get_switch_value(ndr, r);
10211
 
        if (ndr_flags & NDR_SCALARS) {
10212
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10213
 
                if (_level != level) {
10214
 
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10215
 
                }
10216
 
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
10217
 
                switch (level) {
10218
 
                        case 1: {
10219
 
                                uint32_t _ptr_info1;
10220
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10221
 
                                if (_ptr_info1) {
10222
 
                                        NDR_PULL_ALLOC(ndr, r->info1);
10223
 
                                } else {
10224
 
                                        r->info1 = NULL;
10225
 
                                }
10226
 
                        break; }
10227
 
 
10228
 
                        case 2: {
10229
 
                                uint32_t _ptr_info2;
10230
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10231
 
                                if (_ptr_info2) {
10232
 
                                        NDR_PULL_ALLOC(ndr, r->info2);
10233
 
                                } else {
10234
 
                                        r->info2 = NULL;
10235
 
                                }
10236
 
                        break; }
10237
 
 
10238
 
                        case 3: {
10239
 
                                uint32_t _ptr_info3;
10240
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10241
 
                                if (_ptr_info3) {
10242
 
                                        NDR_PULL_ALLOC(ndr, r->info3);
10243
 
                                } else {
10244
 
                                        r->info3 = NULL;
10245
 
                                }
10246
 
                        break; }
10247
 
 
10248
 
                        case 4: {
10249
 
                                uint32_t _ptr_info4;
10250
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10251
 
                                if (_ptr_info4) {
10252
 
                                        NDR_PULL_ALLOC(ndr, r->info4);
10253
 
                                } else {
10254
 
                                        r->info4 = NULL;
10255
 
                                }
10256
 
                        break; }
10257
 
 
10258
 
                        case 6: {
10259
 
                                uint32_t _ptr_info6;
10260
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10261
 
                                if (_ptr_info6) {
10262
 
                                        NDR_PULL_ALLOC(ndr, r->info6);
10263
 
                                } else {
10264
 
                                        r->info6 = NULL;
10265
 
                                }
10266
 
                        break; }
10267
 
 
10268
 
                        case 8: {
10269
 
                                uint32_t _ptr_info8;
10270
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10271
 
                                if (_ptr_info8) {
10272
 
                                        NDR_PULL_ALLOC(ndr, r->info8);
10273
 
                                } else {
10274
 
                                        r->info8 = NULL;
10275
 
                                }
10276
 
                        break; }
10277
 
 
10278
 
                        default:
10279
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10280
 
                }
10281
 
        }
10282
 
        if (ndr_flags & NDR_BUFFERS) {
10283
 
                switch (level) {
10284
 
                        case 1:
10285
 
                                if (r->info1) {
10286
 
                                        _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10287
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10288
 
                                        NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10289
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10290
 
                                }
10291
 
                        break;
10292
 
 
10293
 
                        case 2:
10294
 
                                if (r->info2) {
10295
 
                                        _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10296
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10297
 
                                        NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10298
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10299
 
                                }
10300
 
                        break;
10301
 
 
10302
 
                        case 3:
10303
 
                                if (r->info3) {
10304
 
                                        _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10305
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10306
 
                                        NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10307
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10308
 
                                }
10309
 
                        break;
10310
 
 
10311
 
                        case 4:
10312
 
                                if (r->info4) {
10313
 
                                        _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10314
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10315
 
                                        NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10316
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10317
 
                                }
10318
 
                        break;
10319
 
 
10320
 
                        case 6:
10321
 
                                if (r->info6) {
10322
 
                                        _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10323
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10324
 
                                        NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10325
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10326
 
                                }
10327
 
                        break;
10328
 
 
10329
 
                        case 8:
10330
 
                                if (r->info8) {
10331
 
                                        _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10332
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10333
 
                                        NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10334
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10335
 
                                }
10336
 
                        break;
10337
 
 
10338
 
                        default:
10339
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10340
 
                }
10341
 
        }
10342
 
        return NDR_ERR_SUCCESS;
10343
 
}
10344
 
 
10345
 
_PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10346
 
{
10347
 
        int level;
10348
 
        level = ndr_print_get_switch_value(ndr, r);
10349
 
        ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10350
 
        switch (level) {
10351
 
                case 1:
10352
 
                        ndr_print_ptr(ndr, "info1", r->info1);
10353
 
                        ndr->depth++;
10354
 
                        if (r->info1) {
10355
 
                                ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10356
 
                        }
10357
 
                        ndr->depth--;
10358
 
                break;
10359
 
 
10360
 
                case 2:
10361
 
                        ndr_print_ptr(ndr, "info2", r->info2);
10362
 
                        ndr->depth++;
10363
 
                        if (r->info2) {
10364
 
                                ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10365
 
                        }
10366
 
                        ndr->depth--;
10367
 
                break;
10368
 
 
10369
 
                case 3:
10370
 
                        ndr_print_ptr(ndr, "info3", r->info3);
10371
 
                        ndr->depth++;
10372
 
                        if (r->info3) {
10373
 
                                ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10374
 
                        }
10375
 
                        ndr->depth--;
10376
 
                break;
10377
 
 
10378
 
                case 4:
10379
 
                        ndr_print_ptr(ndr, "info4", r->info4);
10380
 
                        ndr->depth++;
10381
 
                        if (r->info4) {
10382
 
                                ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10383
 
                        }
10384
 
                        ndr->depth--;
10385
 
                break;
10386
 
 
10387
 
                case 6:
10388
 
                        ndr_print_ptr(ndr, "info6", r->info6);
10389
 
                        ndr->depth++;
10390
 
                        if (r->info6) {
10391
 
                                ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10392
 
                        }
10393
 
                        ndr->depth--;
10394
 
                break;
10395
 
 
10396
 
                case 8:
10397
 
                        ndr_print_ptr(ndr, "info8", r->info8);
10398
 
                        ndr->depth++;
10399
 
                        if (r->info8) {
10400
 
                                ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10401
 
                        }
10402
 
                        ndr->depth--;
10403
 
                break;
10404
 
 
10405
 
                default:
10406
 
                        ndr_print_bad_level(ndr, name, level);
10407
 
        }
10408
 
}
10409
 
 
10410
 
static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10411
 
{
10412
 
        if (ndr_flags & NDR_SCALARS) {
10413
 
                NDR_CHECK(ndr_push_align(ndr, 5));
10414
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10415
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10416
 
                NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10417
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10418
 
        }
10419
 
        if (ndr_flags & NDR_BUFFERS) {
10420
 
                NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10421
 
        }
10422
 
        return NDR_ERR_SUCCESS;
10423
 
}
10424
 
 
10425
 
static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10426
 
{
10427
 
        if (ndr_flags & NDR_SCALARS) {
10428
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
10429
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10430
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10431
 
                NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10432
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10433
 
        }
10434
 
        if (ndr_flags & NDR_BUFFERS) {
10435
 
                NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10436
 
        }
10437
 
        return NDR_ERR_SUCCESS;
10438
 
}
10439
 
 
10440
 
_PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10441
 
{
10442
 
        ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10443
 
        ndr->depth++;
10444
 
        ndr_print_uint32(ndr, "level", r->level);
10445
 
        ndr_print_set_switch_value(ndr, &r->info, r->level);
10446
 
        ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10447
 
        ndr->depth--;
10448
 
}
10449
 
 
10450
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10451
 
{
10452
 
        if (ndr_flags & NDR_SCALARS) {
10453
 
                NDR_CHECK(ndr_push_align(ndr, 5));
10454
 
                {
10455
 
                        uint32_t _flags_save_string = ndr->flags;
10456
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10457
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10458
 
                        ndr->flags = _flags_save_string;
10459
 
                }
10460
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10461
 
        }
10462
 
        if (ndr_flags & NDR_BUFFERS) {
10463
 
                {
10464
 
                        uint32_t _flags_save_string = ndr->flags;
10465
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10466
 
                        if (r->driver_name) {
10467
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10468
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10469
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10470
 
                        }
10471
 
                        ndr->flags = _flags_save_string;
10472
 
                }
10473
 
        }
10474
 
        return NDR_ERR_SUCCESS;
10475
 
}
10476
 
 
10477
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10478
 
{
10479
 
        uint32_t _ptr_driver_name;
10480
 
        TALLOC_CTX *_mem_save_driver_name_0;
10481
 
        if (ndr_flags & NDR_SCALARS) {
10482
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
10483
 
                {
10484
 
                        uint32_t _flags_save_string = ndr->flags;
10485
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10486
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10487
 
                        if (_ptr_driver_name) {
10488
 
                                NDR_PULL_ALLOC(ndr, r->driver_name);
10489
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10490
 
                        } else {
10491
 
                                r->driver_name = NULL;
10492
 
                        }
10493
 
                        ndr->flags = _flags_save_string;
10494
 
                }
10495
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10496
 
        }
10497
 
        if (ndr_flags & NDR_BUFFERS) {
10498
 
                {
10499
 
                        uint32_t _flags_save_string = ndr->flags;
10500
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10501
 
                        if (r->driver_name) {
10502
 
                                uint32_t _relative_save_offset;
10503
 
                                _relative_save_offset = ndr->offset;
10504
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10505
 
                                _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10506
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10507
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10508
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10509
 
                                ndr->offset = _relative_save_offset;
10510
 
                        }
10511
 
                        ndr->flags = _flags_save_string;
10512
 
                }
10513
 
        }
10514
 
        return NDR_ERR_SUCCESS;
10515
 
}
10516
 
 
10517
 
_PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10518
 
{
10519
 
        ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10520
 
        ndr->depth++;
10521
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
10522
 
        ndr->depth++;
10523
 
        if (r->driver_name) {
10524
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
10525
 
        }
10526
 
        ndr->depth--;
10527
 
        ndr->depth--;
10528
 
}
10529
 
 
10530
 
_PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10531
 
{
10532
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10533
 
}
10534
 
 
10535
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10536
 
{
10537
 
        if (ndr_flags & NDR_SCALARS) {
10538
 
                NDR_CHECK(ndr_push_align(ndr, 5));
10539
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10540
 
                {
10541
 
                        uint32_t _flags_save_string = ndr->flags;
10542
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10543
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10544
 
                        ndr->flags = _flags_save_string;
10545
 
                }
10546
 
                {
10547
 
                        uint32_t _flags_save_string = ndr->flags;
10548
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10549
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10550
 
                        ndr->flags = _flags_save_string;
10551
 
                }
10552
 
                {
10553
 
                        uint32_t _flags_save_string = ndr->flags;
10554
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10555
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10556
 
                        ndr->flags = _flags_save_string;
10557
 
                }
10558
 
                {
10559
 
                        uint32_t _flags_save_string = ndr->flags;
10560
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10561
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10562
 
                        ndr->flags = _flags_save_string;
10563
 
                }
10564
 
                {
10565
 
                        uint32_t _flags_save_string = ndr->flags;
10566
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10567
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10568
 
                        ndr->flags = _flags_save_string;
10569
 
                }
10570
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10571
 
        }
10572
 
        if (ndr_flags & NDR_BUFFERS) {
10573
 
                {
10574
 
                        uint32_t _flags_save_string = ndr->flags;
10575
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10576
 
                        if (r->driver_name) {
10577
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10578
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10579
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10580
 
                        }
10581
 
                        ndr->flags = _flags_save_string;
10582
 
                }
10583
 
                {
10584
 
                        uint32_t _flags_save_string = ndr->flags;
10585
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10586
 
                        if (r->architecture) {
10587
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
10588
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10589
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
10590
 
                        }
10591
 
                        ndr->flags = _flags_save_string;
10592
 
                }
10593
 
                {
10594
 
                        uint32_t _flags_save_string = ndr->flags;
10595
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10596
 
                        if (r->driver_path) {
10597
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
10598
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10599
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
10600
 
                        }
10601
 
                        ndr->flags = _flags_save_string;
10602
 
                }
10603
 
                {
10604
 
                        uint32_t _flags_save_string = ndr->flags;
10605
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10606
 
                        if (r->data_file) {
10607
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
10608
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10609
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
10610
 
                        }
10611
 
                        ndr->flags = _flags_save_string;
10612
 
                }
10613
 
                {
10614
 
                        uint32_t _flags_save_string = ndr->flags;
10615
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10616
 
                        if (r->config_file) {
10617
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
10618
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10619
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
10620
 
                        }
10621
 
                        ndr->flags = _flags_save_string;
10622
 
                }
10623
 
        }
10624
 
        return NDR_ERR_SUCCESS;
10625
 
}
10626
 
 
10627
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10628
 
{
10629
 
        uint32_t _ptr_driver_name;
10630
 
        TALLOC_CTX *_mem_save_driver_name_0;
10631
 
        uint32_t _ptr_architecture;
10632
 
        TALLOC_CTX *_mem_save_architecture_0;
10633
 
        uint32_t _ptr_driver_path;
10634
 
        TALLOC_CTX *_mem_save_driver_path_0;
10635
 
        uint32_t _ptr_data_file;
10636
 
        TALLOC_CTX *_mem_save_data_file_0;
10637
 
        uint32_t _ptr_config_file;
10638
 
        TALLOC_CTX *_mem_save_config_file_0;
10639
 
        if (ndr_flags & NDR_SCALARS) {
10640
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
10641
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10642
 
                {
10643
 
                        uint32_t _flags_save_string = ndr->flags;
10644
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10645
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10646
 
                        if (_ptr_driver_name) {
10647
 
                                NDR_PULL_ALLOC(ndr, r->driver_name);
10648
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10649
 
                        } else {
10650
 
                                r->driver_name = NULL;
10651
 
                        }
10652
 
                        ndr->flags = _flags_save_string;
10653
 
                }
10654
 
                {
10655
 
                        uint32_t _flags_save_string = ndr->flags;
10656
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10657
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10658
 
                        if (_ptr_architecture) {
10659
 
                                NDR_PULL_ALLOC(ndr, r->architecture);
10660
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10661
 
                        } else {
10662
 
                                r->architecture = NULL;
10663
 
                        }
10664
 
                        ndr->flags = _flags_save_string;
10665
 
                }
10666
 
                {
10667
 
                        uint32_t _flags_save_string = ndr->flags;
10668
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10669
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10670
 
                        if (_ptr_driver_path) {
10671
 
                                NDR_PULL_ALLOC(ndr, r->driver_path);
10672
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10673
 
                        } else {
10674
 
                                r->driver_path = NULL;
10675
 
                        }
10676
 
                        ndr->flags = _flags_save_string;
10677
 
                }
10678
 
                {
10679
 
                        uint32_t _flags_save_string = ndr->flags;
10680
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10681
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10682
 
                        if (_ptr_data_file) {
10683
 
                                NDR_PULL_ALLOC(ndr, r->data_file);
10684
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10685
 
                        } else {
10686
 
                                r->data_file = NULL;
10687
 
                        }
10688
 
                        ndr->flags = _flags_save_string;
10689
 
                }
10690
 
                {
10691
 
                        uint32_t _flags_save_string = ndr->flags;
10692
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10693
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10694
 
                        if (_ptr_config_file) {
10695
 
                                NDR_PULL_ALLOC(ndr, r->config_file);
10696
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10697
 
                        } else {
10698
 
                                r->config_file = NULL;
10699
 
                        }
10700
 
                        ndr->flags = _flags_save_string;
10701
 
                }
10702
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10703
 
        }
10704
 
        if (ndr_flags & NDR_BUFFERS) {
10705
 
                {
10706
 
                        uint32_t _flags_save_string = ndr->flags;
10707
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10708
 
                        if (r->driver_name) {
10709
 
                                uint32_t _relative_save_offset;
10710
 
                                _relative_save_offset = ndr->offset;
10711
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10712
 
                                _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10713
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10714
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10715
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10716
 
                                ndr->offset = _relative_save_offset;
10717
 
                        }
10718
 
                        ndr->flags = _flags_save_string;
10719
 
                }
10720
 
                {
10721
 
                        uint32_t _flags_save_string = ndr->flags;
10722
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10723
 
                        if (r->architecture) {
10724
 
                                uint32_t _relative_save_offset;
10725
 
                                _relative_save_offset = ndr->offset;
10726
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10727
 
                                _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10728
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10729
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10730
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10731
 
                                ndr->offset = _relative_save_offset;
10732
 
                        }
10733
 
                        ndr->flags = _flags_save_string;
10734
 
                }
10735
 
                {
10736
 
                        uint32_t _flags_save_string = ndr->flags;
10737
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10738
 
                        if (r->driver_path) {
10739
 
                                uint32_t _relative_save_offset;
10740
 
                                _relative_save_offset = ndr->offset;
10741
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10742
 
                                _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10743
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10744
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10745
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10746
 
                                ndr->offset = _relative_save_offset;
10747
 
                        }
10748
 
                        ndr->flags = _flags_save_string;
10749
 
                }
10750
 
                {
10751
 
                        uint32_t _flags_save_string = ndr->flags;
10752
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10753
 
                        if (r->data_file) {
10754
 
                                uint32_t _relative_save_offset;
10755
 
                                _relative_save_offset = ndr->offset;
10756
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10757
 
                                _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10758
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10759
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10760
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10761
 
                                ndr->offset = _relative_save_offset;
10762
 
                        }
10763
 
                        ndr->flags = _flags_save_string;
10764
 
                }
10765
 
                {
10766
 
                        uint32_t _flags_save_string = ndr->flags;
10767
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10768
 
                        if (r->config_file) {
10769
 
                                uint32_t _relative_save_offset;
10770
 
                                _relative_save_offset = ndr->offset;
10771
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10772
 
                                _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10773
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10774
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10775
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10776
 
                                ndr->offset = _relative_save_offset;
10777
 
                        }
10778
 
                        ndr->flags = _flags_save_string;
10779
 
                }
10780
 
        }
10781
 
        return NDR_ERR_SUCCESS;
10782
 
}
10783
 
 
10784
 
_PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10785
 
{
10786
 
        ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10787
 
        ndr->depth++;
10788
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10789
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
10790
 
        ndr->depth++;
10791
 
        if (r->driver_name) {
10792
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
10793
 
        }
10794
 
        ndr->depth--;
10795
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
10796
 
        ndr->depth++;
10797
 
        if (r->architecture) {
10798
 
                ndr_print_string(ndr, "architecture", r->architecture);
10799
 
        }
10800
 
        ndr->depth--;
10801
 
        ndr_print_ptr(ndr, "driver_path", r->driver_path);
10802
 
        ndr->depth++;
10803
 
        if (r->driver_path) {
10804
 
                ndr_print_string(ndr, "driver_path", r->driver_path);
10805
 
        }
10806
 
        ndr->depth--;
10807
 
        ndr_print_ptr(ndr, "data_file", r->data_file);
10808
 
        ndr->depth++;
10809
 
        if (r->data_file) {
10810
 
                ndr_print_string(ndr, "data_file", r->data_file);
10811
 
        }
10812
 
        ndr->depth--;
10813
 
        ndr_print_ptr(ndr, "config_file", r->config_file);
10814
 
        ndr->depth++;
10815
 
        if (r->config_file) {
10816
 
                ndr_print_string(ndr, "config_file", r->config_file);
10817
 
        }
10818
 
        ndr->depth--;
10819
 
        ndr->depth--;
10820
 
}
10821
 
 
10822
 
_PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10823
 
{
10824
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10825
 
}
10826
 
 
10827
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10828
 
{
10829
 
        if (ndr_flags & NDR_SCALARS) {
10830
 
                NDR_CHECK(ndr_push_align(ndr, 5));
10831
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10832
 
                {
10833
 
                        uint32_t _flags_save_string = ndr->flags;
10834
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10835
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10836
 
                        ndr->flags = _flags_save_string;
10837
 
                }
10838
 
                {
10839
 
                        uint32_t _flags_save_string = ndr->flags;
10840
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10841
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10842
 
                        ndr->flags = _flags_save_string;
10843
 
                }
10844
 
                {
10845
 
                        uint32_t _flags_save_string = ndr->flags;
10846
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10847
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10848
 
                        ndr->flags = _flags_save_string;
10849
 
                }
10850
 
                {
10851
 
                        uint32_t _flags_save_string = ndr->flags;
10852
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10853
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10854
 
                        ndr->flags = _flags_save_string;
10855
 
                }
10856
 
                {
10857
 
                        uint32_t _flags_save_string = ndr->flags;
10858
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10859
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10860
 
                        ndr->flags = _flags_save_string;
10861
 
                }
10862
 
                {
10863
 
                        uint32_t _flags_save_string = ndr->flags;
10864
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10865
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10866
 
                        ndr->flags = _flags_save_string;
10867
 
                }
10868
 
                {
10869
 
                        uint32_t _flags_save_string_array = ndr->flags;
10870
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10871
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10872
 
                        ndr->flags = _flags_save_string_array;
10873
 
                }
10874
 
                {
10875
 
                        uint32_t _flags_save_string = ndr->flags;
10876
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10877
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10878
 
                        ndr->flags = _flags_save_string;
10879
 
                }
10880
 
                {
10881
 
                        uint32_t _flags_save_string = ndr->flags;
10882
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10883
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10884
 
                        ndr->flags = _flags_save_string;
10885
 
                }
10886
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10887
 
        }
10888
 
        if (ndr_flags & NDR_BUFFERS) {
10889
 
                {
10890
 
                        uint32_t _flags_save_string = ndr->flags;
10891
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10892
 
                        if (r->driver_name) {
10893
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10894
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10895
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10896
 
                        }
10897
 
                        ndr->flags = _flags_save_string;
10898
 
                }
10899
 
                {
10900
 
                        uint32_t _flags_save_string = ndr->flags;
10901
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10902
 
                        if (r->architecture) {
10903
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
10904
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10905
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
10906
 
                        }
10907
 
                        ndr->flags = _flags_save_string;
10908
 
                }
10909
 
                {
10910
 
                        uint32_t _flags_save_string = ndr->flags;
10911
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10912
 
                        if (r->driver_path) {
10913
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
10914
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10915
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
10916
 
                        }
10917
 
                        ndr->flags = _flags_save_string;
10918
 
                }
10919
 
                {
10920
 
                        uint32_t _flags_save_string = ndr->flags;
10921
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10922
 
                        if (r->data_file) {
10923
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
10924
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10925
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
10926
 
                        }
10927
 
                        ndr->flags = _flags_save_string;
10928
 
                }
10929
 
                {
10930
 
                        uint32_t _flags_save_string = ndr->flags;
10931
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10932
 
                        if (r->config_file) {
10933
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
10934
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10935
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
10936
 
                        }
10937
 
                        ndr->flags = _flags_save_string;
10938
 
                }
10939
 
                {
10940
 
                        uint32_t _flags_save_string = ndr->flags;
10941
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10942
 
                        if (r->help_file) {
10943
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
10944
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10945
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
10946
 
                        }
10947
 
                        ndr->flags = _flags_save_string;
10948
 
                }
10949
 
                {
10950
 
                        uint32_t _flags_save_string_array = ndr->flags;
10951
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10952
 
                        if (r->dependent_files) {
10953
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
10954
 
                                NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10955
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
10956
 
                        }
10957
 
                        ndr->flags = _flags_save_string_array;
10958
 
                }
10959
 
                {
10960
 
                        uint32_t _flags_save_string = ndr->flags;
10961
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10962
 
                        if (r->monitor_name) {
10963
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
10964
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10965
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
10966
 
                        }
10967
 
                        ndr->flags = _flags_save_string;
10968
 
                }
10969
 
                {
10970
 
                        uint32_t _flags_save_string = ndr->flags;
10971
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
10972
 
                        if (r->default_datatype) {
10973
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
10974
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10975
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
10976
 
                        }
10977
 
                        ndr->flags = _flags_save_string;
10978
 
                }
10979
 
        }
10980
 
        return NDR_ERR_SUCCESS;
10981
 
}
10982
 
 
10983
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10984
 
{
10985
 
        uint32_t _ptr_driver_name;
10986
 
        TALLOC_CTX *_mem_save_driver_name_0;
10987
 
        uint32_t _ptr_architecture;
10988
 
        TALLOC_CTX *_mem_save_architecture_0;
10989
 
        uint32_t _ptr_driver_path;
10990
 
        TALLOC_CTX *_mem_save_driver_path_0;
10991
 
        uint32_t _ptr_data_file;
10992
 
        TALLOC_CTX *_mem_save_data_file_0;
10993
 
        uint32_t _ptr_config_file;
10994
 
        TALLOC_CTX *_mem_save_config_file_0;
10995
 
        uint32_t _ptr_help_file;
10996
 
        TALLOC_CTX *_mem_save_help_file_0;
10997
 
        uint32_t _ptr_dependent_files;
10998
 
        TALLOC_CTX *_mem_save_dependent_files_0;
10999
 
        uint32_t _ptr_monitor_name;
11000
 
        TALLOC_CTX *_mem_save_monitor_name_0;
11001
 
        uint32_t _ptr_default_datatype;
11002
 
        TALLOC_CTX *_mem_save_default_datatype_0;
11003
 
        if (ndr_flags & NDR_SCALARS) {
11004
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
11005
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11006
 
                {
11007
 
                        uint32_t _flags_save_string = ndr->flags;
11008
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11009
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11010
 
                        if (_ptr_driver_name) {
11011
 
                                NDR_PULL_ALLOC(ndr, r->driver_name);
11012
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11013
 
                        } else {
11014
 
                                r->driver_name = NULL;
11015
 
                        }
11016
 
                        ndr->flags = _flags_save_string;
11017
 
                }
11018
 
                {
11019
 
                        uint32_t _flags_save_string = ndr->flags;
11020
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11021
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11022
 
                        if (_ptr_architecture) {
11023
 
                                NDR_PULL_ALLOC(ndr, r->architecture);
11024
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11025
 
                        } else {
11026
 
                                r->architecture = NULL;
11027
 
                        }
11028
 
                        ndr->flags = _flags_save_string;
11029
 
                }
11030
 
                {
11031
 
                        uint32_t _flags_save_string = ndr->flags;
11032
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11033
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11034
 
                        if (_ptr_driver_path) {
11035
 
                                NDR_PULL_ALLOC(ndr, r->driver_path);
11036
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11037
 
                        } else {
11038
 
                                r->driver_path = NULL;
11039
 
                        }
11040
 
                        ndr->flags = _flags_save_string;
11041
 
                }
11042
 
                {
11043
 
                        uint32_t _flags_save_string = ndr->flags;
11044
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11045
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11046
 
                        if (_ptr_data_file) {
11047
 
                                NDR_PULL_ALLOC(ndr, r->data_file);
11048
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11049
 
                        } else {
11050
 
                                r->data_file = NULL;
11051
 
                        }
11052
 
                        ndr->flags = _flags_save_string;
11053
 
                }
11054
 
                {
11055
 
                        uint32_t _flags_save_string = ndr->flags;
11056
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11057
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11058
 
                        if (_ptr_config_file) {
11059
 
                                NDR_PULL_ALLOC(ndr, r->config_file);
11060
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11061
 
                        } else {
11062
 
                                r->config_file = NULL;
11063
 
                        }
11064
 
                        ndr->flags = _flags_save_string;
11065
 
                }
11066
 
                {
11067
 
                        uint32_t _flags_save_string = ndr->flags;
11068
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11069
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11070
 
                        if (_ptr_help_file) {
11071
 
                                NDR_PULL_ALLOC(ndr, r->help_file);
11072
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11073
 
                        } else {
11074
 
                                r->help_file = NULL;
11075
 
                        }
11076
 
                        ndr->flags = _flags_save_string;
11077
 
                }
11078
 
                {
11079
 
                        uint32_t _flags_save_string_array = ndr->flags;
11080
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11081
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11082
 
                        if (_ptr_dependent_files) {
11083
 
                                NDR_PULL_ALLOC(ndr, r->dependent_files);
11084
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11085
 
                        } else {
11086
 
                                r->dependent_files = NULL;
11087
 
                        }
11088
 
                        ndr->flags = _flags_save_string_array;
11089
 
                }
11090
 
                {
11091
 
                        uint32_t _flags_save_string = ndr->flags;
11092
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11093
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11094
 
                        if (_ptr_monitor_name) {
11095
 
                                NDR_PULL_ALLOC(ndr, r->monitor_name);
11096
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11097
 
                        } else {
11098
 
                                r->monitor_name = NULL;
11099
 
                        }
11100
 
                        ndr->flags = _flags_save_string;
11101
 
                }
11102
 
                {
11103
 
                        uint32_t _flags_save_string = ndr->flags;
11104
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11105
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11106
 
                        if (_ptr_default_datatype) {
11107
 
                                NDR_PULL_ALLOC(ndr, r->default_datatype);
11108
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11109
 
                        } else {
11110
 
                                r->default_datatype = NULL;
11111
 
                        }
11112
 
                        ndr->flags = _flags_save_string;
11113
 
                }
11114
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11115
 
        }
11116
 
        if (ndr_flags & NDR_BUFFERS) {
11117
 
                {
11118
 
                        uint32_t _flags_save_string = ndr->flags;
11119
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11120
 
                        if (r->driver_name) {
11121
 
                                uint32_t _relative_save_offset;
11122
 
                                _relative_save_offset = ndr->offset;
11123
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11124
 
                                _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11125
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11126
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11127
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11128
 
                                ndr->offset = _relative_save_offset;
11129
 
                        }
11130
 
                        ndr->flags = _flags_save_string;
11131
 
                }
11132
 
                {
11133
 
                        uint32_t _flags_save_string = ndr->flags;
11134
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11135
 
                        if (r->architecture) {
11136
 
                                uint32_t _relative_save_offset;
11137
 
                                _relative_save_offset = ndr->offset;
11138
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11139
 
                                _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11140
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11141
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11142
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11143
 
                                ndr->offset = _relative_save_offset;
11144
 
                        }
11145
 
                        ndr->flags = _flags_save_string;
11146
 
                }
11147
 
                {
11148
 
                        uint32_t _flags_save_string = ndr->flags;
11149
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11150
 
                        if (r->driver_path) {
11151
 
                                uint32_t _relative_save_offset;
11152
 
                                _relative_save_offset = ndr->offset;
11153
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11154
 
                                _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11155
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11156
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11157
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11158
 
                                ndr->offset = _relative_save_offset;
11159
 
                        }
11160
 
                        ndr->flags = _flags_save_string;
11161
 
                }
11162
 
                {
11163
 
                        uint32_t _flags_save_string = ndr->flags;
11164
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11165
 
                        if (r->data_file) {
11166
 
                                uint32_t _relative_save_offset;
11167
 
                                _relative_save_offset = ndr->offset;
11168
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11169
 
                                _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11170
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11171
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11172
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11173
 
                                ndr->offset = _relative_save_offset;
11174
 
                        }
11175
 
                        ndr->flags = _flags_save_string;
11176
 
                }
11177
 
                {
11178
 
                        uint32_t _flags_save_string = ndr->flags;
11179
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11180
 
                        if (r->config_file) {
11181
 
                                uint32_t _relative_save_offset;
11182
 
                                _relative_save_offset = ndr->offset;
11183
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11184
 
                                _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11185
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11186
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11187
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11188
 
                                ndr->offset = _relative_save_offset;
11189
 
                        }
11190
 
                        ndr->flags = _flags_save_string;
11191
 
                }
11192
 
                {
11193
 
                        uint32_t _flags_save_string = ndr->flags;
11194
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11195
 
                        if (r->help_file) {
11196
 
                                uint32_t _relative_save_offset;
11197
 
                                _relative_save_offset = ndr->offset;
11198
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11199
 
                                _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11200
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11201
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11202
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11203
 
                                ndr->offset = _relative_save_offset;
11204
 
                        }
11205
 
                        ndr->flags = _flags_save_string;
11206
 
                }
11207
 
                {
11208
 
                        uint32_t _flags_save_string_array = ndr->flags;
11209
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11210
 
                        if (r->dependent_files) {
11211
 
                                uint32_t _relative_save_offset;
11212
 
                                _relative_save_offset = ndr->offset;
11213
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11214
 
                                _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11215
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11216
 
                                NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11217
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11218
 
                                ndr->offset = _relative_save_offset;
11219
 
                        }
11220
 
                        ndr->flags = _flags_save_string_array;
11221
 
                }
11222
 
                {
11223
 
                        uint32_t _flags_save_string = ndr->flags;
11224
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11225
 
                        if (r->monitor_name) {
11226
 
                                uint32_t _relative_save_offset;
11227
 
                                _relative_save_offset = ndr->offset;
11228
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11229
 
                                _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11230
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11231
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11232
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11233
 
                                ndr->offset = _relative_save_offset;
11234
 
                        }
11235
 
                        ndr->flags = _flags_save_string;
11236
 
                }
11237
 
                {
11238
 
                        uint32_t _flags_save_string = ndr->flags;
11239
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11240
 
                        if (r->default_datatype) {
11241
 
                                uint32_t _relative_save_offset;
11242
 
                                _relative_save_offset = ndr->offset;
11243
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11244
 
                                _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11245
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11246
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11247
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11248
 
                                ndr->offset = _relative_save_offset;
11249
 
                        }
11250
 
                        ndr->flags = _flags_save_string;
11251
 
                }
11252
 
        }
11253
 
        return NDR_ERR_SUCCESS;
11254
 
}
11255
 
 
11256
 
_PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11257
 
{
11258
 
        ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11259
 
        ndr->depth++;
11260
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11261
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
11262
 
        ndr->depth++;
11263
 
        if (r->driver_name) {
11264
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
11265
 
        }
11266
 
        ndr->depth--;
11267
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
11268
 
        ndr->depth++;
11269
 
        if (r->architecture) {
11270
 
                ndr_print_string(ndr, "architecture", r->architecture);
11271
 
        }
11272
 
        ndr->depth--;
11273
 
        ndr_print_ptr(ndr, "driver_path", r->driver_path);
11274
 
        ndr->depth++;
11275
 
        if (r->driver_path) {
11276
 
                ndr_print_string(ndr, "driver_path", r->driver_path);
11277
 
        }
11278
 
        ndr->depth--;
11279
 
        ndr_print_ptr(ndr, "data_file", r->data_file);
11280
 
        ndr->depth++;
11281
 
        if (r->data_file) {
11282
 
                ndr_print_string(ndr, "data_file", r->data_file);
11283
 
        }
11284
 
        ndr->depth--;
11285
 
        ndr_print_ptr(ndr, "config_file", r->config_file);
11286
 
        ndr->depth++;
11287
 
        if (r->config_file) {
11288
 
                ndr_print_string(ndr, "config_file", r->config_file);
11289
 
        }
11290
 
        ndr->depth--;
11291
 
        ndr_print_ptr(ndr, "help_file", r->help_file);
11292
 
        ndr->depth++;
11293
 
        if (r->help_file) {
11294
 
                ndr_print_string(ndr, "help_file", r->help_file);
11295
 
        }
11296
 
        ndr->depth--;
11297
 
        ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11298
 
        ndr->depth++;
11299
 
        if (r->dependent_files) {
11300
 
                ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11301
 
        }
11302
 
        ndr->depth--;
11303
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11304
 
        ndr->depth++;
11305
 
        if (r->monitor_name) {
11306
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
11307
 
        }
11308
 
        ndr->depth--;
11309
 
        ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11310
 
        ndr->depth++;
11311
 
        if (r->default_datatype) {
11312
 
                ndr_print_string(ndr, "default_datatype", r->default_datatype);
11313
 
        }
11314
 
        ndr->depth--;
11315
 
        ndr->depth--;
11316
 
}
11317
 
 
11318
 
_PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11319
 
{
11320
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11321
 
}
11322
 
 
11323
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11324
 
{
11325
 
        if (ndr_flags & NDR_SCALARS) {
11326
 
                NDR_CHECK(ndr_push_align(ndr, 5));
11327
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11328
 
                {
11329
 
                        uint32_t _flags_save_string = ndr->flags;
11330
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11331
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11332
 
                        ndr->flags = _flags_save_string;
11333
 
                }
11334
 
                {
11335
 
                        uint32_t _flags_save_string = ndr->flags;
11336
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11337
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11338
 
                        ndr->flags = _flags_save_string;
11339
 
                }
11340
 
                {
11341
 
                        uint32_t _flags_save_string = ndr->flags;
11342
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11343
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11344
 
                        ndr->flags = _flags_save_string;
11345
 
                }
11346
 
                {
11347
 
                        uint32_t _flags_save_string = ndr->flags;
11348
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11349
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11350
 
                        ndr->flags = _flags_save_string;
11351
 
                }
11352
 
                {
11353
 
                        uint32_t _flags_save_string = ndr->flags;
11354
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11355
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11356
 
                        ndr->flags = _flags_save_string;
11357
 
                }
11358
 
                {
11359
 
                        uint32_t _flags_save_string = ndr->flags;
11360
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11361
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11362
 
                        ndr->flags = _flags_save_string;
11363
 
                }
11364
 
                {
11365
 
                        uint32_t _flags_save_string_array = ndr->flags;
11366
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11367
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11368
 
                        ndr->flags = _flags_save_string_array;
11369
 
                }
11370
 
                {
11371
 
                        uint32_t _flags_save_string = ndr->flags;
11372
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11373
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11374
 
                        ndr->flags = _flags_save_string;
11375
 
                }
11376
 
                {
11377
 
                        uint32_t _flags_save_string = ndr->flags;
11378
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11379
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11380
 
                        ndr->flags = _flags_save_string;
11381
 
                }
11382
 
                {
11383
 
                        uint32_t _flags_save_string_array = ndr->flags;
11384
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11385
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11386
 
                        ndr->flags = _flags_save_string_array;
11387
 
                }
11388
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11389
 
        }
11390
 
        if (ndr_flags & NDR_BUFFERS) {
11391
 
                {
11392
 
                        uint32_t _flags_save_string = ndr->flags;
11393
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11394
 
                        if (r->driver_name) {
11395
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11396
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11397
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11398
 
                        }
11399
 
                        ndr->flags = _flags_save_string;
11400
 
                }
11401
 
                {
11402
 
                        uint32_t _flags_save_string = ndr->flags;
11403
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11404
 
                        if (r->architecture) {
11405
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11406
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11407
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11408
 
                        }
11409
 
                        ndr->flags = _flags_save_string;
11410
 
                }
11411
 
                {
11412
 
                        uint32_t _flags_save_string = ndr->flags;
11413
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11414
 
                        if (r->driver_path) {
11415
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11416
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11417
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11418
 
                        }
11419
 
                        ndr->flags = _flags_save_string;
11420
 
                }
11421
 
                {
11422
 
                        uint32_t _flags_save_string = ndr->flags;
11423
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11424
 
                        if (r->data_file) {
11425
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11426
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11427
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11428
 
                        }
11429
 
                        ndr->flags = _flags_save_string;
11430
 
                }
11431
 
                {
11432
 
                        uint32_t _flags_save_string = ndr->flags;
11433
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11434
 
                        if (r->config_file) {
11435
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11436
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11437
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11438
 
                        }
11439
 
                        ndr->flags = _flags_save_string;
11440
 
                }
11441
 
                {
11442
 
                        uint32_t _flags_save_string = ndr->flags;
11443
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11444
 
                        if (r->help_file) {
11445
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11446
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11447
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11448
 
                        }
11449
 
                        ndr->flags = _flags_save_string;
11450
 
                }
11451
 
                {
11452
 
                        uint32_t _flags_save_string_array = ndr->flags;
11453
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11454
 
                        if (r->dependent_files) {
11455
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
11456
 
                                NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11457
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
11458
 
                        }
11459
 
                        ndr->flags = _flags_save_string_array;
11460
 
                }
11461
 
                {
11462
 
                        uint32_t _flags_save_string = ndr->flags;
11463
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11464
 
                        if (r->monitor_name) {
11465
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
11466
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11467
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
11468
 
                        }
11469
 
                        ndr->flags = _flags_save_string;
11470
 
                }
11471
 
                {
11472
 
                        uint32_t _flags_save_string = ndr->flags;
11473
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11474
 
                        if (r->default_datatype) {
11475
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
11476
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11477
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
11478
 
                        }
11479
 
                        ndr->flags = _flags_save_string;
11480
 
                }
11481
 
                {
11482
 
                        uint32_t _flags_save_string_array = ndr->flags;
11483
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11484
 
                        if (r->previous_names) {
11485
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
11486
 
                                NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11487
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
11488
 
                        }
11489
 
                        ndr->flags = _flags_save_string_array;
11490
 
                }
11491
 
        }
11492
 
        return NDR_ERR_SUCCESS;
11493
 
}
11494
 
 
11495
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11496
 
{
11497
 
        uint32_t _ptr_driver_name;
11498
 
        TALLOC_CTX *_mem_save_driver_name_0;
11499
 
        uint32_t _ptr_architecture;
11500
 
        TALLOC_CTX *_mem_save_architecture_0;
11501
 
        uint32_t _ptr_driver_path;
11502
 
        TALLOC_CTX *_mem_save_driver_path_0;
11503
 
        uint32_t _ptr_data_file;
11504
 
        TALLOC_CTX *_mem_save_data_file_0;
11505
 
        uint32_t _ptr_config_file;
11506
 
        TALLOC_CTX *_mem_save_config_file_0;
11507
 
        uint32_t _ptr_help_file;
11508
 
        TALLOC_CTX *_mem_save_help_file_0;
11509
 
        uint32_t _ptr_dependent_files;
11510
 
        TALLOC_CTX *_mem_save_dependent_files_0;
11511
 
        uint32_t _ptr_monitor_name;
11512
 
        TALLOC_CTX *_mem_save_monitor_name_0;
11513
 
        uint32_t _ptr_default_datatype;
11514
 
        TALLOC_CTX *_mem_save_default_datatype_0;
11515
 
        uint32_t _ptr_previous_names;
11516
 
        TALLOC_CTX *_mem_save_previous_names_0;
11517
 
        if (ndr_flags & NDR_SCALARS) {
11518
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
11519
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11520
 
                {
11521
 
                        uint32_t _flags_save_string = ndr->flags;
11522
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11523
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11524
 
                        if (_ptr_driver_name) {
11525
 
                                NDR_PULL_ALLOC(ndr, r->driver_name);
11526
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11527
 
                        } else {
11528
 
                                r->driver_name = NULL;
11529
 
                        }
11530
 
                        ndr->flags = _flags_save_string;
11531
 
                }
11532
 
                {
11533
 
                        uint32_t _flags_save_string = ndr->flags;
11534
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11535
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11536
 
                        if (_ptr_architecture) {
11537
 
                                NDR_PULL_ALLOC(ndr, r->architecture);
11538
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11539
 
                        } else {
11540
 
                                r->architecture = NULL;
11541
 
                        }
11542
 
                        ndr->flags = _flags_save_string;
11543
 
                }
11544
 
                {
11545
 
                        uint32_t _flags_save_string = ndr->flags;
11546
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11547
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11548
 
                        if (_ptr_driver_path) {
11549
 
                                NDR_PULL_ALLOC(ndr, r->driver_path);
11550
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11551
 
                        } else {
11552
 
                                r->driver_path = NULL;
11553
 
                        }
11554
 
                        ndr->flags = _flags_save_string;
11555
 
                }
11556
 
                {
11557
 
                        uint32_t _flags_save_string = ndr->flags;
11558
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11559
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11560
 
                        if (_ptr_data_file) {
11561
 
                                NDR_PULL_ALLOC(ndr, r->data_file);
11562
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11563
 
                        } else {
11564
 
                                r->data_file = NULL;
11565
 
                        }
11566
 
                        ndr->flags = _flags_save_string;
11567
 
                }
11568
 
                {
11569
 
                        uint32_t _flags_save_string = ndr->flags;
11570
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11571
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11572
 
                        if (_ptr_config_file) {
11573
 
                                NDR_PULL_ALLOC(ndr, r->config_file);
11574
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11575
 
                        } else {
11576
 
                                r->config_file = NULL;
11577
 
                        }
11578
 
                        ndr->flags = _flags_save_string;
11579
 
                }
11580
 
                {
11581
 
                        uint32_t _flags_save_string = ndr->flags;
11582
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11583
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11584
 
                        if (_ptr_help_file) {
11585
 
                                NDR_PULL_ALLOC(ndr, r->help_file);
11586
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11587
 
                        } else {
11588
 
                                r->help_file = NULL;
11589
 
                        }
11590
 
                        ndr->flags = _flags_save_string;
11591
 
                }
11592
 
                {
11593
 
                        uint32_t _flags_save_string_array = ndr->flags;
11594
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11595
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11596
 
                        if (_ptr_dependent_files) {
11597
 
                                NDR_PULL_ALLOC(ndr, r->dependent_files);
11598
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11599
 
                        } else {
11600
 
                                r->dependent_files = NULL;
11601
 
                        }
11602
 
                        ndr->flags = _flags_save_string_array;
11603
 
                }
11604
 
                {
11605
 
                        uint32_t _flags_save_string = ndr->flags;
11606
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11607
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11608
 
                        if (_ptr_monitor_name) {
11609
 
                                NDR_PULL_ALLOC(ndr, r->monitor_name);
11610
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11611
 
                        } else {
11612
 
                                r->monitor_name = NULL;
11613
 
                        }
11614
 
                        ndr->flags = _flags_save_string;
11615
 
                }
11616
 
                {
11617
 
                        uint32_t _flags_save_string = ndr->flags;
11618
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11619
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11620
 
                        if (_ptr_default_datatype) {
11621
 
                                NDR_PULL_ALLOC(ndr, r->default_datatype);
11622
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11623
 
                        } else {
11624
 
                                r->default_datatype = NULL;
11625
 
                        }
11626
 
                        ndr->flags = _flags_save_string;
11627
 
                }
11628
 
                {
11629
 
                        uint32_t _flags_save_string_array = ndr->flags;
11630
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11631
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11632
 
                        if (_ptr_previous_names) {
11633
 
                                NDR_PULL_ALLOC(ndr, r->previous_names);
11634
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11635
 
                        } else {
11636
 
                                r->previous_names = NULL;
11637
 
                        }
11638
 
                        ndr->flags = _flags_save_string_array;
11639
 
                }
11640
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11641
 
        }
11642
 
        if (ndr_flags & NDR_BUFFERS) {
11643
 
                {
11644
 
                        uint32_t _flags_save_string = ndr->flags;
11645
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11646
 
                        if (r->driver_name) {
11647
 
                                uint32_t _relative_save_offset;
11648
 
                                _relative_save_offset = ndr->offset;
11649
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11650
 
                                _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11651
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11652
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11653
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11654
 
                                ndr->offset = _relative_save_offset;
11655
 
                        }
11656
 
                        ndr->flags = _flags_save_string;
11657
 
                }
11658
 
                {
11659
 
                        uint32_t _flags_save_string = ndr->flags;
11660
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11661
 
                        if (r->architecture) {
11662
 
                                uint32_t _relative_save_offset;
11663
 
                                _relative_save_offset = ndr->offset;
11664
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11665
 
                                _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11666
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11667
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11668
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11669
 
                                ndr->offset = _relative_save_offset;
11670
 
                        }
11671
 
                        ndr->flags = _flags_save_string;
11672
 
                }
11673
 
                {
11674
 
                        uint32_t _flags_save_string = ndr->flags;
11675
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11676
 
                        if (r->driver_path) {
11677
 
                                uint32_t _relative_save_offset;
11678
 
                                _relative_save_offset = ndr->offset;
11679
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11680
 
                                _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11681
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11682
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11683
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11684
 
                                ndr->offset = _relative_save_offset;
11685
 
                        }
11686
 
                        ndr->flags = _flags_save_string;
11687
 
                }
11688
 
                {
11689
 
                        uint32_t _flags_save_string = ndr->flags;
11690
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11691
 
                        if (r->data_file) {
11692
 
                                uint32_t _relative_save_offset;
11693
 
                                _relative_save_offset = ndr->offset;
11694
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11695
 
                                _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11696
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11697
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11698
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11699
 
                                ndr->offset = _relative_save_offset;
11700
 
                        }
11701
 
                        ndr->flags = _flags_save_string;
11702
 
                }
11703
 
                {
11704
 
                        uint32_t _flags_save_string = ndr->flags;
11705
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11706
 
                        if (r->config_file) {
11707
 
                                uint32_t _relative_save_offset;
11708
 
                                _relative_save_offset = ndr->offset;
11709
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11710
 
                                _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11711
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11712
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11713
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11714
 
                                ndr->offset = _relative_save_offset;
11715
 
                        }
11716
 
                        ndr->flags = _flags_save_string;
11717
 
                }
11718
 
                {
11719
 
                        uint32_t _flags_save_string = ndr->flags;
11720
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11721
 
                        if (r->help_file) {
11722
 
                                uint32_t _relative_save_offset;
11723
 
                                _relative_save_offset = ndr->offset;
11724
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11725
 
                                _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11726
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11727
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11728
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11729
 
                                ndr->offset = _relative_save_offset;
11730
 
                        }
11731
 
                        ndr->flags = _flags_save_string;
11732
 
                }
11733
 
                {
11734
 
                        uint32_t _flags_save_string_array = ndr->flags;
11735
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11736
 
                        if (r->dependent_files) {
11737
 
                                uint32_t _relative_save_offset;
11738
 
                                _relative_save_offset = ndr->offset;
11739
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11740
 
                                _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11741
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11742
 
                                NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11743
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11744
 
                                ndr->offset = _relative_save_offset;
11745
 
                        }
11746
 
                        ndr->flags = _flags_save_string_array;
11747
 
                }
11748
 
                {
11749
 
                        uint32_t _flags_save_string = ndr->flags;
11750
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11751
 
                        if (r->monitor_name) {
11752
 
                                uint32_t _relative_save_offset;
11753
 
                                _relative_save_offset = ndr->offset;
11754
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11755
 
                                _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11756
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11757
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11758
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11759
 
                                ndr->offset = _relative_save_offset;
11760
 
                        }
11761
 
                        ndr->flags = _flags_save_string;
11762
 
                }
11763
 
                {
11764
 
                        uint32_t _flags_save_string = ndr->flags;
11765
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11766
 
                        if (r->default_datatype) {
11767
 
                                uint32_t _relative_save_offset;
11768
 
                                _relative_save_offset = ndr->offset;
11769
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11770
 
                                _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11771
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11772
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11773
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11774
 
                                ndr->offset = _relative_save_offset;
11775
 
                        }
11776
 
                        ndr->flags = _flags_save_string;
11777
 
                }
11778
 
                {
11779
 
                        uint32_t _flags_save_string_array = ndr->flags;
11780
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11781
 
                        if (r->previous_names) {
11782
 
                                uint32_t _relative_save_offset;
11783
 
                                _relative_save_offset = ndr->offset;
11784
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11785
 
                                _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11786
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11787
 
                                NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11788
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11789
 
                                ndr->offset = _relative_save_offset;
11790
 
                        }
11791
 
                        ndr->flags = _flags_save_string_array;
11792
 
                }
11793
 
        }
11794
 
        return NDR_ERR_SUCCESS;
11795
 
}
11796
 
 
11797
 
_PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11798
 
{
11799
 
        ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11800
 
        ndr->depth++;
11801
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11802
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
11803
 
        ndr->depth++;
11804
 
        if (r->driver_name) {
11805
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
11806
 
        }
11807
 
        ndr->depth--;
11808
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
11809
 
        ndr->depth++;
11810
 
        if (r->architecture) {
11811
 
                ndr_print_string(ndr, "architecture", r->architecture);
11812
 
        }
11813
 
        ndr->depth--;
11814
 
        ndr_print_ptr(ndr, "driver_path", r->driver_path);
11815
 
        ndr->depth++;
11816
 
        if (r->driver_path) {
11817
 
                ndr_print_string(ndr, "driver_path", r->driver_path);
11818
 
        }
11819
 
        ndr->depth--;
11820
 
        ndr_print_ptr(ndr, "data_file", r->data_file);
11821
 
        ndr->depth++;
11822
 
        if (r->data_file) {
11823
 
                ndr_print_string(ndr, "data_file", r->data_file);
11824
 
        }
11825
 
        ndr->depth--;
11826
 
        ndr_print_ptr(ndr, "config_file", r->config_file);
11827
 
        ndr->depth++;
11828
 
        if (r->config_file) {
11829
 
                ndr_print_string(ndr, "config_file", r->config_file);
11830
 
        }
11831
 
        ndr->depth--;
11832
 
        ndr_print_ptr(ndr, "help_file", r->help_file);
11833
 
        ndr->depth++;
11834
 
        if (r->help_file) {
11835
 
                ndr_print_string(ndr, "help_file", r->help_file);
11836
 
        }
11837
 
        ndr->depth--;
11838
 
        ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11839
 
        ndr->depth++;
11840
 
        if (r->dependent_files) {
11841
 
                ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11842
 
        }
11843
 
        ndr->depth--;
11844
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11845
 
        ndr->depth++;
11846
 
        if (r->monitor_name) {
11847
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
11848
 
        }
11849
 
        ndr->depth--;
11850
 
        ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11851
 
        ndr->depth++;
11852
 
        if (r->default_datatype) {
11853
 
                ndr_print_string(ndr, "default_datatype", r->default_datatype);
11854
 
        }
11855
 
        ndr->depth--;
11856
 
        ndr_print_ptr(ndr, "previous_names", r->previous_names);
11857
 
        ndr->depth++;
11858
 
        if (r->previous_names) {
11859
 
                ndr_print_string_array(ndr, "previous_names", r->previous_names);
11860
 
        }
11861
 
        ndr->depth--;
11862
 
        ndr->depth--;
11863
 
}
11864
 
 
11865
 
_PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11866
 
{
11867
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11868
 
}
11869
 
 
11870
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11871
 
{
11872
 
        if (ndr_flags & NDR_SCALARS) {
11873
 
                NDR_CHECK(ndr_push_align(ndr, 5));
11874
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11875
 
                {
11876
 
                        uint32_t _flags_save_string = ndr->flags;
11877
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11878
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11879
 
                        ndr->flags = _flags_save_string;
11880
 
                }
11881
 
                {
11882
 
                        uint32_t _flags_save_string = ndr->flags;
11883
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11884
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11885
 
                        ndr->flags = _flags_save_string;
11886
 
                }
11887
 
                {
11888
 
                        uint32_t _flags_save_string = ndr->flags;
11889
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11890
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11891
 
                        ndr->flags = _flags_save_string;
11892
 
                }
11893
 
                {
11894
 
                        uint32_t _flags_save_string = ndr->flags;
11895
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11896
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11897
 
                        ndr->flags = _flags_save_string;
11898
 
                }
11899
 
                {
11900
 
                        uint32_t _flags_save_string = ndr->flags;
11901
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11902
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11903
 
                        ndr->flags = _flags_save_string;
11904
 
                }
11905
 
                NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
11906
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11907
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11908
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11909
 
        }
11910
 
        if (ndr_flags & NDR_BUFFERS) {
11911
 
                {
11912
 
                        uint32_t _flags_save_string = ndr->flags;
11913
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11914
 
                        if (r->driver_name) {
11915
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11916
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11917
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11918
 
                        }
11919
 
                        ndr->flags = _flags_save_string;
11920
 
                }
11921
 
                {
11922
 
                        uint32_t _flags_save_string = ndr->flags;
11923
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11924
 
                        if (r->architecture) {
11925
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11926
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11927
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11928
 
                        }
11929
 
                        ndr->flags = _flags_save_string;
11930
 
                }
11931
 
                {
11932
 
                        uint32_t _flags_save_string = ndr->flags;
11933
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11934
 
                        if (r->driver_path) {
11935
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11936
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11937
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11938
 
                        }
11939
 
                        ndr->flags = _flags_save_string;
11940
 
                }
11941
 
                {
11942
 
                        uint32_t _flags_save_string = ndr->flags;
11943
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11944
 
                        if (r->data_file) {
11945
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11946
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11947
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11948
 
                        }
11949
 
                        ndr->flags = _flags_save_string;
11950
 
                }
11951
 
                {
11952
 
                        uint32_t _flags_save_string = ndr->flags;
11953
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11954
 
                        if (r->config_file) {
11955
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11956
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11957
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11958
 
                        }
11959
 
                        ndr->flags = _flags_save_string;
11960
 
                }
11961
 
        }
11962
 
        return NDR_ERR_SUCCESS;
11963
 
}
11964
 
 
11965
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11966
 
{
11967
 
        uint32_t _ptr_driver_name;
11968
 
        TALLOC_CTX *_mem_save_driver_name_0;
11969
 
        uint32_t _ptr_architecture;
11970
 
        TALLOC_CTX *_mem_save_architecture_0;
11971
 
        uint32_t _ptr_driver_path;
11972
 
        TALLOC_CTX *_mem_save_driver_path_0;
11973
 
        uint32_t _ptr_data_file;
11974
 
        TALLOC_CTX *_mem_save_data_file_0;
11975
 
        uint32_t _ptr_config_file;
11976
 
        TALLOC_CTX *_mem_save_config_file_0;
11977
 
        if (ndr_flags & NDR_SCALARS) {
11978
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
11979
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11980
 
                {
11981
 
                        uint32_t _flags_save_string = ndr->flags;
11982
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11983
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11984
 
                        if (_ptr_driver_name) {
11985
 
                                NDR_PULL_ALLOC(ndr, r->driver_name);
11986
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11987
 
                        } else {
11988
 
                                r->driver_name = NULL;
11989
 
                        }
11990
 
                        ndr->flags = _flags_save_string;
11991
 
                }
11992
 
                {
11993
 
                        uint32_t _flags_save_string = ndr->flags;
11994
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
11995
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11996
 
                        if (_ptr_architecture) {
11997
 
                                NDR_PULL_ALLOC(ndr, r->architecture);
11998
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11999
 
                        } else {
12000
 
                                r->architecture = NULL;
12001
 
                        }
12002
 
                        ndr->flags = _flags_save_string;
12003
 
                }
12004
 
                {
12005
 
                        uint32_t _flags_save_string = ndr->flags;
12006
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12007
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12008
 
                        if (_ptr_driver_path) {
12009
 
                                NDR_PULL_ALLOC(ndr, r->driver_path);
12010
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12011
 
                        } else {
12012
 
                                r->driver_path = NULL;
12013
 
                        }
12014
 
                        ndr->flags = _flags_save_string;
12015
 
                }
12016
 
                {
12017
 
                        uint32_t _flags_save_string = ndr->flags;
12018
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12019
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12020
 
                        if (_ptr_data_file) {
12021
 
                                NDR_PULL_ALLOC(ndr, r->data_file);
12022
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12023
 
                        } else {
12024
 
                                r->data_file = NULL;
12025
 
                        }
12026
 
                        ndr->flags = _flags_save_string;
12027
 
                }
12028
 
                {
12029
 
                        uint32_t _flags_save_string = ndr->flags;
12030
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12031
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12032
 
                        if (_ptr_config_file) {
12033
 
                                NDR_PULL_ALLOC(ndr, r->config_file);
12034
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12035
 
                        } else {
12036
 
                                r->config_file = NULL;
12037
 
                        }
12038
 
                        ndr->flags = _flags_save_string;
12039
 
                }
12040
 
                NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
12041
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
12042
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
12043
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12044
 
        }
12045
 
        if (ndr_flags & NDR_BUFFERS) {
12046
 
                {
12047
 
                        uint32_t _flags_save_string = ndr->flags;
12048
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12049
 
                        if (r->driver_name) {
12050
 
                                uint32_t _relative_save_offset;
12051
 
                                _relative_save_offset = ndr->offset;
12052
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12053
 
                                _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12054
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12055
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12056
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12057
 
                                ndr->offset = _relative_save_offset;
12058
 
                        }
12059
 
                        ndr->flags = _flags_save_string;
12060
 
                }
12061
 
                {
12062
 
                        uint32_t _flags_save_string = ndr->flags;
12063
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12064
 
                        if (r->architecture) {
12065
 
                                uint32_t _relative_save_offset;
12066
 
                                _relative_save_offset = ndr->offset;
12067
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12068
 
                                _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12069
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12070
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12071
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12072
 
                                ndr->offset = _relative_save_offset;
12073
 
                        }
12074
 
                        ndr->flags = _flags_save_string;
12075
 
                }
12076
 
                {
12077
 
                        uint32_t _flags_save_string = ndr->flags;
12078
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12079
 
                        if (r->driver_path) {
12080
 
                                uint32_t _relative_save_offset;
12081
 
                                _relative_save_offset = ndr->offset;
12082
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12083
 
                                _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12084
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12085
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12086
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12087
 
                                ndr->offset = _relative_save_offset;
12088
 
                        }
12089
 
                        ndr->flags = _flags_save_string;
12090
 
                }
12091
 
                {
12092
 
                        uint32_t _flags_save_string = ndr->flags;
12093
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12094
 
                        if (r->data_file) {
12095
 
                                uint32_t _relative_save_offset;
12096
 
                                _relative_save_offset = ndr->offset;
12097
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12098
 
                                _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12099
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12100
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12101
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12102
 
                                ndr->offset = _relative_save_offset;
12103
 
                        }
12104
 
                        ndr->flags = _flags_save_string;
12105
 
                }
12106
 
                {
12107
 
                        uint32_t _flags_save_string = ndr->flags;
12108
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12109
 
                        if (r->config_file) {
12110
 
                                uint32_t _relative_save_offset;
12111
 
                                _relative_save_offset = ndr->offset;
12112
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12113
 
                                _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12114
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12115
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12116
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12117
 
                                ndr->offset = _relative_save_offset;
12118
 
                        }
12119
 
                        ndr->flags = _flags_save_string;
12120
 
                }
12121
 
        }
12122
 
        return NDR_ERR_SUCCESS;
12123
 
}
12124
 
 
12125
 
_PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12126
 
{
12127
 
        ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12128
 
        ndr->depth++;
12129
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12130
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
12131
 
        ndr->depth++;
12132
 
        if (r->driver_name) {
12133
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
12134
 
        }
12135
 
        ndr->depth--;
12136
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
12137
 
        ndr->depth++;
12138
 
        if (r->architecture) {
12139
 
                ndr_print_string(ndr, "architecture", r->architecture);
12140
 
        }
12141
 
        ndr->depth--;
12142
 
        ndr_print_ptr(ndr, "driver_path", r->driver_path);
12143
 
        ndr->depth++;
12144
 
        if (r->driver_path) {
12145
 
                ndr_print_string(ndr, "driver_path", r->driver_path);
12146
 
        }
12147
 
        ndr->depth--;
12148
 
        ndr_print_ptr(ndr, "data_file", r->data_file);
12149
 
        ndr->depth++;
12150
 
        if (r->data_file) {
12151
 
                ndr_print_string(ndr, "data_file", r->data_file);
12152
 
        }
12153
 
        ndr->depth--;
12154
 
        ndr_print_ptr(ndr, "config_file", r->config_file);
12155
 
        ndr->depth++;
12156
 
        if (r->config_file) {
12157
 
                ndr_print_string(ndr, "config_file", r->config_file);
12158
 
        }
12159
 
        ndr->depth--;
12160
 
        ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12161
 
        ndr_print_uint32(ndr, "config_version", r->config_version);
12162
 
        ndr_print_uint32(ndr, "driver_version", r->driver_version);
12163
 
        ndr->depth--;
12164
 
}
12165
 
 
12166
 
_PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12167
 
{
12168
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12169
 
}
12170
 
 
12171
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12172
 
{
12173
 
        if (ndr_flags & NDR_SCALARS) {
12174
 
                NDR_CHECK(ndr_push_align(ndr, 8));
12175
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12176
 
                {
12177
 
                        uint32_t _flags_save_string = ndr->flags;
12178
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12179
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12180
 
                        ndr->flags = _flags_save_string;
12181
 
                }
12182
 
                {
12183
 
                        uint32_t _flags_save_string = ndr->flags;
12184
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12185
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12186
 
                        ndr->flags = _flags_save_string;
12187
 
                }
12188
 
                {
12189
 
                        uint32_t _flags_save_string = ndr->flags;
12190
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12191
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12192
 
                        ndr->flags = _flags_save_string;
12193
 
                }
12194
 
                {
12195
 
                        uint32_t _flags_save_string = ndr->flags;
12196
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12197
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12198
 
                        ndr->flags = _flags_save_string;
12199
 
                }
12200
 
                {
12201
 
                        uint32_t _flags_save_string = ndr->flags;
12202
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12203
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12204
 
                        ndr->flags = _flags_save_string;
12205
 
                }
12206
 
                {
12207
 
                        uint32_t _flags_save_string = ndr->flags;
12208
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12209
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12210
 
                        ndr->flags = _flags_save_string;
12211
 
                }
12212
 
                {
12213
 
                        uint32_t _flags_save_string_array = ndr->flags;
12214
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12215
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12216
 
                        ndr->flags = _flags_save_string_array;
12217
 
                }
12218
 
                {
12219
 
                        uint32_t _flags_save_string = ndr->flags;
12220
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12221
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12222
 
                        ndr->flags = _flags_save_string;
12223
 
                }
12224
 
                {
12225
 
                        uint32_t _flags_save_string = ndr->flags;
12226
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12227
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12228
 
                        ndr->flags = _flags_save_string;
12229
 
                }
12230
 
                {
12231
 
                        uint32_t _flags_save_string_array = ndr->flags;
12232
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12233
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12234
 
                        ndr->flags = _flags_save_string_array;
12235
 
                }
12236
 
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12237
 
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12238
 
                {
12239
 
                        uint32_t _flags_save_string = ndr->flags;
12240
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12241
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12242
 
                        ndr->flags = _flags_save_string;
12243
 
                }
12244
 
                {
12245
 
                        uint32_t _flags_save_string = ndr->flags;
12246
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12247
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12248
 
                        ndr->flags = _flags_save_string;
12249
 
                }
12250
 
                {
12251
 
                        uint32_t _flags_save_string = ndr->flags;
12252
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12253
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12254
 
                        ndr->flags = _flags_save_string;
12255
 
                }
12256
 
                {
12257
 
                        uint32_t _flags_save_string = ndr->flags;
12258
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12259
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12260
 
                        ndr->flags = _flags_save_string;
12261
 
                }
12262
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12263
 
        }
12264
 
        if (ndr_flags & NDR_BUFFERS) {
12265
 
                {
12266
 
                        uint32_t _flags_save_string = ndr->flags;
12267
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12268
 
                        if (r->driver_name) {
12269
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12270
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12271
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12272
 
                        }
12273
 
                        ndr->flags = _flags_save_string;
12274
 
                }
12275
 
                {
12276
 
                        uint32_t _flags_save_string = ndr->flags;
12277
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12278
 
                        if (r->architecture) {
12279
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12280
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12281
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12282
 
                        }
12283
 
                        ndr->flags = _flags_save_string;
12284
 
                }
12285
 
                {
12286
 
                        uint32_t _flags_save_string = ndr->flags;
12287
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12288
 
                        if (r->driver_path) {
12289
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12290
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12291
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12292
 
                        }
12293
 
                        ndr->flags = _flags_save_string;
12294
 
                }
12295
 
                {
12296
 
                        uint32_t _flags_save_string = ndr->flags;
12297
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12298
 
                        if (r->data_file) {
12299
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12300
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12301
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12302
 
                        }
12303
 
                        ndr->flags = _flags_save_string;
12304
 
                }
12305
 
                {
12306
 
                        uint32_t _flags_save_string = ndr->flags;
12307
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12308
 
                        if (r->config_file) {
12309
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12310
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12311
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12312
 
                        }
12313
 
                        ndr->flags = _flags_save_string;
12314
 
                }
12315
 
                {
12316
 
                        uint32_t _flags_save_string = ndr->flags;
12317
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12318
 
                        if (r->help_file) {
12319
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
12320
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12321
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
12322
 
                        }
12323
 
                        ndr->flags = _flags_save_string;
12324
 
                }
12325
 
                {
12326
 
                        uint32_t _flags_save_string_array = ndr->flags;
12327
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12328
 
                        if (r->dependent_files) {
12329
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
12330
 
                                NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12331
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
12332
 
                        }
12333
 
                        ndr->flags = _flags_save_string_array;
12334
 
                }
12335
 
                {
12336
 
                        uint32_t _flags_save_string = ndr->flags;
12337
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12338
 
                        if (r->monitor_name) {
12339
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
12340
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12341
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
12342
 
                        }
12343
 
                        ndr->flags = _flags_save_string;
12344
 
                }
12345
 
                {
12346
 
                        uint32_t _flags_save_string = ndr->flags;
12347
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12348
 
                        if (r->default_datatype) {
12349
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
12350
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12351
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
12352
 
                        }
12353
 
                        ndr->flags = _flags_save_string;
12354
 
                }
12355
 
                {
12356
 
                        uint32_t _flags_save_string_array = ndr->flags;
12357
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12358
 
                        if (r->previous_names) {
12359
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
12360
 
                                NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12361
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
12362
 
                        }
12363
 
                        ndr->flags = _flags_save_string_array;
12364
 
                }
12365
 
                {
12366
 
                        uint32_t _flags_save_string = ndr->flags;
12367
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12368
 
                        if (r->manufacturer_name) {
12369
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
12370
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12371
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
12372
 
                        }
12373
 
                        ndr->flags = _flags_save_string;
12374
 
                }
12375
 
                {
12376
 
                        uint32_t _flags_save_string = ndr->flags;
12377
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12378
 
                        if (r->manufacturer_url) {
12379
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
12380
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12381
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
12382
 
                        }
12383
 
                        ndr->flags = _flags_save_string;
12384
 
                }
12385
 
                {
12386
 
                        uint32_t _flags_save_string = ndr->flags;
12387
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12388
 
                        if (r->hardware_id) {
12389
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
12390
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12391
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
12392
 
                        }
12393
 
                        ndr->flags = _flags_save_string;
12394
 
                }
12395
 
                {
12396
 
                        uint32_t _flags_save_string = ndr->flags;
12397
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12398
 
                        if (r->provider) {
12399
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
12400
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12401
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
12402
 
                        }
12403
 
                        ndr->flags = _flags_save_string;
12404
 
                }
12405
 
        }
12406
 
        return NDR_ERR_SUCCESS;
12407
 
}
12408
 
 
12409
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12410
 
{
12411
 
        uint32_t _ptr_driver_name;
12412
 
        TALLOC_CTX *_mem_save_driver_name_0;
12413
 
        uint32_t _ptr_architecture;
12414
 
        TALLOC_CTX *_mem_save_architecture_0;
12415
 
        uint32_t _ptr_driver_path;
12416
 
        TALLOC_CTX *_mem_save_driver_path_0;
12417
 
        uint32_t _ptr_data_file;
12418
 
        TALLOC_CTX *_mem_save_data_file_0;
12419
 
        uint32_t _ptr_config_file;
12420
 
        TALLOC_CTX *_mem_save_config_file_0;
12421
 
        uint32_t _ptr_help_file;
12422
 
        TALLOC_CTX *_mem_save_help_file_0;
12423
 
        uint32_t _ptr_dependent_files;
12424
 
        TALLOC_CTX *_mem_save_dependent_files_0;
12425
 
        uint32_t _ptr_monitor_name;
12426
 
        TALLOC_CTX *_mem_save_monitor_name_0;
12427
 
        uint32_t _ptr_default_datatype;
12428
 
        TALLOC_CTX *_mem_save_default_datatype_0;
12429
 
        uint32_t _ptr_previous_names;
12430
 
        TALLOC_CTX *_mem_save_previous_names_0;
12431
 
        uint32_t _ptr_manufacturer_name;
12432
 
        TALLOC_CTX *_mem_save_manufacturer_name_0;
12433
 
        uint32_t _ptr_manufacturer_url;
12434
 
        TALLOC_CTX *_mem_save_manufacturer_url_0;
12435
 
        uint32_t _ptr_hardware_id;
12436
 
        TALLOC_CTX *_mem_save_hardware_id_0;
12437
 
        uint32_t _ptr_provider;
12438
 
        TALLOC_CTX *_mem_save_provider_0;
12439
 
        if (ndr_flags & NDR_SCALARS) {
12440
 
                NDR_CHECK(ndr_pull_align(ndr, 8));
12441
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12442
 
                {
12443
 
                        uint32_t _flags_save_string = ndr->flags;
12444
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12445
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12446
 
                        if (_ptr_driver_name) {
12447
 
                                NDR_PULL_ALLOC(ndr, r->driver_name);
12448
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12449
 
                        } else {
12450
 
                                r->driver_name = NULL;
12451
 
                        }
12452
 
                        ndr->flags = _flags_save_string;
12453
 
                }
12454
 
                {
12455
 
                        uint32_t _flags_save_string = ndr->flags;
12456
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12457
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12458
 
                        if (_ptr_architecture) {
12459
 
                                NDR_PULL_ALLOC(ndr, r->architecture);
12460
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12461
 
                        } else {
12462
 
                                r->architecture = NULL;
12463
 
                        }
12464
 
                        ndr->flags = _flags_save_string;
12465
 
                }
12466
 
                {
12467
 
                        uint32_t _flags_save_string = ndr->flags;
12468
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12469
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12470
 
                        if (_ptr_driver_path) {
12471
 
                                NDR_PULL_ALLOC(ndr, r->driver_path);
12472
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12473
 
                        } else {
12474
 
                                r->driver_path = NULL;
12475
 
                        }
12476
 
                        ndr->flags = _flags_save_string;
12477
 
                }
12478
 
                {
12479
 
                        uint32_t _flags_save_string = ndr->flags;
12480
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12481
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12482
 
                        if (_ptr_data_file) {
12483
 
                                NDR_PULL_ALLOC(ndr, r->data_file);
12484
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12485
 
                        } else {
12486
 
                                r->data_file = NULL;
12487
 
                        }
12488
 
                        ndr->flags = _flags_save_string;
12489
 
                }
12490
 
                {
12491
 
                        uint32_t _flags_save_string = ndr->flags;
12492
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12493
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12494
 
                        if (_ptr_config_file) {
12495
 
                                NDR_PULL_ALLOC(ndr, r->config_file);
12496
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12497
 
                        } else {
12498
 
                                r->config_file = NULL;
12499
 
                        }
12500
 
                        ndr->flags = _flags_save_string;
12501
 
                }
12502
 
                {
12503
 
                        uint32_t _flags_save_string = ndr->flags;
12504
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12505
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12506
 
                        if (_ptr_help_file) {
12507
 
                                NDR_PULL_ALLOC(ndr, r->help_file);
12508
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12509
 
                        } else {
12510
 
                                r->help_file = NULL;
12511
 
                        }
12512
 
                        ndr->flags = _flags_save_string;
12513
 
                }
12514
 
                {
12515
 
                        uint32_t _flags_save_string_array = ndr->flags;
12516
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12517
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12518
 
                        if (_ptr_dependent_files) {
12519
 
                                NDR_PULL_ALLOC(ndr, r->dependent_files);
12520
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12521
 
                        } else {
12522
 
                                r->dependent_files = NULL;
12523
 
                        }
12524
 
                        ndr->flags = _flags_save_string_array;
12525
 
                }
12526
 
                {
12527
 
                        uint32_t _flags_save_string = ndr->flags;
12528
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12529
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12530
 
                        if (_ptr_monitor_name) {
12531
 
                                NDR_PULL_ALLOC(ndr, r->monitor_name);
12532
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12533
 
                        } else {
12534
 
                                r->monitor_name = NULL;
12535
 
                        }
12536
 
                        ndr->flags = _flags_save_string;
12537
 
                }
12538
 
                {
12539
 
                        uint32_t _flags_save_string = ndr->flags;
12540
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12541
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12542
 
                        if (_ptr_default_datatype) {
12543
 
                                NDR_PULL_ALLOC(ndr, r->default_datatype);
12544
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12545
 
                        } else {
12546
 
                                r->default_datatype = NULL;
12547
 
                        }
12548
 
                        ndr->flags = _flags_save_string;
12549
 
                }
12550
 
                {
12551
 
                        uint32_t _flags_save_string_array = ndr->flags;
12552
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12553
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12554
 
                        if (_ptr_previous_names) {
12555
 
                                NDR_PULL_ALLOC(ndr, r->previous_names);
12556
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12557
 
                        } else {
12558
 
                                r->previous_names = NULL;
12559
 
                        }
12560
 
                        ndr->flags = _flags_save_string_array;
12561
 
                }
12562
 
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12563
 
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12564
 
                {
12565
 
                        uint32_t _flags_save_string = ndr->flags;
12566
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12567
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12568
 
                        if (_ptr_manufacturer_name) {
12569
 
                                NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12570
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12571
 
                        } else {
12572
 
                                r->manufacturer_name = NULL;
12573
 
                        }
12574
 
                        ndr->flags = _flags_save_string;
12575
 
                }
12576
 
                {
12577
 
                        uint32_t _flags_save_string = ndr->flags;
12578
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12579
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12580
 
                        if (_ptr_manufacturer_url) {
12581
 
                                NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12582
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12583
 
                        } else {
12584
 
                                r->manufacturer_url = NULL;
12585
 
                        }
12586
 
                        ndr->flags = _flags_save_string;
12587
 
                }
12588
 
                {
12589
 
                        uint32_t _flags_save_string = ndr->flags;
12590
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12591
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12592
 
                        if (_ptr_hardware_id) {
12593
 
                                NDR_PULL_ALLOC(ndr, r->hardware_id);
12594
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12595
 
                        } else {
12596
 
                                r->hardware_id = NULL;
12597
 
                        }
12598
 
                        ndr->flags = _flags_save_string;
12599
 
                }
12600
 
                {
12601
 
                        uint32_t _flags_save_string = ndr->flags;
12602
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12603
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12604
 
                        if (_ptr_provider) {
12605
 
                                NDR_PULL_ALLOC(ndr, r->provider);
12606
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12607
 
                        } else {
12608
 
                                r->provider = NULL;
12609
 
                        }
12610
 
                        ndr->flags = _flags_save_string;
12611
 
                }
12612
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12613
 
        }
12614
 
        if (ndr_flags & NDR_BUFFERS) {
12615
 
                {
12616
 
                        uint32_t _flags_save_string = ndr->flags;
12617
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12618
 
                        if (r->driver_name) {
12619
 
                                uint32_t _relative_save_offset;
12620
 
                                _relative_save_offset = ndr->offset;
12621
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12622
 
                                _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12623
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12624
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12625
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12626
 
                                ndr->offset = _relative_save_offset;
12627
 
                        }
12628
 
                        ndr->flags = _flags_save_string;
12629
 
                }
12630
 
                {
12631
 
                        uint32_t _flags_save_string = ndr->flags;
12632
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12633
 
                        if (r->architecture) {
12634
 
                                uint32_t _relative_save_offset;
12635
 
                                _relative_save_offset = ndr->offset;
12636
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12637
 
                                _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12638
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12639
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12640
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12641
 
                                ndr->offset = _relative_save_offset;
12642
 
                        }
12643
 
                        ndr->flags = _flags_save_string;
12644
 
                }
12645
 
                {
12646
 
                        uint32_t _flags_save_string = ndr->flags;
12647
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12648
 
                        if (r->driver_path) {
12649
 
                                uint32_t _relative_save_offset;
12650
 
                                _relative_save_offset = ndr->offset;
12651
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12652
 
                                _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12653
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12654
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12655
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12656
 
                                ndr->offset = _relative_save_offset;
12657
 
                        }
12658
 
                        ndr->flags = _flags_save_string;
12659
 
                }
12660
 
                {
12661
 
                        uint32_t _flags_save_string = ndr->flags;
12662
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12663
 
                        if (r->data_file) {
12664
 
                                uint32_t _relative_save_offset;
12665
 
                                _relative_save_offset = ndr->offset;
12666
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12667
 
                                _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12668
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12669
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12670
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12671
 
                                ndr->offset = _relative_save_offset;
12672
 
                        }
12673
 
                        ndr->flags = _flags_save_string;
12674
 
                }
12675
 
                {
12676
 
                        uint32_t _flags_save_string = ndr->flags;
12677
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12678
 
                        if (r->config_file) {
12679
 
                                uint32_t _relative_save_offset;
12680
 
                                _relative_save_offset = ndr->offset;
12681
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12682
 
                                _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12683
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12684
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12685
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12686
 
                                ndr->offset = _relative_save_offset;
12687
 
                        }
12688
 
                        ndr->flags = _flags_save_string;
12689
 
                }
12690
 
                {
12691
 
                        uint32_t _flags_save_string = ndr->flags;
12692
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12693
 
                        if (r->help_file) {
12694
 
                                uint32_t _relative_save_offset;
12695
 
                                _relative_save_offset = ndr->offset;
12696
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12697
 
                                _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12698
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12699
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12700
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12701
 
                                ndr->offset = _relative_save_offset;
12702
 
                        }
12703
 
                        ndr->flags = _flags_save_string;
12704
 
                }
12705
 
                {
12706
 
                        uint32_t _flags_save_string_array = ndr->flags;
12707
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12708
 
                        if (r->dependent_files) {
12709
 
                                uint32_t _relative_save_offset;
12710
 
                                _relative_save_offset = ndr->offset;
12711
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12712
 
                                _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12713
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12714
 
                                NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12715
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12716
 
                                ndr->offset = _relative_save_offset;
12717
 
                        }
12718
 
                        ndr->flags = _flags_save_string_array;
12719
 
                }
12720
 
                {
12721
 
                        uint32_t _flags_save_string = ndr->flags;
12722
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12723
 
                        if (r->monitor_name) {
12724
 
                                uint32_t _relative_save_offset;
12725
 
                                _relative_save_offset = ndr->offset;
12726
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12727
 
                                _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12728
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12729
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12730
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12731
 
                                ndr->offset = _relative_save_offset;
12732
 
                        }
12733
 
                        ndr->flags = _flags_save_string;
12734
 
                }
12735
 
                {
12736
 
                        uint32_t _flags_save_string = ndr->flags;
12737
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12738
 
                        if (r->default_datatype) {
12739
 
                                uint32_t _relative_save_offset;
12740
 
                                _relative_save_offset = ndr->offset;
12741
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12742
 
                                _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12743
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12744
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12745
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12746
 
                                ndr->offset = _relative_save_offset;
12747
 
                        }
12748
 
                        ndr->flags = _flags_save_string;
12749
 
                }
12750
 
                {
12751
 
                        uint32_t _flags_save_string_array = ndr->flags;
12752
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12753
 
                        if (r->previous_names) {
12754
 
                                uint32_t _relative_save_offset;
12755
 
                                _relative_save_offset = ndr->offset;
12756
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12757
 
                                _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12758
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12759
 
                                NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12760
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12761
 
                                ndr->offset = _relative_save_offset;
12762
 
                        }
12763
 
                        ndr->flags = _flags_save_string_array;
12764
 
                }
12765
 
                {
12766
 
                        uint32_t _flags_save_string = ndr->flags;
12767
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12768
 
                        if (r->manufacturer_name) {
12769
 
                                uint32_t _relative_save_offset;
12770
 
                                _relative_save_offset = ndr->offset;
12771
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12772
 
                                _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12773
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12774
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12775
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12776
 
                                ndr->offset = _relative_save_offset;
12777
 
                        }
12778
 
                        ndr->flags = _flags_save_string;
12779
 
                }
12780
 
                {
12781
 
                        uint32_t _flags_save_string = ndr->flags;
12782
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12783
 
                        if (r->manufacturer_url) {
12784
 
                                uint32_t _relative_save_offset;
12785
 
                                _relative_save_offset = ndr->offset;
12786
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12787
 
                                _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12788
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12789
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12790
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12791
 
                                ndr->offset = _relative_save_offset;
12792
 
                        }
12793
 
                        ndr->flags = _flags_save_string;
12794
 
                }
12795
 
                {
12796
 
                        uint32_t _flags_save_string = ndr->flags;
12797
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12798
 
                        if (r->hardware_id) {
12799
 
                                uint32_t _relative_save_offset;
12800
 
                                _relative_save_offset = ndr->offset;
12801
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12802
 
                                _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12803
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12804
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12805
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12806
 
                                ndr->offset = _relative_save_offset;
12807
 
                        }
12808
 
                        ndr->flags = _flags_save_string;
12809
 
                }
12810
 
                {
12811
 
                        uint32_t _flags_save_string = ndr->flags;
12812
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12813
 
                        if (r->provider) {
12814
 
                                uint32_t _relative_save_offset;
12815
 
                                _relative_save_offset = ndr->offset;
12816
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12817
 
                                _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12818
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12819
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12820
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12821
 
                                ndr->offset = _relative_save_offset;
12822
 
                        }
12823
 
                        ndr->flags = _flags_save_string;
12824
 
                }
12825
 
        }
12826
 
        return NDR_ERR_SUCCESS;
12827
 
}
12828
 
 
12829
 
_PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12830
 
{
12831
 
        ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12832
 
        ndr->depth++;
12833
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12834
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
12835
 
        ndr->depth++;
12836
 
        if (r->driver_name) {
12837
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
12838
 
        }
12839
 
        ndr->depth--;
12840
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
12841
 
        ndr->depth++;
12842
 
        if (r->architecture) {
12843
 
                ndr_print_string(ndr, "architecture", r->architecture);
12844
 
        }
12845
 
        ndr->depth--;
12846
 
        ndr_print_ptr(ndr, "driver_path", r->driver_path);
12847
 
        ndr->depth++;
12848
 
        if (r->driver_path) {
12849
 
                ndr_print_string(ndr, "driver_path", r->driver_path);
12850
 
        }
12851
 
        ndr->depth--;
12852
 
        ndr_print_ptr(ndr, "data_file", r->data_file);
12853
 
        ndr->depth++;
12854
 
        if (r->data_file) {
12855
 
                ndr_print_string(ndr, "data_file", r->data_file);
12856
 
        }
12857
 
        ndr->depth--;
12858
 
        ndr_print_ptr(ndr, "config_file", r->config_file);
12859
 
        ndr->depth++;
12860
 
        if (r->config_file) {
12861
 
                ndr_print_string(ndr, "config_file", r->config_file);
12862
 
        }
12863
 
        ndr->depth--;
12864
 
        ndr_print_ptr(ndr, "help_file", r->help_file);
12865
 
        ndr->depth++;
12866
 
        if (r->help_file) {
12867
 
                ndr_print_string(ndr, "help_file", r->help_file);
12868
 
        }
12869
 
        ndr->depth--;
12870
 
        ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12871
 
        ndr->depth++;
12872
 
        if (r->dependent_files) {
12873
 
                ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12874
 
        }
12875
 
        ndr->depth--;
12876
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12877
 
        ndr->depth++;
12878
 
        if (r->monitor_name) {
12879
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
12880
 
        }
12881
 
        ndr->depth--;
12882
 
        ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12883
 
        ndr->depth++;
12884
 
        if (r->default_datatype) {
12885
 
                ndr_print_string(ndr, "default_datatype", r->default_datatype);
12886
 
        }
12887
 
        ndr->depth--;
12888
 
        ndr_print_ptr(ndr, "previous_names", r->previous_names);
12889
 
        ndr->depth++;
12890
 
        if (r->previous_names) {
12891
 
                ndr_print_string_array(ndr, "previous_names", r->previous_names);
12892
 
        }
12893
 
        ndr->depth--;
12894
 
        ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12895
 
        ndr_print_hyper(ndr, "driver_version", r->driver_version);
12896
 
        ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12897
 
        ndr->depth++;
12898
 
        if (r->manufacturer_name) {
12899
 
                ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12900
 
        }
12901
 
        ndr->depth--;
12902
 
        ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12903
 
        ndr->depth++;
12904
 
        if (r->manufacturer_url) {
12905
 
                ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12906
 
        }
12907
 
        ndr->depth--;
12908
 
        ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12909
 
        ndr->depth++;
12910
 
        if (r->hardware_id) {
12911
 
                ndr_print_string(ndr, "hardware_id", r->hardware_id);
12912
 
        }
12913
 
        ndr->depth--;
12914
 
        ndr_print_ptr(ndr, "provider", r->provider);
12915
 
        ndr->depth++;
12916
 
        if (r->provider) {
12917
 
                ndr_print_string(ndr, "provider", r->provider);
12918
 
        }
12919
 
        ndr->depth--;
12920
 
        ndr->depth--;
12921
 
}
12922
 
 
12923
 
_PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12924
 
{
12925
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12926
 
}
12927
 
 
12928
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo7 *r)
12929
 
{
12930
 
        if (ndr_flags & NDR_SCALARS) {
12931
 
                NDR_CHECK(ndr_push_align(ndr, 5));
12932
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
12933
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12934
 
                {
12935
 
                        uint32_t _flags_save_string = ndr->flags;
12936
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12937
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12938
 
                        ndr->flags = _flags_save_string;
12939
 
                }
12940
 
                {
12941
 
                        uint32_t _flags_save_string = ndr->flags;
12942
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12943
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_name));
12944
 
                        ndr->flags = _flags_save_string;
12945
 
                }
12946
 
                {
12947
 
                        uint32_t _flags_save_string = ndr->flags;
12948
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12949
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->install_source_root));
12950
 
                        ndr->flags = _flags_save_string;
12951
 
                }
12952
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12953
 
        }
12954
 
        if (ndr_flags & NDR_BUFFERS) {
12955
 
                {
12956
 
                        uint32_t _flags_save_string = ndr->flags;
12957
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12958
 
                        if (r->driver_name) {
12959
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12960
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12961
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12962
 
                        }
12963
 
                        ndr->flags = _flags_save_string;
12964
 
                }
12965
 
                {
12966
 
                        uint32_t _flags_save_string = ndr->flags;
12967
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12968
 
                        if (r->inf_name) {
12969
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_name));
12970
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_name));
12971
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_name));
12972
 
                        }
12973
 
                        ndr->flags = _flags_save_string;
12974
 
                }
12975
 
                {
12976
 
                        uint32_t _flags_save_string = ndr->flags;
12977
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
12978
 
                        if (r->install_source_root) {
12979
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->install_source_root));
12980
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->install_source_root));
12981
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->install_source_root));
12982
 
                        }
12983
 
                        ndr->flags = _flags_save_string;
12984
 
                }
12985
 
        }
12986
 
        return NDR_ERR_SUCCESS;
12987
 
}
12988
 
 
12989
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo7 *r)
12990
 
{
12991
 
        uint32_t _ptr_driver_name;
12992
 
        TALLOC_CTX *_mem_save_driver_name_0;
12993
 
        uint32_t _ptr_inf_name;
12994
 
        TALLOC_CTX *_mem_save_inf_name_0;
12995
 
        uint32_t _ptr_install_source_root;
12996
 
        TALLOC_CTX *_mem_save_install_source_root_0;
12997
 
        if (ndr_flags & NDR_SCALARS) {
12998
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
12999
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13000
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13001
 
                {
13002
 
                        uint32_t _flags_save_string = ndr->flags;
13003
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13004
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13005
 
                        if (_ptr_driver_name) {
13006
 
                                NDR_PULL_ALLOC(ndr, r->driver_name);
13007
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13008
 
                        } else {
13009
 
                                r->driver_name = NULL;
13010
 
                        }
13011
 
                        ndr->flags = _flags_save_string;
13012
 
                }
13013
 
                {
13014
 
                        uint32_t _flags_save_string = ndr->flags;
13015
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13016
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_name));
13017
 
                        if (_ptr_inf_name) {
13018
 
                                NDR_PULL_ALLOC(ndr, r->inf_name);
13019
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_name, _ptr_inf_name));
13020
 
                        } else {
13021
 
                                r->inf_name = NULL;
13022
 
                        }
13023
 
                        ndr->flags = _flags_save_string;
13024
 
                }
13025
 
                {
13026
 
                        uint32_t _flags_save_string = ndr->flags;
13027
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13028
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_install_source_root));
13029
 
                        if (_ptr_install_source_root) {
13030
 
                                NDR_PULL_ALLOC(ndr, r->install_source_root);
13031
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->install_source_root, _ptr_install_source_root));
13032
 
                        } else {
13033
 
                                r->install_source_root = NULL;
13034
 
                        }
13035
 
                        ndr->flags = _flags_save_string;
13036
 
                }
13037
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13038
 
        }
13039
 
        if (ndr_flags & NDR_BUFFERS) {
13040
 
                {
13041
 
                        uint32_t _flags_save_string = ndr->flags;
13042
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13043
 
                        if (r->driver_name) {
13044
 
                                uint32_t _relative_save_offset;
13045
 
                                _relative_save_offset = ndr->offset;
13046
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13047
 
                                _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13048
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13049
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13050
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13051
 
                                ndr->offset = _relative_save_offset;
13052
 
                        }
13053
 
                        ndr->flags = _flags_save_string;
13054
 
                }
13055
 
                {
13056
 
                        uint32_t _flags_save_string = ndr->flags;
13057
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13058
 
                        if (r->inf_name) {
13059
 
                                uint32_t _relative_save_offset;
13060
 
                                _relative_save_offset = ndr->offset;
13061
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_name));
13062
 
                                _mem_save_inf_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13063
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->inf_name, 0);
13064
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_name));
13065
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_name_0, 0);
13066
 
                                ndr->offset = _relative_save_offset;
13067
 
                        }
13068
 
                        ndr->flags = _flags_save_string;
13069
 
                }
13070
 
                {
13071
 
                        uint32_t _flags_save_string = ndr->flags;
13072
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13073
 
                        if (r->install_source_root) {
13074
 
                                uint32_t _relative_save_offset;
13075
 
                                _relative_save_offset = ndr->offset;
13076
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->install_source_root));
13077
 
                                _mem_save_install_source_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
13078
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->install_source_root, 0);
13079
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->install_source_root));
13080
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_install_source_root_0, 0);
13081
 
                                ndr->offset = _relative_save_offset;
13082
 
                        }
13083
 
                        ndr->flags = _flags_save_string;
13084
 
                }
13085
 
        }
13086
 
        return NDR_ERR_SUCCESS;
13087
 
}
13088
 
 
13089
 
_PUBLIC_ void ndr_print_spoolss_DriverInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo7 *r)
13090
 
{
13091
 
        ndr_print_struct(ndr, name, "spoolss_DriverInfo7");
13092
 
        ndr->depth++;
13093
 
        ndr_print_uint32(ndr, "size", r->size);
13094
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13095
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
13096
 
        ndr->depth++;
13097
 
        if (r->driver_name) {
13098
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
13099
 
        }
13100
 
        ndr->depth--;
13101
 
        ndr_print_ptr(ndr, "inf_name", r->inf_name);
13102
 
        ndr->depth++;
13103
 
        if (r->inf_name) {
13104
 
                ndr_print_string(ndr, "inf_name", r->inf_name);
13105
 
        }
13106
 
        ndr->depth--;
13107
 
        ndr_print_ptr(ndr, "install_source_root", r->install_source_root);
13108
 
        ndr->depth++;
13109
 
        if (r->install_source_root) {
13110
 
                ndr_print_string(ndr, "install_source_root", r->install_source_root);
13111
 
        }
13112
 
        ndr->depth--;
13113
 
        ndr->depth--;
13114
 
}
13115
 
 
13116
 
_PUBLIC_ size_t ndr_size_spoolss_DriverInfo7(const struct spoolss_DriverInfo7 *r, struct smb_iconv_convenience *ic, int flags)
13117
 
{
13118
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo7, ic);
13119
 
}
13120
 
 
13121
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
13122
 
{
13123
 
        if (ndr_flags & NDR_SCALARS) {
13124
 
                NDR_CHECK(ndr_push_align(ndr, 8));
13125
 
                NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13126
 
                {
13127
 
                        uint32_t _flags_save_string = ndr->flags;
13128
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13129
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13130
 
                        ndr->flags = _flags_save_string;
13131
 
                }
13132
 
                {
13133
 
                        uint32_t _flags_save_string = ndr->flags;
13134
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13135
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
13136
 
                        ndr->flags = _flags_save_string;
13137
 
                }
13138
 
                {
13139
 
                        uint32_t _flags_save_string = ndr->flags;
13140
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13141
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
13142
 
                        ndr->flags = _flags_save_string;
13143
 
                }
13144
 
                {
13145
 
                        uint32_t _flags_save_string = ndr->flags;
13146
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13147
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
13148
 
                        ndr->flags = _flags_save_string;
13149
 
                }
13150
 
                {
13151
 
                        uint32_t _flags_save_string = ndr->flags;
13152
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13153
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
13154
 
                        ndr->flags = _flags_save_string;
13155
 
                }
13156
 
                {
13157
 
                        uint32_t _flags_save_string = ndr->flags;
13158
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13159
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
13160
 
                        ndr->flags = _flags_save_string;
13161
 
                }
13162
 
                {
13163
 
                        uint32_t _flags_save_string_array = ndr->flags;
13164
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13165
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
13166
 
                        ndr->flags = _flags_save_string_array;
13167
 
                }
13168
 
                {
13169
 
                        uint32_t _flags_save_string = ndr->flags;
13170
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13171
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13172
 
                        ndr->flags = _flags_save_string;
13173
 
                }
13174
 
                {
13175
 
                        uint32_t _flags_save_string = ndr->flags;
13176
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13177
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
13178
 
                        ndr->flags = _flags_save_string;
13179
 
                }
13180
 
                {
13181
 
                        uint32_t _flags_save_string_array = ndr->flags;
13182
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13183
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
13184
 
                        ndr->flags = _flags_save_string_array;
13185
 
                }
13186
 
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
13187
 
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
13188
 
                {
13189
 
                        uint32_t _flags_save_string = ndr->flags;
13190
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13191
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
13192
 
                        ndr->flags = _flags_save_string;
13193
 
                }
13194
 
                {
13195
 
                        uint32_t _flags_save_string = ndr->flags;
13196
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13197
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
13198
 
                        ndr->flags = _flags_save_string;
13199
 
                }
13200
 
                {
13201
 
                        uint32_t _flags_save_string = ndr->flags;
13202
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13203
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
13204
 
                        ndr->flags = _flags_save_string;
13205
 
                }
13206
 
                {
13207
 
                        uint32_t _flags_save_string = ndr->flags;
13208
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13209
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
13210
 
                        ndr->flags = _flags_save_string;
13211
 
                }
13212
 
                {
13213
 
                        uint32_t _flags_save_string = ndr->flags;
13214
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13215
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
13216
 
                        ndr->flags = _flags_save_string;
13217
 
                }
13218
 
                {
13219
 
                        uint32_t _flags_save_string = ndr->flags;
13220
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13221
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
13222
 
                        ndr->flags = _flags_save_string;
13223
 
                }
13224
 
                {
13225
 
                        uint32_t _flags_save_string_array = ndr->flags;
13226
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13227
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
13228
 
                        ndr->flags = _flags_save_string_array;
13229
 
                }
13230
 
                {
13231
 
                        uint32_t _flags_save_string = ndr->flags;
13232
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13233
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
13234
 
                        ndr->flags = _flags_save_string;
13235
 
                }
13236
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
13237
 
                {
13238
 
                        uint32_t _flags_save_string_array = ndr->flags;
13239
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13240
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
13241
 
                        ndr->flags = _flags_save_string_array;
13242
 
                }
13243
 
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
13244
 
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
13245
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
13246
 
        }
13247
 
        if (ndr_flags & NDR_BUFFERS) {
13248
 
                {
13249
 
                        uint32_t _flags_save_string = ndr->flags;
13250
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13251
 
                        if (r->driver_name) {
13252
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
13253
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13254
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
13255
 
                        }
13256
 
                        ndr->flags = _flags_save_string;
13257
 
                }
13258
 
                {
13259
 
                        uint32_t _flags_save_string = ndr->flags;
13260
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13261
 
                        if (r->architecture) {
13262
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
13263
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
13264
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
13265
 
                        }
13266
 
                        ndr->flags = _flags_save_string;
13267
 
                }
13268
 
                {
13269
 
                        uint32_t _flags_save_string = ndr->flags;
13270
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13271
 
                        if (r->driver_path) {
13272
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
13273
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
13274
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
13275
 
                        }
13276
 
                        ndr->flags = _flags_save_string;
13277
 
                }
13278
 
                {
13279
 
                        uint32_t _flags_save_string = ndr->flags;
13280
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13281
 
                        if (r->data_file) {
13282
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
13283
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
13284
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
13285
 
                        }
13286
 
                        ndr->flags = _flags_save_string;
13287
 
                }
13288
 
                {
13289
 
                        uint32_t _flags_save_string = ndr->flags;
13290
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13291
 
                        if (r->config_file) {
13292
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
13293
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
13294
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
13295
 
                        }
13296
 
                        ndr->flags = _flags_save_string;
13297
 
                }
13298
 
                {
13299
 
                        uint32_t _flags_save_string = ndr->flags;
13300
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13301
 
                        if (r->help_file) {
13302
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
13303
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
13304
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
13305
 
                        }
13306
 
                        ndr->flags = _flags_save_string;
13307
 
                }
13308
 
                {
13309
 
                        uint32_t _flags_save_string_array = ndr->flags;
13310
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13311
 
                        if (r->dependent_files) {
13312
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
13313
 
                                NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13314
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
13315
 
                        }
13316
 
                        ndr->flags = _flags_save_string_array;
13317
 
                }
13318
 
                {
13319
 
                        uint32_t _flags_save_string = ndr->flags;
13320
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13321
 
                        if (r->monitor_name) {
13322
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
13323
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13324
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
13325
 
                        }
13326
 
                        ndr->flags = _flags_save_string;
13327
 
                }
13328
 
                {
13329
 
                        uint32_t _flags_save_string = ndr->flags;
13330
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13331
 
                        if (r->default_datatype) {
13332
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
13333
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13334
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
13335
 
                        }
13336
 
                        ndr->flags = _flags_save_string;
13337
 
                }
13338
 
                {
13339
 
                        uint32_t _flags_save_string_array = ndr->flags;
13340
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13341
 
                        if (r->previous_names) {
13342
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
13343
 
                                NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13344
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
13345
 
                        }
13346
 
                        ndr->flags = _flags_save_string_array;
13347
 
                }
13348
 
                {
13349
 
                        uint32_t _flags_save_string = ndr->flags;
13350
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13351
 
                        if (r->manufacturer_name) {
13352
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
13353
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
13354
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
13355
 
                        }
13356
 
                        ndr->flags = _flags_save_string;
13357
 
                }
13358
 
                {
13359
 
                        uint32_t _flags_save_string = ndr->flags;
13360
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13361
 
                        if (r->manufacturer_url) {
13362
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
13363
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
13364
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
13365
 
                        }
13366
 
                        ndr->flags = _flags_save_string;
13367
 
                }
13368
 
                {
13369
 
                        uint32_t _flags_save_string = ndr->flags;
13370
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13371
 
                        if (r->hardware_id) {
13372
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
13373
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
13374
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
13375
 
                        }
13376
 
                        ndr->flags = _flags_save_string;
13377
 
                }
13378
 
                {
13379
 
                        uint32_t _flags_save_string = ndr->flags;
13380
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13381
 
                        if (r->provider) {
13382
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
13383
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
13384
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
13385
 
                        }
13386
 
                        ndr->flags = _flags_save_string;
13387
 
                }
13388
 
                {
13389
 
                        uint32_t _flags_save_string = ndr->flags;
13390
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13391
 
                        if (r->print_processor) {
13392
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
13393
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13394
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
13395
 
                        }
13396
 
                        ndr->flags = _flags_save_string;
13397
 
                }
13398
 
                {
13399
 
                        uint32_t _flags_save_string = ndr->flags;
13400
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13401
 
                        if (r->vendor_setup) {
13402
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->vendor_setup));
13403
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13404
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->vendor_setup));
13405
 
                        }
13406
 
                        ndr->flags = _flags_save_string;
13407
 
                }
13408
 
                {
13409
 
                        uint32_t _flags_save_string_array = ndr->flags;
13410
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13411
 
                        if (r->color_profiles) {
13412
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->color_profiles));
13413
 
                                NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13414
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->color_profiles));
13415
 
                        }
13416
 
                        ndr->flags = _flags_save_string_array;
13417
 
                }
13418
 
                {
13419
 
                        uint32_t _flags_save_string = ndr->flags;
13420
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13421
 
                        if (r->inf_path) {
13422
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_path));
13423
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13424
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_path));
13425
 
                        }
13426
 
                        ndr->flags = _flags_save_string;
13427
 
                }
13428
 
                {
13429
 
                        uint32_t _flags_save_string_array = ndr->flags;
13430
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13431
 
                        if (r->core_driver_dependencies) {
13432
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->core_driver_dependencies));
13433
 
                                NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13434
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->core_driver_dependencies));
13435
 
                        }
13436
 
                        ndr->flags = _flags_save_string_array;
13437
 
                }
13438
 
        }
13439
 
        return NDR_ERR_SUCCESS;
13440
 
}
13441
 
 
13442
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13443
 
{
13444
 
        uint32_t _ptr_driver_name;
13445
 
        TALLOC_CTX *_mem_save_driver_name_0;
13446
 
        uint32_t _ptr_architecture;
13447
 
        TALLOC_CTX *_mem_save_architecture_0;
13448
 
        uint32_t _ptr_driver_path;
13449
 
        TALLOC_CTX *_mem_save_driver_path_0;
13450
 
        uint32_t _ptr_data_file;
13451
 
        TALLOC_CTX *_mem_save_data_file_0;
13452
 
        uint32_t _ptr_config_file;
13453
 
        TALLOC_CTX *_mem_save_config_file_0;
13454
 
        uint32_t _ptr_help_file;
13455
 
        TALLOC_CTX *_mem_save_help_file_0;
13456
 
        uint32_t _ptr_dependent_files;
13457
 
        TALLOC_CTX *_mem_save_dependent_files_0;
13458
 
        uint32_t _ptr_monitor_name;
13459
 
        TALLOC_CTX *_mem_save_monitor_name_0;
13460
 
        uint32_t _ptr_default_datatype;
13461
 
        TALLOC_CTX *_mem_save_default_datatype_0;
13462
 
        uint32_t _ptr_previous_names;
13463
 
        TALLOC_CTX *_mem_save_previous_names_0;
13464
 
        uint32_t _ptr_manufacturer_name;
13465
 
        TALLOC_CTX *_mem_save_manufacturer_name_0;
13466
 
        uint32_t _ptr_manufacturer_url;
13467
 
        TALLOC_CTX *_mem_save_manufacturer_url_0;
13468
 
        uint32_t _ptr_hardware_id;
13469
 
        TALLOC_CTX *_mem_save_hardware_id_0;
13470
 
        uint32_t _ptr_provider;
13471
 
        TALLOC_CTX *_mem_save_provider_0;
13472
 
        uint32_t _ptr_print_processor;
13473
 
        TALLOC_CTX *_mem_save_print_processor_0;
13474
 
        uint32_t _ptr_vendor_setup;
13475
 
        TALLOC_CTX *_mem_save_vendor_setup_0;
13476
 
        uint32_t _ptr_color_profiles;
13477
 
        TALLOC_CTX *_mem_save_color_profiles_0;
13478
 
        uint32_t _ptr_inf_path;
13479
 
        TALLOC_CTX *_mem_save_inf_path_0;
13480
 
        uint32_t _ptr_core_driver_dependencies;
13481
 
        TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13482
 
        if (ndr_flags & NDR_SCALARS) {
13483
 
                NDR_CHECK(ndr_pull_align(ndr, 8));
13484
 
                NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13485
 
                {
13486
 
                        uint32_t _flags_save_string = ndr->flags;
13487
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13488
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13489
 
                        if (_ptr_driver_name) {
13490
 
                                NDR_PULL_ALLOC(ndr, r->driver_name);
13491
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13492
 
                        } else {
13493
 
                                r->driver_name = NULL;
13494
 
                        }
13495
 
                        ndr->flags = _flags_save_string;
13496
 
                }
13497
 
                {
13498
 
                        uint32_t _flags_save_string = ndr->flags;
13499
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13500
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13501
 
                        if (_ptr_architecture) {
13502
 
                                NDR_PULL_ALLOC(ndr, r->architecture);
13503
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13504
 
                        } else {
13505
 
                                r->architecture = NULL;
13506
 
                        }
13507
 
                        ndr->flags = _flags_save_string;
13508
 
                }
13509
 
                {
13510
 
                        uint32_t _flags_save_string = ndr->flags;
13511
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13512
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13513
 
                        if (_ptr_driver_path) {
13514
 
                                NDR_PULL_ALLOC(ndr, r->driver_path);
13515
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13516
 
                        } else {
13517
 
                                r->driver_path = NULL;
13518
 
                        }
13519
 
                        ndr->flags = _flags_save_string;
13520
 
                }
13521
 
                {
13522
 
                        uint32_t _flags_save_string = ndr->flags;
13523
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13524
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13525
 
                        if (_ptr_data_file) {
13526
 
                                NDR_PULL_ALLOC(ndr, r->data_file);
13527
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13528
 
                        } else {
13529
 
                                r->data_file = NULL;
13530
 
                        }
13531
 
                        ndr->flags = _flags_save_string;
13532
 
                }
13533
 
                {
13534
 
                        uint32_t _flags_save_string = ndr->flags;
13535
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13536
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13537
 
                        if (_ptr_config_file) {
13538
 
                                NDR_PULL_ALLOC(ndr, r->config_file);
13539
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13540
 
                        } else {
13541
 
                                r->config_file = NULL;
13542
 
                        }
13543
 
                        ndr->flags = _flags_save_string;
13544
 
                }
13545
 
                {
13546
 
                        uint32_t _flags_save_string = ndr->flags;
13547
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13548
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13549
 
                        if (_ptr_help_file) {
13550
 
                                NDR_PULL_ALLOC(ndr, r->help_file);
13551
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13552
 
                        } else {
13553
 
                                r->help_file = NULL;
13554
 
                        }
13555
 
                        ndr->flags = _flags_save_string;
13556
 
                }
13557
 
                {
13558
 
                        uint32_t _flags_save_string_array = ndr->flags;
13559
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13560
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13561
 
                        if (_ptr_dependent_files) {
13562
 
                                NDR_PULL_ALLOC(ndr, r->dependent_files);
13563
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13564
 
                        } else {
13565
 
                                r->dependent_files = NULL;
13566
 
                        }
13567
 
                        ndr->flags = _flags_save_string_array;
13568
 
                }
13569
 
                {
13570
 
                        uint32_t _flags_save_string = ndr->flags;
13571
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13572
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13573
 
                        if (_ptr_monitor_name) {
13574
 
                                NDR_PULL_ALLOC(ndr, r->monitor_name);
13575
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13576
 
                        } else {
13577
 
                                r->monitor_name = NULL;
13578
 
                        }
13579
 
                        ndr->flags = _flags_save_string;
13580
 
                }
13581
 
                {
13582
 
                        uint32_t _flags_save_string = ndr->flags;
13583
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13584
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13585
 
                        if (_ptr_default_datatype) {
13586
 
                                NDR_PULL_ALLOC(ndr, r->default_datatype);
13587
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13588
 
                        } else {
13589
 
                                r->default_datatype = NULL;
13590
 
                        }
13591
 
                        ndr->flags = _flags_save_string;
13592
 
                }
13593
 
                {
13594
 
                        uint32_t _flags_save_string_array = ndr->flags;
13595
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13596
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13597
 
                        if (_ptr_previous_names) {
13598
 
                                NDR_PULL_ALLOC(ndr, r->previous_names);
13599
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13600
 
                        } else {
13601
 
                                r->previous_names = NULL;
13602
 
                        }
13603
 
                        ndr->flags = _flags_save_string_array;
13604
 
                }
13605
 
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13606
 
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13607
 
                {
13608
 
                        uint32_t _flags_save_string = ndr->flags;
13609
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13610
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13611
 
                        if (_ptr_manufacturer_name) {
13612
 
                                NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13613
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13614
 
                        } else {
13615
 
                                r->manufacturer_name = NULL;
13616
 
                        }
13617
 
                        ndr->flags = _flags_save_string;
13618
 
                }
13619
 
                {
13620
 
                        uint32_t _flags_save_string = ndr->flags;
13621
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13622
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13623
 
                        if (_ptr_manufacturer_url) {
13624
 
                                NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13625
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13626
 
                        } else {
13627
 
                                r->manufacturer_url = NULL;
13628
 
                        }
13629
 
                        ndr->flags = _flags_save_string;
13630
 
                }
13631
 
                {
13632
 
                        uint32_t _flags_save_string = ndr->flags;
13633
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13634
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13635
 
                        if (_ptr_hardware_id) {
13636
 
                                NDR_PULL_ALLOC(ndr, r->hardware_id);
13637
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13638
 
                        } else {
13639
 
                                r->hardware_id = NULL;
13640
 
                        }
13641
 
                        ndr->flags = _flags_save_string;
13642
 
                }
13643
 
                {
13644
 
                        uint32_t _flags_save_string = ndr->flags;
13645
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13646
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13647
 
                        if (_ptr_provider) {
13648
 
                                NDR_PULL_ALLOC(ndr, r->provider);
13649
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13650
 
                        } else {
13651
 
                                r->provider = NULL;
13652
 
                        }
13653
 
                        ndr->flags = _flags_save_string;
13654
 
                }
13655
 
                {
13656
 
                        uint32_t _flags_save_string = ndr->flags;
13657
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13658
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13659
 
                        if (_ptr_print_processor) {
13660
 
                                NDR_PULL_ALLOC(ndr, r->print_processor);
13661
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13662
 
                        } else {
13663
 
                                r->print_processor = NULL;
13664
 
                        }
13665
 
                        ndr->flags = _flags_save_string;
13666
 
                }
13667
 
                {
13668
 
                        uint32_t _flags_save_string = ndr->flags;
13669
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13670
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13671
 
                        if (_ptr_vendor_setup) {
13672
 
                                NDR_PULL_ALLOC(ndr, r->vendor_setup);
13673
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
13674
 
                        } else {
13675
 
                                r->vendor_setup = NULL;
13676
 
                        }
13677
 
                        ndr->flags = _flags_save_string;
13678
 
                }
13679
 
                {
13680
 
                        uint32_t _flags_save_string_array = ndr->flags;
13681
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13682
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
13683
 
                        if (_ptr_color_profiles) {
13684
 
                                NDR_PULL_ALLOC(ndr, r->color_profiles);
13685
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
13686
 
                        } else {
13687
 
                                r->color_profiles = NULL;
13688
 
                        }
13689
 
                        ndr->flags = _flags_save_string_array;
13690
 
                }
13691
 
                {
13692
 
                        uint32_t _flags_save_string = ndr->flags;
13693
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13694
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
13695
 
                        if (_ptr_inf_path) {
13696
 
                                NDR_PULL_ALLOC(ndr, r->inf_path);
13697
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
13698
 
                        } else {
13699
 
                                r->inf_path = NULL;
13700
 
                        }
13701
 
                        ndr->flags = _flags_save_string;
13702
 
                }
13703
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
13704
 
                {
13705
 
                        uint32_t _flags_save_string_array = ndr->flags;
13706
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13707
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
13708
 
                        if (_ptr_core_driver_dependencies) {
13709
 
                                NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
13710
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
13711
 
                        } else {
13712
 
                                r->core_driver_dependencies = NULL;
13713
 
                        }
13714
 
                        ndr->flags = _flags_save_string_array;
13715
 
                }
13716
 
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
13717
 
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
13718
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
13719
 
        }
13720
 
        if (ndr_flags & NDR_BUFFERS) {
13721
 
                {
13722
 
                        uint32_t _flags_save_string = ndr->flags;
13723
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13724
 
                        if (r->driver_name) {
13725
 
                                uint32_t _relative_save_offset;
13726
 
                                _relative_save_offset = ndr->offset;
13727
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13728
 
                                _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13729
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13730
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13731
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13732
 
                                ndr->offset = _relative_save_offset;
13733
 
                        }
13734
 
                        ndr->flags = _flags_save_string;
13735
 
                }
13736
 
                {
13737
 
                        uint32_t _flags_save_string = ndr->flags;
13738
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13739
 
                        if (r->architecture) {
13740
 
                                uint32_t _relative_save_offset;
13741
 
                                _relative_save_offset = ndr->offset;
13742
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13743
 
                                _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13744
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13745
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13746
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13747
 
                                ndr->offset = _relative_save_offset;
13748
 
                        }
13749
 
                        ndr->flags = _flags_save_string;
13750
 
                }
13751
 
                {
13752
 
                        uint32_t _flags_save_string = ndr->flags;
13753
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13754
 
                        if (r->driver_path) {
13755
 
                                uint32_t _relative_save_offset;
13756
 
                                _relative_save_offset = ndr->offset;
13757
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13758
 
                                _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13759
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13760
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13761
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13762
 
                                ndr->offset = _relative_save_offset;
13763
 
                        }
13764
 
                        ndr->flags = _flags_save_string;
13765
 
                }
13766
 
                {
13767
 
                        uint32_t _flags_save_string = ndr->flags;
13768
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13769
 
                        if (r->data_file) {
13770
 
                                uint32_t _relative_save_offset;
13771
 
                                _relative_save_offset = ndr->offset;
13772
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13773
 
                                _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13774
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13775
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13776
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13777
 
                                ndr->offset = _relative_save_offset;
13778
 
                        }
13779
 
                        ndr->flags = _flags_save_string;
13780
 
                }
13781
 
                {
13782
 
                        uint32_t _flags_save_string = ndr->flags;
13783
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13784
 
                        if (r->config_file) {
13785
 
                                uint32_t _relative_save_offset;
13786
 
                                _relative_save_offset = ndr->offset;
13787
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
13788
 
                                _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13789
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
13790
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
13791
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
13792
 
                                ndr->offset = _relative_save_offset;
13793
 
                        }
13794
 
                        ndr->flags = _flags_save_string;
13795
 
                }
13796
 
                {
13797
 
                        uint32_t _flags_save_string = ndr->flags;
13798
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13799
 
                        if (r->help_file) {
13800
 
                                uint32_t _relative_save_offset;
13801
 
                                _relative_save_offset = ndr->offset;
13802
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
13803
 
                                _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13804
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
13805
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
13806
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
13807
 
                                ndr->offset = _relative_save_offset;
13808
 
                        }
13809
 
                        ndr->flags = _flags_save_string;
13810
 
                }
13811
 
                {
13812
 
                        uint32_t _flags_save_string_array = ndr->flags;
13813
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13814
 
                        if (r->dependent_files) {
13815
 
                                uint32_t _relative_save_offset;
13816
 
                                _relative_save_offset = ndr->offset;
13817
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13818
 
                                _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13819
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13820
 
                                NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13821
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13822
 
                                ndr->offset = _relative_save_offset;
13823
 
                        }
13824
 
                        ndr->flags = _flags_save_string_array;
13825
 
                }
13826
 
                {
13827
 
                        uint32_t _flags_save_string = ndr->flags;
13828
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13829
 
                        if (r->monitor_name) {
13830
 
                                uint32_t _relative_save_offset;
13831
 
                                _relative_save_offset = ndr->offset;
13832
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13833
 
                                _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13834
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13835
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13836
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13837
 
                                ndr->offset = _relative_save_offset;
13838
 
                        }
13839
 
                        ndr->flags = _flags_save_string;
13840
 
                }
13841
 
                {
13842
 
                        uint32_t _flags_save_string = ndr->flags;
13843
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13844
 
                        if (r->default_datatype) {
13845
 
                                uint32_t _relative_save_offset;
13846
 
                                _relative_save_offset = ndr->offset;
13847
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13848
 
                                _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13849
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13850
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13851
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13852
 
                                ndr->offset = _relative_save_offset;
13853
 
                        }
13854
 
                        ndr->flags = _flags_save_string;
13855
 
                }
13856
 
                {
13857
 
                        uint32_t _flags_save_string_array = ndr->flags;
13858
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13859
 
                        if (r->previous_names) {
13860
 
                                uint32_t _relative_save_offset;
13861
 
                                _relative_save_offset = ndr->offset;
13862
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13863
 
                                _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13864
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13865
 
                                NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13866
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13867
 
                                ndr->offset = _relative_save_offset;
13868
 
                        }
13869
 
                        ndr->flags = _flags_save_string_array;
13870
 
                }
13871
 
                {
13872
 
                        uint32_t _flags_save_string = ndr->flags;
13873
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13874
 
                        if (r->manufacturer_name) {
13875
 
                                uint32_t _relative_save_offset;
13876
 
                                _relative_save_offset = ndr->offset;
13877
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13878
 
                                _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13879
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13880
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13881
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13882
 
                                ndr->offset = _relative_save_offset;
13883
 
                        }
13884
 
                        ndr->flags = _flags_save_string;
13885
 
                }
13886
 
                {
13887
 
                        uint32_t _flags_save_string = ndr->flags;
13888
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13889
 
                        if (r->manufacturer_url) {
13890
 
                                uint32_t _relative_save_offset;
13891
 
                                _relative_save_offset = ndr->offset;
13892
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13893
 
                                _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13894
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13895
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13896
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13897
 
                                ndr->offset = _relative_save_offset;
13898
 
                        }
13899
 
                        ndr->flags = _flags_save_string;
13900
 
                }
13901
 
                {
13902
 
                        uint32_t _flags_save_string = ndr->flags;
13903
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13904
 
                        if (r->hardware_id) {
13905
 
                                uint32_t _relative_save_offset;
13906
 
                                _relative_save_offset = ndr->offset;
13907
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13908
 
                                _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13909
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13910
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13911
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13912
 
                                ndr->offset = _relative_save_offset;
13913
 
                        }
13914
 
                        ndr->flags = _flags_save_string;
13915
 
                }
13916
 
                {
13917
 
                        uint32_t _flags_save_string = ndr->flags;
13918
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13919
 
                        if (r->provider) {
13920
 
                                uint32_t _relative_save_offset;
13921
 
                                _relative_save_offset = ndr->offset;
13922
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13923
 
                                _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13924
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13925
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13926
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13927
 
                                ndr->offset = _relative_save_offset;
13928
 
                        }
13929
 
                        ndr->flags = _flags_save_string;
13930
 
                }
13931
 
                {
13932
 
                        uint32_t _flags_save_string = ndr->flags;
13933
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13934
 
                        if (r->print_processor) {
13935
 
                                uint32_t _relative_save_offset;
13936
 
                                _relative_save_offset = ndr->offset;
13937
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13938
 
                                _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13939
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13940
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13941
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13942
 
                                ndr->offset = _relative_save_offset;
13943
 
                        }
13944
 
                        ndr->flags = _flags_save_string;
13945
 
                }
13946
 
                {
13947
 
                        uint32_t _flags_save_string = ndr->flags;
13948
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13949
 
                        if (r->vendor_setup) {
13950
 
                                uint32_t _relative_save_offset;
13951
 
                                _relative_save_offset = ndr->offset;
13952
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13953
 
                                _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13954
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13955
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13956
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13957
 
                                ndr->offset = _relative_save_offset;
13958
 
                        }
13959
 
                        ndr->flags = _flags_save_string;
13960
 
                }
13961
 
                {
13962
 
                        uint32_t _flags_save_string_array = ndr->flags;
13963
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13964
 
                        if (r->color_profiles) {
13965
 
                                uint32_t _relative_save_offset;
13966
 
                                _relative_save_offset = ndr->offset;
13967
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13968
 
                                _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13969
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13970
 
                                NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13971
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13972
 
                                ndr->offset = _relative_save_offset;
13973
 
                        }
13974
 
                        ndr->flags = _flags_save_string_array;
13975
 
                }
13976
 
                {
13977
 
                        uint32_t _flags_save_string = ndr->flags;
13978
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13979
 
                        if (r->inf_path) {
13980
 
                                uint32_t _relative_save_offset;
13981
 
                                _relative_save_offset = ndr->offset;
13982
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13983
 
                                _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13984
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13985
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13986
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13987
 
                                ndr->offset = _relative_save_offset;
13988
 
                        }
13989
 
                        ndr->flags = _flags_save_string;
13990
 
                }
13991
 
                {
13992
 
                        uint32_t _flags_save_string_array = ndr->flags;
13993
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
13994
 
                        if (r->core_driver_dependencies) {
13995
 
                                uint32_t _relative_save_offset;
13996
 
                                _relative_save_offset = ndr->offset;
13997
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13998
 
                                _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13999
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
14000
 
                                NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
14001
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
14002
 
                                ndr->offset = _relative_save_offset;
14003
 
                        }
14004
 
                        ndr->flags = _flags_save_string_array;
14005
 
                }
14006
 
        }
14007
 
        return NDR_ERR_SUCCESS;
14008
 
}
14009
 
 
14010
 
_PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
14011
 
{
14012
 
        ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
14013
 
        ndr->depth++;
14014
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14015
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
14016
 
        ndr->depth++;
14017
 
        if (r->driver_name) {
14018
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
14019
 
        }
14020
 
        ndr->depth--;
14021
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
14022
 
        ndr->depth++;
14023
 
        if (r->architecture) {
14024
 
                ndr_print_string(ndr, "architecture", r->architecture);
14025
 
        }
14026
 
        ndr->depth--;
14027
 
        ndr_print_ptr(ndr, "driver_path", r->driver_path);
14028
 
        ndr->depth++;
14029
 
        if (r->driver_path) {
14030
 
                ndr_print_string(ndr, "driver_path", r->driver_path);
14031
 
        }
14032
 
        ndr->depth--;
14033
 
        ndr_print_ptr(ndr, "data_file", r->data_file);
14034
 
        ndr->depth++;
14035
 
        if (r->data_file) {
14036
 
                ndr_print_string(ndr, "data_file", r->data_file);
14037
 
        }
14038
 
        ndr->depth--;
14039
 
        ndr_print_ptr(ndr, "config_file", r->config_file);
14040
 
        ndr->depth++;
14041
 
        if (r->config_file) {
14042
 
                ndr_print_string(ndr, "config_file", r->config_file);
14043
 
        }
14044
 
        ndr->depth--;
14045
 
        ndr_print_ptr(ndr, "help_file", r->help_file);
14046
 
        ndr->depth++;
14047
 
        if (r->help_file) {
14048
 
                ndr_print_string(ndr, "help_file", r->help_file);
14049
 
        }
14050
 
        ndr->depth--;
14051
 
        ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
14052
 
        ndr->depth++;
14053
 
        if (r->dependent_files) {
14054
 
                ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
14055
 
        }
14056
 
        ndr->depth--;
14057
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14058
 
        ndr->depth++;
14059
 
        if (r->monitor_name) {
14060
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
14061
 
        }
14062
 
        ndr->depth--;
14063
 
        ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14064
 
        ndr->depth++;
14065
 
        if (r->default_datatype) {
14066
 
                ndr_print_string(ndr, "default_datatype", r->default_datatype);
14067
 
        }
14068
 
        ndr->depth--;
14069
 
        ndr_print_ptr(ndr, "previous_names", r->previous_names);
14070
 
        ndr->depth++;
14071
 
        if (r->previous_names) {
14072
 
                ndr_print_string_array(ndr, "previous_names", r->previous_names);
14073
 
        }
14074
 
        ndr->depth--;
14075
 
        ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14076
 
        ndr_print_hyper(ndr, "driver_version", r->driver_version);
14077
 
        ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14078
 
        ndr->depth++;
14079
 
        if (r->manufacturer_name) {
14080
 
                ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14081
 
        }
14082
 
        ndr->depth--;
14083
 
        ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14084
 
        ndr->depth++;
14085
 
        if (r->manufacturer_url) {
14086
 
                ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14087
 
        }
14088
 
        ndr->depth--;
14089
 
        ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14090
 
        ndr->depth++;
14091
 
        if (r->hardware_id) {
14092
 
                ndr_print_string(ndr, "hardware_id", r->hardware_id);
14093
 
        }
14094
 
        ndr->depth--;
14095
 
        ndr_print_ptr(ndr, "provider", r->provider);
14096
 
        ndr->depth++;
14097
 
        if (r->provider) {
14098
 
                ndr_print_string(ndr, "provider", r->provider);
14099
 
        }
14100
 
        ndr->depth--;
14101
 
        ndr_print_ptr(ndr, "print_processor", r->print_processor);
14102
 
        ndr->depth++;
14103
 
        if (r->print_processor) {
14104
 
                ndr_print_string(ndr, "print_processor", r->print_processor);
14105
 
        }
14106
 
        ndr->depth--;
14107
 
        ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
14108
 
        ndr->depth++;
14109
 
        if (r->vendor_setup) {
14110
 
                ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
14111
 
        }
14112
 
        ndr->depth--;
14113
 
        ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
14114
 
        ndr->depth++;
14115
 
        if (r->color_profiles) {
14116
 
                ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
14117
 
        }
14118
 
        ndr->depth--;
14119
 
        ndr_print_ptr(ndr, "inf_path", r->inf_path);
14120
 
        ndr->depth++;
14121
 
        if (r->inf_path) {
14122
 
                ndr_print_string(ndr, "inf_path", r->inf_path);
14123
 
        }
14124
 
        ndr->depth--;
14125
 
        ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
14126
 
        ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14127
 
        ndr->depth++;
14128
 
        if (r->core_driver_dependencies) {
14129
 
                ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14130
 
        }
14131
 
        ndr->depth--;
14132
 
        ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
14133
 
        ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
14134
 
        ndr->depth--;
14135
 
}
14136
 
 
14137
 
_PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
14138
 
{
14139
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
14140
 
}
14141
 
 
14142
 
static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
14143
 
{
14144
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
14145
 
        return NDR_ERR_SUCCESS;
14146
 
}
14147
 
 
14148
 
static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
14149
 
{
14150
 
        uint32_t v;
14151
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
14152
 
        *r = v;
14153
 
        return NDR_ERR_SUCCESS;
14154
 
}
14155
 
 
14156
 
_PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
14157
 
{
14158
 
        const char *val = NULL;
14159
 
 
14160
 
        switch (r) {
14161
 
                case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
14162
 
                case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
14163
 
                case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
14164
 
                case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
14165
 
                case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
14166
 
        }
14167
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
14168
 
}
14169
 
 
14170
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
14171
 
{
14172
 
        if (ndr_flags & NDR_SCALARS) {
14173
 
                NDR_CHECK(ndr_push_align(ndr, 5));
14174
 
                {
14175
 
                        uint32_t _flags_save_string = ndr->flags;
14176
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14177
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
14178
 
                        ndr->flags = _flags_save_string;
14179
 
                }
14180
 
                NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
14181
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
14182
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14183
 
        }
14184
 
        if (ndr_flags & NDR_BUFFERS) {
14185
 
                {
14186
 
                        uint32_t _flags_save_string = ndr->flags;
14187
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14188
 
                        if (r->file_name) {
14189
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->file_name));
14190
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
14191
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->file_name));
14192
 
                        }
14193
 
                        ndr->flags = _flags_save_string;
14194
 
                }
14195
 
        }
14196
 
        return NDR_ERR_SUCCESS;
14197
 
}
14198
 
 
14199
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
14200
 
{
14201
 
        uint32_t _ptr_file_name;
14202
 
        TALLOC_CTX *_mem_save_file_name_0;
14203
 
        if (ndr_flags & NDR_SCALARS) {
14204
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
14205
 
                {
14206
 
                        uint32_t _flags_save_string = ndr->flags;
14207
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14208
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
14209
 
                        if (_ptr_file_name) {
14210
 
                                NDR_PULL_ALLOC(ndr, r->file_name);
14211
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
14212
 
                        } else {
14213
 
                                r->file_name = NULL;
14214
 
                        }
14215
 
                        ndr->flags = _flags_save_string;
14216
 
                }
14217
 
                NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
14218
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
14219
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14220
 
        }
14221
 
        if (ndr_flags & NDR_BUFFERS) {
14222
 
                {
14223
 
                        uint32_t _flags_save_string = ndr->flags;
14224
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14225
 
                        if (r->file_name) {
14226
 
                                uint32_t _relative_save_offset;
14227
 
                                _relative_save_offset = ndr->offset;
14228
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
14229
 
                                _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14230
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
14231
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
14232
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
14233
 
                                ndr->offset = _relative_save_offset;
14234
 
                        }
14235
 
                        ndr->flags = _flags_save_string;
14236
 
                }
14237
 
        }
14238
 
        return NDR_ERR_SUCCESS;
14239
 
}
14240
 
 
14241
 
_PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
14242
 
{
14243
 
        ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
14244
 
        ndr->depth++;
14245
 
        ndr_print_ptr(ndr, "file_name", r->file_name);
14246
 
        ndr->depth++;
14247
 
        if (r->file_name) {
14248
 
                ndr_print_string(ndr, "file_name", r->file_name);
14249
 
        }
14250
 
        ndr->depth--;
14251
 
        ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
14252
 
        ndr_print_uint32(ndr, "file_version", r->file_version);
14253
 
        ndr->depth--;
14254
 
}
14255
 
 
14256
 
_PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
14257
 
{
14258
 
        uint32_t cntr_file_info_1;
14259
 
        ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
14260
 
        ndr->depth++;
14261
 
        ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14262
 
        ndr_print_ptr(ndr, "driver_name", r->driver_name);
14263
 
        ndr->depth++;
14264
 
        if (r->driver_name) {
14265
 
                ndr_print_string(ndr, "driver_name", r->driver_name);
14266
 
        }
14267
 
        ndr->depth--;
14268
 
        ndr_print_ptr(ndr, "architecture", r->architecture);
14269
 
        ndr->depth++;
14270
 
        if (r->architecture) {
14271
 
                ndr_print_string(ndr, "architecture", r->architecture);
14272
 
        }
14273
 
        ndr->depth--;
14274
 
        ndr_print_ptr(ndr, "file_info", r->file_info);
14275
 
        ndr->depth++;
14276
 
        if (r->file_info) {
14277
 
                ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
14278
 
                ndr->depth++;
14279
 
                for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
14280
 
                        char *idx_1=NULL;
14281
 
                        if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
14282
 
                                ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
14283
 
                                free(idx_1);
14284
 
                        }
14285
 
                }
14286
 
                ndr->depth--;
14287
 
        }
14288
 
        ndr->depth--;
14289
 
        ndr_print_uint32(ndr, "file_count", r->file_count);
14290
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14291
 
        ndr->depth++;
14292
 
        if (r->monitor_name) {
14293
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
14294
 
        }
14295
 
        ndr->depth--;
14296
 
        ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14297
 
        ndr->depth++;
14298
 
        if (r->default_datatype) {
14299
 
                ndr_print_string(ndr, "default_datatype", r->default_datatype);
14300
 
        }
14301
 
        ndr->depth--;
14302
 
        ndr_print_ptr(ndr, "previous_names", r->previous_names);
14303
 
        ndr->depth++;
14304
 
        if (r->previous_names) {
14305
 
                ndr_print_string_array(ndr, "previous_names", r->previous_names);
14306
 
        }
14307
 
        ndr->depth--;
14308
 
        ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14309
 
        ndr_print_hyper(ndr, "driver_version", r->driver_version);
14310
 
        ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14311
 
        ndr->depth++;
14312
 
        if (r->manufacturer_name) {
14313
 
                ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14314
 
        }
14315
 
        ndr->depth--;
14316
 
        ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14317
 
        ndr->depth++;
14318
 
        if (r->manufacturer_url) {
14319
 
                ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14320
 
        }
14321
 
        ndr->depth--;
14322
 
        ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14323
 
        ndr->depth++;
14324
 
        if (r->hardware_id) {
14325
 
                ndr_print_string(ndr, "hardware_id", r->hardware_id);
14326
 
        }
14327
 
        ndr->depth--;
14328
 
        ndr_print_ptr(ndr, "provider", r->provider);
14329
 
        ndr->depth++;
14330
 
        if (r->provider) {
14331
 
                ndr_print_string(ndr, "provider", r->provider);
14332
 
        }
14333
 
        ndr->depth--;
14334
 
        ndr->depth--;
14335
 
}
14336
 
 
14337
 
_PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
14338
 
{
14339
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
14340
 
}
14341
 
 
14342
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
14343
 
{
14344
 
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14345
 
        {
14346
 
                uint32_t _flags_save_UNION = ndr->flags;
14347
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14348
 
                if (ndr_flags & NDR_SCALARS) {
14349
 
                        int level = ndr_push_get_switch_value(ndr, r);
14350
 
                        NDR_CHECK(ndr_push_union_align(ndr, 8));
14351
 
                        switch (level) {
14352
 
                                case 1: {
14353
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
14354
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14355
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14356
 
                                break; }
14357
 
 
14358
 
                                case 2: {
14359
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
14360
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14361
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14362
 
                                break; }
14363
 
 
14364
 
                                case 3: {
14365
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
14366
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14367
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14368
 
                                break; }
14369
 
 
14370
 
                                case 4: {
14371
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
14372
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14373
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14374
 
                                break; }
14375
 
 
14376
 
                                case 5: {
14377
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
14378
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14379
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14380
 
                                break; }
14381
 
 
14382
 
                                case 6: {
14383
 
                                        NDR_CHECK(ndr_push_align(ndr, 8));
14384
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14385
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14386
 
                                break; }
14387
 
 
14388
 
                                case 7: {
14389
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
14390
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14391
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14392
 
                                break; }
14393
 
 
14394
 
                                case 8: {
14395
 
                                        NDR_CHECK(ndr_push_align(ndr, 8));
14396
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14397
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14398
 
                                break; }
14399
 
 
14400
 
                                case 101: {
14401
 
                                        NDR_CHECK(ndr_push_align(ndr, 8));
14402
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14403
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14404
 
                                break; }
14405
 
 
14406
 
                                default: {
14407
 
                                break; }
14408
 
 
14409
 
                        }
14410
 
                }
14411
 
                if (ndr_flags & NDR_BUFFERS) {
14412
 
                        int level = ndr_push_get_switch_value(ndr, r);
14413
 
                        NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14414
 
                        switch (level) {
14415
 
                                case 1:
14416
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14417
 
                                break;
14418
 
 
14419
 
                                case 2:
14420
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14421
 
                                break;
14422
 
 
14423
 
                                case 3:
14424
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14425
 
                                break;
14426
 
 
14427
 
                                case 4:
14428
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14429
 
                                break;
14430
 
 
14431
 
                                case 5:
14432
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14433
 
                                break;
14434
 
 
14435
 
                                case 6:
14436
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14437
 
                                break;
14438
 
 
14439
 
                                case 7:
14440
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14441
 
                                break;
14442
 
 
14443
 
                                case 8:
14444
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14445
 
                                break;
14446
 
 
14447
 
                                case 101:
14448
 
                                        NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14449
 
                                break;
14450
 
 
14451
 
                                default:
14452
 
                                break;
14453
 
 
14454
 
                        }
14455
 
                }
14456
 
                ndr->flags = _flags_save_UNION;
14457
 
        }
14458
 
        ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14459
 
        return NDR_ERR_SUCCESS;
14460
 
}
14461
 
 
14462
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14463
 
{
14464
 
        uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14465
 
        int level;
14466
 
        {
14467
 
                uint32_t _flags_save_UNION = ndr->flags;
14468
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14469
 
                level = ndr_pull_get_switch_value(ndr, r);
14470
 
                if (ndr_flags & NDR_SCALARS) {
14471
 
                        NDR_CHECK(ndr_pull_union_align(ndr, 8));
14472
 
                        switch (level) {
14473
 
                                case 1: {
14474
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
14475
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14476
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14477
 
                                break; }
14478
 
 
14479
 
                                case 2: {
14480
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
14481
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14482
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14483
 
                                break; }
14484
 
 
14485
 
                                case 3: {
14486
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
14487
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14488
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14489
 
                                break; }
14490
 
 
14491
 
                                case 4: {
14492
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
14493
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14494
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14495
 
                                break; }
14496
 
 
14497
 
                                case 5: {
14498
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
14499
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14500
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14501
 
                                break; }
14502
 
 
14503
 
                                case 6: {
14504
 
                                        NDR_CHECK(ndr_pull_align(ndr, 8));
14505
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14506
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14507
 
                                break; }
14508
 
 
14509
 
                                case 7: {
14510
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
14511
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14512
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14513
 
                                break; }
14514
 
 
14515
 
                                case 8: {
14516
 
                                        NDR_CHECK(ndr_pull_align(ndr, 8));
14517
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14518
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14519
 
                                break; }
14520
 
 
14521
 
                                case 101: {
14522
 
                                        NDR_CHECK(ndr_pull_align(ndr, 8));
14523
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14524
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14525
 
                                break; }
14526
 
 
14527
 
                                default: {
14528
 
                                break; }
14529
 
 
14530
 
                        }
14531
 
                }
14532
 
                if (ndr_flags & NDR_BUFFERS) {
14533
 
                        NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14534
 
                        switch (level) {
14535
 
                                case 1:
14536
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14537
 
                                break;
14538
 
 
14539
 
                                case 2:
14540
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14541
 
                                break;
14542
 
 
14543
 
                                case 3:
14544
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14545
 
                                break;
14546
 
 
14547
 
                                case 4:
14548
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14549
 
                                break;
14550
 
 
14551
 
                                case 5:
14552
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14553
 
                                break;
14554
 
 
14555
 
                                case 6:
14556
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14557
 
                                break;
14558
 
 
14559
 
                                case 7:
14560
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14561
 
                                break;
14562
 
 
14563
 
                                case 8:
14564
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14565
 
                                break;
14566
 
 
14567
 
                                case 101:
14568
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14569
 
                                break;
14570
 
 
14571
 
                                default:
14572
 
                                break;
14573
 
 
14574
 
                        }
14575
 
                }
14576
 
                ndr->flags = _flags_save_UNION;
14577
 
        }
14578
 
        ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14579
 
        return NDR_ERR_SUCCESS;
14580
 
}
14581
 
 
14582
 
_PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14583
 
{
14584
 
        int level;
14585
 
        {
14586
 
                uint32_t _flags_save_UNION = ndr->flags;
14587
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14588
 
                level = ndr_print_get_switch_value(ndr, r);
14589
 
                ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14590
 
                switch (level) {
14591
 
                        case 1:
14592
 
                                ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14593
 
                        break;
14594
 
 
14595
 
                        case 2:
14596
 
                                ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14597
 
                        break;
14598
 
 
14599
 
                        case 3:
14600
 
                                ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14601
 
                        break;
14602
 
 
14603
 
                        case 4:
14604
 
                                ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14605
 
                        break;
14606
 
 
14607
 
                        case 5:
14608
 
                                ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14609
 
                        break;
14610
 
 
14611
 
                        case 6:
14612
 
                                ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14613
 
                        break;
14614
 
 
14615
 
                        case 7:
14616
 
                                ndr_print_spoolss_DriverInfo7(ndr, "info7", &r->info7);
14617
 
                        break;
14618
 
 
14619
 
                        case 8:
14620
 
                                ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
14621
 
                        break;
14622
 
 
14623
 
                        case 101:
14624
 
                                ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
14625
 
                        break;
14626
 
 
14627
 
                        default:
14628
 
                        break;
14629
 
 
14630
 
                }
14631
 
                ndr->flags = _flags_save_UNION;
14632
 
        }
14633
 
}
14634
 
 
14635
 
_PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14636
 
{
14637
 
        flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
14638
 
        return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
14639
 
}
14640
 
 
14641
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
14642
 
{
14643
 
        if (ndr_flags & NDR_SCALARS) {
14644
 
                NDR_CHECK(ndr_push_align(ndr, 4));
14645
 
                {
14646
 
                        uint32_t _flags_save_string = ndr->flags;
14647
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14648
 
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14649
 
                        ndr->flags = _flags_save_string;
14650
 
                }
14651
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
14652
 
        }
14653
 
        if (ndr_flags & NDR_BUFFERS) {
14654
 
        }
14655
 
        return NDR_ERR_SUCCESS;
14656
 
}
14657
 
 
14658
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
14659
 
{
14660
 
        if (ndr_flags & NDR_SCALARS) {
14661
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
14662
 
                {
14663
 
                        uint32_t _flags_save_string = ndr->flags;
14664
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14665
 
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14666
 
                        ndr->flags = _flags_save_string;
14667
 
                }
14668
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
14669
 
        }
14670
 
        if (ndr_flags & NDR_BUFFERS) {
14671
 
        }
14672
 
        return NDR_ERR_SUCCESS;
14673
 
}
14674
 
 
14675
 
_PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
14676
 
{
14677
 
        ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
14678
 
        ndr->depth++;
14679
 
        ndr_print_string(ndr, "directory_name", r->directory_name);
14680
 
        ndr->depth--;
14681
 
}
14682
 
 
14683
 
_PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14684
 
{
14685
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
14686
 
}
14687
 
 
14688
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
14689
 
{
14690
 
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14691
 
        {
14692
 
                uint32_t _flags_save_UNION = ndr->flags;
14693
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14694
 
                if (ndr_flags & NDR_SCALARS) {
14695
 
                        int level = ndr_push_get_switch_value(ndr, r);
14696
 
                        NDR_CHECK(ndr_push_union_align(ndr, 4));
14697
 
                        switch (level) {
14698
 
                                case 1: {
14699
 
                                        NDR_CHECK(ndr_push_align(ndr, 4));
14700
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14701
 
                                        NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14702
 
                                break; }
14703
 
 
14704
 
                                default: {
14705
 
                                        NDR_CHECK(ndr_push_align(ndr, 4));
14706
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14707
 
                                        NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14708
 
                                break; }
14709
 
 
14710
 
                        }
14711
 
                }
14712
 
                if (ndr_flags & NDR_BUFFERS) {
14713
 
                        int level = ndr_push_get_switch_value(ndr, r);
14714
 
                        NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14715
 
                        switch (level) {
14716
 
                                case 1:
14717
 
                                break;
14718
 
 
14719
 
                                default:
14720
 
                                break;
14721
 
 
14722
 
                        }
14723
 
                }
14724
 
                ndr->flags = _flags_save_UNION;
14725
 
        }
14726
 
        ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14727
 
        return NDR_ERR_SUCCESS;
14728
 
}
14729
 
 
14730
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
14731
 
{
14732
 
        uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14733
 
        int level;
14734
 
        {
14735
 
                uint32_t _flags_save_UNION = ndr->flags;
14736
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14737
 
                level = ndr_pull_get_switch_value(ndr, r);
14738
 
                if (ndr_flags & NDR_SCALARS) {
14739
 
                        NDR_CHECK(ndr_pull_union_align(ndr, 4));
14740
 
                        switch (level) {
14741
 
                                case 1: {
14742
 
                                        NDR_CHECK(ndr_pull_align(ndr, 4));
14743
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14744
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14745
 
                                break; }
14746
 
 
14747
 
                                default: {
14748
 
                                        NDR_CHECK(ndr_pull_align(ndr, 4));
14749
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14750
 
                                        NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14751
 
                                break; }
14752
 
 
14753
 
                        }
14754
 
                }
14755
 
                if (ndr_flags & NDR_BUFFERS) {
14756
 
                        NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14757
 
                        switch (level) {
14758
 
                                case 1:
14759
 
                                break;
14760
 
 
14761
 
                                default:
14762
 
                                break;
14763
 
 
14764
 
                        }
14765
 
                }
14766
 
                ndr->flags = _flags_save_UNION;
14767
 
        }
14768
 
        ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14769
 
        return NDR_ERR_SUCCESS;
14770
 
}
14771
 
 
14772
 
_PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
14773
 
{
14774
 
        int level;
14775
 
        {
14776
 
                uint32_t _flags_save_UNION = ndr->flags;
14777
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14778
 
                level = ndr_print_get_switch_value(ndr, r);
14779
 
                ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
14780
 
                switch (level) {
14781
 
                        case 1:
14782
 
                                ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14783
 
                        break;
14784
 
 
14785
 
                        default:
14786
 
                                ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
14787
 
                        break;
14788
 
 
14789
 
                }
14790
 
                ndr->flags = _flags_save_UNION;
14791
 
        }
14792
 
}
14793
 
 
14794
 
_PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14795
 
{
14796
 
        flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
14797
 
        return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
14798
 
}
14799
 
 
14800
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
14801
 
{
14802
 
        if (ndr_flags & NDR_SCALARS) {
14803
 
                NDR_CHECK(ndr_push_align(ndr, 5));
14804
 
                {
14805
 
                        uint32_t _flags_save_string = ndr->flags;
14806
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14807
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
14808
 
                        ndr->flags = _flags_save_string;
14809
 
                }
14810
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14811
 
        }
14812
 
        if (ndr_flags & NDR_BUFFERS) {
14813
 
                {
14814
 
                        uint32_t _flags_save_string = ndr->flags;
14815
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14816
 
                        if (r->print_processor_name) {
14817
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor_name));
14818
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
14819
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor_name));
14820
 
                        }
14821
 
                        ndr->flags = _flags_save_string;
14822
 
                }
14823
 
        }
14824
 
        return NDR_ERR_SUCCESS;
14825
 
}
14826
 
 
14827
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
14828
 
{
14829
 
        uint32_t _ptr_print_processor_name;
14830
 
        TALLOC_CTX *_mem_save_print_processor_name_0;
14831
 
        if (ndr_flags & NDR_SCALARS) {
14832
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
14833
 
                {
14834
 
                        uint32_t _flags_save_string = ndr->flags;
14835
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14836
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
14837
 
                        if (_ptr_print_processor_name) {
14838
 
                                NDR_PULL_ALLOC(ndr, r->print_processor_name);
14839
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
14840
 
                        } else {
14841
 
                                r->print_processor_name = NULL;
14842
 
                        }
14843
 
                        ndr->flags = _flags_save_string;
14844
 
                }
14845
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14846
 
        }
14847
 
        if (ndr_flags & NDR_BUFFERS) {
14848
 
                {
14849
 
                        uint32_t _flags_save_string = ndr->flags;
14850
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14851
 
                        if (r->print_processor_name) {
14852
 
                                uint32_t _relative_save_offset;
14853
 
                                _relative_save_offset = ndr->offset;
14854
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
14855
 
                                _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14856
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
14857
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
14858
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
14859
 
                                ndr->offset = _relative_save_offset;
14860
 
                        }
14861
 
                        ndr->flags = _flags_save_string;
14862
 
                }
14863
 
        }
14864
 
        return NDR_ERR_SUCCESS;
14865
 
}
14866
 
 
14867
 
_PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
14868
 
{
14869
 
        ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
14870
 
        ndr->depth++;
14871
 
        ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
14872
 
        ndr->depth++;
14873
 
        if (r->print_processor_name) {
14874
 
                ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
14875
 
        }
14876
 
        ndr->depth--;
14877
 
        ndr->depth--;
14878
 
}
14879
 
 
14880
 
_PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14881
 
{
14882
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
14883
 
}
14884
 
 
14885
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
14886
 
{
14887
 
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14888
 
        {
14889
 
                uint32_t _flags_save_UNION = ndr->flags;
14890
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14891
 
                if (ndr_flags & NDR_SCALARS) {
14892
 
                        int level = ndr_push_get_switch_value(ndr, r);
14893
 
                        NDR_CHECK(ndr_push_union_align(ndr, 5));
14894
 
                        switch (level) {
14895
 
                                case 1: {
14896
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
14897
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14898
 
                                        NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14899
 
                                break; }
14900
 
 
14901
 
                                default: {
14902
 
                                break; }
14903
 
 
14904
 
                        }
14905
 
                }
14906
 
                if (ndr_flags & NDR_BUFFERS) {
14907
 
                        int level = ndr_push_get_switch_value(ndr, r);
14908
 
                        NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14909
 
                        switch (level) {
14910
 
                                case 1:
14911
 
                                        NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14912
 
                                break;
14913
 
 
14914
 
                                default:
14915
 
                                break;
14916
 
 
14917
 
                        }
14918
 
                }
14919
 
                ndr->flags = _flags_save_UNION;
14920
 
        }
14921
 
        ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14922
 
        return NDR_ERR_SUCCESS;
14923
 
}
14924
 
 
14925
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
14926
 
{
14927
 
        uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14928
 
        int level;
14929
 
        {
14930
 
                uint32_t _flags_save_UNION = ndr->flags;
14931
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14932
 
                level = ndr_pull_get_switch_value(ndr, r);
14933
 
                if (ndr_flags & NDR_SCALARS) {
14934
 
                        NDR_CHECK(ndr_pull_union_align(ndr, 5));
14935
 
                        switch (level) {
14936
 
                                case 1: {
14937
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
14938
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14939
 
                                        NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14940
 
                                break; }
14941
 
 
14942
 
                                default: {
14943
 
                                break; }
14944
 
 
14945
 
                        }
14946
 
                }
14947
 
                if (ndr_flags & NDR_BUFFERS) {
14948
 
                        NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14949
 
                        switch (level) {
14950
 
                                case 1:
14951
 
                                        NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14952
 
                                break;
14953
 
 
14954
 
                                default:
14955
 
                                break;
14956
 
 
14957
 
                        }
14958
 
                }
14959
 
                ndr->flags = _flags_save_UNION;
14960
 
        }
14961
 
        ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14962
 
        return NDR_ERR_SUCCESS;
14963
 
}
14964
 
 
14965
 
_PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14966
 
{
14967
 
        int level;
14968
 
        {
14969
 
                uint32_t _flags_save_UNION = ndr->flags;
14970
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
14971
 
                level = ndr_print_get_switch_value(ndr, r);
14972
 
                ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14973
 
                switch (level) {
14974
 
                        case 1:
14975
 
                                ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14976
 
                        break;
14977
 
 
14978
 
                        default:
14979
 
                        break;
14980
 
 
14981
 
                }
14982
 
                ndr->flags = _flags_save_UNION;
14983
 
        }
14984
 
}
14985
 
 
14986
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14987
 
{
14988
 
        if (ndr_flags & NDR_SCALARS) {
14989
 
                NDR_CHECK(ndr_push_align(ndr, 4));
14990
 
                {
14991
 
                        uint32_t _flags_save_string = ndr->flags;
14992
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
14993
 
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14994
 
                        ndr->flags = _flags_save_string;
14995
 
                }
14996
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
14997
 
        }
14998
 
        if (ndr_flags & NDR_BUFFERS) {
14999
 
        }
15000
 
        return NDR_ERR_SUCCESS;
15001
 
}
15002
 
 
15003
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
15004
 
{
15005
 
        if (ndr_flags & NDR_SCALARS) {
15006
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
15007
 
                {
15008
 
                        uint32_t _flags_save_string = ndr->flags;
15009
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15010
 
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15011
 
                        ndr->flags = _flags_save_string;
15012
 
                }
15013
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15014
 
        }
15015
 
        if (ndr_flags & NDR_BUFFERS) {
15016
 
        }
15017
 
        return NDR_ERR_SUCCESS;
15018
 
}
15019
 
 
15020
 
_PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15021
 
{
15022
 
        ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
15023
 
        ndr->depth++;
15024
 
        ndr_print_string(ndr, "directory_name", r->directory_name);
15025
 
        ndr->depth--;
15026
 
}
15027
 
 
15028
 
_PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15029
 
{
15030
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
15031
 
}
15032
 
 
15033
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
15034
 
{
15035
 
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15036
 
        {
15037
 
                uint32_t _flags_save_UNION = ndr->flags;
15038
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15039
 
                if (ndr_flags & NDR_SCALARS) {
15040
 
                        int level = ndr_push_get_switch_value(ndr, r);
15041
 
                        NDR_CHECK(ndr_push_union_align(ndr, 4));
15042
 
                        switch (level) {
15043
 
                                case 1: {
15044
 
                                        NDR_CHECK(ndr_push_align(ndr, 4));
15045
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15046
 
                                        NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15047
 
                                break; }
15048
 
 
15049
 
                                default: {
15050
 
                                        NDR_CHECK(ndr_push_align(ndr, 4));
15051
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15052
 
                                        NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15053
 
                                break; }
15054
 
 
15055
 
                        }
15056
 
                }
15057
 
                if (ndr_flags & NDR_BUFFERS) {
15058
 
                        int level = ndr_push_get_switch_value(ndr, r);
15059
 
                        NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15060
 
                        switch (level) {
15061
 
                                case 1:
15062
 
                                break;
15063
 
 
15064
 
                                default:
15065
 
                                break;
15066
 
 
15067
 
                        }
15068
 
                }
15069
 
                ndr->flags = _flags_save_UNION;
15070
 
        }
15071
 
        ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15072
 
        return NDR_ERR_SUCCESS;
15073
 
}
15074
 
 
15075
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
15076
 
{
15077
 
        uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15078
 
        int level;
15079
 
        {
15080
 
                uint32_t _flags_save_UNION = ndr->flags;
15081
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15082
 
                level = ndr_pull_get_switch_value(ndr, r);
15083
 
                if (ndr_flags & NDR_SCALARS) {
15084
 
                        NDR_CHECK(ndr_pull_union_align(ndr, 4));
15085
 
                        switch (level) {
15086
 
                                case 1: {
15087
 
                                        NDR_CHECK(ndr_pull_align(ndr, 4));
15088
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15089
 
                                        NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15090
 
                                break; }
15091
 
 
15092
 
                                default: {
15093
 
                                        NDR_CHECK(ndr_pull_align(ndr, 4));
15094
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15095
 
                                        NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15096
 
                                break; }
15097
 
 
15098
 
                        }
15099
 
                }
15100
 
                if (ndr_flags & NDR_BUFFERS) {
15101
 
                        NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15102
 
                        switch (level) {
15103
 
                                case 1:
15104
 
                                break;
15105
 
 
15106
 
                                default:
15107
 
                                break;
15108
 
 
15109
 
                        }
15110
 
                }
15111
 
                ndr->flags = _flags_save_UNION;
15112
 
        }
15113
 
        ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15114
 
        return NDR_ERR_SUCCESS;
15115
 
}
15116
 
 
15117
 
_PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
15118
 
{
15119
 
        int level;
15120
 
        {
15121
 
                uint32_t _flags_save_UNION = ndr->flags;
15122
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15123
 
                level = ndr_print_get_switch_value(ndr, r);
15124
 
                ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
15125
 
                switch (level) {
15126
 
                        case 1:
15127
 
                                ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15128
 
                        break;
15129
 
 
15130
 
                        default:
15131
 
                                ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15132
 
                        break;
15133
 
 
15134
 
                }
15135
 
                ndr->flags = _flags_save_UNION;
15136
 
        }
15137
 
}
15138
 
 
15139
 
_PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15140
 
{
15141
 
        flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15142
 
        return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
15143
 
}
15144
 
 
15145
 
static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
15146
 
{
15147
 
        if (ndr_flags & NDR_SCALARS) {
15148
 
                NDR_CHECK(ndr_push_align(ndr, 5));
15149
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
15150
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
15151
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
15152
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15153
 
        }
15154
 
        if (ndr_flags & NDR_BUFFERS) {
15155
 
                if (r->document_name) {
15156
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15157
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15158
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15159
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15160
 
                }
15161
 
                if (r->output_file) {
15162
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15163
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15164
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15165
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15166
 
                }
15167
 
                if (r->datatype) {
15168
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15169
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15170
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15171
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15172
 
                }
15173
 
        }
15174
 
        return NDR_ERR_SUCCESS;
15175
 
}
15176
 
 
15177
 
static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
15178
 
{
15179
 
        uint32_t _ptr_document_name;
15180
 
        TALLOC_CTX *_mem_save_document_name_0;
15181
 
        uint32_t _ptr_output_file;
15182
 
        TALLOC_CTX *_mem_save_output_file_0;
15183
 
        uint32_t _ptr_datatype;
15184
 
        TALLOC_CTX *_mem_save_datatype_0;
15185
 
        if (ndr_flags & NDR_SCALARS) {
15186
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
15187
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
15188
 
                if (_ptr_document_name) {
15189
 
                        NDR_PULL_ALLOC(ndr, r->document_name);
15190
 
                } else {
15191
 
                        r->document_name = NULL;
15192
 
                }
15193
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
15194
 
                if (_ptr_output_file) {
15195
 
                        NDR_PULL_ALLOC(ndr, r->output_file);
15196
 
                } else {
15197
 
                        r->output_file = NULL;
15198
 
                }
15199
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15200
 
                if (_ptr_datatype) {
15201
 
                        NDR_PULL_ALLOC(ndr, r->datatype);
15202
 
                } else {
15203
 
                        r->datatype = NULL;
15204
 
                }
15205
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15206
 
        }
15207
 
        if (ndr_flags & NDR_BUFFERS) {
15208
 
                if (r->document_name) {
15209
 
                        _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15210
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
15211
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
15212
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
15213
 
                        if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
15214
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
15215
 
                        }
15216
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
15217
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
15218
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
15219
 
                }
15220
 
                if (r->output_file) {
15221
 
                        _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
15222
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
15223
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
15224
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
15225
 
                        if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
15226
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->output_file), ndr_get_array_length(ndr, &r->output_file));
15227
 
                        }
15228
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
15229
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
15230
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
15231
 
                }
15232
 
                if (r->datatype) {
15233
 
                        _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15234
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
15235
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
15236
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
15237
 
                        if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
15238
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
15239
 
                        }
15240
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
15241
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
15242
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15243
 
                }
15244
 
        }
15245
 
        return NDR_ERR_SUCCESS;
15246
 
}
15247
 
 
15248
 
_PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
15249
 
{
15250
 
        ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
15251
 
        ndr->depth++;
15252
 
        ndr_print_ptr(ndr, "document_name", r->document_name);
15253
 
        ndr->depth++;
15254
 
        if (r->document_name) {
15255
 
                ndr_print_string(ndr, "document_name", r->document_name);
15256
 
        }
15257
 
        ndr->depth--;
15258
 
        ndr_print_ptr(ndr, "output_file", r->output_file);
15259
 
        ndr->depth++;
15260
 
        if (r->output_file) {
15261
 
                ndr_print_string(ndr, "output_file", r->output_file);
15262
 
        }
15263
 
        ndr->depth--;
15264
 
        ndr_print_ptr(ndr, "datatype", r->datatype);
15265
 
        ndr->depth++;
15266
 
        if (r->datatype) {
15267
 
                ndr_print_string(ndr, "datatype", r->datatype);
15268
 
        }
15269
 
        ndr->depth--;
15270
 
        ndr->depth--;
15271
 
}
15272
 
 
15273
 
static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
15274
 
{
15275
 
        if (ndr_flags & NDR_SCALARS) {
15276
 
                int level = ndr_push_get_switch_value(ndr, r);
15277
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15278
 
                NDR_CHECK(ndr_push_union_align(ndr, 5));
15279
 
                switch (level) {
15280
 
                        case 1: {
15281
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15282
 
                        break; }
15283
 
 
15284
 
                        case 2: {
15285
 
                        break; }
15286
 
 
15287
 
                        case 3: {
15288
 
                        break; }
15289
 
 
15290
 
                        default: {
15291
 
                        break; }
15292
 
 
15293
 
                }
15294
 
        }
15295
 
        if (ndr_flags & NDR_BUFFERS) {
15296
 
                int level = ndr_push_get_switch_value(ndr, r);
15297
 
                switch (level) {
15298
 
                        case 1:
15299
 
                                if (r->info1) {
15300
 
                                        NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15301
 
                                }
15302
 
                        break;
15303
 
 
15304
 
                        case 2:
15305
 
                        break;
15306
 
 
15307
 
                        case 3:
15308
 
                        break;
15309
 
 
15310
 
                        default:
15311
 
                        break;
15312
 
 
15313
 
                }
15314
 
        }
15315
 
        return NDR_ERR_SUCCESS;
15316
 
}
15317
 
 
15318
 
static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
15319
 
{
15320
 
        int level;
15321
 
        uint32_t _level;
15322
 
        TALLOC_CTX *_mem_save_info1_0;
15323
 
        level = ndr_pull_get_switch_value(ndr, r);
15324
 
        if (ndr_flags & NDR_SCALARS) {
15325
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15326
 
                if (_level != level) {
15327
 
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
15328
 
                }
15329
 
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
15330
 
                switch (level) {
15331
 
                        case 1: {
15332
 
                                uint32_t _ptr_info1;
15333
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15334
 
                                if (_ptr_info1) {
15335
 
                                        NDR_PULL_ALLOC(ndr, r->info1);
15336
 
                                } else {
15337
 
                                        r->info1 = NULL;
15338
 
                                }
15339
 
                        break; }
15340
 
 
15341
 
                        case 2: {
15342
 
                        break; }
15343
 
 
15344
 
                        case 3: {
15345
 
                        break; }
15346
 
 
15347
 
                        default: {
15348
 
                        break; }
15349
 
 
15350
 
                }
15351
 
        }
15352
 
        if (ndr_flags & NDR_BUFFERS) {
15353
 
                switch (level) {
15354
 
                        case 1:
15355
 
                                if (r->info1) {
15356
 
                                        _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15357
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15358
 
                                        NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15359
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15360
 
                                }
15361
 
                        break;
15362
 
 
15363
 
                        case 2:
15364
 
                        break;
15365
 
 
15366
 
                        case 3:
15367
 
                        break;
15368
 
 
15369
 
                        default:
15370
 
                        break;
15371
 
 
15372
 
                }
15373
 
        }
15374
 
        return NDR_ERR_SUCCESS;
15375
 
}
15376
 
 
15377
 
_PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
15378
 
{
15379
 
        int level;
15380
 
        level = ndr_print_get_switch_value(ndr, r);
15381
 
        ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
15382
 
        switch (level) {
15383
 
                case 1:
15384
 
                        ndr_print_ptr(ndr, "info1", r->info1);
15385
 
                        ndr->depth++;
15386
 
                        if (r->info1) {
15387
 
                                ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
15388
 
                        }
15389
 
                        ndr->depth--;
15390
 
                break;
15391
 
 
15392
 
                case 2:
15393
 
                break;
15394
 
 
15395
 
                case 3:
15396
 
                break;
15397
 
 
15398
 
                default:
15399
 
                break;
15400
 
 
15401
 
        }
15402
 
}
15403
 
 
15404
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
15405
 
{
15406
 
        if (ndr_flags & NDR_SCALARS) {
15407
 
                NDR_CHECK(ndr_push_align(ndr, 4));
15408
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
15409
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15410
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15411
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15412
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15413
 
                {
15414
 
                        uint32_t _flags_save_string = ndr->flags;
15415
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15416
 
                        {
15417
 
                                struct ndr_push *_ndr_extra_string;
15418
 
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15419
 
                                NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15420
 
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15421
 
                        }
15422
 
                        ndr->flags = _flags_save_string;
15423
 
                }
15424
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15425
 
        }
15426
 
        if (ndr_flags & NDR_BUFFERS) {
15427
 
        }
15428
 
        return NDR_ERR_SUCCESS;
15429
 
}
15430
 
 
15431
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
15432
 
{
15433
 
        if (ndr_flags & NDR_SCALARS) {
15434
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
15435
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15436
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15437
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15438
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15439
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15440
 
                {
15441
 
                        uint32_t _flags_save_string = ndr->flags;
15442
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15443
 
                        {
15444
 
                                struct ndr_pull *_ndr_extra_string;
15445
 
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15446
 
                                NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15447
 
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15448
 
                        }
15449
 
                        ndr->flags = _flags_save_string;
15450
 
                }
15451
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15452
 
        }
15453
 
        if (ndr_flags & NDR_BUFFERS) {
15454
 
        }
15455
 
        return NDR_ERR_SUCCESS;
15456
 
}
15457
 
 
15458
 
_PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
15459
 
{
15460
 
        ndr_print_struct(ndr, name, "spoolss_OSVersion");
15461
 
        ndr->depth++;
15462
 
        ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
15463
 
        ndr_print_uint32(ndr, "major", r->major);
15464
 
        ndr_print_uint32(ndr, "minor", r->minor);
15465
 
        ndr_print_uint32(ndr, "build", r->build);
15466
 
        ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15467
 
        ndr_print_string(ndr, "extra_string", r->extra_string);
15468
 
        ndr->depth--;
15469
 
}
15470
 
 
15471
 
_PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
15472
 
{
15473
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
15474
 
}
15475
 
 
15476
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
15477
 
{
15478
 
        if (ndr_flags & NDR_SCALARS) {
15479
 
                NDR_CHECK(ndr_push_align(ndr, 4));
15480
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
15481
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15482
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15483
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15484
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15485
 
                {
15486
 
                        uint32_t _flags_save_string = ndr->flags;
15487
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15488
 
                        {
15489
 
                                struct ndr_push *_ndr_extra_string;
15490
 
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15491
 
                                NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15492
 
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15493
 
                        }
15494
 
                        ndr->flags = _flags_save_string;
15495
 
                }
15496
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
15497
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
15498
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
15499
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
15500
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
15501
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15502
 
        }
15503
 
        if (ndr_flags & NDR_BUFFERS) {
15504
 
        }
15505
 
        return NDR_ERR_SUCCESS;
15506
 
}
15507
 
 
15508
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15509
 
{
15510
 
        if (ndr_flags & NDR_SCALARS) {
15511
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
15512
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15513
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15514
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15515
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15516
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15517
 
                {
15518
 
                        uint32_t _flags_save_string = ndr->flags;
15519
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15520
 
                        {
15521
 
                                struct ndr_pull *_ndr_extra_string;
15522
 
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15523
 
                                NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15524
 
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15525
 
                        }
15526
 
                        ndr->flags = _flags_save_string;
15527
 
                }
15528
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15529
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15530
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15531
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15532
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15533
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15534
 
        }
15535
 
        if (ndr_flags & NDR_BUFFERS) {
15536
 
        }
15537
 
        return NDR_ERR_SUCCESS;
15538
 
}
15539
 
 
15540
 
_PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15541
 
{
15542
 
        ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15543
 
        ndr->depth++;
15544
 
        ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
15545
 
        ndr_print_uint32(ndr, "major", r->major);
15546
 
        ndr_print_uint32(ndr, "minor", r->minor);
15547
 
        ndr_print_uint32(ndr, "build", r->build);
15548
 
        ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15549
 
        ndr_print_string(ndr, "extra_string", r->extra_string);
15550
 
        ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15551
 
        ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15552
 
        ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15553
 
        ndr_print_uint8(ndr, "product_type", r->product_type);
15554
 
        ndr_print_uint8(ndr, "reserved", r->reserved);
15555
 
        ndr->depth--;
15556
 
}
15557
 
 
15558
 
_PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15559
 
{
15560
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15561
 
}
15562
 
 
15563
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15564
 
{
15565
 
        if (ndr_flags & NDR_SCALARS) {
15566
 
                int level = ndr_push_get_switch_value(ndr, r);
15567
 
                NDR_CHECK(ndr_push_union_align(ndr, 4));
15568
 
                switch (level) {
15569
 
                        case REG_NONE: {
15570
 
                        break; }
15571
 
 
15572
 
                        case REG_SZ: {
15573
 
                                {
15574
 
                                        uint32_t _flags_save_string = ndr->flags;
15575
 
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15576
 
                                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15577
 
                                        ndr->flags = _flags_save_string;
15578
 
                                }
15579
 
                        break; }
15580
 
 
15581
 
                        case REG_BINARY: {
15582
 
                                {
15583
 
                                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
15584
 
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15585
 
                                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15586
 
                                        ndr->flags = _flags_save_DATA_BLOB;
15587
 
                                }
15588
 
                        break; }
15589
 
 
15590
 
                        case REG_DWORD: {
15591
 
                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15592
 
                        break; }
15593
 
 
15594
 
                        case REG_MULTI_SZ: {
15595
 
                                {
15596
 
                                        uint32_t _flags_save_string_array = ndr->flags;
15597
 
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15598
 
                                        NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15599
 
                                        ndr->flags = _flags_save_string_array;
15600
 
                                }
15601
 
                        break; }
15602
 
 
15603
 
                        default: {
15604
 
                                {
15605
 
                                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
15606
 
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15607
 
                                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15608
 
                                        ndr->flags = _flags_save_DATA_BLOB;
15609
 
                                }
15610
 
                        break; }
15611
 
 
15612
 
                }
15613
 
        }
15614
 
        if (ndr_flags & NDR_BUFFERS) {
15615
 
                int level = ndr_push_get_switch_value(ndr, r);
15616
 
                switch (level) {
15617
 
                        case REG_NONE:
15618
 
                        break;
15619
 
 
15620
 
                        case REG_SZ:
15621
 
                        break;
15622
 
 
15623
 
                        case REG_BINARY:
15624
 
                        break;
15625
 
 
15626
 
                        case REG_DWORD:
15627
 
                        break;
15628
 
 
15629
 
                        case REG_MULTI_SZ:
15630
 
                        break;
15631
 
 
15632
 
                        default:
15633
 
                        break;
15634
 
 
15635
 
                }
15636
 
        }
15637
 
        return NDR_ERR_SUCCESS;
15638
 
}
15639
 
 
15640
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
15641
 
{
15642
 
        int level;
15643
 
        level = ndr_pull_get_switch_value(ndr, r);
15644
 
        if (ndr_flags & NDR_SCALARS) {
15645
 
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
15646
 
                switch (level) {
15647
 
                        case REG_NONE: {
15648
 
                        break; }
15649
 
 
15650
 
                        case REG_SZ: {
15651
 
                                {
15652
 
                                        uint32_t _flags_save_string = ndr->flags;
15653
 
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15654
 
                                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
15655
 
                                        ndr->flags = _flags_save_string;
15656
 
                                }
15657
 
                        break; }
15658
 
 
15659
 
                        case REG_BINARY: {
15660
 
                                {
15661
 
                                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
15662
 
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15663
 
                                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
15664
 
                                        ndr->flags = _flags_save_DATA_BLOB;
15665
 
                                }
15666
 
                        break; }
15667
 
 
15668
 
                        case REG_DWORD: {
15669
 
                                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
15670
 
                        break; }
15671
 
 
15672
 
                        case REG_MULTI_SZ: {
15673
 
                                {
15674
 
                                        uint32_t _flags_save_string_array = ndr->flags;
15675
 
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15676
 
                                        NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
15677
 
                                        ndr->flags = _flags_save_string_array;
15678
 
                                }
15679
 
                        break; }
15680
 
 
15681
 
                        default: {
15682
 
                                {
15683
 
                                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
15684
 
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15685
 
                                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
15686
 
                                        ndr->flags = _flags_save_DATA_BLOB;
15687
 
                                }
15688
 
                        break; }
15689
 
 
15690
 
                }
15691
 
        }
15692
 
        if (ndr_flags & NDR_BUFFERS) {
15693
 
                switch (level) {
15694
 
                        case REG_NONE:
15695
 
                        break;
15696
 
 
15697
 
                        case REG_SZ:
15698
 
                        break;
15699
 
 
15700
 
                        case REG_BINARY:
15701
 
                        break;
15702
 
 
15703
 
                        case REG_DWORD:
15704
 
                        break;
15705
 
 
15706
 
                        case REG_MULTI_SZ:
15707
 
                        break;
15708
 
 
15709
 
                        default:
15710
 
                        break;
15711
 
 
15712
 
                }
15713
 
        }
15714
 
        return NDR_ERR_SUCCESS;
15715
 
}
15716
 
 
15717
 
_PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
15718
 
{
15719
 
        int level;
15720
 
        level = ndr_print_get_switch_value(ndr, r);
15721
 
        ndr_print_union(ndr, name, level, "spoolss_PrinterData");
15722
 
        switch (level) {
15723
 
                case REG_NONE:
15724
 
                break;
15725
 
 
15726
 
                case REG_SZ:
15727
 
                        ndr_print_string(ndr, "string", r->string);
15728
 
                break;
15729
 
 
15730
 
                case REG_BINARY:
15731
 
                        ndr_print_DATA_BLOB(ndr, "binary", r->binary);
15732
 
                break;
15733
 
 
15734
 
                case REG_DWORD:
15735
 
                        ndr_print_uint32(ndr, "value", r->value);
15736
 
                break;
15737
 
 
15738
 
                case REG_MULTI_SZ:
15739
 
                        ndr_print_string_array(ndr, "string_array", r->string_array);
15740
 
                break;
15741
 
 
15742
 
                default:
15743
 
                        ndr_print_DATA_BLOB(ndr, "data", r->data);
15744
 
                break;
15745
 
 
15746
 
        }
15747
 
}
15748
 
 
15749
 
static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
15750
 
{
15751
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
15752
 
        return NDR_ERR_SUCCESS;
15753
 
}
15754
 
 
15755
 
static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
15756
 
{
15757
 
        uint32_t v;
15758
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
15759
 
        *r = v;
15760
 
        return NDR_ERR_SUCCESS;
15761
 
}
15762
 
 
15763
 
_PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
15764
 
{
15765
 
        const char *val = NULL;
15766
 
 
15767
 
        switch (r) {
15768
 
                case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
15769
 
                case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
15770
 
                case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
15771
 
        }
15772
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
15773
 
}
15774
 
 
15775
 
static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
15776
 
{
15777
 
        if (ndr_flags & NDR_SCALARS) {
15778
 
                NDR_CHECK(ndr_push_align(ndr, 4));
15779
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
15780
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
15781
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15782
 
        }
15783
 
        if (ndr_flags & NDR_BUFFERS) {
15784
 
        }
15785
 
        return NDR_ERR_SUCCESS;
15786
 
}
15787
 
 
15788
 
static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
15789
 
{
15790
 
        if (ndr_flags & NDR_SCALARS) {
15791
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
15792
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
15793
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
15794
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15795
 
        }
15796
 
        if (ndr_flags & NDR_BUFFERS) {
15797
 
        }
15798
 
        return NDR_ERR_SUCCESS;
15799
 
}
15800
 
 
15801
 
_PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
15802
 
{
15803
 
        ndr_print_struct(ndr, name, "spoolss_FormSize");
15804
 
        ndr->depth++;
15805
 
        ndr_print_uint32(ndr, "width", r->width);
15806
 
        ndr_print_uint32(ndr, "height", r->height);
15807
 
        ndr->depth--;
15808
 
}
15809
 
 
15810
 
static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
15811
 
{
15812
 
        if (ndr_flags & NDR_SCALARS) {
15813
 
                NDR_CHECK(ndr_push_align(ndr, 4));
15814
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
15815
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
15816
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
15817
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
15818
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15819
 
        }
15820
 
        if (ndr_flags & NDR_BUFFERS) {
15821
 
        }
15822
 
        return NDR_ERR_SUCCESS;
15823
 
}
15824
 
 
15825
 
static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
15826
 
{
15827
 
        if (ndr_flags & NDR_SCALARS) {
15828
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
15829
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
15830
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
15831
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
15832
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
15833
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15834
 
        }
15835
 
        if (ndr_flags & NDR_BUFFERS) {
15836
 
        }
15837
 
        return NDR_ERR_SUCCESS;
15838
 
}
15839
 
 
15840
 
_PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
15841
 
{
15842
 
        ndr_print_struct(ndr, name, "spoolss_FormArea");
15843
 
        ndr->depth++;
15844
 
        ndr_print_uint32(ndr, "left", r->left);
15845
 
        ndr_print_uint32(ndr, "top", r->top);
15846
 
        ndr_print_uint32(ndr, "right", r->right);
15847
 
        ndr_print_uint32(ndr, "bottom", r->bottom);
15848
 
        ndr->depth--;
15849
 
}
15850
 
 
15851
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
15852
 
{
15853
 
        if (ndr_flags & NDR_SCALARS) {
15854
 
                NDR_CHECK(ndr_push_align(ndr, 5));
15855
 
                NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15856
 
                {
15857
 
                        uint32_t _flags_save_string = ndr->flags;
15858
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15859
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15860
 
                        ndr->flags = _flags_save_string;
15861
 
                }
15862
 
                NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15863
 
                NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15864
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15865
 
        }
15866
 
        if (ndr_flags & NDR_BUFFERS) {
15867
 
                {
15868
 
                        uint32_t _flags_save_string = ndr->flags;
15869
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15870
 
                        if (r->form_name) {
15871
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
15872
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15873
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
15874
 
                        }
15875
 
                        ndr->flags = _flags_save_string;
15876
 
                }
15877
 
        }
15878
 
        return NDR_ERR_SUCCESS;
15879
 
}
15880
 
 
15881
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
15882
 
{
15883
 
        uint32_t _ptr_form_name;
15884
 
        TALLOC_CTX *_mem_save_form_name_0;
15885
 
        if (ndr_flags & NDR_SCALARS) {
15886
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
15887
 
                NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15888
 
                {
15889
 
                        uint32_t _flags_save_string = ndr->flags;
15890
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15891
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15892
 
                        if (_ptr_form_name) {
15893
 
                                NDR_PULL_ALLOC(ndr, r->form_name);
15894
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15895
 
                        } else {
15896
 
                                r->form_name = NULL;
15897
 
                        }
15898
 
                        ndr->flags = _flags_save_string;
15899
 
                }
15900
 
                NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15901
 
                NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15902
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15903
 
        }
15904
 
        if (ndr_flags & NDR_BUFFERS) {
15905
 
                {
15906
 
                        uint32_t _flags_save_string = ndr->flags;
15907
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15908
 
                        if (r->form_name) {
15909
 
                                uint32_t _relative_save_offset;
15910
 
                                _relative_save_offset = ndr->offset;
15911
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15912
 
                                _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15913
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15914
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15915
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15916
 
                                ndr->offset = _relative_save_offset;
15917
 
                        }
15918
 
                        ndr->flags = _flags_save_string;
15919
 
                }
15920
 
        }
15921
 
        return NDR_ERR_SUCCESS;
15922
 
}
15923
 
 
15924
 
_PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
15925
 
{
15926
 
        ndr_print_struct(ndr, name, "spoolss_FormInfo1");
15927
 
        ndr->depth++;
15928
 
        ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15929
 
        ndr_print_ptr(ndr, "form_name", r->form_name);
15930
 
        ndr->depth++;
15931
 
        if (r->form_name) {
15932
 
                ndr_print_string(ndr, "form_name", r->form_name);
15933
 
        }
15934
 
        ndr->depth--;
15935
 
        ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15936
 
        ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15937
 
        ndr->depth--;
15938
 
}
15939
 
 
15940
 
_PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15941
 
{
15942
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
15943
 
}
15944
 
 
15945
 
static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15946
 
{
15947
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15948
 
        return NDR_ERR_SUCCESS;
15949
 
}
15950
 
 
15951
 
static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15952
 
{
15953
 
        uint32_t v;
15954
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15955
 
        *r = v;
15956
 
        return NDR_ERR_SUCCESS;
15957
 
}
15958
 
 
15959
 
_PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
15960
 
{
15961
 
        ndr_print_uint32(ndr, name, r);
15962
 
        ndr->depth++;
15963
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
15964
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
15965
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
15966
 
        ndr->depth--;
15967
 
}
15968
 
 
15969
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
15970
 
{
15971
 
        if (ndr_flags & NDR_SCALARS) {
15972
 
                NDR_CHECK(ndr_push_align(ndr, 5));
15973
 
                NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15974
 
                {
15975
 
                        uint32_t _flags_save_string = ndr->flags;
15976
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15977
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
15978
 
                        ndr->flags = _flags_save_string;
15979
 
                }
15980
 
                NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15981
 
                NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15982
 
                {
15983
 
                        uint32_t _flags_save_string = ndr->flags;
15984
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15985
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
15986
 
                        ndr->flags = _flags_save_string;
15987
 
                }
15988
 
                NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15989
 
                {
15990
 
                        uint32_t _flags_save_string = ndr->flags;
15991
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15992
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
15993
 
                        ndr->flags = _flags_save_string;
15994
 
                }
15995
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15996
 
                {
15997
 
                        uint32_t _flags_save_string = ndr->flags;
15998
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
15999
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
16000
 
                        ndr->flags = _flags_save_string;
16001
 
                }
16002
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lang_id));
16003
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unused));
16004
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16005
 
        }
16006
 
        if (ndr_flags & NDR_BUFFERS) {
16007
 
                {
16008
 
                        uint32_t _flags_save_string = ndr->flags;
16009
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16010
 
                        if (r->form_name) {
16011
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
16012
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16013
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
16014
 
                        }
16015
 
                        ndr->flags = _flags_save_string;
16016
 
                }
16017
 
                {
16018
 
                        uint32_t _flags_save_string = ndr->flags;
16019
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16020
 
                        if (r->keyword) {
16021
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->keyword));
16022
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
16023
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->keyword));
16024
 
                        }
16025
 
                        ndr->flags = _flags_save_string;
16026
 
                }
16027
 
                {
16028
 
                        uint32_t _flags_save_string = ndr->flags;
16029
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16030
 
                        if (r->mui_dll) {
16031
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->mui_dll));
16032
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
16033
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->mui_dll));
16034
 
                        }
16035
 
                        ndr->flags = _flags_save_string;
16036
 
                }
16037
 
                {
16038
 
                        uint32_t _flags_save_string = ndr->flags;
16039
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16040
 
                        if (r->display_name) {
16041
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
16042
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
16043
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
16044
 
                        }
16045
 
                        ndr->flags = _flags_save_string;
16046
 
                }
16047
 
        }
16048
 
        return NDR_ERR_SUCCESS;
16049
 
}
16050
 
 
16051
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
16052
 
{
16053
 
        uint32_t _ptr_form_name;
16054
 
        TALLOC_CTX *_mem_save_form_name_0;
16055
 
        uint32_t _ptr_keyword;
16056
 
        TALLOC_CTX *_mem_save_keyword_0;
16057
 
        uint32_t _ptr_mui_dll;
16058
 
        TALLOC_CTX *_mem_save_mui_dll_0;
16059
 
        uint32_t _ptr_display_name;
16060
 
        TALLOC_CTX *_mem_save_display_name_0;
16061
 
        if (ndr_flags & NDR_SCALARS) {
16062
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
16063
 
                NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16064
 
                {
16065
 
                        uint32_t _flags_save_string = ndr->flags;
16066
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16067
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16068
 
                        if (_ptr_form_name) {
16069
 
                                NDR_PULL_ALLOC(ndr, r->form_name);
16070
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16071
 
                        } else {
16072
 
                                r->form_name = NULL;
16073
 
                        }
16074
 
                        ndr->flags = _flags_save_string;
16075
 
                }
16076
 
                NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16077
 
                NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16078
 
                {
16079
 
                        uint32_t _flags_save_string = ndr->flags;
16080
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16081
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16082
 
                        if (_ptr_keyword) {
16083
 
                                NDR_PULL_ALLOC(ndr, r->keyword);
16084
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
16085
 
                        } else {
16086
 
                                r->keyword = NULL;
16087
 
                        }
16088
 
                        ndr->flags = _flags_save_string;
16089
 
                }
16090
 
                NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16091
 
                {
16092
 
                        uint32_t _flags_save_string = ndr->flags;
16093
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16094
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16095
 
                        if (_ptr_mui_dll) {
16096
 
                                NDR_PULL_ALLOC(ndr, r->mui_dll);
16097
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
16098
 
                        } else {
16099
 
                                r->mui_dll = NULL;
16100
 
                        }
16101
 
                        ndr->flags = _flags_save_string;
16102
 
                }
16103
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16104
 
                {
16105
 
                        uint32_t _flags_save_string = ndr->flags;
16106
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16107
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16108
 
                        if (_ptr_display_name) {
16109
 
                                NDR_PULL_ALLOC(ndr, r->display_name);
16110
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
16111
 
                        } else {
16112
 
                                r->display_name = NULL;
16113
 
                        }
16114
 
                        ndr->flags = _flags_save_string;
16115
 
                }
16116
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lang_id));
16117
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unused));
16118
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16119
 
        }
16120
 
        if (ndr_flags & NDR_BUFFERS) {
16121
 
                {
16122
 
                        uint32_t _flags_save_string = ndr->flags;
16123
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16124
 
                        if (r->form_name) {
16125
 
                                uint32_t _relative_save_offset;
16126
 
                                _relative_save_offset = ndr->offset;
16127
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16128
 
                                _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16129
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16130
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16131
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16132
 
                                ndr->offset = _relative_save_offset;
16133
 
                        }
16134
 
                        ndr->flags = _flags_save_string;
16135
 
                }
16136
 
                {
16137
 
                        uint32_t _flags_save_string = ndr->flags;
16138
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16139
 
                        if (r->keyword) {
16140
 
                                uint32_t _relative_save_offset;
16141
 
                                _relative_save_offset = ndr->offset;
16142
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
16143
 
                                _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16144
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16145
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
16146
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16147
 
                                ndr->offset = _relative_save_offset;
16148
 
                        }
16149
 
                        ndr->flags = _flags_save_string;
16150
 
                }
16151
 
                {
16152
 
                        uint32_t _flags_save_string = ndr->flags;
16153
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16154
 
                        if (r->mui_dll) {
16155
 
                                uint32_t _relative_save_offset;
16156
 
                                _relative_save_offset = ndr->offset;
16157
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
16158
 
                                _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16159
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16160
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
16161
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16162
 
                                ndr->offset = _relative_save_offset;
16163
 
                        }
16164
 
                        ndr->flags = _flags_save_string;
16165
 
                }
16166
 
                {
16167
 
                        uint32_t _flags_save_string = ndr->flags;
16168
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16169
 
                        if (r->display_name) {
16170
 
                                uint32_t _relative_save_offset;
16171
 
                                _relative_save_offset = ndr->offset;
16172
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
16173
 
                                _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16174
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16175
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
16176
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16177
 
                                ndr->offset = _relative_save_offset;
16178
 
                        }
16179
 
                        ndr->flags = _flags_save_string;
16180
 
                }
16181
 
        }
16182
 
        return NDR_ERR_SUCCESS;
16183
 
}
16184
 
 
16185
 
_PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
16186
 
{
16187
 
        ndr_print_struct(ndr, name, "spoolss_FormInfo2");
16188
 
        ndr->depth++;
16189
 
        ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16190
 
        ndr_print_ptr(ndr, "form_name", r->form_name);
16191
 
        ndr->depth++;
16192
 
        if (r->form_name) {
16193
 
                ndr_print_string(ndr, "form_name", r->form_name);
16194
 
        }
16195
 
        ndr->depth--;
16196
 
        ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16197
 
        ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16198
 
        ndr_print_ptr(ndr, "keyword", r->keyword);
16199
 
        ndr->depth++;
16200
 
        if (r->keyword) {
16201
 
                ndr_print_string(ndr, "keyword", r->keyword);
16202
 
        }
16203
 
        ndr->depth--;
16204
 
        ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16205
 
        ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16206
 
        ndr->depth++;
16207
 
        if (r->mui_dll) {
16208
 
                ndr_print_string(ndr, "mui_dll", r->mui_dll);
16209
 
        }
16210
 
        ndr->depth--;
16211
 
        ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16212
 
        ndr_print_ptr(ndr, "display_name", r->display_name);
16213
 
        ndr->depth++;
16214
 
        if (r->display_name) {
16215
 
                ndr_print_string(ndr, "display_name", r->display_name);
16216
 
        }
16217
 
        ndr->depth--;
16218
 
        ndr_print_uint16(ndr, "lang_id", r->lang_id);
16219
 
        ndr_print_uint16(ndr, "unused", r->unused);
16220
 
        ndr->depth--;
16221
 
}
16222
 
 
16223
 
_PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16224
 
{
16225
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
16226
 
}
16227
 
 
16228
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
16229
 
{
16230
 
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16231
 
        {
16232
 
                uint32_t _flags_save_UNION = ndr->flags;
16233
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16234
 
                if (ndr_flags & NDR_SCALARS) {
16235
 
                        int level = ndr_push_get_switch_value(ndr, r);
16236
 
                        NDR_CHECK(ndr_push_union_align(ndr, 5));
16237
 
                        switch (level) {
16238
 
                                case 1: {
16239
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
16240
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16241
 
                                        NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16242
 
                                break; }
16243
 
 
16244
 
                                case 2: {
16245
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
16246
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16247
 
                                        NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16248
 
                                break; }
16249
 
 
16250
 
                                default: {
16251
 
                                break; }
16252
 
 
16253
 
                        }
16254
 
                }
16255
 
                if (ndr_flags & NDR_BUFFERS) {
16256
 
                        int level = ndr_push_get_switch_value(ndr, r);
16257
 
                        NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16258
 
                        switch (level) {
16259
 
                                case 1:
16260
 
                                        NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16261
 
                                break;
16262
 
 
16263
 
                                case 2:
16264
 
                                        NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16265
 
                                break;
16266
 
 
16267
 
                                default:
16268
 
                                break;
16269
 
 
16270
 
                        }
16271
 
                }
16272
 
                ndr->flags = _flags_save_UNION;
16273
 
        }
16274
 
        ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16275
 
        return NDR_ERR_SUCCESS;
16276
 
}
16277
 
 
16278
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
16279
 
{
16280
 
        uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16281
 
        int level;
16282
 
        {
16283
 
                uint32_t _flags_save_UNION = ndr->flags;
16284
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16285
 
                level = ndr_pull_get_switch_value(ndr, r);
16286
 
                if (ndr_flags & NDR_SCALARS) {
16287
 
                        NDR_CHECK(ndr_pull_union_align(ndr, 5));
16288
 
                        switch (level) {
16289
 
                                case 1: {
16290
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
16291
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16292
 
                                        NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16293
 
                                break; }
16294
 
 
16295
 
                                case 2: {
16296
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
16297
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16298
 
                                        NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16299
 
                                break; }
16300
 
 
16301
 
                                default: {
16302
 
                                break; }
16303
 
 
16304
 
                        }
16305
 
                }
16306
 
                if (ndr_flags & NDR_BUFFERS) {
16307
 
                        NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16308
 
                        switch (level) {
16309
 
                                case 1:
16310
 
                                        NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16311
 
                                break;
16312
 
 
16313
 
                                case 2:
16314
 
                                        NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16315
 
                                break;
16316
 
 
16317
 
                                default:
16318
 
                                break;
16319
 
 
16320
 
                        }
16321
 
                }
16322
 
                ndr->flags = _flags_save_UNION;
16323
 
        }
16324
 
        ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16325
 
        return NDR_ERR_SUCCESS;
16326
 
}
16327
 
 
16328
 
_PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
16329
 
{
16330
 
        int level;
16331
 
        {
16332
 
                uint32_t _flags_save_UNION = ndr->flags;
16333
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16334
 
                level = ndr_print_get_switch_value(ndr, r);
16335
 
                ndr_print_union(ndr, name, level, "spoolss_FormInfo");
16336
 
                switch (level) {
16337
 
                        case 1:
16338
 
                                ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
16339
 
                        break;
16340
 
 
16341
 
                        case 2:
16342
 
                                ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
16343
 
                        break;
16344
 
 
16345
 
                        default:
16346
 
                        break;
16347
 
 
16348
 
                }
16349
 
                ndr->flags = _flags_save_UNION;
16350
 
        }
16351
 
}
16352
 
 
16353
 
_PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
16354
 
{
16355
 
        flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
16356
 
        return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
16357
 
}
16358
 
 
16359
 
static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
16360
 
{
16361
 
        if (ndr_flags & NDR_SCALARS) {
16362
 
                NDR_CHECK(ndr_push_align(ndr, 5));
16363
 
                NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16364
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16365
 
                NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16366
 
                NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16367
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16368
 
        }
16369
 
        if (ndr_flags & NDR_BUFFERS) {
16370
 
                if (r->form_name) {
16371
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16372
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16373
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16374
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16375
 
                }
16376
 
        }
16377
 
        return NDR_ERR_SUCCESS;
16378
 
}
16379
 
 
16380
 
static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
16381
 
{
16382
 
        uint32_t _ptr_form_name;
16383
 
        TALLOC_CTX *_mem_save_form_name_0;
16384
 
        if (ndr_flags & NDR_SCALARS) {
16385
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
16386
 
                NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16387
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16388
 
                if (_ptr_form_name) {
16389
 
                        NDR_PULL_ALLOC(ndr, r->form_name);
16390
 
                } else {
16391
 
                        r->form_name = NULL;
16392
 
                }
16393
 
                NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16394
 
                NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16395
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16396
 
        }
16397
 
        if (ndr_flags & NDR_BUFFERS) {
16398
 
                if (r->form_name) {
16399
 
                        _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16400
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16401
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16402
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16403
 
                        if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16404
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
16405
 
                        }
16406
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16407
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16408
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16409
 
                }
16410
 
        }
16411
 
        return NDR_ERR_SUCCESS;
16412
 
}
16413
 
 
16414
 
_PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
16415
 
{
16416
 
        ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
16417
 
        ndr->depth++;
16418
 
        ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16419
 
        ndr_print_ptr(ndr, "form_name", r->form_name);
16420
 
        ndr->depth++;
16421
 
        if (r->form_name) {
16422
 
                ndr_print_string(ndr, "form_name", r->form_name);
16423
 
        }
16424
 
        ndr->depth--;
16425
 
        ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16426
 
        ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16427
 
        ndr->depth--;
16428
 
}
16429
 
 
16430
 
static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
16431
 
{
16432
 
        if (ndr_flags & NDR_SCALARS) {
16433
 
                NDR_CHECK(ndr_push_align(ndr, 5));
16434
 
                NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16435
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16436
 
                NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16437
 
                NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16438
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
16439
 
                NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16440
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
16441
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16442
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
16443
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
16444
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16445
 
        }
16446
 
        if (ndr_flags & NDR_BUFFERS) {
16447
 
                if (r->form_name) {
16448
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16449
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16450
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16451
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16452
 
                }
16453
 
                if (r->keyword) {
16454
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16455
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16456
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16457
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
16458
 
                }
16459
 
                if (r->mui_dll) {
16460
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16461
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16462
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16463
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16464
 
                }
16465
 
                if (r->display_name) {
16466
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16467
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16468
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16469
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16470
 
                }
16471
 
        }
16472
 
        return NDR_ERR_SUCCESS;
16473
 
}
16474
 
 
16475
 
static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
16476
 
{
16477
 
        uint32_t _ptr_form_name;
16478
 
        TALLOC_CTX *_mem_save_form_name_0;
16479
 
        uint32_t _ptr_keyword;
16480
 
        TALLOC_CTX *_mem_save_keyword_0;
16481
 
        uint32_t _ptr_mui_dll;
16482
 
        TALLOC_CTX *_mem_save_mui_dll_0;
16483
 
        uint32_t _ptr_display_name;
16484
 
        TALLOC_CTX *_mem_save_display_name_0;
16485
 
        if (ndr_flags & NDR_SCALARS) {
16486
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
16487
 
                NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16488
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16489
 
                if (_ptr_form_name) {
16490
 
                        NDR_PULL_ALLOC(ndr, r->form_name);
16491
 
                } else {
16492
 
                        r->form_name = NULL;
16493
 
                }
16494
 
                NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16495
 
                NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16496
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16497
 
                if (_ptr_keyword) {
16498
 
                        NDR_PULL_ALLOC(ndr, r->keyword);
16499
 
                } else {
16500
 
                        r->keyword = NULL;
16501
 
                }
16502
 
                NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16503
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16504
 
                if (_ptr_mui_dll) {
16505
 
                        NDR_PULL_ALLOC(ndr, r->mui_dll);
16506
 
                } else {
16507
 
                        r->mui_dll = NULL;
16508
 
                }
16509
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16510
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16511
 
                if (_ptr_display_name) {
16512
 
                        NDR_PULL_ALLOC(ndr, r->display_name);
16513
 
                } else {
16514
 
                        r->display_name = NULL;
16515
 
                }
16516
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16517
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16518
 
        }
16519
 
        if (ndr_flags & NDR_BUFFERS) {
16520
 
                if (r->form_name) {
16521
 
                        _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16522
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16523
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16524
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16525
 
                        if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16526
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
16527
 
                        }
16528
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16529
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16530
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16531
 
                }
16532
 
                if (r->keyword) {
16533
 
                        _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16534
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16535
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
16536
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
16537
 
                        if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
16538
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->keyword), ndr_get_array_length(ndr, &r->keyword));
16539
 
                        }
16540
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
16541
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
16542
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16543
 
                }
16544
 
                if (r->mui_dll) {
16545
 
                        _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16546
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16547
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16548
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16549
 
                        if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
16550
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->mui_dll), ndr_get_array_length(ndr, &r->mui_dll));
16551
 
                        }
16552
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
16553
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
16554
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16555
 
                }
16556
 
                if (r->display_name) {
16557
 
                        _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16558
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16559
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16560
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16561
 
                        if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
16562
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->display_name), ndr_get_array_length(ndr, &r->display_name));
16563
 
                        }
16564
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
16565
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
16566
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16567
 
                }
16568
 
        }
16569
 
        return NDR_ERR_SUCCESS;
16570
 
}
16571
 
 
16572
 
_PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16573
 
{
16574
 
        ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16575
 
        ndr->depth++;
16576
 
        ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16577
 
        ndr_print_ptr(ndr, "form_name", r->form_name);
16578
 
        ndr->depth++;
16579
 
        if (r->form_name) {
16580
 
                ndr_print_string(ndr, "form_name", r->form_name);
16581
 
        }
16582
 
        ndr->depth--;
16583
 
        ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16584
 
        ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16585
 
        ndr_print_ptr(ndr, "keyword", r->keyword);
16586
 
        ndr->depth++;
16587
 
        if (r->keyword) {
16588
 
                ndr_print_string(ndr, "keyword", r->keyword);
16589
 
        }
16590
 
        ndr->depth--;
16591
 
        ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16592
 
        ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16593
 
        ndr->depth++;
16594
 
        if (r->mui_dll) {
16595
 
                ndr_print_string(ndr, "mui_dll", r->mui_dll);
16596
 
        }
16597
 
        ndr->depth--;
16598
 
        ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16599
 
        ndr_print_ptr(ndr, "display_name", r->display_name);
16600
 
        ndr->depth++;
16601
 
        if (r->display_name) {
16602
 
                ndr_print_string(ndr, "display_name", r->display_name);
16603
 
        }
16604
 
        ndr->depth--;
16605
 
        ndr_print_uint32(ndr, "lang_id", r->lang_id);
16606
 
        ndr->depth--;
16607
 
}
16608
 
 
16609
 
static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
16610
 
{
16611
 
        if (ndr_flags & NDR_SCALARS) {
16612
 
                int level = ndr_push_get_switch_value(ndr, r);
16613
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16614
 
                NDR_CHECK(ndr_push_union_align(ndr, 5));
16615
 
                switch (level) {
16616
 
                        case 1: {
16617
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
16618
 
                        break; }
16619
 
 
16620
 
                        case 2: {
16621
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
16622
 
                        break; }
16623
 
 
16624
 
                        default:
16625
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16626
 
                }
16627
 
        }
16628
 
        if (ndr_flags & NDR_BUFFERS) {
16629
 
                int level = ndr_push_get_switch_value(ndr, r);
16630
 
                switch (level) {
16631
 
                        case 1:
16632
 
                                if (r->info1) {
16633
 
                                        NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16634
 
                                }
16635
 
                        break;
16636
 
 
16637
 
                        case 2:
16638
 
                                if (r->info2) {
16639
 
                                        NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16640
 
                                }
16641
 
                        break;
16642
 
 
16643
 
                        default:
16644
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16645
 
                }
16646
 
        }
16647
 
        return NDR_ERR_SUCCESS;
16648
 
}
16649
 
 
16650
 
static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
16651
 
{
16652
 
        int level;
16653
 
        uint32_t _level;
16654
 
        TALLOC_CTX *_mem_save_info1_0;
16655
 
        TALLOC_CTX *_mem_save_info2_0;
16656
 
        level = ndr_pull_get_switch_value(ndr, r);
16657
 
        if (ndr_flags & NDR_SCALARS) {
16658
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16659
 
                if (_level != level) {
16660
 
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
16661
 
                }
16662
 
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
16663
 
                switch (level) {
16664
 
                        case 1: {
16665
 
                                uint32_t _ptr_info1;
16666
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16667
 
                                if (_ptr_info1) {
16668
 
                                        NDR_PULL_ALLOC(ndr, r->info1);
16669
 
                                } else {
16670
 
                                        r->info1 = NULL;
16671
 
                                }
16672
 
                        break; }
16673
 
 
16674
 
                        case 2: {
16675
 
                                uint32_t _ptr_info2;
16676
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
16677
 
                                if (_ptr_info2) {
16678
 
                                        NDR_PULL_ALLOC(ndr, r->info2);
16679
 
                                } else {
16680
 
                                        r->info2 = NULL;
16681
 
                                }
16682
 
                        break; }
16683
 
 
16684
 
                        default:
16685
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16686
 
                }
16687
 
        }
16688
 
        if (ndr_flags & NDR_BUFFERS) {
16689
 
                switch (level) {
16690
 
                        case 1:
16691
 
                                if (r->info1) {
16692
 
                                        _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16693
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
16694
 
                                        NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16695
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
16696
 
                                }
16697
 
                        break;
16698
 
 
16699
 
                        case 2:
16700
 
                                if (r->info2) {
16701
 
                                        _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
16702
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
16703
 
                                        NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16704
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
16705
 
                                }
16706
 
                        break;
16707
 
 
16708
 
                        default:
16709
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16710
 
                }
16711
 
        }
16712
 
        return NDR_ERR_SUCCESS;
16713
 
}
16714
 
 
16715
 
_PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
16716
 
{
16717
 
        int level;
16718
 
        level = ndr_print_get_switch_value(ndr, r);
16719
 
        ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
16720
 
        switch (level) {
16721
 
                case 1:
16722
 
                        ndr_print_ptr(ndr, "info1", r->info1);
16723
 
                        ndr->depth++;
16724
 
                        if (r->info1) {
16725
 
                                ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
16726
 
                        }
16727
 
                        ndr->depth--;
16728
 
                break;
16729
 
 
16730
 
                case 2:
16731
 
                        ndr_print_ptr(ndr, "info2", r->info2);
16732
 
                        ndr->depth++;
16733
 
                        if (r->info2) {
16734
 
                                ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
16735
 
                        }
16736
 
                        ndr->depth--;
16737
 
                break;
16738
 
 
16739
 
                default:
16740
 
                        ndr_print_bad_level(ndr, name, level);
16741
 
        }
16742
 
}
16743
 
 
16744
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
16745
 
{
16746
 
        if (ndr_flags & NDR_SCALARS) {
16747
 
                NDR_CHECK(ndr_push_align(ndr, 5));
16748
 
                {
16749
 
                        uint32_t _flags_save_string = ndr->flags;
16750
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16751
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16752
 
                        ndr->flags = _flags_save_string;
16753
 
                }
16754
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16755
 
        }
16756
 
        if (ndr_flags & NDR_BUFFERS) {
16757
 
                {
16758
 
                        uint32_t _flags_save_string = ndr->flags;
16759
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16760
 
                        if (r->port_name) {
16761
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
16762
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16763
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
16764
 
                        }
16765
 
                        ndr->flags = _flags_save_string;
16766
 
                }
16767
 
        }
16768
 
        return NDR_ERR_SUCCESS;
16769
 
}
16770
 
 
16771
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
16772
 
{
16773
 
        uint32_t _ptr_port_name;
16774
 
        TALLOC_CTX *_mem_save_port_name_0;
16775
 
        if (ndr_flags & NDR_SCALARS) {
16776
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
16777
 
                {
16778
 
                        uint32_t _flags_save_string = ndr->flags;
16779
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16780
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16781
 
                        if (_ptr_port_name) {
16782
 
                                NDR_PULL_ALLOC(ndr, r->port_name);
16783
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16784
 
                        } else {
16785
 
                                r->port_name = NULL;
16786
 
                        }
16787
 
                        ndr->flags = _flags_save_string;
16788
 
                }
16789
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16790
 
        }
16791
 
        if (ndr_flags & NDR_BUFFERS) {
16792
 
                {
16793
 
                        uint32_t _flags_save_string = ndr->flags;
16794
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16795
 
                        if (r->port_name) {
16796
 
                                uint32_t _relative_save_offset;
16797
 
                                _relative_save_offset = ndr->offset;
16798
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16799
 
                                _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16800
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16801
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16802
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16803
 
                                ndr->offset = _relative_save_offset;
16804
 
                        }
16805
 
                        ndr->flags = _flags_save_string;
16806
 
                }
16807
 
        }
16808
 
        return NDR_ERR_SUCCESS;
16809
 
}
16810
 
 
16811
 
_PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
16812
 
{
16813
 
        ndr_print_struct(ndr, name, "spoolss_PortInfo1");
16814
 
        ndr->depth++;
16815
 
        ndr_print_ptr(ndr, "port_name", r->port_name);
16816
 
        ndr->depth++;
16817
 
        if (r->port_name) {
16818
 
                ndr_print_string(ndr, "port_name", r->port_name);
16819
 
        }
16820
 
        ndr->depth--;
16821
 
        ndr->depth--;
16822
 
}
16823
 
 
16824
 
_PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16825
 
{
16826
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
16827
 
}
16828
 
 
16829
 
static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16830
 
{
16831
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16832
 
        return NDR_ERR_SUCCESS;
16833
 
}
16834
 
 
16835
 
static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16836
 
{
16837
 
        uint32_t v;
16838
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16839
 
        *r = v;
16840
 
        return NDR_ERR_SUCCESS;
16841
 
}
16842
 
 
16843
 
_PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
16844
 
{
16845
 
        ndr_print_uint32(ndr, name, r);
16846
 
        ndr->depth++;
16847
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
16848
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
16849
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
16850
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
16851
 
        ndr->depth--;
16852
 
}
16853
 
 
16854
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
16855
 
{
16856
 
        if (ndr_flags & NDR_SCALARS) {
16857
 
                NDR_CHECK(ndr_push_align(ndr, 5));
16858
 
                {
16859
 
                        uint32_t _flags_save_string = ndr->flags;
16860
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16861
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16862
 
                        ndr->flags = _flags_save_string;
16863
 
                }
16864
 
                {
16865
 
                        uint32_t _flags_save_string = ndr->flags;
16866
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16867
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16868
 
                        ndr->flags = _flags_save_string;
16869
 
                }
16870
 
                {
16871
 
                        uint32_t _flags_save_string = ndr->flags;
16872
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16873
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
16874
 
                        ndr->flags = _flags_save_string;
16875
 
                }
16876
 
                NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
16877
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
16878
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16879
 
        }
16880
 
        if (ndr_flags & NDR_BUFFERS) {
16881
 
                {
16882
 
                        uint32_t _flags_save_string = ndr->flags;
16883
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16884
 
                        if (r->port_name) {
16885
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
16886
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16887
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
16888
 
                        }
16889
 
                        ndr->flags = _flags_save_string;
16890
 
                }
16891
 
                {
16892
 
                        uint32_t _flags_save_string = ndr->flags;
16893
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16894
 
                        if (r->monitor_name) {
16895
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
16896
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16897
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
16898
 
                        }
16899
 
                        ndr->flags = _flags_save_string;
16900
 
                }
16901
 
                {
16902
 
                        uint32_t _flags_save_string = ndr->flags;
16903
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16904
 
                        if (r->description) {
16905
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
16906
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
16907
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
16908
 
                        }
16909
 
                        ndr->flags = _flags_save_string;
16910
 
                }
16911
 
        }
16912
 
        return NDR_ERR_SUCCESS;
16913
 
}
16914
 
 
16915
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
16916
 
{
16917
 
        uint32_t _ptr_port_name;
16918
 
        TALLOC_CTX *_mem_save_port_name_0;
16919
 
        uint32_t _ptr_monitor_name;
16920
 
        TALLOC_CTX *_mem_save_monitor_name_0;
16921
 
        uint32_t _ptr_description;
16922
 
        TALLOC_CTX *_mem_save_description_0;
16923
 
        if (ndr_flags & NDR_SCALARS) {
16924
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
16925
 
                {
16926
 
                        uint32_t _flags_save_string = ndr->flags;
16927
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16928
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16929
 
                        if (_ptr_port_name) {
16930
 
                                NDR_PULL_ALLOC(ndr, r->port_name);
16931
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16932
 
                        } else {
16933
 
                                r->port_name = NULL;
16934
 
                        }
16935
 
                        ndr->flags = _flags_save_string;
16936
 
                }
16937
 
                {
16938
 
                        uint32_t _flags_save_string = ndr->flags;
16939
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16940
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16941
 
                        if (_ptr_monitor_name) {
16942
 
                                NDR_PULL_ALLOC(ndr, r->monitor_name);
16943
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16944
 
                        } else {
16945
 
                                r->monitor_name = NULL;
16946
 
                        }
16947
 
                        ndr->flags = _flags_save_string;
16948
 
                }
16949
 
                {
16950
 
                        uint32_t _flags_save_string = ndr->flags;
16951
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16952
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
16953
 
                        if (_ptr_description) {
16954
 
                                NDR_PULL_ALLOC(ndr, r->description);
16955
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
16956
 
                        } else {
16957
 
                                r->description = NULL;
16958
 
                        }
16959
 
                        ndr->flags = _flags_save_string;
16960
 
                }
16961
 
                NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
16962
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
16963
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16964
 
        }
16965
 
        if (ndr_flags & NDR_BUFFERS) {
16966
 
                {
16967
 
                        uint32_t _flags_save_string = ndr->flags;
16968
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16969
 
                        if (r->port_name) {
16970
 
                                uint32_t _relative_save_offset;
16971
 
                                _relative_save_offset = ndr->offset;
16972
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16973
 
                                _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16974
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16975
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16976
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16977
 
                                ndr->offset = _relative_save_offset;
16978
 
                        }
16979
 
                        ndr->flags = _flags_save_string;
16980
 
                }
16981
 
                {
16982
 
                        uint32_t _flags_save_string = ndr->flags;
16983
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16984
 
                        if (r->monitor_name) {
16985
 
                                uint32_t _relative_save_offset;
16986
 
                                _relative_save_offset = ndr->offset;
16987
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16988
 
                                _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16989
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16990
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16991
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16992
 
                                ndr->offset = _relative_save_offset;
16993
 
                        }
16994
 
                        ndr->flags = _flags_save_string;
16995
 
                }
16996
 
                {
16997
 
                        uint32_t _flags_save_string = ndr->flags;
16998
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
16999
 
                        if (r->description) {
17000
 
                                uint32_t _relative_save_offset;
17001
 
                                _relative_save_offset = ndr->offset;
17002
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
17003
 
                                _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
17004
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
17005
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
17006
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
17007
 
                                ndr->offset = _relative_save_offset;
17008
 
                        }
17009
 
                        ndr->flags = _flags_save_string;
17010
 
                }
17011
 
        }
17012
 
        return NDR_ERR_SUCCESS;
17013
 
}
17014
 
 
17015
 
_PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
17016
 
{
17017
 
        ndr_print_struct(ndr, name, "spoolss_PortInfo2");
17018
 
        ndr->depth++;
17019
 
        ndr_print_ptr(ndr, "port_name", r->port_name);
17020
 
        ndr->depth++;
17021
 
        if (r->port_name) {
17022
 
                ndr_print_string(ndr, "port_name", r->port_name);
17023
 
        }
17024
 
        ndr->depth--;
17025
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17026
 
        ndr->depth++;
17027
 
        if (r->monitor_name) {
17028
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
17029
 
        }
17030
 
        ndr->depth--;
17031
 
        ndr_print_ptr(ndr, "description", r->description);
17032
 
        ndr->depth++;
17033
 
        if (r->description) {
17034
 
                ndr_print_string(ndr, "description", r->description);
17035
 
        }
17036
 
        ndr->depth--;
17037
 
        ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
17038
 
        ndr_print_uint32(ndr, "reserved", r->reserved);
17039
 
        ndr->depth--;
17040
 
}
17041
 
 
17042
 
_PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17043
 
{
17044
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
17045
 
}
17046
 
 
17047
 
static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
17048
 
{
17049
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17050
 
        return NDR_ERR_SUCCESS;
17051
 
}
17052
 
 
17053
 
static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
17054
 
{
17055
 
        uint32_t v;
17056
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17057
 
        *r = v;
17058
 
        return NDR_ERR_SUCCESS;
17059
 
}
17060
 
 
17061
 
_PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
17062
 
{
17063
 
        const char *val = NULL;
17064
 
 
17065
 
        switch (r) {
17066
 
                case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
17067
 
                case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
17068
 
                case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
17069
 
                case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
17070
 
                case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
17071
 
                case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
17072
 
                case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
17073
 
                case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
17074
 
                case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
17075
 
                case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
17076
 
                case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
17077
 
                case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
17078
 
                case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
17079
 
        }
17080
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
17081
 
}
17082
 
 
17083
 
static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
17084
 
{
17085
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17086
 
        return NDR_ERR_SUCCESS;
17087
 
}
17088
 
 
17089
 
static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
17090
 
{
17091
 
        uint32_t v;
17092
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17093
 
        *r = v;
17094
 
        return NDR_ERR_SUCCESS;
17095
 
}
17096
 
 
17097
 
_PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
17098
 
{
17099
 
        const char *val = NULL;
17100
 
 
17101
 
        switch (r) {
17102
 
                case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
17103
 
                case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
17104
 
                case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
17105
 
        }
17106
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
17107
 
}
17108
 
 
17109
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
17110
 
{
17111
 
        if (ndr_flags & NDR_SCALARS) {
17112
 
                NDR_CHECK(ndr_push_align(ndr, 5));
17113
 
                NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
17114
 
                {
17115
 
                        uint32_t _flags_save_string = ndr->flags;
17116
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17117
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
17118
 
                        ndr->flags = _flags_save_string;
17119
 
                }
17120
 
                NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
17121
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17122
 
        }
17123
 
        if (ndr_flags & NDR_BUFFERS) {
17124
 
                {
17125
 
                        uint32_t _flags_save_string = ndr->flags;
17126
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17127
 
                        if (r->status_string) {
17128
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->status_string));
17129
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
17130
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->status_string));
17131
 
                        }
17132
 
                        ndr->flags = _flags_save_string;
17133
 
                }
17134
 
        }
17135
 
        return NDR_ERR_SUCCESS;
17136
 
}
17137
 
 
17138
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
17139
 
{
17140
 
        uint32_t _ptr_status_string;
17141
 
        TALLOC_CTX *_mem_save_status_string_0;
17142
 
        if (ndr_flags & NDR_SCALARS) {
17143
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
17144
 
                NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
17145
 
                {
17146
 
                        uint32_t _flags_save_string = ndr->flags;
17147
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17148
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
17149
 
                        if (_ptr_status_string) {
17150
 
                                NDR_PULL_ALLOC(ndr, r->status_string);
17151
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
17152
 
                        } else {
17153
 
                                r->status_string = NULL;
17154
 
                        }
17155
 
                        ndr->flags = _flags_save_string;
17156
 
                }
17157
 
                NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
17158
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17159
 
        }
17160
 
        if (ndr_flags & NDR_BUFFERS) {
17161
 
                {
17162
 
                        uint32_t _flags_save_string = ndr->flags;
17163
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17164
 
                        if (r->status_string) {
17165
 
                                uint32_t _relative_save_offset;
17166
 
                                _relative_save_offset = ndr->offset;
17167
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
17168
 
                                _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17169
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
17170
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
17171
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
17172
 
                                ndr->offset = _relative_save_offset;
17173
 
                        }
17174
 
                        ndr->flags = _flags_save_string;
17175
 
                }
17176
 
        }
17177
 
        return NDR_ERR_SUCCESS;
17178
 
}
17179
 
 
17180
 
_PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
17181
 
{
17182
 
        ndr_print_struct(ndr, name, "spoolss_PortInfo3");
17183
 
        ndr->depth++;
17184
 
        ndr_print_spoolss_PortStatus(ndr, "status", r->status);
17185
 
        ndr_print_ptr(ndr, "status_string", r->status_string);
17186
 
        ndr->depth++;
17187
 
        if (r->status_string) {
17188
 
                ndr_print_string(ndr, "status_string", r->status_string);
17189
 
        }
17190
 
        ndr->depth--;
17191
 
        ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
17192
 
        ndr->depth--;
17193
 
}
17194
 
 
17195
 
_PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
17196
 
{
17197
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
17198
 
}
17199
 
 
17200
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
17201
 
{
17202
 
        if (ndr_flags & NDR_SCALARS) {
17203
 
                NDR_CHECK(ndr_push_align(ndr, 5));
17204
 
                {
17205
 
                        uint32_t _flags_save_string = ndr->flags;
17206
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17207
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17208
 
                        ndr->flags = _flags_save_string;
17209
 
                }
17210
 
                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
17211
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17212
 
        }
17213
 
        if (ndr_flags & NDR_BUFFERS) {
17214
 
                {
17215
 
                        uint32_t _flags_save_string = ndr->flags;
17216
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17217
 
                        if (r->port_name) {
17218
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17219
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17220
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17221
 
                        }
17222
 
                        ndr->flags = _flags_save_string;
17223
 
                }
17224
 
        }
17225
 
        return NDR_ERR_SUCCESS;
17226
 
}
17227
 
 
17228
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
17229
 
{
17230
 
        uint32_t _ptr_port_name;
17231
 
        TALLOC_CTX *_mem_save_port_name_0;
17232
 
        if (ndr_flags & NDR_SCALARS) {
17233
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
17234
 
                {
17235
 
                        uint32_t _flags_save_string = ndr->flags;
17236
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17237
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17238
 
                        if (_ptr_port_name) {
17239
 
                                NDR_PULL_ALLOC(ndr, r->port_name);
17240
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17241
 
                        } else {
17242
 
                                r->port_name = NULL;
17243
 
                        }
17244
 
                        ndr->flags = _flags_save_string;
17245
 
                }
17246
 
                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
17247
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17248
 
        }
17249
 
        if (ndr_flags & NDR_BUFFERS) {
17250
 
                {
17251
 
                        uint32_t _flags_save_string = ndr->flags;
17252
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17253
 
                        if (r->port_name) {
17254
 
                                uint32_t _relative_save_offset;
17255
 
                                _relative_save_offset = ndr->offset;
17256
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17257
 
                                _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17258
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17259
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17260
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17261
 
                                ndr->offset = _relative_save_offset;
17262
 
                        }
17263
 
                        ndr->flags = _flags_save_string;
17264
 
                }
17265
 
        }
17266
 
        return NDR_ERR_SUCCESS;
17267
 
}
17268
 
 
17269
 
_PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
17270
 
{
17271
 
        ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
17272
 
        ndr->depth++;
17273
 
        ndr_print_ptr(ndr, "port_name", r->port_name);
17274
 
        ndr->depth++;
17275
 
        if (r->port_name) {
17276
 
                ndr_print_string(ndr, "port_name", r->port_name);
17277
 
        }
17278
 
        ndr->depth--;
17279
 
        ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
17280
 
        ndr->depth--;
17281
 
}
17282
 
 
17283
 
_PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
17284
 
{
17285
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
17286
 
}
17287
 
 
17288
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
17289
 
{
17290
 
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17291
 
        {
17292
 
                uint32_t _flags_save_UNION = ndr->flags;
17293
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17294
 
                if (ndr_flags & NDR_SCALARS) {
17295
 
                        int level = ndr_push_get_switch_value(ndr, r);
17296
 
                        NDR_CHECK(ndr_push_union_align(ndr, 5));
17297
 
                        switch (level) {
17298
 
                                case 1: {
17299
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
17300
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17301
 
                                        NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17302
 
                                break; }
17303
 
 
17304
 
                                case 2: {
17305
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
17306
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17307
 
                                        NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17308
 
                                break; }
17309
 
 
17310
 
                                case 3: {
17311
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
17312
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17313
 
                                        NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17314
 
                                break; }
17315
 
 
17316
 
                                case 0xff: {
17317
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
17318
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17319
 
                                        NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17320
 
                                break; }
17321
 
 
17322
 
                                default: {
17323
 
                                break; }
17324
 
 
17325
 
                        }
17326
 
                }
17327
 
                if (ndr_flags & NDR_BUFFERS) {
17328
 
                        int level = ndr_push_get_switch_value(ndr, r);
17329
 
                        NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17330
 
                        switch (level) {
17331
 
                                case 1:
17332
 
                                        NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17333
 
                                break;
17334
 
 
17335
 
                                case 2:
17336
 
                                        NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17337
 
                                break;
17338
 
 
17339
 
                                case 3:
17340
 
                                        NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17341
 
                                break;
17342
 
 
17343
 
                                case 0xff:
17344
 
                                        NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17345
 
                                break;
17346
 
 
17347
 
                                default:
17348
 
                                break;
17349
 
 
17350
 
                        }
17351
 
                }
17352
 
                ndr->flags = _flags_save_UNION;
17353
 
        }
17354
 
        ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17355
 
        return NDR_ERR_SUCCESS;
17356
 
}
17357
 
 
17358
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
17359
 
{
17360
 
        uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17361
 
        int level;
17362
 
        {
17363
 
                uint32_t _flags_save_UNION = ndr->flags;
17364
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17365
 
                level = ndr_pull_get_switch_value(ndr, r);
17366
 
                if (ndr_flags & NDR_SCALARS) {
17367
 
                        NDR_CHECK(ndr_pull_union_align(ndr, 5));
17368
 
                        switch (level) {
17369
 
                                case 1: {
17370
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
17371
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17372
 
                                        NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17373
 
                                break; }
17374
 
 
17375
 
                                case 2: {
17376
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
17377
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17378
 
                                        NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17379
 
                                break; }
17380
 
 
17381
 
                                case 3: {
17382
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
17383
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17384
 
                                        NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17385
 
                                break; }
17386
 
 
17387
 
                                case 0xff: {
17388
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
17389
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17390
 
                                        NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17391
 
                                break; }
17392
 
 
17393
 
                                default: {
17394
 
                                break; }
17395
 
 
17396
 
                        }
17397
 
                }
17398
 
                if (ndr_flags & NDR_BUFFERS) {
17399
 
                        NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17400
 
                        switch (level) {
17401
 
                                case 1:
17402
 
                                        NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17403
 
                                break;
17404
 
 
17405
 
                                case 2:
17406
 
                                        NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17407
 
                                break;
17408
 
 
17409
 
                                case 3:
17410
 
                                        NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17411
 
                                break;
17412
 
 
17413
 
                                case 0xff:
17414
 
                                        NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17415
 
                                break;
17416
 
 
17417
 
                                default:
17418
 
                                break;
17419
 
 
17420
 
                        }
17421
 
                }
17422
 
                ndr->flags = _flags_save_UNION;
17423
 
        }
17424
 
        ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17425
 
        return NDR_ERR_SUCCESS;
17426
 
}
17427
 
 
17428
 
_PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
17429
 
{
17430
 
        int level;
17431
 
        {
17432
 
                uint32_t _flags_save_UNION = ndr->flags;
17433
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17434
 
                level = ndr_print_get_switch_value(ndr, r);
17435
 
                ndr_print_union(ndr, name, level, "spoolss_PortInfo");
17436
 
                switch (level) {
17437
 
                        case 1:
17438
 
                                ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
17439
 
                        break;
17440
 
 
17441
 
                        case 2:
17442
 
                                ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
17443
 
                        break;
17444
 
 
17445
 
                        case 3:
17446
 
                                ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
17447
 
                        break;
17448
 
 
17449
 
                        case 0xff:
17450
 
                                ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
17451
 
                        break;
17452
 
 
17453
 
                        default:
17454
 
                        break;
17455
 
 
17456
 
                }
17457
 
                ndr->flags = _flags_save_UNION;
17458
 
        }
17459
 
}
17460
 
 
17461
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
17462
 
{
17463
 
        if (ndr_flags & NDR_SCALARS) {
17464
 
                NDR_CHECK(ndr_push_align(ndr, 5));
17465
 
                {
17466
 
                        uint32_t _flags_save_string = ndr->flags;
17467
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17468
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17469
 
                        ndr->flags = _flags_save_string;
17470
 
                }
17471
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17472
 
        }
17473
 
        if (ndr_flags & NDR_BUFFERS) {
17474
 
                {
17475
 
                        uint32_t _flags_save_string = ndr->flags;
17476
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17477
 
                        if (r->monitor_name) {
17478
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17479
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17480
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17481
 
                        }
17482
 
                        ndr->flags = _flags_save_string;
17483
 
                }
17484
 
        }
17485
 
        return NDR_ERR_SUCCESS;
17486
 
}
17487
 
 
17488
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
17489
 
{
17490
 
        uint32_t _ptr_monitor_name;
17491
 
        TALLOC_CTX *_mem_save_monitor_name_0;
17492
 
        if (ndr_flags & NDR_SCALARS) {
17493
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
17494
 
                {
17495
 
                        uint32_t _flags_save_string = ndr->flags;
17496
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17497
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17498
 
                        if (_ptr_monitor_name) {
17499
 
                                NDR_PULL_ALLOC(ndr, r->monitor_name);
17500
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17501
 
                        } else {
17502
 
                                r->monitor_name = NULL;
17503
 
                        }
17504
 
                        ndr->flags = _flags_save_string;
17505
 
                }
17506
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17507
 
        }
17508
 
        if (ndr_flags & NDR_BUFFERS) {
17509
 
                {
17510
 
                        uint32_t _flags_save_string = ndr->flags;
17511
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17512
 
                        if (r->monitor_name) {
17513
 
                                uint32_t _relative_save_offset;
17514
 
                                _relative_save_offset = ndr->offset;
17515
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17516
 
                                _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17517
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17518
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17519
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17520
 
                                ndr->offset = _relative_save_offset;
17521
 
                        }
17522
 
                        ndr->flags = _flags_save_string;
17523
 
                }
17524
 
        }
17525
 
        return NDR_ERR_SUCCESS;
17526
 
}
17527
 
 
17528
 
_PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
17529
 
{
17530
 
        ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
17531
 
        ndr->depth++;
17532
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17533
 
        ndr->depth++;
17534
 
        if (r->monitor_name) {
17535
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
17536
 
        }
17537
 
        ndr->depth--;
17538
 
        ndr->depth--;
17539
 
}
17540
 
 
17541
 
_PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17542
 
{
17543
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
17544
 
}
17545
 
 
17546
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
17547
 
{
17548
 
        if (ndr_flags & NDR_SCALARS) {
17549
 
                NDR_CHECK(ndr_push_align(ndr, 5));
17550
 
                {
17551
 
                        uint32_t _flags_save_string = ndr->flags;
17552
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17553
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17554
 
                        ndr->flags = _flags_save_string;
17555
 
                }
17556
 
                {
17557
 
                        uint32_t _flags_save_string = ndr->flags;
17558
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17559
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
17560
 
                        ndr->flags = _flags_save_string;
17561
 
                }
17562
 
                {
17563
 
                        uint32_t _flags_save_string = ndr->flags;
17564
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17565
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
17566
 
                        ndr->flags = _flags_save_string;
17567
 
                }
17568
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17569
 
        }
17570
 
        if (ndr_flags & NDR_BUFFERS) {
17571
 
                {
17572
 
                        uint32_t _flags_save_string = ndr->flags;
17573
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17574
 
                        if (r->monitor_name) {
17575
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17576
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17577
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17578
 
                        }
17579
 
                        ndr->flags = _flags_save_string;
17580
 
                }
17581
 
                {
17582
 
                        uint32_t _flags_save_string = ndr->flags;
17583
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17584
 
                        if (r->environment) {
17585
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->environment));
17586
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
17587
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->environment));
17588
 
                        }
17589
 
                        ndr->flags = _flags_save_string;
17590
 
                }
17591
 
                {
17592
 
                        uint32_t _flags_save_string = ndr->flags;
17593
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17594
 
                        if (r->dll_name) {
17595
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dll_name));
17596
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
17597
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dll_name));
17598
 
                        }
17599
 
                        ndr->flags = _flags_save_string;
17600
 
                }
17601
 
        }
17602
 
        return NDR_ERR_SUCCESS;
17603
 
}
17604
 
 
17605
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
17606
 
{
17607
 
        uint32_t _ptr_monitor_name;
17608
 
        TALLOC_CTX *_mem_save_monitor_name_0;
17609
 
        uint32_t _ptr_environment;
17610
 
        TALLOC_CTX *_mem_save_environment_0;
17611
 
        uint32_t _ptr_dll_name;
17612
 
        TALLOC_CTX *_mem_save_dll_name_0;
17613
 
        if (ndr_flags & NDR_SCALARS) {
17614
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
17615
 
                {
17616
 
                        uint32_t _flags_save_string = ndr->flags;
17617
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17618
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17619
 
                        if (_ptr_monitor_name) {
17620
 
                                NDR_PULL_ALLOC(ndr, r->monitor_name);
17621
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17622
 
                        } else {
17623
 
                                r->monitor_name = NULL;
17624
 
                        }
17625
 
                        ndr->flags = _flags_save_string;
17626
 
                }
17627
 
                {
17628
 
                        uint32_t _flags_save_string = ndr->flags;
17629
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17630
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17631
 
                        if (_ptr_environment) {
17632
 
                                NDR_PULL_ALLOC(ndr, r->environment);
17633
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
17634
 
                        } else {
17635
 
                                r->environment = NULL;
17636
 
                        }
17637
 
                        ndr->flags = _flags_save_string;
17638
 
                }
17639
 
                {
17640
 
                        uint32_t _flags_save_string = ndr->flags;
17641
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17642
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
17643
 
                        if (_ptr_dll_name) {
17644
 
                                NDR_PULL_ALLOC(ndr, r->dll_name);
17645
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
17646
 
                        } else {
17647
 
                                r->dll_name = NULL;
17648
 
                        }
17649
 
                        ndr->flags = _flags_save_string;
17650
 
                }
17651
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17652
 
        }
17653
 
        if (ndr_flags & NDR_BUFFERS) {
17654
 
                {
17655
 
                        uint32_t _flags_save_string = ndr->flags;
17656
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17657
 
                        if (r->monitor_name) {
17658
 
                                uint32_t _relative_save_offset;
17659
 
                                _relative_save_offset = ndr->offset;
17660
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17661
 
                                _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17662
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17663
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17664
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17665
 
                                ndr->offset = _relative_save_offset;
17666
 
                        }
17667
 
                        ndr->flags = _flags_save_string;
17668
 
                }
17669
 
                {
17670
 
                        uint32_t _flags_save_string = ndr->flags;
17671
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17672
 
                        if (r->environment) {
17673
 
                                uint32_t _relative_save_offset;
17674
 
                                _relative_save_offset = ndr->offset;
17675
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
17676
 
                                _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17677
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
17678
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
17679
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17680
 
                                ndr->offset = _relative_save_offset;
17681
 
                        }
17682
 
                        ndr->flags = _flags_save_string;
17683
 
                }
17684
 
                {
17685
 
                        uint32_t _flags_save_string = ndr->flags;
17686
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17687
 
                        if (r->dll_name) {
17688
 
                                uint32_t _relative_save_offset;
17689
 
                                _relative_save_offset = ndr->offset;
17690
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
17691
 
                                _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17692
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
17693
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
17694
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
17695
 
                                ndr->offset = _relative_save_offset;
17696
 
                        }
17697
 
                        ndr->flags = _flags_save_string;
17698
 
                }
17699
 
        }
17700
 
        return NDR_ERR_SUCCESS;
17701
 
}
17702
 
 
17703
 
_PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
17704
 
{
17705
 
        ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
17706
 
        ndr->depth++;
17707
 
        ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17708
 
        ndr->depth++;
17709
 
        if (r->monitor_name) {
17710
 
                ndr_print_string(ndr, "monitor_name", r->monitor_name);
17711
 
        }
17712
 
        ndr->depth--;
17713
 
        ndr_print_ptr(ndr, "environment", r->environment);
17714
 
        ndr->depth++;
17715
 
        if (r->environment) {
17716
 
                ndr_print_string(ndr, "environment", r->environment);
17717
 
        }
17718
 
        ndr->depth--;
17719
 
        ndr_print_ptr(ndr, "dll_name", r->dll_name);
17720
 
        ndr->depth++;
17721
 
        if (r->dll_name) {
17722
 
                ndr_print_string(ndr, "dll_name", r->dll_name);
17723
 
        }
17724
 
        ndr->depth--;
17725
 
        ndr->depth--;
17726
 
}
17727
 
 
17728
 
_PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17729
 
{
17730
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
17731
 
}
17732
 
 
17733
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
17734
 
{
17735
 
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17736
 
        {
17737
 
                uint32_t _flags_save_UNION = ndr->flags;
17738
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17739
 
                if (ndr_flags & NDR_SCALARS) {
17740
 
                        int level = ndr_push_get_switch_value(ndr, r);
17741
 
                        NDR_CHECK(ndr_push_union_align(ndr, 5));
17742
 
                        switch (level) {
17743
 
                                case 1: {
17744
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
17745
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17746
 
                                        NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17747
 
                                break; }
17748
 
 
17749
 
                                case 2: {
17750
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
17751
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17752
 
                                        NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17753
 
                                break; }
17754
 
 
17755
 
                                default: {
17756
 
                                break; }
17757
 
 
17758
 
                        }
17759
 
                }
17760
 
                if (ndr_flags & NDR_BUFFERS) {
17761
 
                        int level = ndr_push_get_switch_value(ndr, r);
17762
 
                        NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17763
 
                        switch (level) {
17764
 
                                case 1:
17765
 
                                        NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17766
 
                                break;
17767
 
 
17768
 
                                case 2:
17769
 
                                        NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17770
 
                                break;
17771
 
 
17772
 
                                default:
17773
 
                                break;
17774
 
 
17775
 
                        }
17776
 
                }
17777
 
                ndr->flags = _flags_save_UNION;
17778
 
        }
17779
 
        ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17780
 
        return NDR_ERR_SUCCESS;
17781
 
}
17782
 
 
17783
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
17784
 
{
17785
 
        uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17786
 
        int level;
17787
 
        {
17788
 
                uint32_t _flags_save_UNION = ndr->flags;
17789
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17790
 
                level = ndr_pull_get_switch_value(ndr, r);
17791
 
                if (ndr_flags & NDR_SCALARS) {
17792
 
                        NDR_CHECK(ndr_pull_union_align(ndr, 5));
17793
 
                        switch (level) {
17794
 
                                case 1: {
17795
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
17796
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17797
 
                                        NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17798
 
                                break; }
17799
 
 
17800
 
                                case 2: {
17801
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
17802
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17803
 
                                        NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17804
 
                                break; }
17805
 
 
17806
 
                                default: {
17807
 
                                break; }
17808
 
 
17809
 
                        }
17810
 
                }
17811
 
                if (ndr_flags & NDR_BUFFERS) {
17812
 
                        NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17813
 
                        switch (level) {
17814
 
                                case 1:
17815
 
                                        NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17816
 
                                break;
17817
 
 
17818
 
                                case 2:
17819
 
                                        NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17820
 
                                break;
17821
 
 
17822
 
                                default:
17823
 
                                break;
17824
 
 
17825
 
                        }
17826
 
                }
17827
 
                ndr->flags = _flags_save_UNION;
17828
 
        }
17829
 
        ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17830
 
        return NDR_ERR_SUCCESS;
17831
 
}
17832
 
 
17833
 
_PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
17834
 
{
17835
 
        int level;
17836
 
        {
17837
 
                uint32_t _flags_save_UNION = ndr->flags;
17838
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17839
 
                level = ndr_print_get_switch_value(ndr, r);
17840
 
                ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
17841
 
                switch (level) {
17842
 
                        case 1:
17843
 
                                ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
17844
 
                        break;
17845
 
 
17846
 
                        case 2:
17847
 
                                ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
17848
 
                        break;
17849
 
 
17850
 
                        default:
17851
 
                        break;
17852
 
 
17853
 
                }
17854
 
                ndr->flags = _flags_save_UNION;
17855
 
        }
17856
 
}
17857
 
 
17858
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
17859
 
{
17860
 
        if (ndr_flags & NDR_SCALARS) {
17861
 
                NDR_CHECK(ndr_push_align(ndr, 5));
17862
 
                {
17863
 
                        uint32_t _flags_save_string = ndr->flags;
17864
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17865
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
17866
 
                        ndr->flags = _flags_save_string;
17867
 
                }
17868
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17869
 
        }
17870
 
        if (ndr_flags & NDR_BUFFERS) {
17871
 
                {
17872
 
                        uint32_t _flags_save_string = ndr->flags;
17873
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17874
 
                        if (r->name_array) {
17875
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name_array));
17876
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
17877
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name_array));
17878
 
                        }
17879
 
                        ndr->flags = _flags_save_string;
17880
 
                }
17881
 
        }
17882
 
        return NDR_ERR_SUCCESS;
17883
 
}
17884
 
 
17885
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
17886
 
{
17887
 
        uint32_t _ptr_name_array;
17888
 
        TALLOC_CTX *_mem_save_name_array_0;
17889
 
        if (ndr_flags & NDR_SCALARS) {
17890
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
17891
 
                {
17892
 
                        uint32_t _flags_save_string = ndr->flags;
17893
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17894
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
17895
 
                        if (_ptr_name_array) {
17896
 
                                NDR_PULL_ALLOC(ndr, r->name_array);
17897
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
17898
 
                        } else {
17899
 
                                r->name_array = NULL;
17900
 
                        }
17901
 
                        ndr->flags = _flags_save_string;
17902
 
                }
17903
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17904
 
        }
17905
 
        if (ndr_flags & NDR_BUFFERS) {
17906
 
                {
17907
 
                        uint32_t _flags_save_string = ndr->flags;
17908
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
17909
 
                        if (r->name_array) {
17910
 
                                uint32_t _relative_save_offset;
17911
 
                                _relative_save_offset = ndr->offset;
17912
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
17913
 
                                _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
17914
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
17915
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
17916
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
17917
 
                                ndr->offset = _relative_save_offset;
17918
 
                        }
17919
 
                        ndr->flags = _flags_save_string;
17920
 
                }
17921
 
        }
17922
 
        return NDR_ERR_SUCCESS;
17923
 
}
17924
 
 
17925
 
_PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
17926
 
{
17927
 
        ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
17928
 
        ndr->depth++;
17929
 
        ndr_print_ptr(ndr, "name_array", r->name_array);
17930
 
        ndr->depth++;
17931
 
        if (r->name_array) {
17932
 
                ndr_print_string(ndr, "name_array", r->name_array);
17933
 
        }
17934
 
        ndr->depth--;
17935
 
        ndr->depth--;
17936
 
}
17937
 
 
17938
 
_PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17939
 
{
17940
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
17941
 
}
17942
 
 
17943
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
17944
 
{
17945
 
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17946
 
        {
17947
 
                uint32_t _flags_save_UNION = ndr->flags;
17948
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17949
 
                if (ndr_flags & NDR_SCALARS) {
17950
 
                        int level = ndr_push_get_switch_value(ndr, r);
17951
 
                        NDR_CHECK(ndr_push_union_align(ndr, 5));
17952
 
                        switch (level) {
17953
 
                                case 1: {
17954
 
                                        NDR_CHECK(ndr_push_align(ndr, 5));
17955
 
                                        NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17956
 
                                        NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17957
 
                                break; }
17958
 
 
17959
 
                                default: {
17960
 
                                break; }
17961
 
 
17962
 
                        }
17963
 
                }
17964
 
                if (ndr_flags & NDR_BUFFERS) {
17965
 
                        int level = ndr_push_get_switch_value(ndr, r);
17966
 
                        NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17967
 
                        switch (level) {
17968
 
                                case 1:
17969
 
                                        NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
17970
 
                                break;
17971
 
 
17972
 
                                default:
17973
 
                                break;
17974
 
 
17975
 
                        }
17976
 
                }
17977
 
                ndr->flags = _flags_save_UNION;
17978
 
        }
17979
 
        ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17980
 
        return NDR_ERR_SUCCESS;
17981
 
}
17982
 
 
17983
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
17984
 
{
17985
 
        uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17986
 
        int level;
17987
 
        {
17988
 
                uint32_t _flags_save_UNION = ndr->flags;
17989
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17990
 
                level = ndr_pull_get_switch_value(ndr, r);
17991
 
                if (ndr_flags & NDR_SCALARS) {
17992
 
                        NDR_CHECK(ndr_pull_union_align(ndr, 5));
17993
 
                        switch (level) {
17994
 
                                case 1: {
17995
 
                                        NDR_CHECK(ndr_pull_align(ndr, 5));
17996
 
                                        NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17997
 
                                        NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
17998
 
                                break; }
17999
 
 
18000
 
                                default: {
18001
 
                                break; }
18002
 
 
18003
 
                        }
18004
 
                }
18005
 
                if (ndr_flags & NDR_BUFFERS) {
18006
 
                        NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18007
 
                        switch (level) {
18008
 
                                case 1:
18009
 
                                        NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18010
 
                                break;
18011
 
 
18012
 
                                default:
18013
 
                                break;
18014
 
 
18015
 
                        }
18016
 
                }
18017
 
                ndr->flags = _flags_save_UNION;
18018
 
        }
18019
 
        ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18020
 
        return NDR_ERR_SUCCESS;
18021
 
}
18022
 
 
18023
 
_PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
18024
 
{
18025
 
        int level;
18026
 
        {
18027
 
                uint32_t _flags_save_UNION = ndr->flags;
18028
 
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18029
 
                level = ndr_print_get_switch_value(ndr, r);
18030
 
                ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
18031
 
                switch (level) {
18032
 
                        case 1:
18033
 
                                ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
18034
 
                        break;
18035
 
 
18036
 
                        default:
18037
 
                        break;
18038
 
 
18039
 
                }
18040
 
                ndr->flags = _flags_save_UNION;
18041
 
        }
18042
 
}
18043
 
 
18044
 
static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18045
 
{
18046
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18047
 
        return NDR_ERR_SUCCESS;
18048
 
}
18049
 
 
18050
 
static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18051
 
{
18052
 
        uint32_t v;
18053
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18054
 
        *r = v;
18055
 
        return NDR_ERR_SUCCESS;
18056
 
}
18057
 
 
18058
 
_PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18059
 
{
18060
 
        ndr_print_uint32(ndr, name, r);
18061
 
        ndr->depth++;
18062
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
18063
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
18064
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
18065
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
18066
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
18067
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
18068
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
18069
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
18070
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
18071
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
18072
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
18073
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
18074
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
18075
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
18076
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
18077
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
18078
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
18079
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
18080
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
18081
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
18082
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
18083
 
        ndr->depth--;
18084
 
}
18085
 
 
18086
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
18087
 
{
18088
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18089
 
        return NDR_ERR_SUCCESS;
18090
 
}
18091
 
 
18092
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
18093
 
{
18094
 
        uint16_t v;
18095
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18096
 
        *r = v;
18097
 
        return NDR_ERR_SUCCESS;
18098
 
}
18099
 
 
18100
 
_PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
18101
 
{
18102
 
        const char *val = NULL;
18103
 
 
18104
 
        switch (r) {
18105
 
                case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
18106
 
                case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
18107
 
                case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
18108
 
                case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
18109
 
                case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
18110
 
                case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
18111
 
                case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18112
 
                case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
18113
 
                case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
18114
 
                case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
18115
 
                case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
18116
 
                case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
18117
 
                case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18118
 
                case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
18119
 
                case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
18120
 
                case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
18121
 
                case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
18122
 
                case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
18123
 
                case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
18124
 
                case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
18125
 
                case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
18126
 
                case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
18127
 
                case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
18128
 
                case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
18129
 
        }
18130
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
18131
 
}
18132
 
 
18133
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
18134
 
{
18135
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18136
 
        return NDR_ERR_SUCCESS;
18137
 
}
18138
 
 
18139
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
18140
 
{
18141
 
        uint16_t v;
18142
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18143
 
        *r = v;
18144
 
        return NDR_ERR_SUCCESS;
18145
 
}
18146
 
 
18147
 
_PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
18148
 
{
18149
 
        const char *val = NULL;
18150
 
 
18151
 
        switch (r) {
18152
 
                case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
18153
 
                case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
18154
 
                case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
18155
 
                case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
18156
 
                case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
18157
 
                case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
18158
 
                case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
18159
 
                case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
18160
 
                case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
18161
 
                case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18162
 
                case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
18163
 
                case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
18164
 
                case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18165
 
                case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
18166
 
                case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
18167
 
                case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
18168
 
                case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
18169
 
                case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
18170
 
                case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
18171
 
                case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
18172
 
                case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
18173
 
                case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
18174
 
                case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
18175
 
                case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
18176
 
                case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
18177
 
                case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
18178
 
                case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
18179
 
                case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
18180
 
        }
18181
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
18182
 
}
18183
 
 
18184
 
static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
18185
 
{
18186
 
        NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18187
 
        return NDR_ERR_SUCCESS;
18188
 
}
18189
 
 
18190
 
static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
18191
 
{
18192
 
        uint16_t v;
18193
 
        NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18194
 
        *r = v;
18195
 
        return NDR_ERR_SUCCESS;
18196
 
}
18197
 
 
18198
 
_PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
18199
 
{
18200
 
        const char *val = NULL;
18201
 
 
18202
 
        switch (r) {
18203
 
                case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
18204
 
                case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
18205
 
        }
18206
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
18207
 
}
18208
 
 
18209
 
static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
18210
 
{
18211
 
        if (ndr_flags & NDR_SCALARS) {
18212
 
                int level = ndr_push_get_switch_value(ndr, r);
18213
 
                NDR_CHECK(ndr_push_union_align(ndr, 2));
18214
 
                switch (level) {
18215
 
                        case PRINTER_NOTIFY_TYPE: {
18216
 
                                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18217
 
                        break; }
18218
 
 
18219
 
                        case JOB_NOTIFY_TYPE: {
18220
 
                                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18221
 
                        break; }
18222
 
 
18223
 
                        default: {
18224
 
                                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18225
 
                        break; }
18226
 
 
18227
 
                }
18228
 
        }
18229
 
        if (ndr_flags & NDR_BUFFERS) {
18230
 
                int level = ndr_push_get_switch_value(ndr, r);
18231
 
                switch (level) {
18232
 
                        case PRINTER_NOTIFY_TYPE:
18233
 
                        break;
18234
 
 
18235
 
                        case JOB_NOTIFY_TYPE:
18236
 
                        break;
18237
 
 
18238
 
                        default:
18239
 
                        break;
18240
 
 
18241
 
                }
18242
 
        }
18243
 
        return NDR_ERR_SUCCESS;
18244
 
}
18245
 
 
18246
 
static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
18247
 
{
18248
 
        int level;
18249
 
        level = ndr_pull_get_switch_value(ndr, r);
18250
 
        if (ndr_flags & NDR_SCALARS) {
18251
 
                NDR_CHECK(ndr_pull_union_align(ndr, 2));
18252
 
                switch (level) {
18253
 
                        case PRINTER_NOTIFY_TYPE: {
18254
 
                                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18255
 
                        break; }
18256
 
 
18257
 
                        case JOB_NOTIFY_TYPE: {
18258
 
                                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18259
 
                        break; }
18260
 
 
18261
 
                        default: {
18262
 
                                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18263
 
                        break; }
18264
 
 
18265
 
                }
18266
 
        }
18267
 
        if (ndr_flags & NDR_BUFFERS) {
18268
 
                switch (level) {
18269
 
                        case PRINTER_NOTIFY_TYPE:
18270
 
                        break;
18271
 
 
18272
 
                        case JOB_NOTIFY_TYPE:
18273
 
                        break;
18274
 
 
18275
 
                        default:
18276
 
                        break;
18277
 
 
18278
 
                }
18279
 
        }
18280
 
        return NDR_ERR_SUCCESS;
18281
 
}
18282
 
 
18283
 
static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
18284
 
{
18285
 
        uint32_t cntr_fields_1;
18286
 
        if (ndr_flags & NDR_SCALARS) {
18287
 
                NDR_CHECK(ndr_push_align(ndr, 5));
18288
 
                NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18289
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
18290
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
18291
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
18292
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18293
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
18294
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18295
 
        }
18296
 
        if (ndr_flags & NDR_BUFFERS) {
18297
 
                if (r->fields) {
18298
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18299
 
                        for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18300
 
                                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18301
 
                                NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18302
 
                        }
18303
 
                }
18304
 
        }
18305
 
        return NDR_ERR_SUCCESS;
18306
 
}
18307
 
 
18308
 
static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
18309
 
{
18310
 
        uint32_t _ptr_fields;
18311
 
        uint32_t cntr_fields_1;
18312
 
        TALLOC_CTX *_mem_save_fields_0;
18313
 
        TALLOC_CTX *_mem_save_fields_1;
18314
 
        if (ndr_flags & NDR_SCALARS) {
18315
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
18316
 
                NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18317
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
18318
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
18319
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
18320
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18321
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
18322
 
                if (_ptr_fields) {
18323
 
                        NDR_PULL_ALLOC(ndr, r->fields);
18324
 
                } else {
18325
 
                        r->fields = NULL;
18326
 
                }
18327
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18328
 
        }
18329
 
        if (ndr_flags & NDR_BUFFERS) {
18330
 
                if (r->fields) {
18331
 
                        _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
18332
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18333
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
18334
 
                        NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
18335
 
                        _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
18336
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18337
 
                        for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18338
 
                                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18339
 
                                NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18340
 
                        }
18341
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
18342
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
18343
 
                }
18344
 
                if (r->fields) {
18345
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
18346
 
                }
18347
 
        }
18348
 
        return NDR_ERR_SUCCESS;
18349
 
}
18350
 
 
18351
 
_PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
18352
 
{
18353
 
        uint32_t cntr_fields_1;
18354
 
        ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
18355
 
        ndr->depth++;
18356
 
        ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18357
 
        ndr_print_uint16(ndr, "u1", r->u1);
18358
 
        ndr_print_uint32(ndr, "u2", r->u2);
18359
 
        ndr_print_uint32(ndr, "u3", r->u3);
18360
 
        ndr_print_uint32(ndr, "count", r->count);
18361
 
        ndr_print_ptr(ndr, "fields", r->fields);
18362
 
        ndr->depth++;
18363
 
        if (r->fields) {
18364
 
                ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
18365
 
                ndr->depth++;
18366
 
                for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
18367
 
                        char *idx_1=NULL;
18368
 
                        if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
18369
 
                                ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
18370
 
                                ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
18371
 
                                free(idx_1);
18372
 
                        }
18373
 
                }
18374
 
                ndr->depth--;
18375
 
        }
18376
 
        ndr->depth--;
18377
 
        ndr->depth--;
18378
 
}
18379
 
 
18380
 
static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18381
 
{
18382
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18383
 
        return NDR_ERR_SUCCESS;
18384
 
}
18385
 
 
18386
 
static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18387
 
{
18388
 
        uint32_t v;
18389
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18390
 
        *r = v;
18391
 
        return NDR_ERR_SUCCESS;
18392
 
}
18393
 
 
18394
 
_PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18395
 
{
18396
 
        ndr_print_uint32(ndr, name, r);
18397
 
        ndr->depth++;
18398
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
18399
 
        ndr->depth--;
18400
 
}
18401
 
 
18402
 
static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
18403
 
{
18404
 
        uint32_t cntr_types_1;
18405
 
        if (ndr_flags & NDR_SCALARS) {
18406
 
                NDR_CHECK(ndr_push_align(ndr, 5));
18407
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18408
 
                NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
18409
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18410
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
18411
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18412
 
        }
18413
 
        if (ndr_flags & NDR_BUFFERS) {
18414
 
                if (r->types) {
18415
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18416
 
                        for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18417
 
                                NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18418
 
                        }
18419
 
                        for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18420
 
                                NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18421
 
                        }
18422
 
                }
18423
 
        }
18424
 
        return NDR_ERR_SUCCESS;
18425
 
}
18426
 
 
18427
 
static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
18428
 
{
18429
 
        uint32_t _ptr_types;
18430
 
        uint32_t cntr_types_1;
18431
 
        TALLOC_CTX *_mem_save_types_0;
18432
 
        TALLOC_CTX *_mem_save_types_1;
18433
 
        if (ndr_flags & NDR_SCALARS) {
18434
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
18435
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18436
 
                NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
18437
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18438
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
18439
 
                if (_ptr_types) {
18440
 
                        NDR_PULL_ALLOC(ndr, r->types);
18441
 
                } else {
18442
 
                        r->types = NULL;
18443
 
                }
18444
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18445
 
        }
18446
 
        if (ndr_flags & NDR_BUFFERS) {
18447
 
                if (r->types) {
18448
 
                        _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
18449
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18450
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
18451
 
                        NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
18452
 
                        _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
18453
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18454
 
                        for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18455
 
                                NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18456
 
                        }
18457
 
                        for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18458
 
                                NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18459
 
                        }
18460
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
18461
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
18462
 
                }
18463
 
                if (r->types) {
18464
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
18465
 
                }
18466
 
        }
18467
 
        return NDR_ERR_SUCCESS;
18468
 
}
18469
 
 
18470
 
_PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
18471
 
{
18472
 
        uint32_t cntr_types_1;
18473
 
        ndr_print_struct(ndr, name, "spoolss_NotifyOption");
18474
 
        ndr->depth++;
18475
 
        ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18476
 
        ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
18477
 
        ndr_print_uint32(ndr, "count", r->count);
18478
 
        ndr_print_ptr(ndr, "types", r->types);
18479
 
        ndr->depth++;
18480
 
        if (r->types) {
18481
 
                ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
18482
 
                ndr->depth++;
18483
 
                for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
18484
 
                        char *idx_1=NULL;
18485
 
                        if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
18486
 
                                ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
18487
 
                                free(idx_1);
18488
 
                        }
18489
 
                }
18490
 
                ndr->depth--;
18491
 
        }
18492
 
        ndr->depth--;
18493
 
        ndr->depth--;
18494
 
}
18495
 
 
18496
 
static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
18497
 
{
18498
 
        if (ndr_flags & NDR_SCALARS) {
18499
 
                NDR_CHECK(ndr_push_align(ndr, 5));
18500
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18501
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
18502
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18503
 
        }
18504
 
        if (ndr_flags & NDR_BUFFERS) {
18505
 
                if (r->string) {
18506
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
18507
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
18508
 
                }
18509
 
        }
18510
 
        return NDR_ERR_SUCCESS;
18511
 
}
18512
 
 
18513
 
static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
18514
 
{
18515
 
        uint32_t _ptr_string;
18516
 
        TALLOC_CTX *_mem_save_string_0;
18517
 
        if (ndr_flags & NDR_SCALARS) {
18518
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
18519
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18520
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
18521
 
                if (_ptr_string) {
18522
 
                        NDR_PULL_ALLOC(ndr, r->string);
18523
 
                } else {
18524
 
                        r->string = NULL;
18525
 
                }
18526
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18527
 
        }
18528
 
        if (ndr_flags & NDR_BUFFERS) {
18529
 
                if (r->string) {
18530
 
                        _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
18531
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
18532
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
18533
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
18534
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
18535
 
                }
18536
 
                if (r->string) {
18537
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
18538
 
                }
18539
 
        }
18540
 
        return NDR_ERR_SUCCESS;
18541
 
}
18542
 
 
18543
 
_PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
18544
 
{
18545
 
        ndr_print_struct(ndr, name, "spoolss_NotifyString");
18546
 
        ndr->depth++;
18547
 
        ndr_print_uint32(ndr, "size", r->size);
18548
 
        ndr_print_ptr(ndr, "string", r->string);
18549
 
        ndr->depth++;
18550
 
        if (r->string) {
18551
 
                ndr_print_string(ndr, "string", r->string);
18552
 
        }
18553
 
        ndr->depth--;
18554
 
        ndr->depth--;
18555
 
}
18556
 
 
18557
 
static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
18558
 
{
18559
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
18560
 
        return NDR_ERR_SUCCESS;
18561
 
}
18562
 
 
18563
 
static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
18564
 
{
18565
 
        uint32_t v;
18566
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
18567
 
        *r = v;
18568
 
        return NDR_ERR_SUCCESS;
18569
 
}
18570
 
 
18571
 
_PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
18572
 
{
18573
 
        const char *val = NULL;
18574
 
 
18575
 
        switch (r) {
18576
 
                case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
18577
 
                case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
18578
 
                case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
18579
 
                case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
18580
 
                case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
18581
 
        }
18582
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
18583
 
}
18584
 
 
18585
 
static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
18586
 
{
18587
 
        if (ndr_flags & NDR_SCALARS) {
18588
 
                int level = ndr_push_get_switch_value(ndr, r);
18589
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18590
 
                NDR_CHECK(ndr_push_union_align(ndr, 5));
18591
 
                switch (level) {
18592
 
                        case 1: {
18593
 
                                uint32_t cntr_integer_0;
18594
 
                                for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18595
 
                                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
18596
 
                                }
18597
 
                        break; }
18598
 
 
18599
 
                        case 2: {
18600
 
                                NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18601
 
                        break; }
18602
 
 
18603
 
                        case 3: {
18604
 
                                NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18605
 
                        break; }
18606
 
 
18607
 
                        case 4: {
18608
 
                                NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18609
 
                        break; }
18610
 
 
18611
 
                        case 5: {
18612
 
                                NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18613
 
                        break; }
18614
 
 
18615
 
                        default:
18616
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18617
 
                }
18618
 
        }
18619
 
        if (ndr_flags & NDR_BUFFERS) {
18620
 
                int level = ndr_push_get_switch_value(ndr, r);
18621
 
                switch (level) {
18622
 
                        case 1:
18623
 
                        break;
18624
 
 
18625
 
                        case 2:
18626
 
                                NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18627
 
                        break;
18628
 
 
18629
 
                        case 3:
18630
 
                                NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18631
 
                        break;
18632
 
 
18633
 
                        case 4:
18634
 
                                NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18635
 
                        break;
18636
 
 
18637
 
                        case 5:
18638
 
                                NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18639
 
                        break;
18640
 
 
18641
 
                        default:
18642
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18643
 
                }
18644
 
        }
18645
 
        return NDR_ERR_SUCCESS;
18646
 
}
18647
 
 
18648
 
static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
18649
 
{
18650
 
        int level;
18651
 
        uint32_t _level;
18652
 
        level = ndr_pull_get_switch_value(ndr, r);
18653
 
        if (ndr_flags & NDR_SCALARS) {
18654
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18655
 
                if (_level != level) {
18656
 
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18657
 
                }
18658
 
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
18659
 
                switch (level) {
18660
 
                        case 1: {
18661
 
                                uint32_t cntr_integer_0;
18662
 
                                for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18663
 
                                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
18664
 
                                }
18665
 
                        break; }
18666
 
 
18667
 
                        case 2: {
18668
 
                                NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18669
 
                        break; }
18670
 
 
18671
 
                        case 3: {
18672
 
                                NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18673
 
                        break; }
18674
 
 
18675
 
                        case 4: {
18676
 
                                NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18677
 
                        break; }
18678
 
 
18679
 
                        case 5: {
18680
 
                                NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18681
 
                        break; }
18682
 
 
18683
 
                        default:
18684
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18685
 
                }
18686
 
        }
18687
 
        if (ndr_flags & NDR_BUFFERS) {
18688
 
                switch (level) {
18689
 
                        case 1:
18690
 
                        break;
18691
 
 
18692
 
                        case 2:
18693
 
                                NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18694
 
                        break;
18695
 
 
18696
 
                        case 3:
18697
 
                                NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18698
 
                        break;
18699
 
 
18700
 
                        case 4:
18701
 
                                NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18702
 
                        break;
18703
 
 
18704
 
                        case 5:
18705
 
                                NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18706
 
                        break;
18707
 
 
18708
 
                        default:
18709
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18710
 
                }
18711
 
        }
18712
 
        return NDR_ERR_SUCCESS;
18713
 
}
18714
 
 
18715
 
_PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
18716
 
{
18717
 
        int level;
18718
 
        uint32_t cntr_integer_0;
18719
 
        level = ndr_print_get_switch_value(ndr, r);
18720
 
        ndr_print_union(ndr, name, level, "spoolss_NotifyData");
18721
 
        switch (level) {
18722
 
                case 1:
18723
 
                        ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
18724
 
                        ndr->depth++;
18725
 
                        for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
18726
 
                                char *idx_0=NULL;
18727
 
                                if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
18728
 
                                        ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
18729
 
                                        free(idx_0);
18730
 
                                }
18731
 
                        }
18732
 
                        ndr->depth--;
18733
 
                break;
18734
 
 
18735
 
                case 2:
18736
 
                        ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
18737
 
                break;
18738
 
 
18739
 
                case 3:
18740
 
                        ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
18741
 
                break;
18742
 
 
18743
 
                case 4:
18744
 
                        ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
18745
 
                break;
18746
 
 
18747
 
                case 5:
18748
 
                        ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
18749
 
                break;
18750
 
 
18751
 
                default:
18752
 
                        ndr_print_bad_level(ndr, name, level);
18753
 
        }
18754
 
}
18755
 
 
18756
 
static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
18757
 
{
18758
 
        if (ndr_flags & NDR_SCALARS) {
18759
 
                NDR_CHECK(ndr_push_align(ndr, 5));
18760
 
                NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18761
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
18762
 
                NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18763
 
                NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
18764
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
18765
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
18766
 
                NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18767
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18768
 
        }
18769
 
        if (ndr_flags & NDR_BUFFERS) {
18770
 
                NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18771
 
        }
18772
 
        return NDR_ERR_SUCCESS;
18773
 
}
18774
 
 
18775
 
static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
18776
 
{
18777
 
        if (ndr_flags & NDR_SCALARS) {
18778
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
18779
 
                NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18780
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
18781
 
                NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18782
 
                NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
18783
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
18784
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
18785
 
                NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18786
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18787
 
        }
18788
 
        if (ndr_flags & NDR_BUFFERS) {
18789
 
                NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18790
 
        }
18791
 
        return NDR_ERR_SUCCESS;
18792
 
}
18793
 
 
18794
 
_PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
18795
 
{
18796
 
        ndr_print_struct(ndr, name, "spoolss_Notify");
18797
 
        ndr->depth++;
18798
 
        ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18799
 
        ndr_print_set_switch_value(ndr, &r->field, r->type);
18800
 
        ndr_print_spoolss_Field(ndr, "field", &r->field);
18801
 
        ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
18802
 
        ndr_print_uint32(ndr, "job_id", r->job_id);
18803
 
        ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
18804
 
        ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
18805
 
        ndr->depth--;
18806
 
}
18807
 
 
18808
 
static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
18809
 
{
18810
 
        uint32_t cntr_notifies_0;
18811
 
        if (ndr_flags & NDR_SCALARS) {
18812
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18813
 
                NDR_CHECK(ndr_push_align(ndr, 5));
18814
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18815
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18816
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18817
 
                for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18818
 
                        NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18819
 
                }
18820
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18821
 
        }
18822
 
        if (ndr_flags & NDR_BUFFERS) {
18823
 
                for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18824
 
                        NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18825
 
                }
18826
 
        }
18827
 
        return NDR_ERR_SUCCESS;
18828
 
}
18829
 
 
18830
 
static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
18831
 
{
18832
 
        uint32_t cntr_notifies_0;
18833
 
        TALLOC_CTX *_mem_save_notifies_0;
18834
 
        if (ndr_flags & NDR_SCALARS) {
18835
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
18836
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
18837
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18838
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18839
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18840
 
                NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
18841
 
                _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18842
 
                NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18843
 
                for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18844
 
                        NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18845
 
                }
18846
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18847
 
                if (r->notifies) {
18848
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
18849
 
                }
18850
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18851
 
        }
18852
 
        if (ndr_flags & NDR_BUFFERS) {
18853
 
                _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
18854
 
                NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
18855
 
                for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18856
 
                        NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18857
 
                }
18858
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
18859
 
        }
18860
 
        return NDR_ERR_SUCCESS;
18861
 
}
18862
 
 
18863
 
_PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
18864
 
{
18865
 
        uint32_t cntr_notifies_0;
18866
 
        ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
18867
 
        ndr->depth++;
18868
 
        ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18869
 
        ndr_print_uint32(ndr, "flags", r->flags);
18870
 
        ndr_print_uint32(ndr, "count", r->count);
18871
 
        ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
18872
 
        ndr->depth++;
18873
 
        for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
18874
 
                char *idx_0=NULL;
18875
 
                if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
18876
 
                        ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
18877
 
                        free(idx_0);
18878
 
                }
18879
 
        }
18880
 
        ndr->depth--;
18881
 
        ndr->depth--;
18882
 
}
18883
 
 
18884
 
static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
18885
 
{
18886
 
        if (ndr_flags & NDR_SCALARS) {
18887
 
                int level = ndr_push_get_switch_value(ndr, r);
18888
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18889
 
                NDR_CHECK(ndr_push_union_align(ndr, 5));
18890
 
                switch (level) {
18891
 
                        case 0: {
18892
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
18893
 
                        break; }
18894
 
 
18895
 
                        default:
18896
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18897
 
                }
18898
 
        }
18899
 
        if (ndr_flags & NDR_BUFFERS) {
18900
 
                int level = ndr_push_get_switch_value(ndr, r);
18901
 
                switch (level) {
18902
 
                        case 0:
18903
 
                                if (r->info0) {
18904
 
                                        NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18905
 
                                }
18906
 
                        break;
18907
 
 
18908
 
                        default:
18909
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18910
 
                }
18911
 
        }
18912
 
        return NDR_ERR_SUCCESS;
18913
 
}
18914
 
 
18915
 
static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
18916
 
{
18917
 
        int level;
18918
 
        uint32_t _level;
18919
 
        TALLOC_CTX *_mem_save_info0_0;
18920
 
        level = ndr_pull_get_switch_value(ndr, r);
18921
 
        if (ndr_flags & NDR_SCALARS) {
18922
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18923
 
                if (_level != level) {
18924
 
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18925
 
                }
18926
 
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
18927
 
                switch (level) {
18928
 
                        case 0: {
18929
 
                                uint32_t _ptr_info0;
18930
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
18931
 
                                if (_ptr_info0) {
18932
 
                                        NDR_PULL_ALLOC(ndr, r->info0);
18933
 
                                } else {
18934
 
                                        r->info0 = NULL;
18935
 
                                }
18936
 
                        break; }
18937
 
 
18938
 
                        default:
18939
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18940
 
                }
18941
 
        }
18942
 
        if (ndr_flags & NDR_BUFFERS) {
18943
 
                switch (level) {
18944
 
                        case 0:
18945
 
                                if (r->info0) {
18946
 
                                        _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
18947
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
18948
 
                                        NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
18949
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
18950
 
                                }
18951
 
                        break;
18952
 
 
18953
 
                        default:
18954
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18955
 
                }
18956
 
        }
18957
 
        return NDR_ERR_SUCCESS;
18958
 
}
18959
 
 
18960
 
_PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
18961
 
{
18962
 
        int level;
18963
 
        level = ndr_print_get_switch_value(ndr, r);
18964
 
        ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
18965
 
        switch (level) {
18966
 
                case 0:
18967
 
                        ndr_print_ptr(ndr, "info0", r->info0);
18968
 
                        ndr->depth++;
18969
 
                        if (r->info0) {
18970
 
                                ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
18971
 
                        }
18972
 
                        ndr->depth--;
18973
 
                break;
18974
 
 
18975
 
                default:
18976
 
                        ndr_print_bad_level(ndr, name, level);
18977
 
        }
18978
 
}
18979
 
 
18980
 
static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18981
 
{
18982
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18983
 
        return NDR_ERR_SUCCESS;
18984
 
}
18985
 
 
18986
 
static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18987
 
{
18988
 
        uint32_t v;
18989
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18990
 
        *r = v;
18991
 
        return NDR_ERR_SUCCESS;
18992
 
}
18993
 
 
18994
 
_PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18995
 
{
18996
 
        ndr_print_uint32(ndr, name, r);
18997
 
        ndr->depth++;
18998
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
18999
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
19000
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
19001
 
        ndr->depth--;
19002
 
}
19003
 
 
19004
 
static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
19005
 
{
19006
 
        if (ndr_flags & NDR_SCALARS) {
19007
 
                NDR_CHECK(ndr_push_align(ndr, 5));
19008
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19009
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19010
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19011
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19012
 
                NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19013
 
                NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19014
 
                NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19015
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19016
 
        }
19017
 
        if (ndr_flags & NDR_BUFFERS) {
19018
 
                if (r->client) {
19019
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19020
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19021
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19022
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19023
 
                }
19024
 
                if (r->user) {
19025
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19026
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19027
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19028
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19029
 
                }
19030
 
        }
19031
 
        return NDR_ERR_SUCCESS;
19032
 
}
19033
 
 
19034
 
static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
19035
 
{
19036
 
        uint32_t _ptr_client;
19037
 
        TALLOC_CTX *_mem_save_client_0;
19038
 
        uint32_t _ptr_user;
19039
 
        TALLOC_CTX *_mem_save_user_0;
19040
 
        if (ndr_flags & NDR_SCALARS) {
19041
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
19042
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19043
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19044
 
                if (_ptr_client) {
19045
 
                        NDR_PULL_ALLOC(ndr, r->client);
19046
 
                } else {
19047
 
                        r->client = NULL;
19048
 
                }
19049
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19050
 
                if (_ptr_user) {
19051
 
                        NDR_PULL_ALLOC(ndr, r->user);
19052
 
                } else {
19053
 
                        r->user = NULL;
19054
 
                }
19055
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19056
 
                NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19057
 
                NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19058
 
                NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19059
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19060
 
        }
19061
 
        if (ndr_flags & NDR_BUFFERS) {
19062
 
                if (r->client) {
19063
 
                        _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19064
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19065
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19066
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19067
 
                        if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19068
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
19069
 
                        }
19070
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19071
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19072
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19073
 
                }
19074
 
                if (r->user) {
19075
 
                        _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19076
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19077
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19078
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19079
 
                        if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19080
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user), ndr_get_array_length(ndr, &r->user));
19081
 
                        }
19082
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19083
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19084
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19085
 
                }
19086
 
        }
19087
 
        return NDR_ERR_SUCCESS;
19088
 
}
19089
 
 
19090
 
_PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
19091
 
{
19092
 
        ndr_print_struct(ndr, name, "spoolss_UserLevel1");
19093
 
        ndr->depth++;
19094
 
        ndr_print_uint32(ndr, "size", r->size);
19095
 
        ndr_print_ptr(ndr, "client", r->client);
19096
 
        ndr->depth++;
19097
 
        if (r->client) {
19098
 
                ndr_print_string(ndr, "client", r->client);
19099
 
        }
19100
 
        ndr->depth--;
19101
 
        ndr_print_ptr(ndr, "user", r->user);
19102
 
        ndr->depth++;
19103
 
        if (r->user) {
19104
 
                ndr_print_string(ndr, "user", r->user);
19105
 
        }
19106
 
        ndr->depth--;
19107
 
        ndr_print_uint32(ndr, "build", r->build);
19108
 
        ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19109
 
        ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19110
 
        ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19111
 
        ndr->depth--;
19112
 
}
19113
 
 
19114
 
static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
19115
 
{
19116
 
        if (ndr_flags & NDR_SCALARS) {
19117
 
                NDR_CHECK(ndr_push_align(ndr, 4));
19118
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
19119
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19120
 
        }
19121
 
        if (ndr_flags & NDR_BUFFERS) {
19122
 
        }
19123
 
        return NDR_ERR_SUCCESS;
19124
 
}
19125
 
 
19126
 
static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
19127
 
{
19128
 
        if (ndr_flags & NDR_SCALARS) {
19129
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
19130
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
19131
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19132
 
        }
19133
 
        if (ndr_flags & NDR_BUFFERS) {
19134
 
        }
19135
 
        return NDR_ERR_SUCCESS;
19136
 
}
19137
 
 
19138
 
_PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
19139
 
{
19140
 
        ndr_print_struct(ndr, name, "spoolss_UserLevel2");
19141
 
        ndr->depth++;
19142
 
        ndr_print_uint32(ndr, "not_used", r->not_used);
19143
 
        ndr->depth--;
19144
 
}
19145
 
 
19146
 
static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
19147
 
{
19148
 
        if (ndr_flags & NDR_SCALARS) {
19149
 
                NDR_CHECK(ndr_push_align(ndr, 5));
19150
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19151
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19152
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
19153
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19154
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19155
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19156
 
                NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19157
 
                NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19158
 
                NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19159
 
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
19160
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19161
 
        }
19162
 
        if (ndr_flags & NDR_BUFFERS) {
19163
 
                if (r->client) {
19164
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19165
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19166
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19167
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19168
 
                }
19169
 
                if (r->user) {
19170
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19171
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19172
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19173
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19174
 
                }
19175
 
        }
19176
 
        return NDR_ERR_SUCCESS;
19177
 
}
19178
 
 
19179
 
static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
19180
 
{
19181
 
        uint32_t _ptr_client;
19182
 
        TALLOC_CTX *_mem_save_client_0;
19183
 
        uint32_t _ptr_user;
19184
 
        TALLOC_CTX *_mem_save_user_0;
19185
 
        if (ndr_flags & NDR_SCALARS) {
19186
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
19187
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19188
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19189
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
19190
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19191
 
                if (_ptr_client) {
19192
 
                        NDR_PULL_ALLOC(ndr, r->client);
19193
 
                } else {
19194
 
                        r->client = NULL;
19195
 
                }
19196
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19197
 
                if (_ptr_user) {
19198
 
                        NDR_PULL_ALLOC(ndr, r->user);
19199
 
                } else {
19200
 
                        r->user = NULL;
19201
 
                }
19202
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19203
 
                NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19204
 
                NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19205
 
                NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19206
 
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
19207
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19208
 
        }
19209
 
        if (ndr_flags & NDR_BUFFERS) {
19210
 
                if (r->client) {
19211
 
                        _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19212
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19213
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19214
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19215
 
                        if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19216
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
19217
 
                        }
19218
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19219
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19220
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19221
 
                }
19222
 
                if (r->user) {
19223
 
                        _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19224
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19225
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19226
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19227
 
                        if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19228
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user), ndr_get_array_length(ndr, &r->user));
19229
 
                        }
19230
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19231
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19232
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19233
 
                }
19234
 
        }
19235
 
        return NDR_ERR_SUCCESS;
19236
 
}
19237
 
 
19238
 
_PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
19239
 
{
19240
 
        ndr_print_struct(ndr, name, "spoolss_UserLevel3");
19241
 
        ndr->depth++;
19242
 
        ndr_print_uint32(ndr, "size", r->size);
19243
 
        ndr_print_uint32(ndr, "flags", r->flags);
19244
 
        ndr_print_uint32(ndr, "size2", r->size2);
19245
 
        ndr_print_ptr(ndr, "client", r->client);
19246
 
        ndr->depth++;
19247
 
        if (r->client) {
19248
 
                ndr_print_string(ndr, "client", r->client);
19249
 
        }
19250
 
        ndr->depth--;
19251
 
        ndr_print_ptr(ndr, "user", r->user);
19252
 
        ndr->depth++;
19253
 
        if (r->user) {
19254
 
                ndr_print_string(ndr, "user", r->user);
19255
 
        }
19256
 
        ndr->depth--;
19257
 
        ndr_print_uint32(ndr, "build", r->build);
19258
 
        ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19259
 
        ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19260
 
        ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19261
 
        ndr_print_udlong(ndr, "reserved", r->reserved);
19262
 
        ndr->depth--;
19263
 
}
19264
 
 
19265
 
static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
19266
 
{
19267
 
        if (ndr_flags & NDR_SCALARS) {
19268
 
                int level = ndr_push_get_switch_value(ndr, r);
19269
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19270
 
                NDR_CHECK(ndr_push_union_align(ndr, 5));
19271
 
                switch (level) {
19272
 
                        case 1: {
19273
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
19274
 
                        break; }
19275
 
 
19276
 
                        case 2: {
19277
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
19278
 
                        break; }
19279
 
 
19280
 
                        case 3: {
19281
 
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
19282
 
                        break; }
19283
 
 
19284
 
                        default:
19285
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19286
 
                }
19287
 
        }
19288
 
        if (ndr_flags & NDR_BUFFERS) {
19289
 
                int level = ndr_push_get_switch_value(ndr, r);
19290
 
                switch (level) {
19291
 
                        case 1:
19292
 
                                if (r->level1) {
19293
 
                                        NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19294
 
                                }
19295
 
                        break;
19296
 
 
19297
 
                        case 2:
19298
 
                                if (r->level2) {
19299
 
                                        NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19300
 
                                }
19301
 
                        break;
19302
 
 
19303
 
                        case 3:
19304
 
                                if (r->level3) {
19305
 
                                        NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19306
 
                                }
19307
 
                        break;
19308
 
 
19309
 
                        default:
19310
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19311
 
                }
19312
 
        }
19313
 
        return NDR_ERR_SUCCESS;
19314
 
}
19315
 
 
19316
 
static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
19317
 
{
19318
 
        int level;
19319
 
        uint32_t _level;
19320
 
        TALLOC_CTX *_mem_save_level1_0;
19321
 
        TALLOC_CTX *_mem_save_level2_0;
19322
 
        TALLOC_CTX *_mem_save_level3_0;
19323
 
        level = ndr_pull_get_switch_value(ndr, r);
19324
 
        if (ndr_flags & NDR_SCALARS) {
19325
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19326
 
                if (_level != level) {
19327
 
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19328
 
                }
19329
 
                NDR_CHECK(ndr_pull_union_align(ndr, 5));
19330
 
                switch (level) {
19331
 
                        case 1: {
19332
 
                                uint32_t _ptr_level1;
19333
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
19334
 
                                if (_ptr_level1) {
19335
 
                                        NDR_PULL_ALLOC(ndr, r->level1);
19336
 
                                } else {
19337
 
                                        r->level1 = NULL;
19338
 
                                }
19339
 
                        break; }
19340
 
 
19341
 
                        case 2: {
19342
 
                                uint32_t _ptr_level2;
19343
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
19344
 
                                if (_ptr_level2) {
19345
 
                                        NDR_PULL_ALLOC(ndr, r->level2);
19346
 
                                } else {
19347
 
                                        r->level2 = NULL;
19348
 
                                }
19349
 
                        break; }
19350
 
 
19351
 
                        case 3: {
19352
 
                                uint32_t _ptr_level3;
19353
 
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
19354
 
                                if (_ptr_level3) {
19355
 
                                        NDR_PULL_ALLOC(ndr, r->level3);
19356
 
                                } else {
19357
 
                                        r->level3 = NULL;
19358
 
                                }
19359
 
                        break; }
19360
 
 
19361
 
                        default:
19362
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19363
 
                }
19364
 
        }
19365
 
        if (ndr_flags & NDR_BUFFERS) {
19366
 
                switch (level) {
19367
 
                        case 1:
19368
 
                                if (r->level1) {
19369
 
                                        _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
19370
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
19371
 
                                        NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19372
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
19373
 
                                }
19374
 
                        break;
19375
 
 
19376
 
                        case 2:
19377
 
                                if (r->level2) {
19378
 
                                        _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
19379
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
19380
 
                                        NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19381
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
19382
 
                                }
19383
 
                        break;
19384
 
 
19385
 
                        case 3:
19386
 
                                if (r->level3) {
19387
 
                                        _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
19388
 
                                        NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
19389
 
                                        NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19390
 
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
19391
 
                                }
19392
 
                        break;
19393
 
 
19394
 
                        default:
19395
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19396
 
                }
19397
 
        }
19398
 
        return NDR_ERR_SUCCESS;
19399
 
}
19400
 
 
19401
 
_PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
19402
 
{
19403
 
        int level;
19404
 
        level = ndr_print_get_switch_value(ndr, r);
19405
 
        ndr_print_union(ndr, name, level, "spoolss_UserLevel");
19406
 
        switch (level) {
19407
 
                case 1:
19408
 
                        ndr_print_ptr(ndr, "level1", r->level1);
19409
 
                        ndr->depth++;
19410
 
                        if (r->level1) {
19411
 
                                ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
19412
 
                        }
19413
 
                        ndr->depth--;
19414
 
                break;
19415
 
 
19416
 
                case 2:
19417
 
                        ndr_print_ptr(ndr, "level2", r->level2);
19418
 
                        ndr->depth++;
19419
 
                        if (r->level2) {
19420
 
                                ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
19421
 
                        }
19422
 
                        ndr->depth--;
19423
 
                break;
19424
 
 
19425
 
                case 3:
19426
 
                        ndr_print_ptr(ndr, "level3", r->level3);
19427
 
                        ndr->depth++;
19428
 
                        if (r->level3) {
19429
 
                                ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
19430
 
                        }
19431
 
                        ndr->depth--;
19432
 
                break;
19433
 
 
19434
 
                default:
19435
 
                        ndr_print_bad_level(ndr, name, level);
19436
 
        }
19437
 
}
19438
 
 
19439
 
static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
19440
 
{
19441
 
        if (ndr_flags & NDR_SCALARS) {
19442
 
                NDR_CHECK(ndr_push_align(ndr, 5));
19443
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
19444
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
19445
 
                NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19446
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19447
 
        }
19448
 
        if (ndr_flags & NDR_BUFFERS) {
19449
 
                NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19450
 
        }
19451
 
        return NDR_ERR_SUCCESS;
19452
 
}
19453
 
 
19454
 
static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
19455
 
{
19456
 
        if (ndr_flags & NDR_SCALARS) {
19457
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
19458
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
19459
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
19460
 
                NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19461
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19462
 
        }
19463
 
        if (ndr_flags & NDR_BUFFERS) {
19464
 
                NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19465
 
        }
19466
 
        return NDR_ERR_SUCCESS;
19467
 
}
19468
 
 
19469
 
_PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
19470
 
{
19471
 
        ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
19472
 
        ndr->depth++;
19473
 
        ndr_print_uint32(ndr, "level", r->level);
19474
 
        ndr_print_set_switch_value(ndr, &r->user_info, r->level);
19475
 
        ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
19476
 
        ndr->depth--;
19477
 
}
19478
 
 
19479
 
static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19480
 
{
19481
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19482
 
        return NDR_ERR_SUCCESS;
19483
 
}
19484
 
 
19485
 
static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19486
 
{
19487
 
        uint32_t v;
19488
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19489
 
        *r = v;
19490
 
        return NDR_ERR_SUCCESS;
19491
 
}
19492
 
 
19493
 
_PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
19494
 
{
19495
 
        ndr_print_uint32(ndr, name, r);
19496
 
        ndr->depth++;
19497
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
19498
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
19499
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
19500
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
19501
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
19502
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
19503
 
        ndr->depth--;
19504
 
}
19505
 
 
19506
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
19507
 
{
19508
 
        uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
19509
 
        if (ndr_flags & NDR_SCALARS) {
19510
 
                NDR_CHECK(ndr_push_align(ndr, 5));
19511
 
                NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
19512
 
                {
19513
 
                        uint32_t _flags_save_string = ndr->flags;
19514
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
19515
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
19516
 
                        ndr->flags = _flags_save_string;
19517
 
                }
19518
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
19519
 
                NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
19520
 
                {
19521
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
19522
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING|ndr_spoolss_PrinterEnumValues_align(r->type));
19523
 
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
19524
 
                        ndr->flags = _flags_save_DATA_BLOB;
19525
 
                }
19526
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->data?r->data->length:0));
19527
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19528
 
        }
19529
 
        if (ndr_flags & NDR_BUFFERS) {
19530
 
                NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
19531
 
                {
19532
 
                        uint32_t _flags_save_string = ndr->flags;
19533
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
19534
 
                        if (r->value_name) {
19535
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->value_name));
19536
 
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
19537
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->value_name));
19538
 
                        }
19539
 
                        ndr->flags = _flags_save_string;
19540
 
                }
19541
 
                {
19542
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
19543
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING|ndr_spoolss_PrinterEnumValues_align(r->type));
19544
 
                        if (r->data) {
19545
 
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data));
19546
 
                                {
19547
 
                                        struct ndr_push *_ndr_data;
19548
 
                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data?r->data->length:0));
19549
 
                                        NDR_CHECK(ndr_push_DATA_BLOB(_ndr_data, NDR_SCALARS, *r->data));
19550
 
                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data?r->data->length:0));
19551
 
                                }
19552
 
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data));
19553
 
                        }
19554
 
                        ndr->flags = _flags_save_DATA_BLOB;
19555
 
                }
19556
 
        }
19557
 
        ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
19558
 
        return NDR_ERR_SUCCESS;
19559
 
}
19560
 
 
19561
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
19562
 
{
19563
 
        uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
19564
 
        uint32_t _ptr_value_name;
19565
 
        TALLOC_CTX *_mem_save_value_name_0;
19566
 
        uint32_t _ptr_data;
19567
 
        TALLOC_CTX *_mem_save_data_0;
19568
 
        if (ndr_flags & NDR_SCALARS) {
19569
 
                NDR_CHECK(ndr_pull_align(ndr, 5));
19570
 
                NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
19571
 
                {
19572
 
                        uint32_t _flags_save_string = ndr->flags;
19573
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
19574
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
19575
 
                        if (_ptr_value_name) {
19576
 
                                NDR_PULL_ALLOC(ndr, r->value_name);
19577
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
19578
 
                        } else {
19579
 
                                r->value_name = NULL;
19580
 
                        }
19581
 
                        ndr->flags = _flags_save_string;
19582
 
                }
19583
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
19584
 
                NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
19585
 
                {
19586
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
19587
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING|ndr_spoolss_PrinterEnumValues_align(r->type));
19588
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
19589
 
                        if (_ptr_data) {
19590
 
                                NDR_PULL_ALLOC(ndr, r->data);
19591
 
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
19592
 
                        } else {
19593
 
                                r->data = NULL;
19594
 
                        }
19595
 
                        ndr->flags = _flags_save_DATA_BLOB;
19596
 
                }
19597
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
19598
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19599
 
        }
19600
 
        if (ndr_flags & NDR_BUFFERS) {
19601
 
                NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
19602
 
                {
19603
 
                        uint32_t _flags_save_string = ndr->flags;
19604
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
19605
 
                        if (r->value_name) {
19606
 
                                uint32_t _relative_save_offset;
19607
 
                                _relative_save_offset = ndr->offset;
19608
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
19609
 
                                _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19610
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
19611
 
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
19612
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
19613
 
                                ndr->offset = _relative_save_offset;
19614
 
                        }
19615
 
                        ndr->flags = _flags_save_string;
19616
 
                }
19617
 
                {
19618
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
19619
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING|ndr_spoolss_PrinterEnumValues_align(r->type));
19620
 
                        if (r->data) {
19621
 
                                uint32_t _relative_save_offset;
19622
 
                                _relative_save_offset = ndr->offset;
19623
 
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
19624
 
                                _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
19625
 
                                NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
19626
 
                                {
19627
 
                                        struct ndr_pull *_ndr_data;
19628
 
                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19629
 
                                        NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_data, NDR_SCALARS, r->data));
19630
 
                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19631
 
                                }
19632
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
19633
 
                                ndr->offset = _relative_save_offset;
19634
 
                        }
19635
 
                        ndr->flags = _flags_save_DATA_BLOB;
19636
 
                }
19637
 
        }
19638
 
        ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
19639
 
        return NDR_ERR_SUCCESS;
19640
 
}
19641
 
 
19642
 
_PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
19643
 
{
19644
 
        ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
19645
 
        ndr->depth++;
19646
 
        ndr_print_ptr(ndr, "value_name", r->value_name);
19647
 
        ndr->depth++;
19648
 
        if (r->value_name) {
19649
 
                ndr_print_string(ndr, "value_name", r->value_name);
19650
 
        }
19651
 
        ndr->depth--;
19652
 
        ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
19653
 
        ndr_print_winreg_Type(ndr, "type", r->type);
19654
 
        ndr_print_ptr(ndr, "data", r->data);
19655
 
        ndr->depth++;
19656
 
        if (r->data) {
19657
 
                ndr_print_DATA_BLOB(ndr, "data", *r->data);
19658
 
        }
19659
 
        ndr->depth--;
19660
 
        ndr_print_uint32(ndr, "data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->data?r->data->length:0:r->data_length);
19661
 
        ndr->depth--;
19662
 
}
19663
 
 
19664
 
_PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
19665
 
{
19666
 
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
19667
 
}
19668
 
 
19669
 
static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
19670
 
{
19671
 
        if (ndr_flags & NDR_SCALARS) {
19672
 
                int level = ndr_push_get_switch_value(ndr, r);
19673
 
                NDR_CHECK(ndr_push_union_align(ndr, 4));
19674
 
                switch (level) {
19675
 
                        case 0: {
19676
 
                        break; }
19677
 
 
19678
 
                        case 1: {
19679
 
                        break; }
19680
 
 
19681
 
                        default: {
19682
 
                                {
19683
 
                                        uint32_t _flags_save_string_array = ndr->flags;
19684
 
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
19685
 
                                        NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
19686
 
                                        ndr->flags = _flags_save_string_array;
19687
 
                                }
19688
 
                        break; }
19689
 
 
19690
 
                }
19691
 
        }
19692
 
        if (ndr_flags & NDR_BUFFERS) {
19693
 
                int level = ndr_push_get_switch_value(ndr, r);
19694
 
                switch (level) {
19695
 
                        case 0:
19696
 
                        break;
19697
 
 
19698
 
                        case 1:
19699
 
                        break;
19700
 
 
19701
 
                        default:
19702
 
                        break;
19703
 
 
19704
 
                }
19705
 
        }
19706
 
        return NDR_ERR_SUCCESS;
19707
 
}
19708
 
 
19709
 
static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
19710
 
{
19711
 
        int level;
19712
 
        level = ndr_pull_get_switch_value(ndr, r);
19713
 
        if (ndr_flags & NDR_SCALARS) {
19714
 
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
19715
 
                switch (level) {
19716
 
                        case 0: {
19717
 
                        break; }
19718
 
 
19719
 
                        case 1: {
19720
 
                        break; }
19721
 
 
19722
 
                        default: {
19723
 
                                {
19724
 
                                        uint32_t _flags_save_string_array = ndr->flags;
19725
 
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
19726
 
                                        NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
19727
 
                                        ndr->flags = _flags_save_string_array;
19728
 
                                }
19729
 
                        break; }
19730
 
 
19731
 
                }
19732
 
        }
19733
 
        if (ndr_flags & NDR_BUFFERS) {
19734
 
                switch (level) {
19735
 
                        case 0:
19736
 
                        break;
19737
 
 
19738
 
                        case 1:
19739
 
                        break;
19740
 
 
19741
 
                        default:
19742
 
                        break;
19743
 
 
19744
 
                }
19745
 
        }
19746
 
        return NDR_ERR_SUCCESS;
19747
 
}
19748
 
 
19749
 
_PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
19750
 
{
19751
 
        int level;
19752
 
        level = ndr_print_get_switch_value(ndr, r);
19753
 
        ndr_print_union(ndr, name, level, "spoolss_KeyNames");
19754
 
        switch (level) {
19755
 
                case 0:
19756
 
                break;
19757
 
 
19758
 
                case 1:
19759
 
                break;
19760
 
 
19761
 
                default:
19762
 
                        ndr_print_string_array(ndr, "string_array", r->string_array);
19763
 
                break;
19764
 
 
19765
 
        }
19766
 
}
19767
 
 
19768
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19769
 
{
19770
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19771
 
        return NDR_ERR_SUCCESS;
19772
 
}
19773
 
 
19774
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19775
 
{
19776
 
        uint32_t v;
19777
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19778
 
        *r = v;
19779
 
        return NDR_ERR_SUCCESS;
19780
 
}
19781
 
 
19782
 
_PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19783
 
{
19784
 
        ndr_print_uint32(ndr, name, r);
19785
 
        ndr->depth++;
19786
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
19787
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
19788
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
19789
 
        ndr->depth--;
19790
 
}
19791
 
 
19792
 
static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
19793
 
{
19794
 
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
19795
 
        return NDR_ERR_SUCCESS;
19796
 
}
19797
 
 
19798
 
static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
19799
 
{
19800
 
        uint32_t v;
19801
 
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
19802
 
        *r = v;
19803
 
        return NDR_ERR_SUCCESS;
19804
 
}
19805
 
 
19806
 
_PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
19807
 
{
19808
 
        const char *val = NULL;
19809
 
 
19810
 
        switch (r) {
19811
 
                case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
19812
 
                case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
19813
 
        }
19814
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
19815
 
}
19816
 
 
19817
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
19818
 
{
19819
 
        if (ndr_flags & NDR_SCALARS) {
19820
 
                NDR_CHECK(ndr_push_align(ndr, 4));
19821
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19822
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
19823
 
                NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19824
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19825
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19826
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19827
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19828
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19829
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19830
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19831
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19832
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19833
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19834
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19835
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19836
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19837
 
        }
19838
 
        if (ndr_flags & NDR_BUFFERS) {
19839
 
        }
19840
 
        return NDR_ERR_SUCCESS;
19841
 
}
19842
 
 
19843
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
19844
 
{
19845
 
        if (ndr_flags & NDR_SCALARS) {
19846
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
19847
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19848
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19849
 
                NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19850
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19851
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19852
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19853
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19854
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19855
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19856
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19857
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19858
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19859
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19860
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19861
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19862
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19863
 
        }
19864
 
        if (ndr_flags & NDR_BUFFERS) {
19865
 
        }
19866
 
        return NDR_ERR_SUCCESS;
19867
 
}
19868
 
 
19869
 
_PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
19870
 
{
19871
 
        ndr_print_struct(ndr, name, "spoolss_PortData1");
19872
 
        ndr->depth++;
19873
 
        ndr_print_string(ndr, "portname", r->portname);
19874
 
        ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
19875
 
        ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19876
 
        ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19877
 
        ndr_print_uint32(ndr, "reserved", r->reserved);
19878
 
        ndr_print_string(ndr, "hostaddress", r->hostaddress);
19879
 
        ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19880
 
        ndr_print_uint32(ndr, "dblspool", r->dblspool);
19881
 
        ndr_print_string(ndr, "queue", r->queue);
19882
 
        ndr_print_string(ndr, "ip_address", r->ip_address);
19883
 
        ndr_print_string(ndr, "hardware_address", r->hardware_address);
19884
 
        ndr_print_string(ndr, "device_type", r->device_type);
19885
 
        ndr_print_uint32(ndr, "port_number", r->port_number);
19886
 
        ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19887
 
        ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19888
 
        ndr->depth--;
19889
 
}
19890
 
 
19891
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
19892
 
{
19893
 
        if (ndr_flags & NDR_SCALARS) {
19894
 
                NDR_CHECK(ndr_push_align(ndr, 4));
19895
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19896
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
19897
 
                NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19898
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19899
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19900
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19901
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19902
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19903
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19904
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19905
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19906
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19907
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19908
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
19909
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19910
 
        }
19911
 
        if (ndr_flags & NDR_BUFFERS) {
19912
 
        }
19913
 
        return NDR_ERR_SUCCESS;
19914
 
}
19915
 
 
19916
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
19917
 
{
19918
 
        if (ndr_flags & NDR_SCALARS) {
19919
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
19920
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
19921
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19922
 
                NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
19923
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19924
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
19925
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
19926
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19927
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
19928
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
19929
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19930
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
19931
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
19932
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
19933
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
19934
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19935
 
        }
19936
 
        if (ndr_flags & NDR_BUFFERS) {
19937
 
        }
19938
 
        return NDR_ERR_SUCCESS;
19939
 
}
19940
 
 
19941
 
_PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
19942
 
{
19943
 
        ndr_print_struct(ndr, name, "spoolss_PortData2");
19944
 
        ndr->depth++;
19945
 
        ndr_print_string(ndr, "portname", r->portname);
19946
 
        ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
19947
 
        ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
19948
 
        ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
19949
 
        ndr_print_uint32(ndr, "reserved", r->reserved);
19950
 
        ndr_print_string(ndr, "hostaddress", r->hostaddress);
19951
 
        ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
19952
 
        ndr_print_uint32(ndr, "dblspool", r->dblspool);
19953
 
        ndr_print_string(ndr, "queue", r->queue);
19954
 
        ndr_print_string(ndr, "device_type", r->device_type);
19955
 
        ndr_print_uint32(ndr, "port_number", r->port_number);
19956
 
        ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
19957
 
        ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
19958
 
        ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
19959
 
        ndr->depth--;
19960
 
}
19961
 
 
19962
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
19963
 
{
19964
 
        if (ndr_flags & NDR_SCALARS) {
19965
 
                NDR_CHECK(ndr_push_align(ndr, 4));
19966
 
                {
19967
 
                        uint32_t _flags_save_string = ndr->flags;
19968
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
19969
 
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
19970
 
                        ndr->flags = _flags_save_string;
19971
 
                }
19972
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19973
 
        }
19974
 
        if (ndr_flags & NDR_BUFFERS) {
19975
 
        }
19976
 
        return NDR_ERR_SUCCESS;
19977
 
}
19978
 
 
19979
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
19980
 
{
19981
 
        if (ndr_flags & NDR_SCALARS) {
19982
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
19983
 
                {
19984
 
                        uint32_t _flags_save_string = ndr->flags;
19985
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
19986
 
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
19987
 
                        ndr->flags = _flags_save_string;
19988
 
                }
19989
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19990
 
        }
19991
 
        if (ndr_flags & NDR_BUFFERS) {
19992
 
        }
19993
 
        return NDR_ERR_SUCCESS;
19994
 
}
19995
 
 
19996
 
_PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
19997
 
{
19998
 
        ndr_print_struct(ndr, name, "spoolss_MonitorUi");
19999
 
        ndr->depth++;
20000
 
        ndr_print_string(ndr, "dll_name", r->dll_name);
20001
 
        ndr->depth--;
20002
 
}
20003
 
 
20004
 
static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20005
 
{
20006
 
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20007
 
        return NDR_ERR_SUCCESS;
20008
 
}
20009
 
 
20010
 
static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20011
 
{
20012
 
        uint32_t v;
20013
 
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20014
 
        *r = v;
20015
 
        return NDR_ERR_SUCCESS;
20016
 
}
20017
 
 
20018
 
_PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20019
 
{
20020
 
        ndr_print_uint32(ndr, name, r);
20021
 
        ndr->depth++;
20022
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
20023
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
20024
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
20025
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
20026
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
20027
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
20028
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
20029
 
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
20030
 
        ndr->depth--;
20031
 
}
20032
 
 
20033
 
static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
20034
 
{
20035
 
        if (ndr_flags & NDR_SCALARS) {
20036
 
                NDR_CHECK(ndr_push_align(ndr, 8));
20037
 
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20038
 
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
20039
 
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
20040
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
20041
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
20042
 
        }
20043
 
        if (ndr_flags & NDR_BUFFERS) {
20044
 
        }
20045
 
        return NDR_ERR_SUCCESS;
20046
 
}
20047
 
 
20048
 
static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
20049
 
{
20050
 
        if (ndr_flags & NDR_SCALARS) {
20051
 
                NDR_CHECK(ndr_pull_align(ndr, 8));
20052
 
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20053
 
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
20054
 
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
20055
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
20056
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
20057
 
        }
20058
 
        if (ndr_flags & NDR_BUFFERS) {
20059
 
        }
20060
 
        return NDR_ERR_SUCCESS;
20061
 
}
20062
 
 
20063
 
_PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
20064
 
{
20065
 
        ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
20066
 
        ndr->depth++;
20067
 
        ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
20068
 
        ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
20069
 
        ndr_print_hyper(ndr, "driver_version", r->driver_version);
20070
 
        ndr_print_string(ndr, "formname", r->formname);
20071
 
        ndr->depth--;
20072
 
}
20073
 
 
20074
 
_PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
20075
 
{
20076
 
        if (flags & NDR_IN) {
20077
 
                NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
20078
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20079
 
                if (r->in.server) {
20080
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20081
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20082
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20083
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20084
 
                }
20085
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20086
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20087
 
                if (r->in.buffer) {
20088
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20089
 
                }
20090
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20091
 
        }
20092
 
        if (flags & NDR_OUT) {
20093
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20094
 
                if (r->out.info) {
20095
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20096
 
                }
20097
 
                if (r->out.needed == NULL) {
20098
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20099
 
                }
20100
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20101
 
                if (r->out.count == NULL) {
20102
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20103
 
                }
20104
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20105
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20106
 
        }
20107
 
        return NDR_ERR_SUCCESS;
20108
 
}
20109
 
 
20110
 
_PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
20111
 
{
20112
 
        uint32_t _ptr_server;
20113
 
        uint32_t _ptr_buffer;
20114
 
        uint32_t _ptr_info;
20115
 
        TALLOC_CTX *_mem_save_server_0;
20116
 
        TALLOC_CTX *_mem_save_buffer_0;
20117
 
        TALLOC_CTX *_mem_save_info_0;
20118
 
        TALLOC_CTX *_mem_save_needed_0;
20119
 
        TALLOC_CTX *_mem_save_count_0;
20120
 
        if (flags & NDR_IN) {
20121
 
                ZERO_STRUCT(r->out);
20122
 
 
20123
 
                NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
20124
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20125
 
                if (_ptr_server) {
20126
 
                        NDR_PULL_ALLOC(ndr, r->in.server);
20127
 
                } else {
20128
 
                        r->in.server = NULL;
20129
 
                }
20130
 
                if (r->in.server) {
20131
 
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20132
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20133
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20134
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20135
 
                        if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20136
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
20137
 
                        }
20138
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20139
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20140
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20141
 
                }
20142
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20143
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20144
 
                if (_ptr_buffer) {
20145
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
20146
 
                } else {
20147
 
                        r->in.buffer = NULL;
20148
 
                }
20149
 
                if (r->in.buffer) {
20150
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20151
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20152
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20153
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20154
 
                }
20155
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20156
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
20157
 
                ZERO_STRUCTP(r->out.needed);
20158
 
                NDR_PULL_ALLOC(ndr, r->out.count);
20159
 
                ZERO_STRUCTP(r->out.count);
20160
 
        }
20161
 
        if (flags & NDR_OUT) {
20162
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20163
 
                if (_ptr_info) {
20164
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
20165
 
                } else {
20166
 
                        r->out.info = NULL;
20167
 
                }
20168
 
                if (r->out.info) {
20169
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20170
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20171
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20172
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20173
 
                }
20174
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20175
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
20176
 
                }
20177
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20178
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20179
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20180
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20181
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20182
 
                        NDR_PULL_ALLOC(ndr, r->out.count);
20183
 
                }
20184
 
                _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20185
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20186
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20187
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20188
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20189
 
        }
20190
 
        return NDR_ERR_SUCCESS;
20191
 
}
20192
 
 
20193
 
_PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
20194
 
{
20195
 
        uint32_t cntr_info_0;
20196
 
        if (flags & NDR_IN) {
20197
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20198
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20199
 
        }
20200
 
        if (flags & NDR_OUT) {
20201
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20202
 
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20203
 
                        NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20204
 
                }
20205
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20206
 
                        NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20207
 
                }
20208
 
        }
20209
 
        return NDR_ERR_SUCCESS;
20210
 
}
20211
 
 
20212
 
_PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
20213
 
{
20214
 
        uint32_t cntr_info_0;
20215
 
        TALLOC_CTX *_mem_save_info_0;
20216
 
        if (flags & NDR_IN) {
20217
 
                ZERO_STRUCT(r->out);
20218
 
 
20219
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20220
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20221
 
        }
20222
 
        if (flags & NDR_OUT) {
20223
 
                NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20224
 
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20225
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20226
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20227
 
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20228
 
                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20229
 
                }
20230
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20231
 
                        NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20232
 
                }
20233
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20234
 
        }
20235
 
        return NDR_ERR_SUCCESS;
20236
 
}
20237
 
 
20238
 
_PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
20239
 
{
20240
 
        uint32_t cntr_info_2;
20241
 
        ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
20242
 
        ndr->depth++;
20243
 
        if (flags & NDR_SET_VALUES) {
20244
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20245
 
        }
20246
 
        if (flags & NDR_IN) {
20247
 
                ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
20248
 
                ndr->depth++;
20249
 
                ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
20250
 
                ndr_print_ptr(ndr, "server", r->in.server);
20251
 
                ndr->depth++;
20252
 
                if (r->in.server) {
20253
 
                        ndr_print_string(ndr, "server", r->in.server);
20254
 
                }
20255
 
                ndr->depth--;
20256
 
                ndr_print_uint32(ndr, "level", r->in.level);
20257
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
20258
 
                ndr->depth++;
20259
 
                if (r->in.buffer) {
20260
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20261
 
                }
20262
 
                ndr->depth--;
20263
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
20264
 
                ndr->depth--;
20265
 
        }
20266
 
        if (flags & NDR_OUT) {
20267
 
                ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
20268
 
                ndr->depth++;
20269
 
                ndr_print_ptr(ndr, "count", r->out.count);
20270
 
                ndr->depth++;
20271
 
                ndr_print_uint32(ndr, "count", *r->out.count);
20272
 
                ndr->depth--;
20273
 
                ndr_print_ptr(ndr, "info", r->out.info);
20274
 
                ndr->depth++;
20275
 
                ndr_print_ptr(ndr, "info", *r->out.info);
20276
 
                ndr->depth++;
20277
 
                if (*r->out.info) {
20278
 
                        ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20279
 
                        ndr->depth++;
20280
 
                        for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20281
 
                                char *idx_2=NULL;
20282
 
                                if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20283
 
                                        ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20284
 
                                        ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20285
 
                                        free(idx_2);
20286
 
                                }
20287
 
                        }
20288
 
                        ndr->depth--;
20289
 
                }
20290
 
                ndr->depth--;
20291
 
                ndr->depth--;
20292
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
20293
 
                ndr->depth++;
20294
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
20295
 
                ndr->depth--;
20296
 
                ndr_print_WERROR(ndr, "result", r->out.result);
20297
 
                ndr->depth--;
20298
 
        }
20299
 
        ndr->depth--;
20300
 
}
20301
 
 
20302
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
20303
 
{
20304
 
        if (flags & NDR_IN) {
20305
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20306
 
                if (r->in.printername) {
20307
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20308
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20309
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20310
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20311
 
                }
20312
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20313
 
                if (r->in.datatype) {
20314
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20315
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20316
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20317
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20318
 
                }
20319
 
                NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20320
 
                NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
20321
 
        }
20322
 
        if (flags & NDR_OUT) {
20323
 
                if (r->out.handle == NULL) {
20324
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20325
 
                }
20326
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20327
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20328
 
        }
20329
 
        return NDR_ERR_SUCCESS;
20330
 
}
20331
 
 
20332
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
20333
 
{
20334
 
        uint32_t _ptr_printername;
20335
 
        uint32_t _ptr_datatype;
20336
 
        TALLOC_CTX *_mem_save_printername_0;
20337
 
        TALLOC_CTX *_mem_save_datatype_0;
20338
 
        TALLOC_CTX *_mem_save_handle_0;
20339
 
        if (flags & NDR_IN) {
20340
 
                ZERO_STRUCT(r->out);
20341
 
 
20342
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
20343
 
                if (_ptr_printername) {
20344
 
                        NDR_PULL_ALLOC(ndr, r->in.printername);
20345
 
                } else {
20346
 
                        r->in.printername = NULL;
20347
 
                }
20348
 
                if (r->in.printername) {
20349
 
                        _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20350
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
20351
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
20352
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
20353
 
                        if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
20354
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.printername), ndr_get_array_length(ndr, &r->in.printername));
20355
 
                        }
20356
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
20357
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
20358
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
20359
 
                }
20360
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
20361
 
                if (_ptr_datatype) {
20362
 
                        NDR_PULL_ALLOC(ndr, r->in.datatype);
20363
 
                } else {
20364
 
                        r->in.datatype = NULL;
20365
 
                }
20366
 
                if (r->in.datatype) {
20367
 
                        _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
20368
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
20369
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
20370
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
20371
 
                        if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
20372
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.datatype), ndr_get_array_length(ndr, &r->in.datatype));
20373
 
                        }
20374
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
20375
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
20376
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
20377
 
                }
20378
 
                NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20379
 
                NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
20380
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
20381
 
                ZERO_STRUCTP(r->out.handle);
20382
 
        }
20383
 
        if (flags & NDR_OUT) {
20384
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20385
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
20386
 
                }
20387
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20388
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20389
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20390
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20391
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20392
 
        }
20393
 
        return NDR_ERR_SUCCESS;
20394
 
}
20395
 
 
20396
 
_PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
20397
 
{
20398
 
        ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
20399
 
        ndr->depth++;
20400
 
        if (flags & NDR_SET_VALUES) {
20401
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20402
 
        }
20403
 
        if (flags & NDR_IN) {
20404
 
                ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
20405
 
                ndr->depth++;
20406
 
                ndr_print_ptr(ndr, "printername", r->in.printername);
20407
 
                ndr->depth++;
20408
 
                if (r->in.printername) {
20409
 
                        ndr_print_string(ndr, "printername", r->in.printername);
20410
 
                }
20411
 
                ndr->depth--;
20412
 
                ndr_print_ptr(ndr, "datatype", r->in.datatype);
20413
 
                ndr->depth++;
20414
 
                if (r->in.datatype) {
20415
 
                        ndr_print_string(ndr, "datatype", r->in.datatype);
20416
 
                }
20417
 
                ndr->depth--;
20418
 
                ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
20419
 
                ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
20420
 
                ndr->depth--;
20421
 
        }
20422
 
        if (flags & NDR_OUT) {
20423
 
                ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
20424
 
                ndr->depth++;
20425
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
20426
 
                ndr->depth++;
20427
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
20428
 
                ndr->depth--;
20429
 
                ndr_print_WERROR(ndr, "result", r->out.result);
20430
 
                ndr->depth--;
20431
 
        }
20432
 
        ndr->depth--;
20433
 
}
20434
 
 
20435
 
static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
20436
 
{
20437
 
        if (flags & NDR_IN) {
20438
 
                if (r->in.handle == NULL) {
20439
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20440
 
                }
20441
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20442
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20443
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
20444
 
                if (r->in.ctr) {
20445
 
                        NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20446
 
                }
20447
 
                NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
20448
 
        }
20449
 
        if (flags & NDR_OUT) {
20450
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20451
 
        }
20452
 
        return NDR_ERR_SUCCESS;
20453
 
}
20454
 
 
20455
 
static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
20456
 
{
20457
 
        uint32_t _ptr_ctr;
20458
 
        TALLOC_CTX *_mem_save_handle_0;
20459
 
        TALLOC_CTX *_mem_save_ctr_0;
20460
 
        if (flags & NDR_IN) {
20461
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20462
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
20463
 
                }
20464
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20465
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20466
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20467
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20468
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20469
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
20470
 
                if (_ptr_ctr) {
20471
 
                        NDR_PULL_ALLOC(ndr, r->in.ctr);
20472
 
                } else {
20473
 
                        r->in.ctr = NULL;
20474
 
                }
20475
 
                if (r->in.ctr) {
20476
 
                        _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20477
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
20478
 
                        NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20479
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
20480
 
                }
20481
 
                NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
20482
 
        }
20483
 
        if (flags & NDR_OUT) {
20484
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20485
 
        }
20486
 
        return NDR_ERR_SUCCESS;
20487
 
}
20488
 
 
20489
 
_PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
20490
 
{
20491
 
        ndr_print_struct(ndr, name, "spoolss_SetJob");
20492
 
        ndr->depth++;
20493
 
        if (flags & NDR_SET_VALUES) {
20494
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20495
 
        }
20496
 
        if (flags & NDR_IN) {
20497
 
                ndr_print_struct(ndr, "in", "spoolss_SetJob");
20498
 
                ndr->depth++;
20499
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
20500
 
                ndr->depth++;
20501
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
20502
 
                ndr->depth--;
20503
 
                ndr_print_uint32(ndr, "job_id", r->in.job_id);
20504
 
                ndr_print_ptr(ndr, "ctr", r->in.ctr);
20505
 
                ndr->depth++;
20506
 
                if (r->in.ctr) {
20507
 
                        ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
20508
 
                }
20509
 
                ndr->depth--;
20510
 
                ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
20511
 
                ndr->depth--;
20512
 
        }
20513
 
        if (flags & NDR_OUT) {
20514
 
                ndr_print_struct(ndr, "out", "spoolss_SetJob");
20515
 
                ndr->depth++;
20516
 
                ndr_print_WERROR(ndr, "result", r->out.result);
20517
 
                ndr->depth--;
20518
 
        }
20519
 
        ndr->depth--;
20520
 
}
20521
 
 
20522
 
static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
20523
 
{
20524
 
        if (flags & NDR_IN) {
20525
 
                if (r->in.handle == NULL) {
20526
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20527
 
                }
20528
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20529
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20530
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20531
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20532
 
                if (r->in.buffer) {
20533
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20534
 
                }
20535
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20536
 
        }
20537
 
        if (flags & NDR_OUT) {
20538
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20539
 
                if (r->out.info) {
20540
 
                        {
20541
 
                                struct ndr_push *_ndr_info;
20542
 
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20543
 
                                NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20544
 
                                NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20545
 
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20546
 
                        }
20547
 
                }
20548
 
                if (r->out.needed == NULL) {
20549
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20550
 
                }
20551
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20552
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20553
 
        }
20554
 
        return NDR_ERR_SUCCESS;
20555
 
}
20556
 
 
20557
 
static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
20558
 
{
20559
 
        uint32_t _ptr_buffer;
20560
 
        uint32_t _ptr_info;
20561
 
        TALLOC_CTX *_mem_save_handle_0;
20562
 
        TALLOC_CTX *_mem_save_buffer_0;
20563
 
        TALLOC_CTX *_mem_save_info_0;
20564
 
        TALLOC_CTX *_mem_save_needed_0;
20565
 
        if (flags & NDR_IN) {
20566
 
                ZERO_STRUCT(r->out);
20567
 
 
20568
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20569
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
20570
 
                }
20571
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20572
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20573
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20574
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20575
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20576
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20577
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20578
 
                if (_ptr_buffer) {
20579
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
20580
 
                } else {
20581
 
                        r->in.buffer = NULL;
20582
 
                }
20583
 
                if (r->in.buffer) {
20584
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20585
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20586
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20587
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20588
 
                }
20589
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20590
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
20591
 
                ZERO_STRUCTP(r->out.needed);
20592
 
        }
20593
 
        if (flags & NDR_OUT) {
20594
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20595
 
                if (_ptr_info) {
20596
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
20597
 
                } else {
20598
 
                        r->out.info = NULL;
20599
 
                }
20600
 
                if (r->out.info) {
20601
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20602
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20603
 
                        {
20604
 
                                struct ndr_pull *_ndr_info;
20605
 
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20606
 
                                NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20607
 
                                NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20608
 
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20609
 
                        }
20610
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20611
 
                }
20612
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20613
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
20614
 
                }
20615
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20616
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20617
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20618
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20619
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20620
 
        }
20621
 
        return NDR_ERR_SUCCESS;
20622
 
}
20623
 
 
20624
 
_PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
20625
 
{
20626
 
        ndr_print_struct(ndr, name, "spoolss_GetJob");
20627
 
        ndr->depth++;
20628
 
        if (flags & NDR_SET_VALUES) {
20629
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20630
 
        }
20631
 
        if (flags & NDR_IN) {
20632
 
                ndr_print_struct(ndr, "in", "spoolss_GetJob");
20633
 
                ndr->depth++;
20634
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
20635
 
                ndr->depth++;
20636
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
20637
 
                ndr->depth--;
20638
 
                ndr_print_uint32(ndr, "job_id", r->in.job_id);
20639
 
                ndr_print_uint32(ndr, "level", r->in.level);
20640
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
20641
 
                ndr->depth++;
20642
 
                if (r->in.buffer) {
20643
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20644
 
                }
20645
 
                ndr->depth--;
20646
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
20647
 
                ndr->depth--;
20648
 
        }
20649
 
        if (flags & NDR_OUT) {
20650
 
                ndr_print_struct(ndr, "out", "spoolss_GetJob");
20651
 
                ndr->depth++;
20652
 
                ndr_print_ptr(ndr, "info", r->out.info);
20653
 
                ndr->depth++;
20654
 
                if (r->out.info) {
20655
 
                        ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20656
 
                        ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
20657
 
                }
20658
 
                ndr->depth--;
20659
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
20660
 
                ndr->depth++;
20661
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
20662
 
                ndr->depth--;
20663
 
                ndr_print_WERROR(ndr, "result", r->out.result);
20664
 
                ndr->depth--;
20665
 
        }
20666
 
        ndr->depth--;
20667
 
}
20668
 
 
20669
 
_PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
20670
 
{
20671
 
        if (flags & NDR_IN) {
20672
 
                if (r->in.handle == NULL) {
20673
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20674
 
                }
20675
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20676
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
20677
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
20678
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20679
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20680
 
                if (r->in.buffer) {
20681
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20682
 
                }
20683
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20684
 
        }
20685
 
        if (flags & NDR_OUT) {
20686
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20687
 
                if (r->out.info) {
20688
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20689
 
                }
20690
 
                if (r->out.needed == NULL) {
20691
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20692
 
                }
20693
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20694
 
                if (r->out.count == NULL) {
20695
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20696
 
                }
20697
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20698
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20699
 
        }
20700
 
        return NDR_ERR_SUCCESS;
20701
 
}
20702
 
 
20703
 
_PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
20704
 
{
20705
 
        uint32_t _ptr_buffer;
20706
 
        uint32_t _ptr_info;
20707
 
        TALLOC_CTX *_mem_save_handle_0;
20708
 
        TALLOC_CTX *_mem_save_buffer_0;
20709
 
        TALLOC_CTX *_mem_save_info_0;
20710
 
        TALLOC_CTX *_mem_save_needed_0;
20711
 
        TALLOC_CTX *_mem_save_count_0;
20712
 
        if (flags & NDR_IN) {
20713
 
                ZERO_STRUCT(r->out);
20714
 
 
20715
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20716
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
20717
 
                }
20718
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20719
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20720
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20721
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20722
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
20723
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
20724
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20725
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20726
 
                if (_ptr_buffer) {
20727
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
20728
 
                } else {
20729
 
                        r->in.buffer = NULL;
20730
 
                }
20731
 
                if (r->in.buffer) {
20732
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20733
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20734
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20735
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20736
 
                }
20737
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20738
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
20739
 
                ZERO_STRUCTP(r->out.needed);
20740
 
                NDR_PULL_ALLOC(ndr, r->out.count);
20741
 
                ZERO_STRUCTP(r->out.count);
20742
 
        }
20743
 
        if (flags & NDR_OUT) {
20744
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20745
 
                if (_ptr_info) {
20746
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
20747
 
                } else {
20748
 
                        r->out.info = NULL;
20749
 
                }
20750
 
                if (r->out.info) {
20751
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20752
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20753
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20754
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20755
 
                }
20756
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20757
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
20758
 
                }
20759
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20760
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20761
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20762
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20763
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20764
 
                        NDR_PULL_ALLOC(ndr, r->out.count);
20765
 
                }
20766
 
                _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20767
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20768
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20769
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20770
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20771
 
        }
20772
 
        return NDR_ERR_SUCCESS;
20773
 
}
20774
 
 
20775
 
_PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
20776
 
{
20777
 
        uint32_t cntr_info_0;
20778
 
        if (flags & NDR_IN) {
20779
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20780
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20781
 
        }
20782
 
        if (flags & NDR_OUT) {
20783
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20784
 
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20785
 
                        NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20786
 
                }
20787
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20788
 
                        NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20789
 
                }
20790
 
        }
20791
 
        return NDR_ERR_SUCCESS;
20792
 
}
20793
 
 
20794
 
_PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
20795
 
{
20796
 
        uint32_t cntr_info_0;
20797
 
        TALLOC_CTX *_mem_save_info_0;
20798
 
        if (flags & NDR_IN) {
20799
 
                ZERO_STRUCT(r->out);
20800
 
 
20801
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20802
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20803
 
        }
20804
 
        if (flags & NDR_OUT) {
20805
 
                NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20806
 
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20807
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20808
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20809
 
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20810
 
                        NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20811
 
                }
20812
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20813
 
                        NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20814
 
                }
20815
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20816
 
        }
20817
 
        return NDR_ERR_SUCCESS;
20818
 
}
20819
 
 
20820
 
_PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
20821
 
{
20822
 
        uint32_t cntr_info_2;
20823
 
        ndr_print_struct(ndr, name, "spoolss_EnumJobs");
20824
 
        ndr->depth++;
20825
 
        if (flags & NDR_SET_VALUES) {
20826
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20827
 
        }
20828
 
        if (flags & NDR_IN) {
20829
 
                ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
20830
 
                ndr->depth++;
20831
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
20832
 
                ndr->depth++;
20833
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
20834
 
                ndr->depth--;
20835
 
                ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
20836
 
                ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
20837
 
                ndr_print_uint32(ndr, "level", r->in.level);
20838
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
20839
 
                ndr->depth++;
20840
 
                if (r->in.buffer) {
20841
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20842
 
                }
20843
 
                ndr->depth--;
20844
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
20845
 
                ndr->depth--;
20846
 
        }
20847
 
        if (flags & NDR_OUT) {
20848
 
                ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
20849
 
                ndr->depth++;
20850
 
                ndr_print_ptr(ndr, "count", r->out.count);
20851
 
                ndr->depth++;
20852
 
                ndr_print_uint32(ndr, "count", *r->out.count);
20853
 
                ndr->depth--;
20854
 
                ndr_print_ptr(ndr, "info", r->out.info);
20855
 
                ndr->depth++;
20856
 
                ndr_print_ptr(ndr, "info", *r->out.info);
20857
 
                ndr->depth++;
20858
 
                if (*r->out.info) {
20859
 
                        ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20860
 
                        ndr->depth++;
20861
 
                        for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20862
 
                                char *idx_2=NULL;
20863
 
                                if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20864
 
                                        ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20865
 
                                        ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20866
 
                                        free(idx_2);
20867
 
                                }
20868
 
                        }
20869
 
                        ndr->depth--;
20870
 
                }
20871
 
                ndr->depth--;
20872
 
                ndr->depth--;
20873
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
20874
 
                ndr->depth++;
20875
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
20876
 
                ndr->depth--;
20877
 
                ndr_print_WERROR(ndr, "result", r->out.result);
20878
 
                ndr->depth--;
20879
 
        }
20880
 
        ndr->depth--;
20881
 
}
20882
 
 
20883
 
static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
20884
 
{
20885
 
        if (flags & NDR_IN) {
20886
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20887
 
                if (r->in.server) {
20888
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20889
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20890
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20891
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20892
 
                }
20893
 
                if (r->in.info_ctr == NULL) {
20894
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20895
 
                }
20896
 
                NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20897
 
                if (r->in.devmode_ctr == NULL) {
20898
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20899
 
                }
20900
 
                NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20901
 
                if (r->in.secdesc_ctr == NULL) {
20902
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20903
 
                }
20904
 
                NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20905
 
        }
20906
 
        if (flags & NDR_OUT) {
20907
 
                if (r->out.handle == NULL) {
20908
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20909
 
                }
20910
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20911
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20912
 
        }
20913
 
        return NDR_ERR_SUCCESS;
20914
 
}
20915
 
 
20916
 
static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
20917
 
{
20918
 
        uint32_t _ptr_server;
20919
 
        TALLOC_CTX *_mem_save_server_0;
20920
 
        TALLOC_CTX *_mem_save_info_ctr_0;
20921
 
        TALLOC_CTX *_mem_save_devmode_ctr_0;
20922
 
        TALLOC_CTX *_mem_save_secdesc_ctr_0;
20923
 
        TALLOC_CTX *_mem_save_handle_0;
20924
 
        if (flags & NDR_IN) {
20925
 
                ZERO_STRUCT(r->out);
20926
 
 
20927
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20928
 
                if (_ptr_server) {
20929
 
                        NDR_PULL_ALLOC(ndr, r->in.server);
20930
 
                } else {
20931
 
                        r->in.server = NULL;
20932
 
                }
20933
 
                if (r->in.server) {
20934
 
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20935
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20936
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20937
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20938
 
                        if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20939
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
20940
 
                        }
20941
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20942
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20943
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20944
 
                }
20945
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20946
 
                        NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20947
 
                }
20948
 
                _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20949
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20950
 
                NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20951
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20952
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20953
 
                        NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
20954
 
                }
20955
 
                _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20956
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
20957
 
                NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
20958
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20959
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20960
 
                        NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
20961
 
                }
20962
 
                _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20963
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
20964
 
                NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
20965
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20966
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
20967
 
                ZERO_STRUCTP(r->out.handle);
20968
 
        }
20969
 
        if (flags & NDR_OUT) {
20970
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20971
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
20972
 
                }
20973
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20974
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20975
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20976
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20977
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20978
 
        }
20979
 
        return NDR_ERR_SUCCESS;
20980
 
}
20981
 
 
20982
 
_PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
20983
 
{
20984
 
        ndr_print_struct(ndr, name, "spoolss_AddPrinter");
20985
 
        ndr->depth++;
20986
 
        if (flags & NDR_SET_VALUES) {
20987
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20988
 
        }
20989
 
        if (flags & NDR_IN) {
20990
 
                ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
20991
 
                ndr->depth++;
20992
 
                ndr_print_ptr(ndr, "server", r->in.server);
20993
 
                ndr->depth++;
20994
 
                if (r->in.server) {
20995
 
                        ndr_print_string(ndr, "server", r->in.server);
20996
 
                }
20997
 
                ndr->depth--;
20998
 
                ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20999
 
                ndr->depth++;
21000
 
                ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21001
 
                ndr->depth--;
21002
 
                ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21003
 
                ndr->depth++;
21004
 
                ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21005
 
                ndr->depth--;
21006
 
                ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21007
 
                ndr->depth++;
21008
 
                ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21009
 
                ndr->depth--;
21010
 
                ndr->depth--;
21011
 
        }
21012
 
        if (flags & NDR_OUT) {
21013
 
                ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
21014
 
                ndr->depth++;
21015
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
21016
 
                ndr->depth++;
21017
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
21018
 
                ndr->depth--;
21019
 
                ndr_print_WERROR(ndr, "result", r->out.result);
21020
 
                ndr->depth--;
21021
 
        }
21022
 
        ndr->depth--;
21023
 
}
21024
 
 
21025
 
static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
21026
 
{
21027
 
        if (flags & NDR_IN) {
21028
 
                if (r->in.handle == NULL) {
21029
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21030
 
                }
21031
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21032
 
        }
21033
 
        if (flags & NDR_OUT) {
21034
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21035
 
        }
21036
 
        return NDR_ERR_SUCCESS;
21037
 
}
21038
 
 
21039
 
static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
21040
 
{
21041
 
        TALLOC_CTX *_mem_save_handle_0;
21042
 
        if (flags & NDR_IN) {
21043
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21044
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
21045
 
                }
21046
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21047
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21048
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21049
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21050
 
        }
21051
 
        if (flags & NDR_OUT) {
21052
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21053
 
        }
21054
 
        return NDR_ERR_SUCCESS;
21055
 
}
21056
 
 
21057
 
_PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
21058
 
{
21059
 
        ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
21060
 
        ndr->depth++;
21061
 
        if (flags & NDR_SET_VALUES) {
21062
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21063
 
        }
21064
 
        if (flags & NDR_IN) {
21065
 
                ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
21066
 
                ndr->depth++;
21067
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
21068
 
                ndr->depth++;
21069
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
21070
 
                ndr->depth--;
21071
 
                ndr->depth--;
21072
 
        }
21073
 
        if (flags & NDR_OUT) {
21074
 
                ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
21075
 
                ndr->depth++;
21076
 
                ndr_print_WERROR(ndr, "result", r->out.result);
21077
 
                ndr->depth--;
21078
 
        }
21079
 
        ndr->depth--;
21080
 
}
21081
 
 
21082
 
static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
21083
 
{
21084
 
        if (flags & NDR_IN) {
21085
 
                if (r->in.handle == NULL) {
21086
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21087
 
                }
21088
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21089
 
                if (r->in.info_ctr == NULL) {
21090
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21091
 
                }
21092
 
                NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21093
 
                if (r->in.devmode_ctr == NULL) {
21094
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21095
 
                }
21096
 
                NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21097
 
                if (r->in.secdesc_ctr == NULL) {
21098
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21099
 
                }
21100
 
                NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21101
 
                NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
21102
 
        }
21103
 
        if (flags & NDR_OUT) {
21104
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21105
 
        }
21106
 
        return NDR_ERR_SUCCESS;
21107
 
}
21108
 
 
21109
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
21110
 
{
21111
 
        TALLOC_CTX *_mem_save_handle_0;
21112
 
        TALLOC_CTX *_mem_save_info_ctr_0;
21113
 
        TALLOC_CTX *_mem_save_devmode_ctr_0;
21114
 
        TALLOC_CTX *_mem_save_secdesc_ctr_0;
21115
 
        if (flags & NDR_IN) {
21116
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21117
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
21118
 
                }
21119
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21120
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21121
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21122
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21123
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21124
 
                        NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21125
 
                }
21126
 
                _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21127
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21128
 
                NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21129
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21130
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21131
 
                        NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21132
 
                }
21133
 
                _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21134
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21135
 
                NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21136
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21137
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21138
 
                        NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21139
 
                }
21140
 
                _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21141
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21142
 
                NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21143
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21144
 
                NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
21145
 
        }
21146
 
        if (flags & NDR_OUT) {
21147
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21148
 
        }
21149
 
        return NDR_ERR_SUCCESS;
21150
 
}
21151
 
 
21152
 
_PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
21153
 
{
21154
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinter");
21155
 
        ndr->depth++;
21156
 
        if (flags & NDR_SET_VALUES) {
21157
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21158
 
        }
21159
 
        if (flags & NDR_IN) {
21160
 
                ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
21161
 
                ndr->depth++;
21162
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
21163
 
                ndr->depth++;
21164
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
21165
 
                ndr->depth--;
21166
 
                ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21167
 
                ndr->depth++;
21168
 
                ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21169
 
                ndr->depth--;
21170
 
                ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21171
 
                ndr->depth++;
21172
 
                ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21173
 
                ndr->depth--;
21174
 
                ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21175
 
                ndr->depth++;
21176
 
                ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21177
 
                ndr->depth--;
21178
 
                ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
21179
 
                ndr->depth--;
21180
 
        }
21181
 
        if (flags & NDR_OUT) {
21182
 
                ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
21183
 
                ndr->depth++;
21184
 
                ndr_print_WERROR(ndr, "result", r->out.result);
21185
 
                ndr->depth--;
21186
 
        }
21187
 
        ndr->depth--;
21188
 
}
21189
 
 
21190
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
21191
 
{
21192
 
        if (flags & NDR_IN) {
21193
 
                if (r->in.handle == NULL) {
21194
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21195
 
                }
21196
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21197
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21198
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21199
 
                if (r->in.buffer) {
21200
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21201
 
                }
21202
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21203
 
        }
21204
 
        if (flags & NDR_OUT) {
21205
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21206
 
                if (r->out.info) {
21207
 
                        {
21208
 
                                struct ndr_push *_ndr_info;
21209
 
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21210
 
                                NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21211
 
                                NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21212
 
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21213
 
                        }
21214
 
                }
21215
 
                if (r->out.needed == NULL) {
21216
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21217
 
                }
21218
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21219
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21220
 
        }
21221
 
        return NDR_ERR_SUCCESS;
21222
 
}
21223
 
 
21224
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
21225
 
{
21226
 
        uint32_t _ptr_buffer;
21227
 
        uint32_t _ptr_info;
21228
 
        TALLOC_CTX *_mem_save_handle_0;
21229
 
        TALLOC_CTX *_mem_save_buffer_0;
21230
 
        TALLOC_CTX *_mem_save_info_0;
21231
 
        TALLOC_CTX *_mem_save_needed_0;
21232
 
        if (flags & NDR_IN) {
21233
 
                ZERO_STRUCT(r->out);
21234
 
 
21235
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21236
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
21237
 
                }
21238
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21239
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21240
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21241
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21242
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21243
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21244
 
                if (_ptr_buffer) {
21245
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
21246
 
                } else {
21247
 
                        r->in.buffer = NULL;
21248
 
                }
21249
 
                if (r->in.buffer) {
21250
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21251
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21252
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21253
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21254
 
                }
21255
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21256
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
21257
 
                ZERO_STRUCTP(r->out.needed);
21258
 
        }
21259
 
        if (flags & NDR_OUT) {
21260
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21261
 
                if (_ptr_info) {
21262
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
21263
 
                } else {
21264
 
                        r->out.info = NULL;
21265
 
                }
21266
 
                if (r->out.info) {
21267
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21268
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21269
 
                        {
21270
 
                                struct ndr_pull *_ndr_info;
21271
 
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21272
 
                                NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21273
 
                                NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21274
 
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21275
 
                        }
21276
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21277
 
                }
21278
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21279
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
21280
 
                }
21281
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21282
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21283
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21284
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21285
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21286
 
        }
21287
 
        return NDR_ERR_SUCCESS;
21288
 
}
21289
 
 
21290
 
_PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
21291
 
{
21292
 
        ndr_print_struct(ndr, name, "spoolss_GetPrinter");
21293
 
        ndr->depth++;
21294
 
        if (flags & NDR_SET_VALUES) {
21295
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21296
 
        }
21297
 
        if (flags & NDR_IN) {
21298
 
                ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
21299
 
                ndr->depth++;
21300
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
21301
 
                ndr->depth++;
21302
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
21303
 
                ndr->depth--;
21304
 
                ndr_print_uint32(ndr, "level", r->in.level);
21305
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
21306
 
                ndr->depth++;
21307
 
                if (r->in.buffer) {
21308
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21309
 
                }
21310
 
                ndr->depth--;
21311
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
21312
 
                ndr->depth--;
21313
 
        }
21314
 
        if (flags & NDR_OUT) {
21315
 
                ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
21316
 
                ndr->depth++;
21317
 
                ndr_print_ptr(ndr, "info", r->out.info);
21318
 
                ndr->depth++;
21319
 
                if (r->out.info) {
21320
 
                        ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21321
 
                        ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
21322
 
                }
21323
 
                ndr->depth--;
21324
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
21325
 
                ndr->depth++;
21326
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
21327
 
                ndr->depth--;
21328
 
                ndr_print_WERROR(ndr, "result", r->out.result);
21329
 
                ndr->depth--;
21330
 
        }
21331
 
        ndr->depth--;
21332
 
}
21333
 
 
21334
 
static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
21335
 
{
21336
 
        if (flags & NDR_IN) {
21337
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21338
 
                if (r->in.servername) {
21339
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21340
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21341
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21342
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21343
 
                }
21344
 
                if (r->in.info_ctr == NULL) {
21345
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21346
 
                }
21347
 
                NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21348
 
        }
21349
 
        if (flags & NDR_OUT) {
21350
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21351
 
        }
21352
 
        return NDR_ERR_SUCCESS;
21353
 
}
21354
 
 
21355
 
static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
21356
 
{
21357
 
        uint32_t _ptr_servername;
21358
 
        TALLOC_CTX *_mem_save_servername_0;
21359
 
        TALLOC_CTX *_mem_save_info_ctr_0;
21360
 
        if (flags & NDR_IN) {
21361
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21362
 
                if (_ptr_servername) {
21363
 
                        NDR_PULL_ALLOC(ndr, r->in.servername);
21364
 
                } else {
21365
 
                        r->in.servername = NULL;
21366
 
                }
21367
 
                if (r->in.servername) {
21368
 
                        _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21369
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21370
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21371
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21372
 
                        if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21373
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
21374
 
                        }
21375
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21376
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21377
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21378
 
                }
21379
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21380
 
                        NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21381
 
                }
21382
 
                _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21383
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21384
 
                NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21385
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21386
 
        }
21387
 
        if (flags & NDR_OUT) {
21388
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21389
 
        }
21390
 
        return NDR_ERR_SUCCESS;
21391
 
}
21392
 
 
21393
 
_PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
21394
 
{
21395
 
        ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
21396
 
        ndr->depth++;
21397
 
        if (flags & NDR_SET_VALUES) {
21398
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21399
 
        }
21400
 
        if (flags & NDR_IN) {
21401
 
                ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
21402
 
                ndr->depth++;
21403
 
                ndr_print_ptr(ndr, "servername", r->in.servername);
21404
 
                ndr->depth++;
21405
 
                if (r->in.servername) {
21406
 
                        ndr_print_string(ndr, "servername", r->in.servername);
21407
 
                }
21408
 
                ndr->depth--;
21409
 
                ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21410
 
                ndr->depth++;
21411
 
                ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21412
 
                ndr->depth--;
21413
 
                ndr->depth--;
21414
 
        }
21415
 
        if (flags & NDR_OUT) {
21416
 
                ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
21417
 
                ndr->depth++;
21418
 
                ndr_print_WERROR(ndr, "result", r->out.result);
21419
 
                ndr->depth--;
21420
 
        }
21421
 
        ndr->depth--;
21422
 
}
21423
 
 
21424
 
_PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
21425
 
{
21426
 
        if (flags & NDR_IN) {
21427
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21428
 
                if (r->in.server) {
21429
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21430
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21431
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21432
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21433
 
                }
21434
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21435
 
                if (r->in.environment) {
21436
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21437
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21438
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21439
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21440
 
                }
21441
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21442
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21443
 
                if (r->in.buffer) {
21444
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21445
 
                }
21446
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21447
 
        }
21448
 
        if (flags & NDR_OUT) {
21449
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21450
 
                if (r->out.info) {
21451
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21452
 
                }
21453
 
                if (r->out.needed == NULL) {
21454
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21455
 
                }
21456
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21457
 
                if (r->out.count == NULL) {
21458
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21459
 
                }
21460
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21461
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21462
 
        }
21463
 
        return NDR_ERR_SUCCESS;
21464
 
}
21465
 
 
21466
 
_PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
21467
 
{
21468
 
        uint32_t _ptr_server;
21469
 
        uint32_t _ptr_environment;
21470
 
        uint32_t _ptr_buffer;
21471
 
        uint32_t _ptr_info;
21472
 
        TALLOC_CTX *_mem_save_server_0;
21473
 
        TALLOC_CTX *_mem_save_environment_0;
21474
 
        TALLOC_CTX *_mem_save_buffer_0;
21475
 
        TALLOC_CTX *_mem_save_info_0;
21476
 
        TALLOC_CTX *_mem_save_needed_0;
21477
 
        TALLOC_CTX *_mem_save_count_0;
21478
 
        if (flags & NDR_IN) {
21479
 
                ZERO_STRUCT(r->out);
21480
 
 
21481
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21482
 
                if (_ptr_server) {
21483
 
                        NDR_PULL_ALLOC(ndr, r->in.server);
21484
 
                } else {
21485
 
                        r->in.server = NULL;
21486
 
                }
21487
 
                if (r->in.server) {
21488
 
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21489
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21490
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21491
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21492
 
                        if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21493
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
21494
 
                        }
21495
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21496
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21497
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21498
 
                }
21499
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21500
 
                if (_ptr_environment) {
21501
 
                        NDR_PULL_ALLOC(ndr, r->in.environment);
21502
 
                } else {
21503
 
                        r->in.environment = NULL;
21504
 
                }
21505
 
                if (r->in.environment) {
21506
 
                        _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21507
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21508
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21509
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21510
 
                        if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21511
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
21512
 
                        }
21513
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21514
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21515
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21516
 
                }
21517
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21518
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21519
 
                if (_ptr_buffer) {
21520
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
21521
 
                } else {
21522
 
                        r->in.buffer = NULL;
21523
 
                }
21524
 
                if (r->in.buffer) {
21525
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21526
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21527
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21528
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21529
 
                }
21530
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21531
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
21532
 
                ZERO_STRUCTP(r->out.needed);
21533
 
                NDR_PULL_ALLOC(ndr, r->out.count);
21534
 
                ZERO_STRUCTP(r->out.count);
21535
 
        }
21536
 
        if (flags & NDR_OUT) {
21537
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21538
 
                if (_ptr_info) {
21539
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
21540
 
                } else {
21541
 
                        r->out.info = NULL;
21542
 
                }
21543
 
                if (r->out.info) {
21544
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21545
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21546
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21547
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21548
 
                }
21549
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21550
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
21551
 
                }
21552
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21553
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21554
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21555
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21556
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21557
 
                        NDR_PULL_ALLOC(ndr, r->out.count);
21558
 
                }
21559
 
                _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21560
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21561
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21562
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21563
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21564
 
        }
21565
 
        return NDR_ERR_SUCCESS;
21566
 
}
21567
 
 
21568
 
_PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
21569
 
{
21570
 
        uint32_t cntr_info_0;
21571
 
        if (flags & NDR_IN) {
21572
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21573
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21574
 
        }
21575
 
        if (flags & NDR_OUT) {
21576
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21577
 
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21578
 
                        NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21579
 
                }
21580
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21581
 
                        NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21582
 
                }
21583
 
        }
21584
 
        return NDR_ERR_SUCCESS;
21585
 
}
21586
 
 
21587
 
_PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
21588
 
{
21589
 
        uint32_t cntr_info_0;
21590
 
        TALLOC_CTX *_mem_save_info_0;
21591
 
        if (flags & NDR_IN) {
21592
 
                ZERO_STRUCT(r->out);
21593
 
 
21594
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21595
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21596
 
        }
21597
 
        if (flags & NDR_OUT) {
21598
 
                NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21599
 
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21600
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21601
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21602
 
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21603
 
                        NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21604
 
                }
21605
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21606
 
                        NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21607
 
                }
21608
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21609
 
        }
21610
 
        return NDR_ERR_SUCCESS;
21611
 
}
21612
 
 
21613
 
_PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
21614
 
{
21615
 
        uint32_t cntr_info_2;
21616
 
        ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
21617
 
        ndr->depth++;
21618
 
        if (flags & NDR_SET_VALUES) {
21619
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21620
 
        }
21621
 
        if (flags & NDR_IN) {
21622
 
                ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
21623
 
                ndr->depth++;
21624
 
                ndr_print_ptr(ndr, "server", r->in.server);
21625
 
                ndr->depth++;
21626
 
                if (r->in.server) {
21627
 
                        ndr_print_string(ndr, "server", r->in.server);
21628
 
                }
21629
 
                ndr->depth--;
21630
 
                ndr_print_ptr(ndr, "environment", r->in.environment);
21631
 
                ndr->depth++;
21632
 
                if (r->in.environment) {
21633
 
                        ndr_print_string(ndr, "environment", r->in.environment);
21634
 
                }
21635
 
                ndr->depth--;
21636
 
                ndr_print_uint32(ndr, "level", r->in.level);
21637
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
21638
 
                ndr->depth++;
21639
 
                if (r->in.buffer) {
21640
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21641
 
                }
21642
 
                ndr->depth--;
21643
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
21644
 
                ndr->depth--;
21645
 
        }
21646
 
        if (flags & NDR_OUT) {
21647
 
                ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
21648
 
                ndr->depth++;
21649
 
                ndr_print_ptr(ndr, "count", r->out.count);
21650
 
                ndr->depth++;
21651
 
                ndr_print_uint32(ndr, "count", *r->out.count);
21652
 
                ndr->depth--;
21653
 
                ndr_print_ptr(ndr, "info", r->out.info);
21654
 
                ndr->depth++;
21655
 
                ndr_print_ptr(ndr, "info", *r->out.info);
21656
 
                ndr->depth++;
21657
 
                if (*r->out.info) {
21658
 
                        ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21659
 
                        ndr->depth++;
21660
 
                        for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21661
 
                                char *idx_2=NULL;
21662
 
                                if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21663
 
                                        ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21664
 
                                        ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21665
 
                                        free(idx_2);
21666
 
                                }
21667
 
                        }
21668
 
                        ndr->depth--;
21669
 
                }
21670
 
                ndr->depth--;
21671
 
                ndr->depth--;
21672
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
21673
 
                ndr->depth++;
21674
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
21675
 
                ndr->depth--;
21676
 
                ndr_print_WERROR(ndr, "result", r->out.result);
21677
 
                ndr->depth--;
21678
 
        }
21679
 
        ndr->depth--;
21680
 
}
21681
 
 
21682
 
static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
21683
 
{
21684
 
        if (flags & NDR_IN) {
21685
 
                if (r->in.handle == NULL) {
21686
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21687
 
                }
21688
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21689
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
21690
 
                if (r->in.architecture) {
21691
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21692
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21693
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21694
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21695
 
                }
21696
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21697
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21698
 
                if (r->in.buffer) {
21699
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21700
 
                }
21701
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21702
 
        }
21703
 
        if (flags & NDR_OUT) {
21704
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21705
 
                if (r->out.info) {
21706
 
                        {
21707
 
                                struct ndr_push *_ndr_info;
21708
 
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21709
 
                                NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21710
 
                                NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21711
 
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21712
 
                        }
21713
 
                }
21714
 
                if (r->out.needed == NULL) {
21715
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21716
 
                }
21717
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21718
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21719
 
        }
21720
 
        return NDR_ERR_SUCCESS;
21721
 
}
21722
 
 
21723
 
static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
21724
 
{
21725
 
        uint32_t _ptr_architecture;
21726
 
        uint32_t _ptr_buffer;
21727
 
        uint32_t _ptr_info;
21728
 
        TALLOC_CTX *_mem_save_handle_0;
21729
 
        TALLOC_CTX *_mem_save_architecture_0;
21730
 
        TALLOC_CTX *_mem_save_buffer_0;
21731
 
        TALLOC_CTX *_mem_save_info_0;
21732
 
        TALLOC_CTX *_mem_save_needed_0;
21733
 
        if (flags & NDR_IN) {
21734
 
                ZERO_STRUCT(r->out);
21735
 
 
21736
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21737
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
21738
 
                }
21739
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21740
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21741
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21742
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21743
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
21744
 
                if (_ptr_architecture) {
21745
 
                        NDR_PULL_ALLOC(ndr, r->in.architecture);
21746
 
                } else {
21747
 
                        r->in.architecture = NULL;
21748
 
                }
21749
 
                if (r->in.architecture) {
21750
 
                        _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
21751
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
21752
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21753
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21754
 
                        if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21755
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
21756
 
                        }
21757
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21758
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21759
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
21760
 
                }
21761
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21762
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21763
 
                if (_ptr_buffer) {
21764
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
21765
 
                } else {
21766
 
                        r->in.buffer = NULL;
21767
 
                }
21768
 
                if (r->in.buffer) {
21769
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21770
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21771
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21772
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21773
 
                }
21774
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21775
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
21776
 
                ZERO_STRUCTP(r->out.needed);
21777
 
        }
21778
 
        if (flags & NDR_OUT) {
21779
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21780
 
                if (_ptr_info) {
21781
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
21782
 
                } else {
21783
 
                        r->out.info = NULL;
21784
 
                }
21785
 
                if (r->out.info) {
21786
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21787
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21788
 
                        {
21789
 
                                struct ndr_pull *_ndr_info;
21790
 
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21791
 
                                NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21792
 
                                NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21793
 
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21794
 
                        }
21795
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21796
 
                }
21797
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21798
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
21799
 
                }
21800
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21801
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21802
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21803
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21804
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21805
 
        }
21806
 
        return NDR_ERR_SUCCESS;
21807
 
}
21808
 
 
21809
 
_PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
21810
 
{
21811
 
        ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
21812
 
        ndr->depth++;
21813
 
        if (flags & NDR_SET_VALUES) {
21814
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21815
 
        }
21816
 
        if (flags & NDR_IN) {
21817
 
                ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
21818
 
                ndr->depth++;
21819
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
21820
 
                ndr->depth++;
21821
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
21822
 
                ndr->depth--;
21823
 
                ndr_print_ptr(ndr, "architecture", r->in.architecture);
21824
 
                ndr->depth++;
21825
 
                if (r->in.architecture) {
21826
 
                        ndr_print_string(ndr, "architecture", r->in.architecture);
21827
 
                }
21828
 
                ndr->depth--;
21829
 
                ndr_print_uint32(ndr, "level", r->in.level);
21830
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
21831
 
                ndr->depth++;
21832
 
                if (r->in.buffer) {
21833
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21834
 
                }
21835
 
                ndr->depth--;
21836
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
21837
 
                ndr->depth--;
21838
 
        }
21839
 
        if (flags & NDR_OUT) {
21840
 
                ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
21841
 
                ndr->depth++;
21842
 
                ndr_print_ptr(ndr, "info", r->out.info);
21843
 
                ndr->depth++;
21844
 
                if (r->out.info) {
21845
 
                        ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21846
 
                        ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
21847
 
                }
21848
 
                ndr->depth--;
21849
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
21850
 
                ndr->depth++;
21851
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
21852
 
                ndr->depth--;
21853
 
                ndr_print_WERROR(ndr, "result", r->out.result);
21854
 
                ndr->depth--;
21855
 
        }
21856
 
        ndr->depth--;
21857
 
}
21858
 
 
21859
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
21860
 
{
21861
 
        if (flags & NDR_IN) {
21862
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21863
 
                if (r->in.server) {
21864
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21865
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21866
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21867
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21868
 
                }
21869
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21870
 
                if (r->in.environment) {
21871
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21872
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21873
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21874
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21875
 
                }
21876
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21877
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21878
 
                if (r->in.buffer) {
21879
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21880
 
                }
21881
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21882
 
        }
21883
 
        if (flags & NDR_OUT) {
21884
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21885
 
                if (r->out.info) {
21886
 
                        {
21887
 
                                struct ndr_push *_ndr_info;
21888
 
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21889
 
                                NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21890
 
                                NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21891
 
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21892
 
                        }
21893
 
                }
21894
 
                if (r->out.needed == NULL) {
21895
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21896
 
                }
21897
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21898
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21899
 
        }
21900
 
        return NDR_ERR_SUCCESS;
21901
 
}
21902
 
 
21903
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
21904
 
{
21905
 
        uint32_t _ptr_server;
21906
 
        uint32_t _ptr_environment;
21907
 
        uint32_t _ptr_buffer;
21908
 
        uint32_t _ptr_info;
21909
 
        TALLOC_CTX *_mem_save_server_0;
21910
 
        TALLOC_CTX *_mem_save_environment_0;
21911
 
        TALLOC_CTX *_mem_save_buffer_0;
21912
 
        TALLOC_CTX *_mem_save_info_0;
21913
 
        TALLOC_CTX *_mem_save_needed_0;
21914
 
        if (flags & NDR_IN) {
21915
 
                ZERO_STRUCT(r->out);
21916
 
 
21917
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21918
 
                if (_ptr_server) {
21919
 
                        NDR_PULL_ALLOC(ndr, r->in.server);
21920
 
                } else {
21921
 
                        r->in.server = NULL;
21922
 
                }
21923
 
                if (r->in.server) {
21924
 
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21925
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21926
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21927
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21928
 
                        if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21929
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
21930
 
                        }
21931
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21932
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21933
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21934
 
                }
21935
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21936
 
                if (_ptr_environment) {
21937
 
                        NDR_PULL_ALLOC(ndr, r->in.environment);
21938
 
                } else {
21939
 
                        r->in.environment = NULL;
21940
 
                }
21941
 
                if (r->in.environment) {
21942
 
                        _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21943
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21944
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21945
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21946
 
                        if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21947
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
21948
 
                        }
21949
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21950
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21951
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21952
 
                }
21953
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21954
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21955
 
                if (_ptr_buffer) {
21956
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
21957
 
                } else {
21958
 
                        r->in.buffer = NULL;
21959
 
                }
21960
 
                if (r->in.buffer) {
21961
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21962
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21963
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21964
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21965
 
                }
21966
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21967
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
21968
 
                ZERO_STRUCTP(r->out.needed);
21969
 
        }
21970
 
        if (flags & NDR_OUT) {
21971
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21972
 
                if (_ptr_info) {
21973
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
21974
 
                } else {
21975
 
                        r->out.info = NULL;
21976
 
                }
21977
 
                if (r->out.info) {
21978
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21979
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21980
 
                        {
21981
 
                                struct ndr_pull *_ndr_info;
21982
 
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21983
 
                                NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21984
 
                                NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21985
 
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21986
 
                        }
21987
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21988
 
                }
21989
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21990
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
21991
 
                }
21992
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21993
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21994
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21995
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21996
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21997
 
        }
21998
 
        return NDR_ERR_SUCCESS;
21999
 
}
22000
 
 
22001
 
_PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22002
 
{
22003
 
        ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
22004
 
        ndr->depth++;
22005
 
        if (flags & NDR_SET_VALUES) {
22006
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22007
 
        }
22008
 
        if (flags & NDR_IN) {
22009
 
                ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
22010
 
                ndr->depth++;
22011
 
                ndr_print_ptr(ndr, "server", r->in.server);
22012
 
                ndr->depth++;
22013
 
                if (r->in.server) {
22014
 
                        ndr_print_string(ndr, "server", r->in.server);
22015
 
                }
22016
 
                ndr->depth--;
22017
 
                ndr_print_ptr(ndr, "environment", r->in.environment);
22018
 
                ndr->depth++;
22019
 
                if (r->in.environment) {
22020
 
                        ndr_print_string(ndr, "environment", r->in.environment);
22021
 
                }
22022
 
                ndr->depth--;
22023
 
                ndr_print_uint32(ndr, "level", r->in.level);
22024
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
22025
 
                ndr->depth++;
22026
 
                if (r->in.buffer) {
22027
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22028
 
                }
22029
 
                ndr->depth--;
22030
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
22031
 
                ndr->depth--;
22032
 
        }
22033
 
        if (flags & NDR_OUT) {
22034
 
                ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
22035
 
                ndr->depth++;
22036
 
                ndr_print_ptr(ndr, "info", r->out.info);
22037
 
                ndr->depth++;
22038
 
                if (r->out.info) {
22039
 
                        ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22040
 
                        ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
22041
 
                }
22042
 
                ndr->depth--;
22043
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
22044
 
                ndr->depth++;
22045
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
22046
 
                ndr->depth--;
22047
 
                ndr_print_WERROR(ndr, "result", r->out.result);
22048
 
                ndr->depth--;
22049
 
        }
22050
 
        ndr->depth--;
22051
 
}
22052
 
 
22053
 
static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
22054
 
{
22055
 
        if (flags & NDR_IN) {
22056
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22057
 
                if (r->in.server) {
22058
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22059
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22060
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22061
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22062
 
                }
22063
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22064
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22065
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22066
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22067
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22068
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22069
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22070
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22071
 
        }
22072
 
        if (flags & NDR_OUT) {
22073
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22074
 
        }
22075
 
        return NDR_ERR_SUCCESS;
22076
 
}
22077
 
 
22078
 
static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
22079
 
{
22080
 
        uint32_t _ptr_server;
22081
 
        TALLOC_CTX *_mem_save_server_0;
22082
 
        if (flags & NDR_IN) {
22083
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22084
 
                if (_ptr_server) {
22085
 
                        NDR_PULL_ALLOC(ndr, r->in.server);
22086
 
                } else {
22087
 
                        r->in.server = NULL;
22088
 
                }
22089
 
                if (r->in.server) {
22090
 
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22091
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22092
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22093
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22094
 
                        if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22095
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
22096
 
                        }
22097
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22098
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22099
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22100
 
                }
22101
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22102
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22103
 
                if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22104
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
22105
 
                }
22106
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22107
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22108
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22109
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22110
 
                if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22111
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.driver), ndr_get_array_length(ndr, &r->in.driver));
22112
 
                }
22113
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22114
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22115
 
        }
22116
 
        if (flags & NDR_OUT) {
22117
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22118
 
        }
22119
 
        return NDR_ERR_SUCCESS;
22120
 
}
22121
 
 
22122
 
_PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
22123
 
{
22124
 
        ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
22125
 
        ndr->depth++;
22126
 
        if (flags & NDR_SET_VALUES) {
22127
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22128
 
        }
22129
 
        if (flags & NDR_IN) {
22130
 
                ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
22131
 
                ndr->depth++;
22132
 
                ndr_print_ptr(ndr, "server", r->in.server);
22133
 
                ndr->depth++;
22134
 
                if (r->in.server) {
22135
 
                        ndr_print_string(ndr, "server", r->in.server);
22136
 
                }
22137
 
                ndr->depth--;
22138
 
                ndr_print_string(ndr, "architecture", r->in.architecture);
22139
 
                ndr_print_string(ndr, "driver", r->in.driver);
22140
 
                ndr->depth--;
22141
 
        }
22142
 
        if (flags & NDR_OUT) {
22143
 
                ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
22144
 
                ndr->depth++;
22145
 
                ndr_print_WERROR(ndr, "result", r->out.result);
22146
 
                ndr->depth--;
22147
 
        }
22148
 
        ndr->depth--;
22149
 
}
22150
 
 
22151
 
static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
22152
 
{
22153
 
        if (flags & NDR_IN) {
22154
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22155
 
                if (r->in.server) {
22156
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22157
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22158
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22159
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22160
 
                }
22161
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22162
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22163
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22164
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22165
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22166
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22167
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22168
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.path_name, ndr_charset_length(r->in.path_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22169
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22170
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22171
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22172
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.print_processor_name, ndr_charset_length(r->in.print_processor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22173
 
        }
22174
 
        if (flags & NDR_OUT) {
22175
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22176
 
        }
22177
 
        return NDR_ERR_SUCCESS;
22178
 
}
22179
 
 
22180
 
static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
22181
 
{
22182
 
        uint32_t _ptr_server;
22183
 
        TALLOC_CTX *_mem_save_server_0;
22184
 
        if (flags & NDR_IN) {
22185
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22186
 
                if (_ptr_server) {
22187
 
                        NDR_PULL_ALLOC(ndr, r->in.server);
22188
 
                } else {
22189
 
                        r->in.server = NULL;
22190
 
                }
22191
 
                if (r->in.server) {
22192
 
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22193
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22194
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22195
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22196
 
                        if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22197
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
22198
 
                        }
22199
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22200
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22201
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22202
 
                }
22203
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22204
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22205
 
                if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22206
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
22207
 
                }
22208
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22209
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22210
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
22211
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
22212
 
                if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
22213
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.path_name), ndr_get_array_length(ndr, &r->in.path_name));
22214
 
                }
22215
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
22216
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.path_name, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t), CH_UTF16));
22217
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
22218
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
22219
 
                if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
22220
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.print_processor_name), ndr_get_array_length(ndr, &r->in.print_processor_name));
22221
 
                }
22222
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
22223
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.print_processor_name, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t), CH_UTF16));
22224
 
        }
22225
 
        if (flags & NDR_OUT) {
22226
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22227
 
        }
22228
 
        return NDR_ERR_SUCCESS;
22229
 
}
22230
 
 
22231
 
_PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
22232
 
{
22233
 
        ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
22234
 
        ndr->depth++;
22235
 
        if (flags & NDR_SET_VALUES) {
22236
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22237
 
        }
22238
 
        if (flags & NDR_IN) {
22239
 
                ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
22240
 
                ndr->depth++;
22241
 
                ndr_print_ptr(ndr, "server", r->in.server);
22242
 
                ndr->depth++;
22243
 
                if (r->in.server) {
22244
 
                        ndr_print_string(ndr, "server", r->in.server);
22245
 
                }
22246
 
                ndr->depth--;
22247
 
                ndr_print_string(ndr, "architecture", r->in.architecture);
22248
 
                ndr_print_string(ndr, "path_name", r->in.path_name);
22249
 
                ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
22250
 
                ndr->depth--;
22251
 
        }
22252
 
        if (flags & NDR_OUT) {
22253
 
                ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
22254
 
                ndr->depth++;
22255
 
                ndr_print_WERROR(ndr, "result", r->out.result);
22256
 
                ndr->depth--;
22257
 
        }
22258
 
        ndr->depth--;
22259
 
}
22260
 
 
22261
 
_PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
22262
 
{
22263
 
        if (flags & NDR_IN) {
22264
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22265
 
                if (r->in.servername) {
22266
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22267
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22268
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22269
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22270
 
                }
22271
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22272
 
                if (r->in.environment) {
22273
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22274
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22275
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22276
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22277
 
                }
22278
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22279
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22280
 
                if (r->in.buffer) {
22281
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22282
 
                }
22283
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22284
 
        }
22285
 
        if (flags & NDR_OUT) {
22286
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22287
 
                if (r->out.info) {
22288
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22289
 
                }
22290
 
                if (r->out.needed == NULL) {
22291
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22292
 
                }
22293
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22294
 
                if (r->out.count == NULL) {
22295
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22296
 
                }
22297
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22298
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22299
 
        }
22300
 
        return NDR_ERR_SUCCESS;
22301
 
}
22302
 
 
22303
 
_PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
22304
 
{
22305
 
        uint32_t _ptr_servername;
22306
 
        uint32_t _ptr_environment;
22307
 
        uint32_t _ptr_buffer;
22308
 
        uint32_t _ptr_info;
22309
 
        TALLOC_CTX *_mem_save_servername_0;
22310
 
        TALLOC_CTX *_mem_save_environment_0;
22311
 
        TALLOC_CTX *_mem_save_buffer_0;
22312
 
        TALLOC_CTX *_mem_save_info_0;
22313
 
        TALLOC_CTX *_mem_save_needed_0;
22314
 
        TALLOC_CTX *_mem_save_count_0;
22315
 
        if (flags & NDR_IN) {
22316
 
                ZERO_STRUCT(r->out);
22317
 
 
22318
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22319
 
                if (_ptr_servername) {
22320
 
                        NDR_PULL_ALLOC(ndr, r->in.servername);
22321
 
                } else {
22322
 
                        r->in.servername = NULL;
22323
 
                }
22324
 
                if (r->in.servername) {
22325
 
                        _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22326
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22327
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22328
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22329
 
                        if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22330
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
22331
 
                        }
22332
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22333
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22334
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22335
 
                }
22336
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22337
 
                if (_ptr_environment) {
22338
 
                        NDR_PULL_ALLOC(ndr, r->in.environment);
22339
 
                } else {
22340
 
                        r->in.environment = NULL;
22341
 
                }
22342
 
                if (r->in.environment) {
22343
 
                        _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22344
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22345
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22346
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22347
 
                        if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22348
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
22349
 
                        }
22350
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22351
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22352
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22353
 
                }
22354
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22355
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22356
 
                if (_ptr_buffer) {
22357
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
22358
 
                } else {
22359
 
                        r->in.buffer = NULL;
22360
 
                }
22361
 
                if (r->in.buffer) {
22362
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22363
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22364
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22365
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22366
 
                }
22367
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22368
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
22369
 
                ZERO_STRUCTP(r->out.needed);
22370
 
                NDR_PULL_ALLOC(ndr, r->out.count);
22371
 
                ZERO_STRUCTP(r->out.count);
22372
 
        }
22373
 
        if (flags & NDR_OUT) {
22374
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22375
 
                if (_ptr_info) {
22376
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
22377
 
                } else {
22378
 
                        r->out.info = NULL;
22379
 
                }
22380
 
                if (r->out.info) {
22381
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22382
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22383
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22384
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22385
 
                }
22386
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22387
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
22388
 
                }
22389
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22390
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22391
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22392
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22393
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22394
 
                        NDR_PULL_ALLOC(ndr, r->out.count);
22395
 
                }
22396
 
                _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22397
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22398
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22399
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22400
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22401
 
        }
22402
 
        return NDR_ERR_SUCCESS;
22403
 
}
22404
 
 
22405
 
_PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
22406
 
{
22407
 
        uint32_t cntr_info_0;
22408
 
        if (flags & NDR_IN) {
22409
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22410
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22411
 
        }
22412
 
        if (flags & NDR_OUT) {
22413
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22414
 
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22415
 
                        NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22416
 
                }
22417
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22418
 
                        NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22419
 
                }
22420
 
        }
22421
 
        return NDR_ERR_SUCCESS;
22422
 
}
22423
 
 
22424
 
_PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
22425
 
{
22426
 
        uint32_t cntr_info_0;
22427
 
        TALLOC_CTX *_mem_save_info_0;
22428
 
        if (flags & NDR_IN) {
22429
 
                ZERO_STRUCT(r->out);
22430
 
 
22431
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22432
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22433
 
        }
22434
 
        if (flags & NDR_OUT) {
22435
 
                NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22436
 
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22437
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22438
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22439
 
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22440
 
                        NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22441
 
                }
22442
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22443
 
                        NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22444
 
                }
22445
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22446
 
        }
22447
 
        return NDR_ERR_SUCCESS;
22448
 
}
22449
 
 
22450
 
_PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
22451
 
{
22452
 
        uint32_t cntr_info_2;
22453
 
        ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
22454
 
        ndr->depth++;
22455
 
        if (flags & NDR_SET_VALUES) {
22456
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22457
 
        }
22458
 
        if (flags & NDR_IN) {
22459
 
                ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
22460
 
                ndr->depth++;
22461
 
                ndr_print_ptr(ndr, "servername", r->in.servername);
22462
 
                ndr->depth++;
22463
 
                if (r->in.servername) {
22464
 
                        ndr_print_string(ndr, "servername", r->in.servername);
22465
 
                }
22466
 
                ndr->depth--;
22467
 
                ndr_print_ptr(ndr, "environment", r->in.environment);
22468
 
                ndr->depth++;
22469
 
                if (r->in.environment) {
22470
 
                        ndr_print_string(ndr, "environment", r->in.environment);
22471
 
                }
22472
 
                ndr->depth--;
22473
 
                ndr_print_uint32(ndr, "level", r->in.level);
22474
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
22475
 
                ndr->depth++;
22476
 
                if (r->in.buffer) {
22477
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22478
 
                }
22479
 
                ndr->depth--;
22480
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
22481
 
                ndr->depth--;
22482
 
        }
22483
 
        if (flags & NDR_OUT) {
22484
 
                ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
22485
 
                ndr->depth++;
22486
 
                ndr_print_ptr(ndr, "count", r->out.count);
22487
 
                ndr->depth++;
22488
 
                ndr_print_uint32(ndr, "count", *r->out.count);
22489
 
                ndr->depth--;
22490
 
                ndr_print_ptr(ndr, "info", r->out.info);
22491
 
                ndr->depth++;
22492
 
                ndr_print_ptr(ndr, "info", *r->out.info);
22493
 
                ndr->depth++;
22494
 
                if (*r->out.info) {
22495
 
                        ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22496
 
                        ndr->depth++;
22497
 
                        for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22498
 
                                char *idx_2=NULL;
22499
 
                                if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22500
 
                                        ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22501
 
                                        ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22502
 
                                        free(idx_2);
22503
 
                                }
22504
 
                        }
22505
 
                        ndr->depth--;
22506
 
                }
22507
 
                ndr->depth--;
22508
 
                ndr->depth--;
22509
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
22510
 
                ndr->depth++;
22511
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
22512
 
                ndr->depth--;
22513
 
                ndr_print_WERROR(ndr, "result", r->out.result);
22514
 
                ndr->depth--;
22515
 
        }
22516
 
        ndr->depth--;
22517
 
}
22518
 
 
22519
 
static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22520
 
{
22521
 
        if (flags & NDR_IN) {
22522
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22523
 
                if (r->in.server) {
22524
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22525
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22526
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22527
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22528
 
                }
22529
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22530
 
                if (r->in.environment) {
22531
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22532
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22533
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22534
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22535
 
                }
22536
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22537
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22538
 
                if (r->in.buffer) {
22539
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22540
 
                }
22541
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22542
 
        }
22543
 
        if (flags & NDR_OUT) {
22544
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22545
 
                if (r->out.info) {
22546
 
                        {
22547
 
                                struct ndr_push *_ndr_info;
22548
 
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22549
 
                                NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22550
 
                                NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22551
 
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22552
 
                        }
22553
 
                }
22554
 
                if (r->out.needed == NULL) {
22555
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22556
 
                }
22557
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22558
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22559
 
        }
22560
 
        return NDR_ERR_SUCCESS;
22561
 
}
22562
 
 
22563
 
static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
22564
 
{
22565
 
        uint32_t _ptr_server;
22566
 
        uint32_t _ptr_environment;
22567
 
        uint32_t _ptr_buffer;
22568
 
        uint32_t _ptr_info;
22569
 
        TALLOC_CTX *_mem_save_server_0;
22570
 
        TALLOC_CTX *_mem_save_environment_0;
22571
 
        TALLOC_CTX *_mem_save_buffer_0;
22572
 
        TALLOC_CTX *_mem_save_info_0;
22573
 
        TALLOC_CTX *_mem_save_needed_0;
22574
 
        if (flags & NDR_IN) {
22575
 
                ZERO_STRUCT(r->out);
22576
 
 
22577
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22578
 
                if (_ptr_server) {
22579
 
                        NDR_PULL_ALLOC(ndr, r->in.server);
22580
 
                } else {
22581
 
                        r->in.server = NULL;
22582
 
                }
22583
 
                if (r->in.server) {
22584
 
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22585
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22586
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22587
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22588
 
                        if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22589
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
22590
 
                        }
22591
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22592
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22593
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22594
 
                }
22595
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22596
 
                if (_ptr_environment) {
22597
 
                        NDR_PULL_ALLOC(ndr, r->in.environment);
22598
 
                } else {
22599
 
                        r->in.environment = NULL;
22600
 
                }
22601
 
                if (r->in.environment) {
22602
 
                        _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22603
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22604
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22605
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22606
 
                        if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22607
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
22608
 
                        }
22609
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22610
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22611
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22612
 
                }
22613
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22614
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22615
 
                if (_ptr_buffer) {
22616
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
22617
 
                } else {
22618
 
                        r->in.buffer = NULL;
22619
 
                }
22620
 
                if (r->in.buffer) {
22621
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22622
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22623
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22624
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22625
 
                }
22626
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22627
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
22628
 
                ZERO_STRUCTP(r->out.needed);
22629
 
        }
22630
 
        if (flags & NDR_OUT) {
22631
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22632
 
                if (_ptr_info) {
22633
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
22634
 
                } else {
22635
 
                        r->out.info = NULL;
22636
 
                }
22637
 
                if (r->out.info) {
22638
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22639
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22640
 
                        {
22641
 
                                struct ndr_pull *_ndr_info;
22642
 
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22643
 
                                NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22644
 
                                NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22645
 
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22646
 
                        }
22647
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22648
 
                }
22649
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22650
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
22651
 
                }
22652
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22653
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22654
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22655
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22656
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22657
 
        }
22658
 
        return NDR_ERR_SUCCESS;
22659
 
}
22660
 
 
22661
 
_PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22662
 
{
22663
 
        ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
22664
 
        ndr->depth++;
22665
 
        if (flags & NDR_SET_VALUES) {
22666
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22667
 
        }
22668
 
        if (flags & NDR_IN) {
22669
 
                ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
22670
 
                ndr->depth++;
22671
 
                ndr_print_ptr(ndr, "server", r->in.server);
22672
 
                ndr->depth++;
22673
 
                if (r->in.server) {
22674
 
                        ndr_print_string(ndr, "server", r->in.server);
22675
 
                }
22676
 
                ndr->depth--;
22677
 
                ndr_print_ptr(ndr, "environment", r->in.environment);
22678
 
                ndr->depth++;
22679
 
                if (r->in.environment) {
22680
 
                        ndr_print_string(ndr, "environment", r->in.environment);
22681
 
                }
22682
 
                ndr->depth--;
22683
 
                ndr_print_uint32(ndr, "level", r->in.level);
22684
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
22685
 
                ndr->depth++;
22686
 
                if (r->in.buffer) {
22687
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22688
 
                }
22689
 
                ndr->depth--;
22690
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
22691
 
                ndr->depth--;
22692
 
        }
22693
 
        if (flags & NDR_OUT) {
22694
 
                ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
22695
 
                ndr->depth++;
22696
 
                ndr_print_ptr(ndr, "info", r->out.info);
22697
 
                ndr->depth++;
22698
 
                if (r->out.info) {
22699
 
                        ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22700
 
                        ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
22701
 
                }
22702
 
                ndr->depth--;
22703
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
22704
 
                ndr->depth++;
22705
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
22706
 
                ndr->depth--;
22707
 
                ndr_print_WERROR(ndr, "result", r->out.result);
22708
 
                ndr->depth--;
22709
 
        }
22710
 
        ndr->depth--;
22711
 
}
22712
 
 
22713
 
static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
22714
 
{
22715
 
        if (flags & NDR_IN) {
22716
 
                if (r->in.handle == NULL) {
22717
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22718
 
                }
22719
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22720
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22721
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22722
 
                NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22723
 
        }
22724
 
        if (flags & NDR_OUT) {
22725
 
                if (r->out.job_id == NULL) {
22726
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22727
 
                }
22728
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
22729
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22730
 
        }
22731
 
        return NDR_ERR_SUCCESS;
22732
 
}
22733
 
 
22734
 
static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
22735
 
{
22736
 
        TALLOC_CTX *_mem_save_handle_0;
22737
 
        TALLOC_CTX *_mem_save_job_id_0;
22738
 
        if (flags & NDR_IN) {
22739
 
                ZERO_STRUCT(r->out);
22740
 
 
22741
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22742
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
22743
 
                }
22744
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22745
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22746
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22747
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22748
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22749
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22750
 
                NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22751
 
                NDR_PULL_ALLOC(ndr, r->out.job_id);
22752
 
                ZERO_STRUCTP(r->out.job_id);
22753
 
        }
22754
 
        if (flags & NDR_OUT) {
22755
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22756
 
                        NDR_PULL_ALLOC(ndr, r->out.job_id);
22757
 
                }
22758
 
                _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
22759
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
22760
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
22761
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
22762
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22763
 
        }
22764
 
        return NDR_ERR_SUCCESS;
22765
 
}
22766
 
 
22767
 
_PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
22768
 
{
22769
 
        ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
22770
 
        ndr->depth++;
22771
 
        if (flags & NDR_SET_VALUES) {
22772
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22773
 
        }
22774
 
        if (flags & NDR_IN) {
22775
 
                ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
22776
 
                ndr->depth++;
22777
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
22778
 
                ndr->depth++;
22779
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
22780
 
                ndr->depth--;
22781
 
                ndr_print_uint32(ndr, "level", r->in.level);
22782
 
                ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22783
 
                ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
22784
 
                ndr->depth--;
22785
 
        }
22786
 
        if (flags & NDR_OUT) {
22787
 
                ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
22788
 
                ndr->depth++;
22789
 
                ndr_print_ptr(ndr, "job_id", r->out.job_id);
22790
 
                ndr->depth++;
22791
 
                ndr_print_uint32(ndr, "job_id", *r->out.job_id);
22792
 
                ndr->depth--;
22793
 
                ndr_print_WERROR(ndr, "result", r->out.result);
22794
 
                ndr->depth--;
22795
 
        }
22796
 
        ndr->depth--;
22797
 
}
22798
 
 
22799
 
static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
22800
 
{
22801
 
        if (flags & NDR_IN) {
22802
 
                if (r->in.handle == NULL) {
22803
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22804
 
                }
22805
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22806
 
        }
22807
 
        if (flags & NDR_OUT) {
22808
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22809
 
        }
22810
 
        return NDR_ERR_SUCCESS;
22811
 
}
22812
 
 
22813
 
static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
22814
 
{
22815
 
        TALLOC_CTX *_mem_save_handle_0;
22816
 
        if (flags & NDR_IN) {
22817
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22818
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
22819
 
                }
22820
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22821
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22822
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22823
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22824
 
        }
22825
 
        if (flags & NDR_OUT) {
22826
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22827
 
        }
22828
 
        return NDR_ERR_SUCCESS;
22829
 
}
22830
 
 
22831
 
_PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
22832
 
{
22833
 
        ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
22834
 
        ndr->depth++;
22835
 
        if (flags & NDR_SET_VALUES) {
22836
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22837
 
        }
22838
 
        if (flags & NDR_IN) {
22839
 
                ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
22840
 
                ndr->depth++;
22841
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
22842
 
                ndr->depth++;
22843
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
22844
 
                ndr->depth--;
22845
 
                ndr->depth--;
22846
 
        }
22847
 
        if (flags & NDR_OUT) {
22848
 
                ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
22849
 
                ndr->depth++;
22850
 
                ndr_print_WERROR(ndr, "result", r->out.result);
22851
 
                ndr->depth--;
22852
 
        }
22853
 
        ndr->depth--;
22854
 
}
22855
 
 
22856
 
static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
22857
 
{
22858
 
        if (flags & NDR_IN) {
22859
 
                if (r->in.handle == NULL) {
22860
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22861
 
                }
22862
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22863
 
                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22864
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
22865
 
        }
22866
 
        if (flags & NDR_OUT) {
22867
 
                if (r->out.num_written == NULL) {
22868
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22869
 
                }
22870
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
22871
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22872
 
        }
22873
 
        return NDR_ERR_SUCCESS;
22874
 
}
22875
 
 
22876
 
static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
22877
 
{
22878
 
        TALLOC_CTX *_mem_save_handle_0;
22879
 
        TALLOC_CTX *_mem_save_num_written_0;
22880
 
        if (flags & NDR_IN) {
22881
 
                ZERO_STRUCT(r->out);
22882
 
 
22883
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22884
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
22885
 
                }
22886
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22887
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22888
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22889
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22890
 
                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
22891
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
22892
 
                NDR_PULL_ALLOC(ndr, r->out.num_written);
22893
 
                ZERO_STRUCTP(r->out.num_written);
22894
 
        }
22895
 
        if (flags & NDR_OUT) {
22896
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22897
 
                        NDR_PULL_ALLOC(ndr, r->out.num_written);
22898
 
                }
22899
 
                _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
22900
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
22901
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
22902
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
22903
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22904
 
        }
22905
 
        return NDR_ERR_SUCCESS;
22906
 
}
22907
 
 
22908
 
_PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
22909
 
{
22910
 
        ndr_print_struct(ndr, name, "spoolss_WritePrinter");
22911
 
        ndr->depth++;
22912
 
        if (flags & NDR_SET_VALUES) {
22913
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22914
 
        }
22915
 
        if (flags & NDR_IN) {
22916
 
                ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
22917
 
                ndr->depth++;
22918
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
22919
 
                ndr->depth++;
22920
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
22921
 
                ndr->depth--;
22922
 
                ndr_print_DATA_BLOB(ndr, "data", r->in.data);
22923
 
                ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
22924
 
                ndr->depth--;
22925
 
        }
22926
 
        if (flags & NDR_OUT) {
22927
 
                ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
22928
 
                ndr->depth++;
22929
 
                ndr_print_ptr(ndr, "num_written", r->out.num_written);
22930
 
                ndr->depth++;
22931
 
                ndr_print_uint32(ndr, "num_written", *r->out.num_written);
22932
 
                ndr->depth--;
22933
 
                ndr_print_WERROR(ndr, "result", r->out.result);
22934
 
                ndr->depth--;
22935
 
        }
22936
 
        ndr->depth--;
22937
 
}
22938
 
 
22939
 
static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
22940
 
{
22941
 
        if (flags & NDR_IN) {
22942
 
                if (r->in.handle == NULL) {
22943
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22944
 
                }
22945
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22946
 
        }
22947
 
        if (flags & NDR_OUT) {
22948
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22949
 
        }
22950
 
        return NDR_ERR_SUCCESS;
22951
 
}
22952
 
 
22953
 
static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
22954
 
{
22955
 
        TALLOC_CTX *_mem_save_handle_0;
22956
 
        if (flags & NDR_IN) {
22957
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22958
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
22959
 
                }
22960
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22961
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22962
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22963
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22964
 
        }
22965
 
        if (flags & NDR_OUT) {
22966
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22967
 
        }
22968
 
        return NDR_ERR_SUCCESS;
22969
 
}
22970
 
 
22971
 
_PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
22972
 
{
22973
 
        ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
22974
 
        ndr->depth++;
22975
 
        if (flags & NDR_SET_VALUES) {
22976
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22977
 
        }
22978
 
        if (flags & NDR_IN) {
22979
 
                ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
22980
 
                ndr->depth++;
22981
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
22982
 
                ndr->depth++;
22983
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
22984
 
                ndr->depth--;
22985
 
                ndr->depth--;
22986
 
        }
22987
 
        if (flags & NDR_OUT) {
22988
 
                ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
22989
 
                ndr->depth++;
22990
 
                ndr_print_WERROR(ndr, "result", r->out.result);
22991
 
                ndr->depth--;
22992
 
        }
22993
 
        ndr->depth--;
22994
 
}
22995
 
 
22996
 
static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
22997
 
{
22998
 
        if (flags & NDR_IN) {
22999
 
                if (r->in.handle == NULL) {
23000
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23001
 
                }
23002
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23003
 
        }
23004
 
        if (flags & NDR_OUT) {
23005
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23006
 
        }
23007
 
        return NDR_ERR_SUCCESS;
23008
 
}
23009
 
 
23010
 
static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
23011
 
{
23012
 
        TALLOC_CTX *_mem_save_handle_0;
23013
 
        if (flags & NDR_IN) {
23014
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23015
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
23016
 
                }
23017
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23018
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23019
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23020
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23021
 
        }
23022
 
        if (flags & NDR_OUT) {
23023
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23024
 
        }
23025
 
        return NDR_ERR_SUCCESS;
23026
 
}
23027
 
 
23028
 
_PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
23029
 
{
23030
 
        ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
23031
 
        ndr->depth++;
23032
 
        if (flags & NDR_SET_VALUES) {
23033
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23034
 
        }
23035
 
        if (flags & NDR_IN) {
23036
 
                ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
23037
 
                ndr->depth++;
23038
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
23039
 
                ndr->depth++;
23040
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
23041
 
                ndr->depth--;
23042
 
                ndr->depth--;
23043
 
        }
23044
 
        if (flags & NDR_OUT) {
23045
 
                ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
23046
 
                ndr->depth++;
23047
 
                ndr_print_WERROR(ndr, "result", r->out.result);
23048
 
                ndr->depth--;
23049
 
        }
23050
 
        ndr->depth--;
23051
 
}
23052
 
 
23053
 
static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
23054
 
{
23055
 
        if (flags & NDR_IN) {
23056
 
                if (r->in.handle == NULL) {
23057
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23058
 
                }
23059
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23060
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
23061
 
        }
23062
 
        if (flags & NDR_OUT) {
23063
 
                if (r->out.data == NULL) {
23064
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23065
 
                }
23066
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
23067
 
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
23068
 
                if (r->out._data_size == NULL) {
23069
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23070
 
                }
23071
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
23072
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23073
 
        }
23074
 
        return NDR_ERR_SUCCESS;
23075
 
}
23076
 
 
23077
 
static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
23078
 
{
23079
 
        TALLOC_CTX *_mem_save_handle_0;
23080
 
        TALLOC_CTX *_mem_save__data_size_0;
23081
 
        if (flags & NDR_IN) {
23082
 
                ZERO_STRUCT(r->out);
23083
 
 
23084
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23085
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
23086
 
                }
23087
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23088
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23089
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23090
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23091
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
23092
 
                NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
23093
 
                memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
23094
 
                NDR_PULL_ALLOC(ndr, r->out._data_size);
23095
 
                ZERO_STRUCTP(r->out._data_size);
23096
 
        }
23097
 
        if (flags & NDR_OUT) {
23098
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
23099
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23100
 
                        NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
23101
 
                }
23102
 
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
23103
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23104
 
                        NDR_PULL_ALLOC(ndr, r->out._data_size);
23105
 
                }
23106
 
                _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
23107
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
23108
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
23109
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
23110
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23111
 
                if (r->out.data) {
23112
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
23113
 
                }
23114
 
        }
23115
 
        return NDR_ERR_SUCCESS;
23116
 
}
23117
 
 
23118
 
_PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
23119
 
{
23120
 
        ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
23121
 
        ndr->depth++;
23122
 
        if (flags & NDR_SET_VALUES) {
23123
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23124
 
        }
23125
 
        if (flags & NDR_IN) {
23126
 
                ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
23127
 
                ndr->depth++;
23128
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
23129
 
                ndr->depth++;
23130
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
23131
 
                ndr->depth--;
23132
 
                ndr_print_uint32(ndr, "data_size", r->in.data_size);
23133
 
                ndr->depth--;
23134
 
        }
23135
 
        if (flags & NDR_OUT) {
23136
 
                ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
23137
 
                ndr->depth++;
23138
 
                ndr_print_ptr(ndr, "data", r->out.data);
23139
 
                ndr->depth++;
23140
 
                ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
23141
 
                ndr->depth--;
23142
 
                ndr_print_ptr(ndr, "_data_size", r->out._data_size);
23143
 
                ndr->depth++;
23144
 
                ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
23145
 
                ndr->depth--;
23146
 
                ndr_print_WERROR(ndr, "result", r->out.result);
23147
 
                ndr->depth--;
23148
 
        }
23149
 
        ndr->depth--;
23150
 
}
23151
 
 
23152
 
static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
23153
 
{
23154
 
        if (flags & NDR_IN) {
23155
 
                if (r->in.handle == NULL) {
23156
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23157
 
                }
23158
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23159
 
        }
23160
 
        if (flags & NDR_OUT) {
23161
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23162
 
        }
23163
 
        return NDR_ERR_SUCCESS;
23164
 
}
23165
 
 
23166
 
static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
23167
 
{
23168
 
        TALLOC_CTX *_mem_save_handle_0;
23169
 
        if (flags & NDR_IN) {
23170
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23171
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
23172
 
                }
23173
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23174
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23175
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23176
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23177
 
        }
23178
 
        if (flags & NDR_OUT) {
23179
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23180
 
        }
23181
 
        return NDR_ERR_SUCCESS;
23182
 
}
23183
 
 
23184
 
_PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
23185
 
{
23186
 
        ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
23187
 
        ndr->depth++;
23188
 
        if (flags & NDR_SET_VALUES) {
23189
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23190
 
        }
23191
 
        if (flags & NDR_IN) {
23192
 
                ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
23193
 
                ndr->depth++;
23194
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
23195
 
                ndr->depth++;
23196
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
23197
 
                ndr->depth--;
23198
 
                ndr->depth--;
23199
 
        }
23200
 
        if (flags & NDR_OUT) {
23201
 
                ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
23202
 
                ndr->depth++;
23203
 
                ndr_print_WERROR(ndr, "result", r->out.result);
23204
 
                ndr->depth--;
23205
 
        }
23206
 
        ndr->depth--;
23207
 
}
23208
 
 
23209
 
static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
23210
 
{
23211
 
        if (flags & NDR_IN) {
23212
 
                if (r->in.handle == NULL) {
23213
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23214
 
                }
23215
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23216
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23217
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23218
 
                if (r->in.buffer) {
23219
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23220
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
23221
 
                }
23222
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23223
 
        }
23224
 
        if (flags & NDR_OUT) {
23225
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
23226
 
                if (r->out.buffer) {
23227
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23228
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23229
 
                }
23230
 
                if (r->out.needed == NULL) {
23231
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23232
 
                }
23233
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23234
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23235
 
        }
23236
 
        return NDR_ERR_SUCCESS;
23237
 
}
23238
 
 
23239
 
static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
23240
 
{
23241
 
        uint32_t _ptr_buffer;
23242
 
        TALLOC_CTX *_mem_save_handle_0;
23243
 
        TALLOC_CTX *_mem_save_buffer_0;
23244
 
        TALLOC_CTX *_mem_save_needed_0;
23245
 
        if (flags & NDR_IN) {
23246
 
                ZERO_STRUCT(r->out);
23247
 
 
23248
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23249
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
23250
 
                }
23251
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23252
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23253
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23254
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23255
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23256
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23257
 
                if (_ptr_buffer) {
23258
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
23259
 
                } else {
23260
 
                        r->in.buffer = NULL;
23261
 
                }
23262
 
                if (r->in.buffer) {
23263
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23264
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23265
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23266
 
                        NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
23267
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
23268
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23269
 
                }
23270
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23271
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
23272
 
                ZERO_STRUCTP(r->out.needed);
23273
 
                if (r->in.buffer) {
23274
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
23275
 
                }
23276
 
        }
23277
 
        if (flags & NDR_OUT) {
23278
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23279
 
                if (_ptr_buffer) {
23280
 
                        NDR_PULL_ALLOC(ndr, r->out.buffer);
23281
 
                } else {
23282
 
                        r->out.buffer = NULL;
23283
 
                }
23284
 
                if (r->out.buffer) {
23285
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23286
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
23287
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
23288
 
                        NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
23289
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
23290
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23291
 
                }
23292
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23293
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
23294
 
                }
23295
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23296
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23297
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23298
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23299
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23300
 
                if (r->out.buffer) {
23301
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
23302
 
                }
23303
 
        }
23304
 
        return NDR_ERR_SUCCESS;
23305
 
}
23306
 
 
23307
 
_PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
23308
 
{
23309
 
        ndr_print_struct(ndr, name, "spoolss_AddJob");
23310
 
        ndr->depth++;
23311
 
        if (flags & NDR_SET_VALUES) {
23312
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23313
 
        }
23314
 
        if (flags & NDR_IN) {
23315
 
                ndr_print_struct(ndr, "in", "spoolss_AddJob");
23316
 
                ndr->depth++;
23317
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
23318
 
                ndr->depth++;
23319
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
23320
 
                ndr->depth--;
23321
 
                ndr_print_uint32(ndr, "level", r->in.level);
23322
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
23323
 
                ndr->depth++;
23324
 
                if (r->in.buffer) {
23325
 
                        ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
23326
 
                }
23327
 
                ndr->depth--;
23328
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
23329
 
                ndr->depth--;
23330
 
        }
23331
 
        if (flags & NDR_OUT) {
23332
 
                ndr_print_struct(ndr, "out", "spoolss_AddJob");
23333
 
                ndr->depth++;
23334
 
                ndr_print_ptr(ndr, "buffer", r->out.buffer);
23335
 
                ndr->depth++;
23336
 
                if (r->out.buffer) {
23337
 
                        ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
23338
 
                }
23339
 
                ndr->depth--;
23340
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
23341
 
                ndr->depth++;
23342
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
23343
 
                ndr->depth--;
23344
 
                ndr_print_WERROR(ndr, "result", r->out.result);
23345
 
                ndr->depth--;
23346
 
        }
23347
 
        ndr->depth--;
23348
 
}
23349
 
 
23350
 
static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
23351
 
{
23352
 
        if (flags & NDR_IN) {
23353
 
                if (r->in.handle == NULL) {
23354
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23355
 
                }
23356
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23357
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
23358
 
        }
23359
 
        if (flags & NDR_OUT) {
23360
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23361
 
        }
23362
 
        return NDR_ERR_SUCCESS;
23363
 
}
23364
 
 
23365
 
static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
23366
 
{
23367
 
        TALLOC_CTX *_mem_save_handle_0;
23368
 
        if (flags & NDR_IN) {
23369
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23370
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
23371
 
                }
23372
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23373
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23374
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23375
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23376
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
23377
 
        }
23378
 
        if (flags & NDR_OUT) {
23379
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23380
 
        }
23381
 
        return NDR_ERR_SUCCESS;
23382
 
}
23383
 
 
23384
 
_PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
23385
 
{
23386
 
        ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
23387
 
        ndr->depth++;
23388
 
        if (flags & NDR_SET_VALUES) {
23389
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23390
 
        }
23391
 
        if (flags & NDR_IN) {
23392
 
                ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
23393
 
                ndr->depth++;
23394
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
23395
 
                ndr->depth++;
23396
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
23397
 
                ndr->depth--;
23398
 
                ndr_print_uint32(ndr, "jobid", r->in.jobid);
23399
 
                ndr->depth--;
23400
 
        }
23401
 
        if (flags & NDR_OUT) {
23402
 
                ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
23403
 
                ndr->depth++;
23404
 
                ndr_print_WERROR(ndr, "result", r->out.result);
23405
 
                ndr->depth--;
23406
 
        }
23407
 
        ndr->depth--;
23408
 
}
23409
 
 
23410
 
static enum ndr_err_code ndr_push_spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterData *r)
23411
 
{
23412
 
        if (flags & NDR_IN) {
23413
 
                if (r->in.handle == NULL) {
23414
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23415
 
                }
23416
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23417
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23418
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23419
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23420
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23421
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23422
 
        }
23423
 
        if (flags & NDR_OUT) {
23424
 
                if (r->out.type == NULL) {
23425
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23426
 
                }
23427
 
                NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
23428
 
                if (r->out.data == NULL) {
23429
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23430
 
                }
23431
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23432
 
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.offered));
23433
 
                if (r->out.needed == NULL) {
23434
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23435
 
                }
23436
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23437
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23438
 
        }
23439
 
        return NDR_ERR_SUCCESS;
23440
 
}
23441
 
 
23442
 
static enum ndr_err_code ndr_pull_spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterData *r)
23443
 
{
23444
 
        TALLOC_CTX *_mem_save_handle_0;
23445
 
        TALLOC_CTX *_mem_save_type_0;
23446
 
        TALLOC_CTX *_mem_save_needed_0;
23447
 
        if (flags & NDR_IN) {
23448
 
                ZERO_STRUCT(r->out);
23449
 
 
23450
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23451
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
23452
 
                }
23453
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23454
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23455
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23456
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23457
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23458
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23459
 
                if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23460
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
23461
 
                }
23462
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23463
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
23464
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23465
 
                NDR_PULL_ALLOC(ndr, r->out.type);
23466
 
                ZERO_STRUCTP(r->out.type);
23467
 
                NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.offered);
23468
 
                memset(r->out.data, 0, (r->in.offered) * sizeof(*r->out.data));
23469
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
23470
 
                ZERO_STRUCTP(r->out.needed);
23471
 
        }
23472
 
        if (flags & NDR_OUT) {
23473
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23474
 
                        NDR_PULL_ALLOC(ndr, r->out.type);
23475
 
                }
23476
 
                _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23477
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
23478
 
                NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
23479
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
23480
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
23481
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23482
 
                        NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
23483
 
                }
23484
 
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
23485
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23486
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
23487
 
                }
23488
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23489
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23490
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23491
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23492
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23493
 
                if (r->out.data) {
23494
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.offered));
23495
 
                }
23496
 
        }
23497
 
        return NDR_ERR_SUCCESS;
23498
 
}
23499
 
 
23500
 
_PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
23501
 
{
23502
 
        ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
23503
 
        ndr->depth++;
23504
 
        if (flags & NDR_SET_VALUES) {
23505
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23506
 
        }
23507
 
        if (flags & NDR_IN) {
23508
 
                ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
23509
 
                ndr->depth++;
23510
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
23511
 
                ndr->depth++;
23512
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
23513
 
                ndr->depth--;
23514
 
                ndr_print_string(ndr, "value_name", r->in.value_name);
23515
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
23516
 
                ndr->depth--;
23517
 
        }
23518
 
        if (flags & NDR_OUT) {
23519
 
                ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
23520
 
                ndr->depth++;
23521
 
                ndr_print_ptr(ndr, "type", r->out.type);
23522
 
                ndr->depth++;
23523
 
                ndr_print_winreg_Type(ndr, "type", *r->out.type);
23524
 
                ndr->depth--;
23525
 
                ndr_print_ptr(ndr, "data", r->out.data);
23526
 
                ndr->depth++;
23527
 
                ndr_print_array_uint8(ndr, "data", r->out.data, r->in.offered);
23528
 
                ndr->depth--;
23529
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
23530
 
                ndr->depth++;
23531
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
23532
 
                ndr->depth--;
23533
 
                ndr_print_WERROR(ndr, "result", r->out.result);
23534
 
                ndr->depth--;
23535
 
        }
23536
 
        ndr->depth--;
23537
 
}
23538
 
 
23539
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterData *r)
23540
 
{
23541
 
        if (flags & NDR_IN) {
23542
 
                if (r->in.handle == NULL) {
23543
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23544
 
                }
23545
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23546
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23547
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23548
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23549
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23550
 
                NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23551
 
                if (r->in.data == NULL) {
23552
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23553
 
                }
23554
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23555
 
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.offered));
23556
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23557
 
        }
23558
 
        if (flags & NDR_OUT) {
23559
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23560
 
        }
23561
 
        return NDR_ERR_SUCCESS;
23562
 
}
23563
 
 
23564
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
23565
 
{
23566
 
        TALLOC_CTX *_mem_save_handle_0;
23567
 
        if (flags & NDR_IN) {
23568
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23569
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
23570
 
                }
23571
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23572
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23573
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23574
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23575
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23576
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23577
 
                if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23578
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
23579
 
                }
23580
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23581
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
23582
 
                NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23583
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
23584
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23585
 
                        NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
23586
 
                }
23587
 
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
23588
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23589
 
                if (r->in.data) {
23590
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.offered));
23591
 
                }
23592
 
        }
23593
 
        if (flags & NDR_OUT) {
23594
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23595
 
        }
23596
 
        return NDR_ERR_SUCCESS;
23597
 
}
23598
 
 
23599
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
23600
 
{
23601
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
23602
 
        ndr->depth++;
23603
 
        if (flags & NDR_SET_VALUES) {
23604
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23605
 
        }
23606
 
        if (flags & NDR_IN) {
23607
 
                ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
23608
 
                ndr->depth++;
23609
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
23610
 
                ndr->depth++;
23611
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
23612
 
                ndr->depth--;
23613
 
                ndr_print_string(ndr, "value_name", r->in.value_name);
23614
 
                ndr_print_winreg_Type(ndr, "type", r->in.type);
23615
 
                ndr_print_ptr(ndr, "data", r->in.data);
23616
 
                ndr->depth++;
23617
 
                ndr_print_array_uint8(ndr, "data", r->in.data, r->in.offered);
23618
 
                ndr->depth--;
23619
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
23620
 
                ndr->depth--;
23621
 
        }
23622
 
        if (flags & NDR_OUT) {
23623
 
                ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
23624
 
                ndr->depth++;
23625
 
                ndr_print_WERROR(ndr, "result", r->out.result);
23626
 
                ndr->depth--;
23627
 
        }
23628
 
        ndr->depth--;
23629
 
}
23630
 
 
23631
 
static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
23632
 
{
23633
 
        if (flags & NDR_IN) {
23634
 
        }
23635
 
        if (flags & NDR_OUT) {
23636
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23637
 
        }
23638
 
        return NDR_ERR_SUCCESS;
23639
 
}
23640
 
 
23641
 
static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
23642
 
{
23643
 
        if (flags & NDR_IN) {
23644
 
        }
23645
 
        if (flags & NDR_OUT) {
23646
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23647
 
        }
23648
 
        return NDR_ERR_SUCCESS;
23649
 
}
23650
 
 
23651
 
_PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
23652
 
{
23653
 
        ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
23654
 
        ndr->depth++;
23655
 
        if (flags & NDR_SET_VALUES) {
23656
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23657
 
        }
23658
 
        if (flags & NDR_IN) {
23659
 
                ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
23660
 
                ndr->depth++;
23661
 
                ndr->depth--;
23662
 
        }
23663
 
        if (flags & NDR_OUT) {
23664
 
                ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
23665
 
                ndr->depth++;
23666
 
                ndr_print_WERROR(ndr, "result", r->out.result);
23667
 
                ndr->depth--;
23668
 
        }
23669
 
        ndr->depth--;
23670
 
}
23671
 
 
23672
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
23673
 
{
23674
 
        if (flags & NDR_IN) {
23675
 
                if (r->in.handle == NULL) {
23676
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23677
 
                }
23678
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23679
 
        }
23680
 
        if (flags & NDR_OUT) {
23681
 
                if (r->out.handle == NULL) {
23682
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23683
 
                }
23684
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23685
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23686
 
        }
23687
 
        return NDR_ERR_SUCCESS;
23688
 
}
23689
 
 
23690
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
23691
 
{
23692
 
        TALLOC_CTX *_mem_save_handle_0;
23693
 
        if (flags & NDR_IN) {
23694
 
                ZERO_STRUCT(r->out);
23695
 
 
23696
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23697
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
23698
 
                }
23699
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23700
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23701
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23702
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23703
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
23704
 
                *r->out.handle = *r->in.handle;
23705
 
        }
23706
 
        if (flags & NDR_OUT) {
23707
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23708
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
23709
 
                }
23710
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23711
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
23712
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23713
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23714
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23715
 
        }
23716
 
        return NDR_ERR_SUCCESS;
23717
 
}
23718
 
 
23719
 
_PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
23720
 
{
23721
 
        ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
23722
 
        ndr->depth++;
23723
 
        if (flags & NDR_SET_VALUES) {
23724
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23725
 
        }
23726
 
        if (flags & NDR_IN) {
23727
 
                ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
23728
 
                ndr->depth++;
23729
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
23730
 
                ndr->depth++;
23731
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
23732
 
                ndr->depth--;
23733
 
                ndr->depth--;
23734
 
        }
23735
 
        if (flags & NDR_OUT) {
23736
 
                ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
23737
 
                ndr->depth++;
23738
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
23739
 
                ndr->depth++;
23740
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
23741
 
                ndr->depth--;
23742
 
                ndr_print_WERROR(ndr, "result", r->out.result);
23743
 
                ndr->depth--;
23744
 
        }
23745
 
        ndr->depth--;
23746
 
}
23747
 
 
23748
 
static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
23749
 
{
23750
 
        if (flags & NDR_IN) {
23751
 
                if (r->in.handle == NULL) {
23752
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23753
 
                }
23754
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23755
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23756
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23757
 
                NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23758
 
        }
23759
 
        if (flags & NDR_OUT) {
23760
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23761
 
        }
23762
 
        return NDR_ERR_SUCCESS;
23763
 
}
23764
 
 
23765
 
static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
23766
 
{
23767
 
        TALLOC_CTX *_mem_save_handle_0;
23768
 
        if (flags & NDR_IN) {
23769
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23770
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
23771
 
                }
23772
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23773
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23774
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23775
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23776
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23777
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23778
 
                NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23779
 
        }
23780
 
        if (flags & NDR_OUT) {
23781
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23782
 
        }
23783
 
        return NDR_ERR_SUCCESS;
23784
 
}
23785
 
 
23786
 
_PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
23787
 
{
23788
 
        ndr_print_struct(ndr, name, "spoolss_AddForm");
23789
 
        ndr->depth++;
23790
 
        if (flags & NDR_SET_VALUES) {
23791
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23792
 
        }
23793
 
        if (flags & NDR_IN) {
23794
 
                ndr_print_struct(ndr, "in", "spoolss_AddForm");
23795
 
                ndr->depth++;
23796
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
23797
 
                ndr->depth++;
23798
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
23799
 
                ndr->depth--;
23800
 
                ndr_print_uint32(ndr, "level", r->in.level);
23801
 
                ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23802
 
                ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
23803
 
                ndr->depth--;
23804
 
        }
23805
 
        if (flags & NDR_OUT) {
23806
 
                ndr_print_struct(ndr, "out", "spoolss_AddForm");
23807
 
                ndr->depth++;
23808
 
                ndr_print_WERROR(ndr, "result", r->out.result);
23809
 
                ndr->depth--;
23810
 
        }
23811
 
        ndr->depth--;
23812
 
}
23813
 
 
23814
 
static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
23815
 
{
23816
 
        if (flags & NDR_IN) {
23817
 
                if (r->in.handle == NULL) {
23818
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23819
 
                }
23820
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23821
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23822
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23823
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23824
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.form_name, ndr_charset_length(r->in.form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23825
 
        }
23826
 
        if (flags & NDR_OUT) {
23827
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23828
 
        }
23829
 
        return NDR_ERR_SUCCESS;
23830
 
}
23831
 
 
23832
 
static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
23833
 
{
23834
 
        TALLOC_CTX *_mem_save_handle_0;
23835
 
        if (flags & NDR_IN) {
23836
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23837
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
23838
 
                }
23839
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23840
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23841
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23842
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23843
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23844
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23845
 
                if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23846
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.form_name), ndr_get_array_length(ndr, &r->in.form_name));
23847
 
                }
23848
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23849
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t), CH_UTF16));
23850
 
        }
23851
 
        if (flags & NDR_OUT) {
23852
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23853
 
        }
23854
 
        return NDR_ERR_SUCCESS;
23855
 
}
23856
 
 
23857
 
_PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
23858
 
{
23859
 
        ndr_print_struct(ndr, name, "spoolss_DeleteForm");
23860
 
        ndr->depth++;
23861
 
        if (flags & NDR_SET_VALUES) {
23862
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23863
 
        }
23864
 
        if (flags & NDR_IN) {
23865
 
                ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
23866
 
                ndr->depth++;
23867
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
23868
 
                ndr->depth++;
23869
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
23870
 
                ndr->depth--;
23871
 
                ndr_print_string(ndr, "form_name", r->in.form_name);
23872
 
                ndr->depth--;
23873
 
        }
23874
 
        if (flags & NDR_OUT) {
23875
 
                ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
23876
 
                ndr->depth++;
23877
 
                ndr_print_WERROR(ndr, "result", r->out.result);
23878
 
                ndr->depth--;
23879
 
        }
23880
 
        ndr->depth--;
23881
 
}
23882
 
 
23883
 
static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
23884
 
{
23885
 
        if (flags & NDR_IN) {
23886
 
                if (r->in.handle == NULL) {
23887
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23888
 
                }
23889
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23890
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23891
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23892
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
23893
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.form_name, ndr_charset_length(r->in.form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23894
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23895
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23896
 
                if (r->in.buffer) {
23897
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23898
 
                }
23899
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23900
 
        }
23901
 
        if (flags & NDR_OUT) {
23902
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23903
 
                if (r->out.info) {
23904
 
                        {
23905
 
                                struct ndr_push *_ndr_info;
23906
 
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23907
 
                                NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23908
 
                                NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23909
 
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23910
 
                        }
23911
 
                }
23912
 
                if (r->out.needed == NULL) {
23913
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23914
 
                }
23915
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23916
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23917
 
        }
23918
 
        return NDR_ERR_SUCCESS;
23919
 
}
23920
 
 
23921
 
static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
23922
 
{
23923
 
        uint32_t _ptr_buffer;
23924
 
        uint32_t _ptr_info;
23925
 
        TALLOC_CTX *_mem_save_handle_0;
23926
 
        TALLOC_CTX *_mem_save_buffer_0;
23927
 
        TALLOC_CTX *_mem_save_info_0;
23928
 
        TALLOC_CTX *_mem_save_needed_0;
23929
 
        if (flags & NDR_IN) {
23930
 
                ZERO_STRUCT(r->out);
23931
 
 
23932
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23933
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
23934
 
                }
23935
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23936
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23937
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23938
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23939
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
23940
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
23941
 
                if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
23942
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.form_name), ndr_get_array_length(ndr, &r->in.form_name));
23943
 
                }
23944
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
23945
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t), CH_UTF16));
23946
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23947
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23948
 
                if (_ptr_buffer) {
23949
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
23950
 
                } else {
23951
 
                        r->in.buffer = NULL;
23952
 
                }
23953
 
                if (r->in.buffer) {
23954
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23955
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23956
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23957
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23958
 
                }
23959
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23960
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
23961
 
                ZERO_STRUCTP(r->out.needed);
23962
 
        }
23963
 
        if (flags & NDR_OUT) {
23964
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23965
 
                if (_ptr_info) {
23966
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
23967
 
                } else {
23968
 
                        r->out.info = NULL;
23969
 
                }
23970
 
                if (r->out.info) {
23971
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23972
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23973
 
                        {
23974
 
                                struct ndr_pull *_ndr_info;
23975
 
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23976
 
                                NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23977
 
                                NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23978
 
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23979
 
                        }
23980
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23981
 
                }
23982
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23983
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
23984
 
                }
23985
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23986
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23987
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23988
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23989
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23990
 
        }
23991
 
        return NDR_ERR_SUCCESS;
23992
 
}
23993
 
 
23994
 
_PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
23995
 
{
23996
 
        ndr_print_struct(ndr, name, "spoolss_GetForm");
23997
 
        ndr->depth++;
23998
 
        if (flags & NDR_SET_VALUES) {
23999
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24000
 
        }
24001
 
        if (flags & NDR_IN) {
24002
 
                ndr_print_struct(ndr, "in", "spoolss_GetForm");
24003
 
                ndr->depth++;
24004
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
24005
 
                ndr->depth++;
24006
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
24007
 
                ndr->depth--;
24008
 
                ndr_print_string(ndr, "form_name", r->in.form_name);
24009
 
                ndr_print_uint32(ndr, "level", r->in.level);
24010
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
24011
 
                ndr->depth++;
24012
 
                if (r->in.buffer) {
24013
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24014
 
                }
24015
 
                ndr->depth--;
24016
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
24017
 
                ndr->depth--;
24018
 
        }
24019
 
        if (flags & NDR_OUT) {
24020
 
                ndr_print_struct(ndr, "out", "spoolss_GetForm");
24021
 
                ndr->depth++;
24022
 
                ndr_print_ptr(ndr, "info", r->out.info);
24023
 
                ndr->depth++;
24024
 
                if (r->out.info) {
24025
 
                        ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24026
 
                        ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
24027
 
                }
24028
 
                ndr->depth--;
24029
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
24030
 
                ndr->depth++;
24031
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
24032
 
                ndr->depth--;
24033
 
                ndr_print_WERROR(ndr, "result", r->out.result);
24034
 
                ndr->depth--;
24035
 
        }
24036
 
        ndr->depth--;
24037
 
}
24038
 
 
24039
 
static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
24040
 
{
24041
 
        if (flags & NDR_IN) {
24042
 
                if (r->in.handle == NULL) {
24043
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24044
 
                }
24045
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24046
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24047
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24048
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24049
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.form_name, ndr_charset_length(r->in.form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24050
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24051
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24052
 
                NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24053
 
        }
24054
 
        if (flags & NDR_OUT) {
24055
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24056
 
        }
24057
 
        return NDR_ERR_SUCCESS;
24058
 
}
24059
 
 
24060
 
static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
24061
 
{
24062
 
        TALLOC_CTX *_mem_save_handle_0;
24063
 
        if (flags & NDR_IN) {
24064
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24065
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
24066
 
                }
24067
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24068
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24069
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24070
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24071
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24072
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24073
 
                if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24074
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.form_name), ndr_get_array_length(ndr, &r->in.form_name));
24075
 
                }
24076
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24077
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.form_name, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t), CH_UTF16));
24078
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24079
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24080
 
                NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24081
 
        }
24082
 
        if (flags & NDR_OUT) {
24083
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24084
 
        }
24085
 
        return NDR_ERR_SUCCESS;
24086
 
}
24087
 
 
24088
 
_PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
24089
 
{
24090
 
        ndr_print_struct(ndr, name, "spoolss_SetForm");
24091
 
        ndr->depth++;
24092
 
        if (flags & NDR_SET_VALUES) {
24093
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24094
 
        }
24095
 
        if (flags & NDR_IN) {
24096
 
                ndr_print_struct(ndr, "in", "spoolss_SetForm");
24097
 
                ndr->depth++;
24098
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
24099
 
                ndr->depth++;
24100
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
24101
 
                ndr->depth--;
24102
 
                ndr_print_string(ndr, "form_name", r->in.form_name);
24103
 
                ndr_print_uint32(ndr, "level", r->in.level);
24104
 
                ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24105
 
                ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24106
 
                ndr->depth--;
24107
 
        }
24108
 
        if (flags & NDR_OUT) {
24109
 
                ndr_print_struct(ndr, "out", "spoolss_SetForm");
24110
 
                ndr->depth++;
24111
 
                ndr_print_WERROR(ndr, "result", r->out.result);
24112
 
                ndr->depth--;
24113
 
        }
24114
 
        ndr->depth--;
24115
 
}
24116
 
 
24117
 
_PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
24118
 
{
24119
 
        if (flags & NDR_IN) {
24120
 
                if (r->in.handle == NULL) {
24121
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24122
 
                }
24123
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24124
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24125
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24126
 
                if (r->in.buffer) {
24127
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24128
 
                }
24129
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24130
 
        }
24131
 
        if (flags & NDR_OUT) {
24132
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24133
 
                if (r->out.info) {
24134
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24135
 
                }
24136
 
                if (r->out.needed == NULL) {
24137
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24138
 
                }
24139
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24140
 
                if (r->out.count == NULL) {
24141
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24142
 
                }
24143
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24144
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24145
 
        }
24146
 
        return NDR_ERR_SUCCESS;
24147
 
}
24148
 
 
24149
 
_PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
24150
 
{
24151
 
        uint32_t _ptr_buffer;
24152
 
        uint32_t _ptr_info;
24153
 
        TALLOC_CTX *_mem_save_handle_0;
24154
 
        TALLOC_CTX *_mem_save_buffer_0;
24155
 
        TALLOC_CTX *_mem_save_info_0;
24156
 
        TALLOC_CTX *_mem_save_needed_0;
24157
 
        TALLOC_CTX *_mem_save_count_0;
24158
 
        if (flags & NDR_IN) {
24159
 
                ZERO_STRUCT(r->out);
24160
 
 
24161
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24162
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
24163
 
                }
24164
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24165
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24166
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24167
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24168
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24169
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24170
 
                if (_ptr_buffer) {
24171
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
24172
 
                } else {
24173
 
                        r->in.buffer = NULL;
24174
 
                }
24175
 
                if (r->in.buffer) {
24176
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24177
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24178
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24179
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24180
 
                }
24181
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24182
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
24183
 
                ZERO_STRUCTP(r->out.needed);
24184
 
                NDR_PULL_ALLOC(ndr, r->out.count);
24185
 
                ZERO_STRUCTP(r->out.count);
24186
 
        }
24187
 
        if (flags & NDR_OUT) {
24188
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24189
 
                if (_ptr_info) {
24190
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
24191
 
                } else {
24192
 
                        r->out.info = NULL;
24193
 
                }
24194
 
                if (r->out.info) {
24195
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24196
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24197
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24198
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24199
 
                }
24200
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24201
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
24202
 
                }
24203
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24204
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24205
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24206
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24207
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24208
 
                        NDR_PULL_ALLOC(ndr, r->out.count);
24209
 
                }
24210
 
                _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24211
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24212
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24213
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24214
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24215
 
        }
24216
 
        return NDR_ERR_SUCCESS;
24217
 
}
24218
 
 
24219
 
_PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
24220
 
{
24221
 
        uint32_t cntr_info_0;
24222
 
        if (flags & NDR_IN) {
24223
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24224
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24225
 
        }
24226
 
        if (flags & NDR_OUT) {
24227
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24228
 
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24229
 
                        NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24230
 
                }
24231
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24232
 
                        NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24233
 
                }
24234
 
        }
24235
 
        return NDR_ERR_SUCCESS;
24236
 
}
24237
 
 
24238
 
_PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
24239
 
{
24240
 
        uint32_t cntr_info_0;
24241
 
        TALLOC_CTX *_mem_save_info_0;
24242
 
        if (flags & NDR_IN) {
24243
 
                ZERO_STRUCT(r->out);
24244
 
 
24245
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24246
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24247
 
        }
24248
 
        if (flags & NDR_OUT) {
24249
 
                NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24250
 
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24251
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24252
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24253
 
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24254
 
                        NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24255
 
                }
24256
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24257
 
                        NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24258
 
                }
24259
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24260
 
        }
24261
 
        return NDR_ERR_SUCCESS;
24262
 
}
24263
 
 
24264
 
_PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
24265
 
{
24266
 
        uint32_t cntr_info_2;
24267
 
        ndr_print_struct(ndr, name, "spoolss_EnumForms");
24268
 
        ndr->depth++;
24269
 
        if (flags & NDR_SET_VALUES) {
24270
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24271
 
        }
24272
 
        if (flags & NDR_IN) {
24273
 
                ndr_print_struct(ndr, "in", "spoolss_EnumForms");
24274
 
                ndr->depth++;
24275
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
24276
 
                ndr->depth++;
24277
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
24278
 
                ndr->depth--;
24279
 
                ndr_print_uint32(ndr, "level", r->in.level);
24280
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
24281
 
                ndr->depth++;
24282
 
                if (r->in.buffer) {
24283
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24284
 
                }
24285
 
                ndr->depth--;
24286
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
24287
 
                ndr->depth--;
24288
 
        }
24289
 
        if (flags & NDR_OUT) {
24290
 
                ndr_print_struct(ndr, "out", "spoolss_EnumForms");
24291
 
                ndr->depth++;
24292
 
                ndr_print_ptr(ndr, "count", r->out.count);
24293
 
                ndr->depth++;
24294
 
                ndr_print_uint32(ndr, "count", *r->out.count);
24295
 
                ndr->depth--;
24296
 
                ndr_print_ptr(ndr, "info", r->out.info);
24297
 
                ndr->depth++;
24298
 
                ndr_print_ptr(ndr, "info", *r->out.info);
24299
 
                ndr->depth++;
24300
 
                if (*r->out.info) {
24301
 
                        ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24302
 
                        ndr->depth++;
24303
 
                        for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24304
 
                                char *idx_2=NULL;
24305
 
                                if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24306
 
                                        ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24307
 
                                        ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24308
 
                                        free(idx_2);
24309
 
                                }
24310
 
                        }
24311
 
                        ndr->depth--;
24312
 
                }
24313
 
                ndr->depth--;
24314
 
                ndr->depth--;
24315
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
24316
 
                ndr->depth++;
24317
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
24318
 
                ndr->depth--;
24319
 
                ndr_print_WERROR(ndr, "result", r->out.result);
24320
 
                ndr->depth--;
24321
 
        }
24322
 
        ndr->depth--;
24323
 
}
24324
 
 
24325
 
_PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
24326
 
{
24327
 
        if (flags & NDR_IN) {
24328
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24329
 
                if (r->in.servername) {
24330
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24331
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24332
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24333
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24334
 
                }
24335
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24336
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24337
 
                if (r->in.buffer) {
24338
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24339
 
                }
24340
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24341
 
        }
24342
 
        if (flags & NDR_OUT) {
24343
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24344
 
                if (r->out.info) {
24345
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24346
 
                }
24347
 
                if (r->out.needed == NULL) {
24348
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24349
 
                }
24350
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24351
 
                if (r->out.count == NULL) {
24352
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24353
 
                }
24354
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24355
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24356
 
        }
24357
 
        return NDR_ERR_SUCCESS;
24358
 
}
24359
 
 
24360
 
_PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
24361
 
{
24362
 
        uint32_t _ptr_servername;
24363
 
        uint32_t _ptr_buffer;
24364
 
        uint32_t _ptr_info;
24365
 
        TALLOC_CTX *_mem_save_servername_0;
24366
 
        TALLOC_CTX *_mem_save_buffer_0;
24367
 
        TALLOC_CTX *_mem_save_info_0;
24368
 
        TALLOC_CTX *_mem_save_needed_0;
24369
 
        TALLOC_CTX *_mem_save_count_0;
24370
 
        if (flags & NDR_IN) {
24371
 
                ZERO_STRUCT(r->out);
24372
 
 
24373
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24374
 
                if (_ptr_servername) {
24375
 
                        NDR_PULL_ALLOC(ndr, r->in.servername);
24376
 
                } else {
24377
 
                        r->in.servername = NULL;
24378
 
                }
24379
 
                if (r->in.servername) {
24380
 
                        _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24381
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24382
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24383
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24384
 
                        if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24385
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
24386
 
                        }
24387
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24388
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24389
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24390
 
                }
24391
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24392
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24393
 
                if (_ptr_buffer) {
24394
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
24395
 
                } else {
24396
 
                        r->in.buffer = NULL;
24397
 
                }
24398
 
                if (r->in.buffer) {
24399
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24400
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24401
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24402
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24403
 
                }
24404
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24405
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
24406
 
                ZERO_STRUCTP(r->out.needed);
24407
 
                NDR_PULL_ALLOC(ndr, r->out.count);
24408
 
                ZERO_STRUCTP(r->out.count);
24409
 
        }
24410
 
        if (flags & NDR_OUT) {
24411
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24412
 
                if (_ptr_info) {
24413
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
24414
 
                } else {
24415
 
                        r->out.info = NULL;
24416
 
                }
24417
 
                if (r->out.info) {
24418
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24419
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24420
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24421
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24422
 
                }
24423
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24424
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
24425
 
                }
24426
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24427
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24428
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24429
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24430
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24431
 
                        NDR_PULL_ALLOC(ndr, r->out.count);
24432
 
                }
24433
 
                _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24434
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24435
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24436
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24437
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24438
 
        }
24439
 
        return NDR_ERR_SUCCESS;
24440
 
}
24441
 
 
24442
 
_PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
24443
 
{
24444
 
        uint32_t cntr_info_0;
24445
 
        if (flags & NDR_IN) {
24446
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24447
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24448
 
        }
24449
 
        if (flags & NDR_OUT) {
24450
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24451
 
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24452
 
                        NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24453
 
                }
24454
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24455
 
                        NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24456
 
                }
24457
 
        }
24458
 
        return NDR_ERR_SUCCESS;
24459
 
}
24460
 
 
24461
 
_PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
24462
 
{
24463
 
        uint32_t cntr_info_0;
24464
 
        TALLOC_CTX *_mem_save_info_0;
24465
 
        if (flags & NDR_IN) {
24466
 
                ZERO_STRUCT(r->out);
24467
 
 
24468
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24469
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24470
 
        }
24471
 
        if (flags & NDR_OUT) {
24472
 
                NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24473
 
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24474
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24475
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24476
 
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24477
 
                        NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24478
 
                }
24479
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24480
 
                        NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24481
 
                }
24482
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24483
 
        }
24484
 
        return NDR_ERR_SUCCESS;
24485
 
}
24486
 
 
24487
 
_PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
24488
 
{
24489
 
        uint32_t cntr_info_2;
24490
 
        ndr_print_struct(ndr, name, "spoolss_EnumPorts");
24491
 
        ndr->depth++;
24492
 
        if (flags & NDR_SET_VALUES) {
24493
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24494
 
        }
24495
 
        if (flags & NDR_IN) {
24496
 
                ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
24497
 
                ndr->depth++;
24498
 
                ndr_print_ptr(ndr, "servername", r->in.servername);
24499
 
                ndr->depth++;
24500
 
                if (r->in.servername) {
24501
 
                        ndr_print_string(ndr, "servername", r->in.servername);
24502
 
                }
24503
 
                ndr->depth--;
24504
 
                ndr_print_uint32(ndr, "level", r->in.level);
24505
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
24506
 
                ndr->depth++;
24507
 
                if (r->in.buffer) {
24508
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24509
 
                }
24510
 
                ndr->depth--;
24511
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
24512
 
                ndr->depth--;
24513
 
        }
24514
 
        if (flags & NDR_OUT) {
24515
 
                ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
24516
 
                ndr->depth++;
24517
 
                ndr_print_ptr(ndr, "count", r->out.count);
24518
 
                ndr->depth++;
24519
 
                ndr_print_uint32(ndr, "count", *r->out.count);
24520
 
                ndr->depth--;
24521
 
                ndr_print_ptr(ndr, "info", r->out.info);
24522
 
                ndr->depth++;
24523
 
                ndr_print_ptr(ndr, "info", *r->out.info);
24524
 
                ndr->depth++;
24525
 
                if (*r->out.info) {
24526
 
                        ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24527
 
                        ndr->depth++;
24528
 
                        for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24529
 
                                char *idx_2=NULL;
24530
 
                                if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24531
 
                                        ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24532
 
                                        ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24533
 
                                        free(idx_2);
24534
 
                                }
24535
 
                        }
24536
 
                        ndr->depth--;
24537
 
                }
24538
 
                ndr->depth--;
24539
 
                ndr->depth--;
24540
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
24541
 
                ndr->depth++;
24542
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
24543
 
                ndr->depth--;
24544
 
                ndr_print_WERROR(ndr, "result", r->out.result);
24545
 
                ndr->depth--;
24546
 
        }
24547
 
        ndr->depth--;
24548
 
}
24549
 
 
24550
 
_PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
24551
 
{
24552
 
        if (flags & NDR_IN) {
24553
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24554
 
                if (r->in.servername) {
24555
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24556
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24557
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24558
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24559
 
                }
24560
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24561
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24562
 
                if (r->in.buffer) {
24563
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24564
 
                }
24565
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24566
 
        }
24567
 
        if (flags & NDR_OUT) {
24568
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24569
 
                if (r->out.info) {
24570
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24571
 
                }
24572
 
                if (r->out.needed == NULL) {
24573
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24574
 
                }
24575
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24576
 
                if (r->out.count == NULL) {
24577
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24578
 
                }
24579
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24580
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24581
 
        }
24582
 
        return NDR_ERR_SUCCESS;
24583
 
}
24584
 
 
24585
 
_PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
24586
 
{
24587
 
        uint32_t _ptr_servername;
24588
 
        uint32_t _ptr_buffer;
24589
 
        uint32_t _ptr_info;
24590
 
        TALLOC_CTX *_mem_save_servername_0;
24591
 
        TALLOC_CTX *_mem_save_buffer_0;
24592
 
        TALLOC_CTX *_mem_save_info_0;
24593
 
        TALLOC_CTX *_mem_save_needed_0;
24594
 
        TALLOC_CTX *_mem_save_count_0;
24595
 
        if (flags & NDR_IN) {
24596
 
                ZERO_STRUCT(r->out);
24597
 
 
24598
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24599
 
                if (_ptr_servername) {
24600
 
                        NDR_PULL_ALLOC(ndr, r->in.servername);
24601
 
                } else {
24602
 
                        r->in.servername = NULL;
24603
 
                }
24604
 
                if (r->in.servername) {
24605
 
                        _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24606
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24607
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24608
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24609
 
                        if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24610
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
24611
 
                        }
24612
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24613
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24614
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24615
 
                }
24616
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24617
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24618
 
                if (_ptr_buffer) {
24619
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
24620
 
                } else {
24621
 
                        r->in.buffer = NULL;
24622
 
                }
24623
 
                if (r->in.buffer) {
24624
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24625
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24626
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24627
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24628
 
                }
24629
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24630
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
24631
 
                ZERO_STRUCTP(r->out.needed);
24632
 
                NDR_PULL_ALLOC(ndr, r->out.count);
24633
 
                ZERO_STRUCTP(r->out.count);
24634
 
        }
24635
 
        if (flags & NDR_OUT) {
24636
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24637
 
                if (_ptr_info) {
24638
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
24639
 
                } else {
24640
 
                        r->out.info = NULL;
24641
 
                }
24642
 
                if (r->out.info) {
24643
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24644
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24645
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24646
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24647
 
                }
24648
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24649
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
24650
 
                }
24651
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24652
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24653
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24654
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24655
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24656
 
                        NDR_PULL_ALLOC(ndr, r->out.count);
24657
 
                }
24658
 
                _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24659
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24660
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24661
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24662
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24663
 
        }
24664
 
        return NDR_ERR_SUCCESS;
24665
 
}
24666
 
 
24667
 
_PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
24668
 
{
24669
 
        uint32_t cntr_info_0;
24670
 
        if (flags & NDR_IN) {
24671
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24672
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24673
 
        }
24674
 
        if (flags & NDR_OUT) {
24675
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24676
 
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24677
 
                        NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24678
 
                }
24679
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24680
 
                        NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24681
 
                }
24682
 
        }
24683
 
        return NDR_ERR_SUCCESS;
24684
 
}
24685
 
 
24686
 
_PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
24687
 
{
24688
 
        uint32_t cntr_info_0;
24689
 
        TALLOC_CTX *_mem_save_info_0;
24690
 
        if (flags & NDR_IN) {
24691
 
                ZERO_STRUCT(r->out);
24692
 
 
24693
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24694
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24695
 
        }
24696
 
        if (flags & NDR_OUT) {
24697
 
                NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24698
 
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24699
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24700
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24701
 
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24702
 
                        NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24703
 
                }
24704
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24705
 
                        NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24706
 
                }
24707
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24708
 
        }
24709
 
        return NDR_ERR_SUCCESS;
24710
 
}
24711
 
 
24712
 
_PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
24713
 
{
24714
 
        uint32_t cntr_info_2;
24715
 
        ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
24716
 
        ndr->depth++;
24717
 
        if (flags & NDR_SET_VALUES) {
24718
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24719
 
        }
24720
 
        if (flags & NDR_IN) {
24721
 
                ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
24722
 
                ndr->depth++;
24723
 
                ndr_print_ptr(ndr, "servername", r->in.servername);
24724
 
                ndr->depth++;
24725
 
                if (r->in.servername) {
24726
 
                        ndr_print_string(ndr, "servername", r->in.servername);
24727
 
                }
24728
 
                ndr->depth--;
24729
 
                ndr_print_uint32(ndr, "level", r->in.level);
24730
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
24731
 
                ndr->depth++;
24732
 
                if (r->in.buffer) {
24733
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24734
 
                }
24735
 
                ndr->depth--;
24736
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
24737
 
                ndr->depth--;
24738
 
        }
24739
 
        if (flags & NDR_OUT) {
24740
 
                ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
24741
 
                ndr->depth++;
24742
 
                ndr_print_ptr(ndr, "count", r->out.count);
24743
 
                ndr->depth++;
24744
 
                ndr_print_uint32(ndr, "count", *r->out.count);
24745
 
                ndr->depth--;
24746
 
                ndr_print_ptr(ndr, "info", r->out.info);
24747
 
                ndr->depth++;
24748
 
                ndr_print_ptr(ndr, "info", *r->out.info);
24749
 
                ndr->depth++;
24750
 
                if (*r->out.info) {
24751
 
                        ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24752
 
                        ndr->depth++;
24753
 
                        for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24754
 
                                char *idx_2=NULL;
24755
 
                                if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24756
 
                                        ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24757
 
                                        ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24758
 
                                        free(idx_2);
24759
 
                                }
24760
 
                        }
24761
 
                        ndr->depth--;
24762
 
                }
24763
 
                ndr->depth--;
24764
 
                ndr->depth--;
24765
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
24766
 
                ndr->depth++;
24767
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
24768
 
                ndr->depth--;
24769
 
                ndr_print_WERROR(ndr, "result", r->out.result);
24770
 
                ndr->depth--;
24771
 
        }
24772
 
        ndr->depth--;
24773
 
}
24774
 
 
24775
 
static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
24776
 
{
24777
 
        if (flags & NDR_IN) {
24778
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
24779
 
                if (r->in.server_name) {
24780
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24781
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24782
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24783
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24784
 
                }
24785
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
24786
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24787
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24788
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24789
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.monitor_name, ndr_charset_length(r->in.monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24790
 
        }
24791
 
        if (flags & NDR_OUT) {
24792
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24793
 
        }
24794
 
        return NDR_ERR_SUCCESS;
24795
 
}
24796
 
 
24797
 
static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
24798
 
{
24799
 
        uint32_t _ptr_server_name;
24800
 
        TALLOC_CTX *_mem_save_server_name_0;
24801
 
        if (flags & NDR_IN) {
24802
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
24803
 
                if (_ptr_server_name) {
24804
 
                        NDR_PULL_ALLOC(ndr, r->in.server_name);
24805
 
                } else {
24806
 
                        r->in.server_name = NULL;
24807
 
                }
24808
 
                if (r->in.server_name) {
24809
 
                        _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24810
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
24811
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24812
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24813
 
                        if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24814
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
24815
 
                        }
24816
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24817
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
24818
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
24819
 
                }
24820
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
24821
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
24822
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
24823
 
                if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
24824
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.monitor_name), ndr_get_array_length(ndr, &r->in.monitor_name));
24825
 
                }
24826
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
24827
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.monitor_name, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t), CH_UTF16));
24828
 
        }
24829
 
        if (flags & NDR_OUT) {
24830
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24831
 
        }
24832
 
        return NDR_ERR_SUCCESS;
24833
 
}
24834
 
 
24835
 
_PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
24836
 
{
24837
 
        ndr_print_struct(ndr, name, "spoolss_AddPort");
24838
 
        ndr->depth++;
24839
 
        if (flags & NDR_SET_VALUES) {
24840
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24841
 
        }
24842
 
        if (flags & NDR_IN) {
24843
 
                ndr_print_struct(ndr, "in", "spoolss_AddPort");
24844
 
                ndr->depth++;
24845
 
                ndr_print_ptr(ndr, "server_name", r->in.server_name);
24846
 
                ndr->depth++;
24847
 
                if (r->in.server_name) {
24848
 
                        ndr_print_string(ndr, "server_name", r->in.server_name);
24849
 
                }
24850
 
                ndr->depth--;
24851
 
                ndr_print_uint32(ndr, "unknown", r->in.unknown);
24852
 
                ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
24853
 
                ndr->depth--;
24854
 
        }
24855
 
        if (flags & NDR_OUT) {
24856
 
                ndr_print_struct(ndr, "out", "spoolss_AddPort");
24857
 
                ndr->depth++;
24858
 
                ndr_print_WERROR(ndr, "result", r->out.result);
24859
 
                ndr->depth--;
24860
 
        }
24861
 
        ndr->depth--;
24862
 
}
24863
 
 
24864
 
static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
24865
 
{
24866
 
        if (flags & NDR_IN) {
24867
 
        }
24868
 
        if (flags & NDR_OUT) {
24869
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24870
 
        }
24871
 
        return NDR_ERR_SUCCESS;
24872
 
}
24873
 
 
24874
 
static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
24875
 
{
24876
 
        if (flags & NDR_IN) {
24877
 
        }
24878
 
        if (flags & NDR_OUT) {
24879
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24880
 
        }
24881
 
        return NDR_ERR_SUCCESS;
24882
 
}
24883
 
 
24884
 
_PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
24885
 
{
24886
 
        ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
24887
 
        ndr->depth++;
24888
 
        if (flags & NDR_SET_VALUES) {
24889
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24890
 
        }
24891
 
        if (flags & NDR_IN) {
24892
 
                ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
24893
 
                ndr->depth++;
24894
 
                ndr->depth--;
24895
 
        }
24896
 
        if (flags & NDR_OUT) {
24897
 
                ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
24898
 
                ndr->depth++;
24899
 
                ndr_print_WERROR(ndr, "result", r->out.result);
24900
 
                ndr->depth--;
24901
 
        }
24902
 
        ndr->depth--;
24903
 
}
24904
 
 
24905
 
static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
24906
 
{
24907
 
        if (flags & NDR_IN) {
24908
 
        }
24909
 
        if (flags & NDR_OUT) {
24910
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24911
 
        }
24912
 
        return NDR_ERR_SUCCESS;
24913
 
}
24914
 
 
24915
 
static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
24916
 
{
24917
 
        if (flags & NDR_IN) {
24918
 
        }
24919
 
        if (flags & NDR_OUT) {
24920
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24921
 
        }
24922
 
        return NDR_ERR_SUCCESS;
24923
 
}
24924
 
 
24925
 
_PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
24926
 
{
24927
 
        ndr_print_struct(ndr, name, "spoolss_DeletePort");
24928
 
        ndr->depth++;
24929
 
        if (flags & NDR_SET_VALUES) {
24930
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24931
 
        }
24932
 
        if (flags & NDR_IN) {
24933
 
                ndr_print_struct(ndr, "in", "spoolss_DeletePort");
24934
 
                ndr->depth++;
24935
 
                ndr->depth--;
24936
 
        }
24937
 
        if (flags & NDR_OUT) {
24938
 
                ndr_print_struct(ndr, "out", "spoolss_DeletePort");
24939
 
                ndr->depth++;
24940
 
                ndr_print_WERROR(ndr, "result", r->out.result);
24941
 
                ndr->depth--;
24942
 
        }
24943
 
        ndr->depth--;
24944
 
}
24945
 
 
24946
 
static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
24947
 
{
24948
 
        if (flags & NDR_IN) {
24949
 
                if (r->in.handle == NULL) {
24950
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24951
 
                }
24952
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24953
 
                if (r->in.devmode_ctr == NULL) {
24954
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24955
 
                }
24956
 
                NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24957
 
        }
24958
 
        if (flags & NDR_OUT) {
24959
 
                if (r->out.gdi_handle == NULL) {
24960
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24961
 
                }
24962
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
24963
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24964
 
        }
24965
 
        return NDR_ERR_SUCCESS;
24966
 
}
24967
 
 
24968
 
static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
24969
 
{
24970
 
        TALLOC_CTX *_mem_save_handle_0;
24971
 
        TALLOC_CTX *_mem_save_gdi_handle_0;
24972
 
        TALLOC_CTX *_mem_save_devmode_ctr_0;
24973
 
        if (flags & NDR_IN) {
24974
 
                ZERO_STRUCT(r->out);
24975
 
 
24976
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24977
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
24978
 
                }
24979
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24980
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24981
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24982
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24983
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24984
 
                        NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24985
 
                }
24986
 
                _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24987
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24988
 
                NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24989
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24990
 
                NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24991
 
                ZERO_STRUCTP(r->out.gdi_handle);
24992
 
        }
24993
 
        if (flags & NDR_OUT) {
24994
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24995
 
                        NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
24996
 
                }
24997
 
                _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24998
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
24999
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25000
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25001
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25002
 
        }
25003
 
        return NDR_ERR_SUCCESS;
25004
 
}
25005
 
 
25006
 
_PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
25007
 
{
25008
 
        ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
25009
 
        ndr->depth++;
25010
 
        if (flags & NDR_SET_VALUES) {
25011
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25012
 
        }
25013
 
        if (flags & NDR_IN) {
25014
 
                ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
25015
 
                ndr->depth++;
25016
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
25017
 
                ndr->depth++;
25018
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
25019
 
                ndr->depth--;
25020
 
                ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25021
 
                ndr->depth++;
25022
 
                ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25023
 
                ndr->depth--;
25024
 
                ndr->depth--;
25025
 
        }
25026
 
        if (flags & NDR_OUT) {
25027
 
                ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
25028
 
                ndr->depth++;
25029
 
                ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25030
 
                ndr->depth++;
25031
 
                ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25032
 
                ndr->depth--;
25033
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25034
 
                ndr->depth--;
25035
 
        }
25036
 
        ndr->depth--;
25037
 
}
25038
 
 
25039
 
static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25040
 
{
25041
 
        if (flags & NDR_IN) {
25042
 
        }
25043
 
        if (flags & NDR_OUT) {
25044
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25045
 
        }
25046
 
        return NDR_ERR_SUCCESS;
25047
 
}
25048
 
 
25049
 
static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
25050
 
{
25051
 
        if (flags & NDR_IN) {
25052
 
        }
25053
 
        if (flags & NDR_OUT) {
25054
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25055
 
        }
25056
 
        return NDR_ERR_SUCCESS;
25057
 
}
25058
 
 
25059
 
_PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25060
 
{
25061
 
        ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
25062
 
        ndr->depth++;
25063
 
        if (flags & NDR_SET_VALUES) {
25064
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25065
 
        }
25066
 
        if (flags & NDR_IN) {
25067
 
                ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
25068
 
                ndr->depth++;
25069
 
                ndr->depth--;
25070
 
        }
25071
 
        if (flags & NDR_OUT) {
25072
 
                ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
25073
 
                ndr->depth++;
25074
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25075
 
                ndr->depth--;
25076
 
        }
25077
 
        ndr->depth--;
25078
 
}
25079
 
 
25080
 
static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
25081
 
{
25082
 
        if (flags & NDR_IN) {
25083
 
                if (r->in.gdi_handle == NULL) {
25084
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25085
 
                }
25086
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25087
 
        }
25088
 
        if (flags & NDR_OUT) {
25089
 
                if (r->out.gdi_handle == NULL) {
25090
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25091
 
                }
25092
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25093
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25094
 
        }
25095
 
        return NDR_ERR_SUCCESS;
25096
 
}
25097
 
 
25098
 
static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
25099
 
{
25100
 
        TALLOC_CTX *_mem_save_gdi_handle_0;
25101
 
        if (flags & NDR_IN) {
25102
 
                ZERO_STRUCT(r->out);
25103
 
 
25104
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25105
 
                        NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
25106
 
                }
25107
 
                _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25108
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25109
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25110
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25111
 
                NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25112
 
                *r->out.gdi_handle = *r->in.gdi_handle;
25113
 
        }
25114
 
        if (flags & NDR_OUT) {
25115
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25116
 
                        NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25117
 
                }
25118
 
                _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25119
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25120
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25121
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25122
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25123
 
        }
25124
 
        return NDR_ERR_SUCCESS;
25125
 
}
25126
 
 
25127
 
_PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
25128
 
{
25129
 
        ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
25130
 
        ndr->depth++;
25131
 
        if (flags & NDR_SET_VALUES) {
25132
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25133
 
        }
25134
 
        if (flags & NDR_IN) {
25135
 
                ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
25136
 
                ndr->depth++;
25137
 
                ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
25138
 
                ndr->depth++;
25139
 
                ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
25140
 
                ndr->depth--;
25141
 
                ndr->depth--;
25142
 
        }
25143
 
        if (flags & NDR_OUT) {
25144
 
                ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
25145
 
                ndr->depth++;
25146
 
                ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25147
 
                ndr->depth++;
25148
 
                ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25149
 
                ndr->depth--;
25150
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25151
 
                ndr->depth--;
25152
 
        }
25153
 
        ndr->depth--;
25154
 
}
25155
 
 
25156
 
static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
25157
 
{
25158
 
        if (flags & NDR_IN) {
25159
 
        }
25160
 
        if (flags & NDR_OUT) {
25161
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25162
 
        }
25163
 
        return NDR_ERR_SUCCESS;
25164
 
}
25165
 
 
25166
 
static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
25167
 
{
25168
 
        if (flags & NDR_IN) {
25169
 
        }
25170
 
        if (flags & NDR_OUT) {
25171
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25172
 
        }
25173
 
        return NDR_ERR_SUCCESS;
25174
 
}
25175
 
 
25176
 
_PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
25177
 
{
25178
 
        ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
25179
 
        ndr->depth++;
25180
 
        if (flags & NDR_SET_VALUES) {
25181
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25182
 
        }
25183
 
        if (flags & NDR_IN) {
25184
 
                ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
25185
 
                ndr->depth++;
25186
 
                ndr->depth--;
25187
 
        }
25188
 
        if (flags & NDR_OUT) {
25189
 
                ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
25190
 
                ndr->depth++;
25191
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25192
 
                ndr->depth--;
25193
 
        }
25194
 
        ndr->depth--;
25195
 
}
25196
 
 
25197
 
static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
25198
 
{
25199
 
        if (flags & NDR_IN) {
25200
 
        }
25201
 
        if (flags & NDR_OUT) {
25202
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25203
 
        }
25204
 
        return NDR_ERR_SUCCESS;
25205
 
}
25206
 
 
25207
 
static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
25208
 
{
25209
 
        if (flags & NDR_IN) {
25210
 
        }
25211
 
        if (flags & NDR_OUT) {
25212
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25213
 
        }
25214
 
        return NDR_ERR_SUCCESS;
25215
 
}
25216
 
 
25217
 
_PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
25218
 
{
25219
 
        ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
25220
 
        ndr->depth++;
25221
 
        if (flags & NDR_SET_VALUES) {
25222
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25223
 
        }
25224
 
        if (flags & NDR_IN) {
25225
 
                ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
25226
 
                ndr->depth++;
25227
 
                ndr->depth--;
25228
 
        }
25229
 
        if (flags & NDR_OUT) {
25230
 
                ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
25231
 
                ndr->depth++;
25232
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25233
 
                ndr->depth--;
25234
 
        }
25235
 
        ndr->depth--;
25236
 
}
25237
 
 
25238
 
static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
25239
 
{
25240
 
        if (flags & NDR_IN) {
25241
 
        }
25242
 
        if (flags & NDR_OUT) {
25243
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25244
 
        }
25245
 
        return NDR_ERR_SUCCESS;
25246
 
}
25247
 
 
25248
 
static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
25249
 
{
25250
 
        if (flags & NDR_IN) {
25251
 
        }
25252
 
        if (flags & NDR_OUT) {
25253
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25254
 
        }
25255
 
        return NDR_ERR_SUCCESS;
25256
 
}
25257
 
 
25258
 
_PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
25259
 
{
25260
 
        ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
25261
 
        ndr->depth++;
25262
 
        if (flags & NDR_SET_VALUES) {
25263
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25264
 
        }
25265
 
        if (flags & NDR_IN) {
25266
 
                ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
25267
 
                ndr->depth++;
25268
 
                ndr->depth--;
25269
 
        }
25270
 
        if (flags & NDR_OUT) {
25271
 
                ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
25272
 
                ndr->depth++;
25273
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25274
 
                ndr->depth--;
25275
 
        }
25276
 
        ndr->depth--;
25277
 
}
25278
 
 
25279
 
static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
25280
 
{
25281
 
        if (flags & NDR_IN) {
25282
 
        }
25283
 
        if (flags & NDR_OUT) {
25284
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25285
 
        }
25286
 
        return NDR_ERR_SUCCESS;
25287
 
}
25288
 
 
25289
 
static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
25290
 
{
25291
 
        if (flags & NDR_IN) {
25292
 
        }
25293
 
        if (flags & NDR_OUT) {
25294
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25295
 
        }
25296
 
        return NDR_ERR_SUCCESS;
25297
 
}
25298
 
 
25299
 
_PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
25300
 
{
25301
 
        ndr_print_struct(ndr, name, "spoolss_AddMonitor");
25302
 
        ndr->depth++;
25303
 
        if (flags & NDR_SET_VALUES) {
25304
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25305
 
        }
25306
 
        if (flags & NDR_IN) {
25307
 
                ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
25308
 
                ndr->depth++;
25309
 
                ndr->depth--;
25310
 
        }
25311
 
        if (flags & NDR_OUT) {
25312
 
                ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
25313
 
                ndr->depth++;
25314
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25315
 
                ndr->depth--;
25316
 
        }
25317
 
        ndr->depth--;
25318
 
}
25319
 
 
25320
 
static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
25321
 
{
25322
 
        if (flags & NDR_IN) {
25323
 
        }
25324
 
        if (flags & NDR_OUT) {
25325
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25326
 
        }
25327
 
        return NDR_ERR_SUCCESS;
25328
 
}
25329
 
 
25330
 
static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
25331
 
{
25332
 
        if (flags & NDR_IN) {
25333
 
        }
25334
 
        if (flags & NDR_OUT) {
25335
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25336
 
        }
25337
 
        return NDR_ERR_SUCCESS;
25338
 
}
25339
 
 
25340
 
_PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
25341
 
{
25342
 
        ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
25343
 
        ndr->depth++;
25344
 
        if (flags & NDR_SET_VALUES) {
25345
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25346
 
        }
25347
 
        if (flags & NDR_IN) {
25348
 
                ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
25349
 
                ndr->depth++;
25350
 
                ndr->depth--;
25351
 
        }
25352
 
        if (flags & NDR_OUT) {
25353
 
                ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
25354
 
                ndr->depth++;
25355
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25356
 
                ndr->depth--;
25357
 
        }
25358
 
        ndr->depth--;
25359
 
}
25360
 
 
25361
 
static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
25362
 
{
25363
 
        if (flags & NDR_IN) {
25364
 
        }
25365
 
        if (flags & NDR_OUT) {
25366
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25367
 
        }
25368
 
        return NDR_ERR_SUCCESS;
25369
 
}
25370
 
 
25371
 
static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
25372
 
{
25373
 
        if (flags & NDR_IN) {
25374
 
        }
25375
 
        if (flags & NDR_OUT) {
25376
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25377
 
        }
25378
 
        return NDR_ERR_SUCCESS;
25379
 
}
25380
 
 
25381
 
_PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
25382
 
{
25383
 
        ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
25384
 
        ndr->depth++;
25385
 
        if (flags & NDR_SET_VALUES) {
25386
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25387
 
        }
25388
 
        if (flags & NDR_IN) {
25389
 
                ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
25390
 
                ndr->depth++;
25391
 
                ndr->depth--;
25392
 
        }
25393
 
        if (flags & NDR_OUT) {
25394
 
                ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
25395
 
                ndr->depth++;
25396
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25397
 
                ndr->depth--;
25398
 
        }
25399
 
        ndr->depth--;
25400
 
}
25401
 
 
25402
 
static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
25403
 
{
25404
 
        if (flags & NDR_IN) {
25405
 
        }
25406
 
        if (flags & NDR_OUT) {
25407
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25408
 
        }
25409
 
        return NDR_ERR_SUCCESS;
25410
 
}
25411
 
 
25412
 
static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
25413
 
{
25414
 
        if (flags & NDR_IN) {
25415
 
        }
25416
 
        if (flags & NDR_OUT) {
25417
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25418
 
        }
25419
 
        return NDR_ERR_SUCCESS;
25420
 
}
25421
 
 
25422
 
_PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
25423
 
{
25424
 
        ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
25425
 
        ndr->depth++;
25426
 
        if (flags & NDR_SET_VALUES) {
25427
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25428
 
        }
25429
 
        if (flags & NDR_IN) {
25430
 
                ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
25431
 
                ndr->depth++;
25432
 
                ndr->depth--;
25433
 
        }
25434
 
        if (flags & NDR_OUT) {
25435
 
                ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
25436
 
                ndr->depth++;
25437
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25438
 
                ndr->depth--;
25439
 
        }
25440
 
        ndr->depth--;
25441
 
}
25442
 
 
25443
 
static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
25444
 
{
25445
 
        if (flags & NDR_IN) {
25446
 
        }
25447
 
        if (flags & NDR_OUT) {
25448
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25449
 
        }
25450
 
        return NDR_ERR_SUCCESS;
25451
 
}
25452
 
 
25453
 
static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
25454
 
{
25455
 
        if (flags & NDR_IN) {
25456
 
        }
25457
 
        if (flags & NDR_OUT) {
25458
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25459
 
        }
25460
 
        return NDR_ERR_SUCCESS;
25461
 
}
25462
 
 
25463
 
_PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
25464
 
{
25465
 
        ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
25466
 
        ndr->depth++;
25467
 
        if (flags & NDR_SET_VALUES) {
25468
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25469
 
        }
25470
 
        if (flags & NDR_IN) {
25471
 
                ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
25472
 
                ndr->depth++;
25473
 
                ndr->depth--;
25474
 
        }
25475
 
        if (flags & NDR_OUT) {
25476
 
                ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
25477
 
                ndr->depth++;
25478
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25479
 
                ndr->depth--;
25480
 
        }
25481
 
        ndr->depth--;
25482
 
}
25483
 
 
25484
 
_PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
25485
 
{
25486
 
        if (flags & NDR_IN) {
25487
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25488
 
                if (r->in.servername) {
25489
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25490
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25491
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25492
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25493
 
                }
25494
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
25495
 
                if (r->in.print_processor_name) {
25496
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25497
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25498
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25499
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.print_processor_name, ndr_charset_length(r->in.print_processor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25500
 
                }
25501
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25502
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25503
 
                if (r->in.buffer) {
25504
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25505
 
                }
25506
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25507
 
        }
25508
 
        if (flags & NDR_OUT) {
25509
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25510
 
                if (r->out.info) {
25511
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25512
 
                }
25513
 
                if (r->out.needed == NULL) {
25514
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25515
 
                }
25516
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25517
 
                if (r->out.count == NULL) {
25518
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25519
 
                }
25520
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25521
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25522
 
        }
25523
 
        return NDR_ERR_SUCCESS;
25524
 
}
25525
 
 
25526
 
_PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
25527
 
{
25528
 
        uint32_t _ptr_servername;
25529
 
        uint32_t _ptr_print_processor_name;
25530
 
        uint32_t _ptr_buffer;
25531
 
        uint32_t _ptr_info;
25532
 
        TALLOC_CTX *_mem_save_servername_0;
25533
 
        TALLOC_CTX *_mem_save_print_processor_name_0;
25534
 
        TALLOC_CTX *_mem_save_buffer_0;
25535
 
        TALLOC_CTX *_mem_save_info_0;
25536
 
        TALLOC_CTX *_mem_save_needed_0;
25537
 
        TALLOC_CTX *_mem_save_count_0;
25538
 
        if (flags & NDR_IN) {
25539
 
                ZERO_STRUCT(r->out);
25540
 
 
25541
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25542
 
                if (_ptr_servername) {
25543
 
                        NDR_PULL_ALLOC(ndr, r->in.servername);
25544
 
                } else {
25545
 
                        r->in.servername = NULL;
25546
 
                }
25547
 
                if (r->in.servername) {
25548
 
                        _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25549
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25550
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25551
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25552
 
                        if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25553
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
25554
 
                        }
25555
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25556
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25557
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25558
 
                }
25559
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
25560
 
                if (_ptr_print_processor_name) {
25561
 
                        NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
25562
 
                } else {
25563
 
                        r->in.print_processor_name = NULL;
25564
 
                }
25565
 
                if (r->in.print_processor_name) {
25566
 
                        _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25567
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
25568
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
25569
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
25570
 
                        if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
25571
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.print_processor_name), ndr_get_array_length(ndr, &r->in.print_processor_name));
25572
 
                        }
25573
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
25574
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.print_processor_name, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t), CH_UTF16));
25575
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
25576
 
                }
25577
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25578
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25579
 
                if (_ptr_buffer) {
25580
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
25581
 
                } else {
25582
 
                        r->in.buffer = NULL;
25583
 
                }
25584
 
                if (r->in.buffer) {
25585
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25586
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25587
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25588
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25589
 
                }
25590
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25591
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
25592
 
                ZERO_STRUCTP(r->out.needed);
25593
 
                NDR_PULL_ALLOC(ndr, r->out.count);
25594
 
                ZERO_STRUCTP(r->out.count);
25595
 
        }
25596
 
        if (flags & NDR_OUT) {
25597
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25598
 
                if (_ptr_info) {
25599
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
25600
 
                } else {
25601
 
                        r->out.info = NULL;
25602
 
                }
25603
 
                if (r->out.info) {
25604
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25605
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25606
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25607
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25608
 
                }
25609
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25610
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
25611
 
                }
25612
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25613
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25614
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25615
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25616
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25617
 
                        NDR_PULL_ALLOC(ndr, r->out.count);
25618
 
                }
25619
 
                _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25620
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25621
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25622
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25623
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25624
 
        }
25625
 
        return NDR_ERR_SUCCESS;
25626
 
}
25627
 
 
25628
 
_PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
25629
 
{
25630
 
        uint32_t cntr_info_0;
25631
 
        if (flags & NDR_IN) {
25632
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25633
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25634
 
        }
25635
 
        if (flags & NDR_OUT) {
25636
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25637
 
                        NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25638
 
                        NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25639
 
                }
25640
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25641
 
                        NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25642
 
                }
25643
 
        }
25644
 
        return NDR_ERR_SUCCESS;
25645
 
}
25646
 
 
25647
 
_PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
25648
 
{
25649
 
        uint32_t cntr_info_0;
25650
 
        TALLOC_CTX *_mem_save_info_0;
25651
 
        if (flags & NDR_IN) {
25652
 
                ZERO_STRUCT(r->out);
25653
 
 
25654
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25655
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25656
 
        }
25657
 
        if (flags & NDR_OUT) {
25658
 
                NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25659
 
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25660
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25661
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25662
 
                        NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25663
 
                        NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25664
 
                }
25665
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25666
 
                        NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25667
 
                }
25668
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25669
 
        }
25670
 
        return NDR_ERR_SUCCESS;
25671
 
}
25672
 
 
25673
 
_PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
25674
 
{
25675
 
        uint32_t cntr_info_2;
25676
 
        ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
25677
 
        ndr->depth++;
25678
 
        if (flags & NDR_SET_VALUES) {
25679
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25680
 
        }
25681
 
        if (flags & NDR_IN) {
25682
 
                ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
25683
 
                ndr->depth++;
25684
 
                ndr_print_ptr(ndr, "servername", r->in.servername);
25685
 
                ndr->depth++;
25686
 
                if (r->in.servername) {
25687
 
                        ndr_print_string(ndr, "servername", r->in.servername);
25688
 
                }
25689
 
                ndr->depth--;
25690
 
                ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
25691
 
                ndr->depth++;
25692
 
                if (r->in.print_processor_name) {
25693
 
                        ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
25694
 
                }
25695
 
                ndr->depth--;
25696
 
                ndr_print_uint32(ndr, "level", r->in.level);
25697
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
25698
 
                ndr->depth++;
25699
 
                if (r->in.buffer) {
25700
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25701
 
                }
25702
 
                ndr->depth--;
25703
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
25704
 
                ndr->depth--;
25705
 
        }
25706
 
        if (flags & NDR_OUT) {
25707
 
                ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
25708
 
                ndr->depth++;
25709
 
                ndr_print_ptr(ndr, "count", r->out.count);
25710
 
                ndr->depth++;
25711
 
                ndr_print_uint32(ndr, "count", *r->out.count);
25712
 
                ndr->depth--;
25713
 
                ndr_print_ptr(ndr, "info", r->out.info);
25714
 
                ndr->depth++;
25715
 
                ndr_print_ptr(ndr, "info", *r->out.info);
25716
 
                ndr->depth++;
25717
 
                if (*r->out.info) {
25718
 
                        ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25719
 
                        ndr->depth++;
25720
 
                        for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25721
 
                                char *idx_2=NULL;
25722
 
                                if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25723
 
                                        ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25724
 
                                        ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25725
 
                                        free(idx_2);
25726
 
                                }
25727
 
                        }
25728
 
                        ndr->depth--;
25729
 
                }
25730
 
                ndr->depth--;
25731
 
                ndr->depth--;
25732
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
25733
 
                ndr->depth++;
25734
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
25735
 
                ndr->depth--;
25736
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25737
 
                ndr->depth--;
25738
 
        }
25739
 
        ndr->depth--;
25740
 
}
25741
 
 
25742
 
static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
25743
 
{
25744
 
        if (flags & NDR_IN) {
25745
 
                if (r->in.handle == NULL) {
25746
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25747
 
                }
25748
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25749
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
25750
 
                if (r->in.data_type) {
25751
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25752
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25753
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25754
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.data_type, ndr_charset_length(r->in.data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25755
 
                }
25756
 
                if (r->in.devmode_ctr == NULL) {
25757
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25758
 
                }
25759
 
                NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25760
 
        }
25761
 
        if (flags & NDR_OUT) {
25762
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25763
 
        }
25764
 
        return NDR_ERR_SUCCESS;
25765
 
}
25766
 
 
25767
 
static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
25768
 
{
25769
 
        uint32_t _ptr_data_type;
25770
 
        TALLOC_CTX *_mem_save_handle_0;
25771
 
        TALLOC_CTX *_mem_save_data_type_0;
25772
 
        TALLOC_CTX *_mem_save_devmode_ctr_0;
25773
 
        if (flags & NDR_IN) {
25774
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25775
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
25776
 
                }
25777
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25778
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25779
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25780
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25781
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
25782
 
                if (_ptr_data_type) {
25783
 
                        NDR_PULL_ALLOC(ndr, r->in.data_type);
25784
 
                } else {
25785
 
                        r->in.data_type = NULL;
25786
 
                }
25787
 
                if (r->in.data_type) {
25788
 
                        _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25789
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
25790
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
25791
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
25792
 
                        if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
25793
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.data_type), ndr_get_array_length(ndr, &r->in.data_type));
25794
 
                        }
25795
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
25796
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.data_type, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t), CH_UTF16));
25797
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
25798
 
                }
25799
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25800
 
                        NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25801
 
                }
25802
 
                _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25803
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25804
 
                NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25805
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25806
 
        }
25807
 
        if (flags & NDR_OUT) {
25808
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25809
 
        }
25810
 
        return NDR_ERR_SUCCESS;
25811
 
}
25812
 
 
25813
 
_PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
25814
 
{
25815
 
        ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
25816
 
        ndr->depth++;
25817
 
        if (flags & NDR_SET_VALUES) {
25818
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25819
 
        }
25820
 
        if (flags & NDR_IN) {
25821
 
                ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
25822
 
                ndr->depth++;
25823
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
25824
 
                ndr->depth++;
25825
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
25826
 
                ndr->depth--;
25827
 
                ndr_print_ptr(ndr, "data_type", r->in.data_type);
25828
 
                ndr->depth++;
25829
 
                if (r->in.data_type) {
25830
 
                        ndr_print_string(ndr, "data_type", r->in.data_type);
25831
 
                }
25832
 
                ndr->depth--;
25833
 
                ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25834
 
                ndr->depth++;
25835
 
                ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25836
 
                ndr->depth--;
25837
 
                ndr->depth--;
25838
 
        }
25839
 
        if (flags & NDR_OUT) {
25840
 
                ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
25841
 
                ndr->depth++;
25842
 
                ndr_print_WERROR(ndr, "result", r->out.result);
25843
 
                ndr->depth--;
25844
 
        }
25845
 
        ndr->depth--;
25846
 
}
25847
 
 
25848
 
static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
25849
 
{
25850
 
        if (flags & NDR_IN) {
25851
 
                if (r->in.handle == NULL) {
25852
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25853
 
                }
25854
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25855
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
25856
 
                if (r->in.architecture) {
25857
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25858
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25859
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
25860
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25861
 
                }
25862
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25863
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25864
 
                if (r->in.buffer) {
25865
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25866
 
                }
25867
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25868
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
25869
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
25870
 
        }
25871
 
        if (flags & NDR_OUT) {
25872
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25873
 
                if (r->out.info) {
25874
 
                        {
25875
 
                                struct ndr_push *_ndr_info;
25876
 
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25877
 
                                NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
25878
 
                                NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25879
 
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25880
 
                        }
25881
 
                }
25882
 
                if (r->out.needed == NULL) {
25883
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25884
 
                }
25885
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25886
 
                if (r->out.server_major_version == NULL) {
25887
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25888
 
                }
25889
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
25890
 
                if (r->out.server_minor_version == NULL) {
25891
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25892
 
                }
25893
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
25894
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25895
 
        }
25896
 
        return NDR_ERR_SUCCESS;
25897
 
}
25898
 
 
25899
 
static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
25900
 
{
25901
 
        uint32_t _ptr_architecture;
25902
 
        uint32_t _ptr_buffer;
25903
 
        uint32_t _ptr_info;
25904
 
        TALLOC_CTX *_mem_save_handle_0;
25905
 
        TALLOC_CTX *_mem_save_architecture_0;
25906
 
        TALLOC_CTX *_mem_save_buffer_0;
25907
 
        TALLOC_CTX *_mem_save_info_0;
25908
 
        TALLOC_CTX *_mem_save_needed_0;
25909
 
        TALLOC_CTX *_mem_save_server_major_version_0;
25910
 
        TALLOC_CTX *_mem_save_server_minor_version_0;
25911
 
        if (flags & NDR_IN) {
25912
 
                ZERO_STRUCT(r->out);
25913
 
 
25914
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25915
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
25916
 
                }
25917
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25918
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25919
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25920
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25921
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
25922
 
                if (_ptr_architecture) {
25923
 
                        NDR_PULL_ALLOC(ndr, r->in.architecture);
25924
 
                } else {
25925
 
                        r->in.architecture = NULL;
25926
 
                }
25927
 
                if (r->in.architecture) {
25928
 
                        _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
25929
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
25930
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
25931
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
25932
 
                        if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
25933
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
25934
 
                        }
25935
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
25936
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
25937
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
25938
 
                }
25939
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25940
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25941
 
                if (_ptr_buffer) {
25942
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
25943
 
                } else {
25944
 
                        r->in.buffer = NULL;
25945
 
                }
25946
 
                if (r->in.buffer) {
25947
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25948
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25949
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25950
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25951
 
                }
25952
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25953
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
25954
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
25955
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
25956
 
                ZERO_STRUCTP(r->out.needed);
25957
 
                NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25958
 
                ZERO_STRUCTP(r->out.server_major_version);
25959
 
                NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25960
 
                ZERO_STRUCTP(r->out.server_minor_version);
25961
 
        }
25962
 
        if (flags & NDR_OUT) {
25963
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25964
 
                if (_ptr_info) {
25965
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
25966
 
                } else {
25967
 
                        r->out.info = NULL;
25968
 
                }
25969
 
                if (r->out.info) {
25970
 
                        _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25971
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25972
 
                        {
25973
 
                                struct ndr_pull *_ndr_info;
25974
 
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
25975
 
                                NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
25976
 
                                NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
25977
 
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
25978
 
                        }
25979
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25980
 
                }
25981
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25982
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
25983
 
                }
25984
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25985
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25986
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25987
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25988
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25989
 
                        NDR_PULL_ALLOC(ndr, r->out.server_major_version);
25990
 
                }
25991
 
                _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25992
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
25993
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
25994
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
25995
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25996
 
                        NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
25997
 
                }
25998
 
                _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
25999
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
26000
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
26001
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
26002
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26003
 
        }
26004
 
        return NDR_ERR_SUCCESS;
26005
 
}
26006
 
 
26007
 
_PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
26008
 
{
26009
 
        ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
26010
 
        ndr->depth++;
26011
 
        if (flags & NDR_SET_VALUES) {
26012
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26013
 
        }
26014
 
        if (flags & NDR_IN) {
26015
 
                ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
26016
 
                ndr->depth++;
26017
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
26018
 
                ndr->depth++;
26019
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
26020
 
                ndr->depth--;
26021
 
                ndr_print_ptr(ndr, "architecture", r->in.architecture);
26022
 
                ndr->depth++;
26023
 
                if (r->in.architecture) {
26024
 
                        ndr_print_string(ndr, "architecture", r->in.architecture);
26025
 
                }
26026
 
                ndr->depth--;
26027
 
                ndr_print_uint32(ndr, "level", r->in.level);
26028
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
26029
 
                ndr->depth++;
26030
 
                if (r->in.buffer) {
26031
 
                        ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26032
 
                }
26033
 
                ndr->depth--;
26034
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
26035
 
                ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
26036
 
                ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
26037
 
                ndr->depth--;
26038
 
        }
26039
 
        if (flags & NDR_OUT) {
26040
 
                ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
26041
 
                ndr->depth++;
26042
 
                ndr_print_ptr(ndr, "info", r->out.info);
26043
 
                ndr->depth++;
26044
 
                if (r->out.info) {
26045
 
                        ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
26046
 
                        ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
26047
 
                }
26048
 
                ndr->depth--;
26049
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
26050
 
                ndr->depth++;
26051
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
26052
 
                ndr->depth--;
26053
 
                ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
26054
 
                ndr->depth++;
26055
 
                ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
26056
 
                ndr->depth--;
26057
 
                ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
26058
 
                ndr->depth++;
26059
 
                ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
26060
 
                ndr->depth--;
26061
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26062
 
                ndr->depth--;
26063
 
        }
26064
 
        ndr->depth--;
26065
 
}
26066
 
 
26067
 
static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26068
 
{
26069
 
        if (flags & NDR_IN) {
26070
 
        }
26071
 
        if (flags & NDR_OUT) {
26072
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26073
 
        }
26074
 
        return NDR_ERR_SUCCESS;
26075
 
}
26076
 
 
26077
 
static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
26078
 
{
26079
 
        if (flags & NDR_IN) {
26080
 
        }
26081
 
        if (flags & NDR_OUT) {
26082
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26083
 
        }
26084
 
        return NDR_ERR_SUCCESS;
26085
 
}
26086
 
 
26087
 
_PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26088
 
{
26089
 
        ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
26090
 
        ndr->depth++;
26091
 
        if (flags & NDR_SET_VALUES) {
26092
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26093
 
        }
26094
 
        if (flags & NDR_IN) {
26095
 
                ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
26096
 
                ndr->depth++;
26097
 
                ndr->depth--;
26098
 
        }
26099
 
        if (flags & NDR_OUT) {
26100
 
                ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
26101
 
                ndr->depth++;
26102
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26103
 
                ndr->depth--;
26104
 
        }
26105
 
        ndr->depth--;
26106
 
}
26107
 
 
26108
 
static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26109
 
{
26110
 
        if (flags & NDR_IN) {
26111
 
        }
26112
 
        if (flags & NDR_OUT) {
26113
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26114
 
        }
26115
 
        return NDR_ERR_SUCCESS;
26116
 
}
26117
 
 
26118
 
static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
26119
 
{
26120
 
        if (flags & NDR_IN) {
26121
 
        }
26122
 
        if (flags & NDR_OUT) {
26123
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26124
 
        }
26125
 
        return NDR_ERR_SUCCESS;
26126
 
}
26127
 
 
26128
 
_PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26129
 
{
26130
 
        ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
26131
 
        ndr->depth++;
26132
 
        if (flags & NDR_SET_VALUES) {
26133
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26134
 
        }
26135
 
        if (flags & NDR_IN) {
26136
 
                ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
26137
 
                ndr->depth++;
26138
 
                ndr->depth--;
26139
 
        }
26140
 
        if (flags & NDR_OUT) {
26141
 
                ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
26142
 
                ndr->depth++;
26143
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26144
 
                ndr->depth--;
26145
 
        }
26146
 
        ndr->depth--;
26147
 
}
26148
 
 
26149
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
26150
 
{
26151
 
        if (flags & NDR_IN) {
26152
 
                if (r->in.handle == NULL) {
26153
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26154
 
                }
26155
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26156
 
        }
26157
 
        if (flags & NDR_OUT) {
26158
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26159
 
        }
26160
 
        return NDR_ERR_SUCCESS;
26161
 
}
26162
 
 
26163
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
26164
 
{
26165
 
        TALLOC_CTX *_mem_save_handle_0;
26166
 
        if (flags & NDR_IN) {
26167
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26168
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
26169
 
                }
26170
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26171
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26172
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26173
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26174
 
        }
26175
 
        if (flags & NDR_OUT) {
26176
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26177
 
        }
26178
 
        return NDR_ERR_SUCCESS;
26179
 
}
26180
 
 
26181
 
_PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
26182
 
{
26183
 
        ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
26184
 
        ndr->depth++;
26185
 
        if (flags & NDR_SET_VALUES) {
26186
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26187
 
        }
26188
 
        if (flags & NDR_IN) {
26189
 
                ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
26190
 
                ndr->depth++;
26191
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
26192
 
                ndr->depth++;
26193
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
26194
 
                ndr->depth--;
26195
 
                ndr->depth--;
26196
 
        }
26197
 
        if (flags & NDR_OUT) {
26198
 
                ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
26199
 
                ndr->depth++;
26200
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26201
 
                ndr->depth--;
26202
 
        }
26203
 
        ndr->depth--;
26204
 
}
26205
 
 
26206
 
static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26207
 
{
26208
 
        if (flags & NDR_IN) {
26209
 
        }
26210
 
        if (flags & NDR_OUT) {
26211
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26212
 
        }
26213
 
        return NDR_ERR_SUCCESS;
26214
 
}
26215
 
 
26216
 
static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26217
 
{
26218
 
        if (flags & NDR_IN) {
26219
 
        }
26220
 
        if (flags & NDR_OUT) {
26221
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26222
 
        }
26223
 
        return NDR_ERR_SUCCESS;
26224
 
}
26225
 
 
26226
 
_PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26227
 
{
26228
 
        ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26229
 
        ndr->depth++;
26230
 
        if (flags & NDR_SET_VALUES) {
26231
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26232
 
        }
26233
 
        if (flags & NDR_IN) {
26234
 
                ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26235
 
                ndr->depth++;
26236
 
                ndr->depth--;
26237
 
        }
26238
 
        if (flags & NDR_OUT) {
26239
 
                ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26240
 
                ndr->depth++;
26241
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26242
 
                ndr->depth--;
26243
 
        }
26244
 
        ndr->depth--;
26245
 
}
26246
 
 
26247
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
26248
 
{
26249
 
        if (flags & NDR_IN) {
26250
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26251
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26252
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26253
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server_name, ndr_charset_length(r->in.server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26254
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26255
 
                NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26256
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26257
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26258
 
                if (r->in.buffer) {
26259
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26260
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26261
 
                }
26262
 
        }
26263
 
        if (flags & NDR_OUT) {
26264
 
                if (r->out.handle == NULL) {
26265
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26266
 
                }
26267
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26268
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26269
 
        }
26270
 
        return NDR_ERR_SUCCESS;
26271
 
}
26272
 
 
26273
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
26274
 
{
26275
 
        uint32_t _ptr_buffer;
26276
 
        TALLOC_CTX *_mem_save_buffer_0;
26277
 
        TALLOC_CTX *_mem_save_handle_0;
26278
 
        if (flags & NDR_IN) {
26279
 
                ZERO_STRUCT(r->out);
26280
 
 
26281
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
26282
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
26283
 
                if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
26284
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
26285
 
                }
26286
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
26287
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server_name, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t), CH_UTF16));
26288
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26289
 
                NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26290
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26291
 
                if (r->in.bufsize > 512) {
26292
 
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26293
 
                }
26294
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26295
 
                if (_ptr_buffer) {
26296
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
26297
 
                } else {
26298
 
                        r->in.buffer = NULL;
26299
 
                }
26300
 
                if (r->in.buffer) {
26301
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26302
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26303
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26304
 
                        NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26305
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26306
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26307
 
                }
26308
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
26309
 
                ZERO_STRUCTP(r->out.handle);
26310
 
                if (r->in.buffer) {
26311
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26312
 
                }
26313
 
        }
26314
 
        if (flags & NDR_OUT) {
26315
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26316
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
26317
 
                }
26318
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26319
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26320
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26321
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26322
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26323
 
        }
26324
 
        return NDR_ERR_SUCCESS;
26325
 
}
26326
 
 
26327
 
_PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
26328
 
{
26329
 
        ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
26330
 
        ndr->depth++;
26331
 
        if (flags & NDR_SET_VALUES) {
26332
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26333
 
        }
26334
 
        if (flags & NDR_IN) {
26335
 
                ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
26336
 
                ndr->depth++;
26337
 
                ndr_print_string(ndr, "server_name", r->in.server_name);
26338
 
                ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26339
 
                ndr_print_winreg_Type(ndr, "type", r->in.type);
26340
 
                ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26341
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
26342
 
                ndr->depth++;
26343
 
                if (r->in.buffer) {
26344
 
                        ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26345
 
                }
26346
 
                ndr->depth--;
26347
 
                ndr->depth--;
26348
 
        }
26349
 
        if (flags & NDR_OUT) {
26350
 
                ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
26351
 
                ndr->depth++;
26352
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
26353
 
                ndr->depth++;
26354
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
26355
 
                ndr->depth--;
26356
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26357
 
                ndr->depth--;
26358
 
        }
26359
 
        ndr->depth--;
26360
 
}
26361
 
 
26362
 
static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
26363
 
{
26364
 
        if (flags & NDR_IN) {
26365
 
                if (r->in.handle == NULL) {
26366
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26367
 
                }
26368
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26369
 
                NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26370
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26371
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26372
 
                if (r->in.buffer) {
26373
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26374
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26375
 
                }
26376
 
        }
26377
 
        if (flags & NDR_OUT) {
26378
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26379
 
        }
26380
 
        return NDR_ERR_SUCCESS;
26381
 
}
26382
 
 
26383
 
static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
26384
 
{
26385
 
        uint32_t _ptr_buffer;
26386
 
        TALLOC_CTX *_mem_save_handle_0;
26387
 
        TALLOC_CTX *_mem_save_buffer_0;
26388
 
        if (flags & NDR_IN) {
26389
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26390
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
26391
 
                }
26392
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26393
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26394
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26395
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26396
 
                NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26397
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26398
 
                if (r->in.bufsize > 512) {
26399
 
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26400
 
                }
26401
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26402
 
                if (_ptr_buffer) {
26403
 
                        NDR_PULL_ALLOC(ndr, r->in.buffer);
26404
 
                } else {
26405
 
                        r->in.buffer = NULL;
26406
 
                }
26407
 
                if (r->in.buffer) {
26408
 
                        _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26409
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26410
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26411
 
                        NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26412
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26413
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26414
 
                }
26415
 
                if (r->in.buffer) {
26416
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26417
 
                }
26418
 
        }
26419
 
        if (flags & NDR_OUT) {
26420
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26421
 
        }
26422
 
        return NDR_ERR_SUCCESS;
26423
 
}
26424
 
 
26425
 
_PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
26426
 
{
26427
 
        ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
26428
 
        ndr->depth++;
26429
 
        if (flags & NDR_SET_VALUES) {
26430
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26431
 
        }
26432
 
        if (flags & NDR_IN) {
26433
 
                ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
26434
 
                ndr->depth++;
26435
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
26436
 
                ndr->depth++;
26437
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
26438
 
                ndr->depth--;
26439
 
                ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26440
 
                ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26441
 
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
26442
 
                ndr->depth++;
26443
 
                if (r->in.buffer) {
26444
 
                        ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26445
 
                }
26446
 
                ndr->depth--;
26447
 
                ndr->depth--;
26448
 
        }
26449
 
        if (flags & NDR_OUT) {
26450
 
                ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
26451
 
                ndr->depth++;
26452
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26453
 
                ndr->depth--;
26454
 
        }
26455
 
        ndr->depth--;
26456
 
}
26457
 
 
26458
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
26459
 
{
26460
 
        if (flags & NDR_IN) {
26461
 
                if (r->in.handle == NULL) {
26462
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26463
 
                }
26464
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26465
 
        }
26466
 
        if (flags & NDR_OUT) {
26467
 
                if (r->out.handle == NULL) {
26468
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26469
 
                }
26470
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26471
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26472
 
        }
26473
 
        return NDR_ERR_SUCCESS;
26474
 
}
26475
 
 
26476
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
26477
 
{
26478
 
        TALLOC_CTX *_mem_save_handle_0;
26479
 
        if (flags & NDR_IN) {
26480
 
                ZERO_STRUCT(r->out);
26481
 
 
26482
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26483
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
26484
 
                }
26485
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26486
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26487
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26488
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26489
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
26490
 
                *r->out.handle = *r->in.handle;
26491
 
        }
26492
 
        if (flags & NDR_OUT) {
26493
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26494
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
26495
 
                }
26496
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26497
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26498
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26499
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26500
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26501
 
        }
26502
 
        return NDR_ERR_SUCCESS;
26503
 
}
26504
 
 
26505
 
_PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
26506
 
{
26507
 
        ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
26508
 
        ndr->depth++;
26509
 
        if (flags & NDR_SET_VALUES) {
26510
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26511
 
        }
26512
 
        if (flags & NDR_IN) {
26513
 
                ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
26514
 
                ndr->depth++;
26515
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
26516
 
                ndr->depth++;
26517
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
26518
 
                ndr->depth--;
26519
 
                ndr->depth--;
26520
 
        }
26521
 
        if (flags & NDR_OUT) {
26522
 
                ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
26523
 
                ndr->depth++;
26524
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
26525
 
                ndr->depth++;
26526
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
26527
 
                ndr->depth--;
26528
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26529
 
                ndr->depth--;
26530
 
        }
26531
 
        ndr->depth--;
26532
 
}
26533
 
 
26534
 
static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
26535
 
{
26536
 
        if (flags & NDR_IN) {
26537
 
        }
26538
 
        if (flags & NDR_OUT) {
26539
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26540
 
        }
26541
 
        return NDR_ERR_SUCCESS;
26542
 
}
26543
 
 
26544
 
static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
26545
 
{
26546
 
        if (flags & NDR_IN) {
26547
 
        }
26548
 
        if (flags & NDR_OUT) {
26549
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26550
 
        }
26551
 
        return NDR_ERR_SUCCESS;
26552
 
}
26553
 
 
26554
 
_PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
26555
 
{
26556
 
        ndr_print_struct(ndr, name, "spoolss_AddPortEx");
26557
 
        ndr->depth++;
26558
 
        if (flags & NDR_SET_VALUES) {
26559
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26560
 
        }
26561
 
        if (flags & NDR_IN) {
26562
 
                ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
26563
 
                ndr->depth++;
26564
 
                ndr->depth--;
26565
 
        }
26566
 
        if (flags & NDR_OUT) {
26567
 
                ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
26568
 
                ndr->depth++;
26569
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26570
 
                ndr->depth--;
26571
 
        }
26572
 
        ndr->depth--;
26573
 
}
26574
 
 
26575
 
static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26576
 
{
26577
 
        if (flags & NDR_IN) {
26578
 
        }
26579
 
        if (flags & NDR_OUT) {
26580
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26581
 
        }
26582
 
        return NDR_ERR_SUCCESS;
26583
 
}
26584
 
 
26585
 
static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26586
 
{
26587
 
        if (flags & NDR_IN) {
26588
 
        }
26589
 
        if (flags & NDR_OUT) {
26590
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26591
 
        }
26592
 
        return NDR_ERR_SUCCESS;
26593
 
}
26594
 
 
26595
 
_PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26596
 
{
26597
 
        ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
26598
 
        ndr->depth++;
26599
 
        if (flags & NDR_SET_VALUES) {
26600
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26601
 
        }
26602
 
        if (flags & NDR_IN) {
26603
 
                ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
26604
 
                ndr->depth++;
26605
 
                ndr->depth--;
26606
 
        }
26607
 
        if (flags & NDR_OUT) {
26608
 
                ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
26609
 
                ndr->depth++;
26610
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26611
 
                ndr->depth--;
26612
 
        }
26613
 
        ndr->depth--;
26614
 
}
26615
 
 
26616
 
static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
26617
 
{
26618
 
        if (flags & NDR_IN) {
26619
 
        }
26620
 
        if (flags & NDR_OUT) {
26621
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26622
 
        }
26623
 
        return NDR_ERR_SUCCESS;
26624
 
}
26625
 
 
26626
 
static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
26627
 
{
26628
 
        if (flags & NDR_IN) {
26629
 
        }
26630
 
        if (flags & NDR_OUT) {
26631
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26632
 
        }
26633
 
        return NDR_ERR_SUCCESS;
26634
 
}
26635
 
 
26636
 
_PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
26637
 
{
26638
 
        ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
26639
 
        ndr->depth++;
26640
 
        if (flags & NDR_SET_VALUES) {
26641
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26642
 
        }
26643
 
        if (flags & NDR_IN) {
26644
 
                ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
26645
 
                ndr->depth++;
26646
 
                ndr->depth--;
26647
 
        }
26648
 
        if (flags & NDR_OUT) {
26649
 
                ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
26650
 
                ndr->depth++;
26651
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26652
 
                ndr->depth--;
26653
 
        }
26654
 
        ndr->depth--;
26655
 
}
26656
 
 
26657
 
static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
26658
 
{
26659
 
        if (flags & NDR_IN) {
26660
 
        }
26661
 
        if (flags & NDR_OUT) {
26662
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26663
 
        }
26664
 
        return NDR_ERR_SUCCESS;
26665
 
}
26666
 
 
26667
 
static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
26668
 
{
26669
 
        if (flags & NDR_IN) {
26670
 
        }
26671
 
        if (flags & NDR_OUT) {
26672
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26673
 
        }
26674
 
        return NDR_ERR_SUCCESS;
26675
 
}
26676
 
 
26677
 
_PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
26678
 
{
26679
 
        ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
26680
 
        ndr->depth++;
26681
 
        if (flags & NDR_SET_VALUES) {
26682
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26683
 
        }
26684
 
        if (flags & NDR_IN) {
26685
 
                ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
26686
 
                ndr->depth++;
26687
 
                ndr->depth--;
26688
 
        }
26689
 
        if (flags & NDR_OUT) {
26690
 
                ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
26691
 
                ndr->depth++;
26692
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26693
 
                ndr->depth--;
26694
 
        }
26695
 
        ndr->depth--;
26696
 
}
26697
 
 
26698
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26699
 
{
26700
 
        if (flags & NDR_IN) {
26701
 
                if (r->in.handle == NULL) {
26702
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26703
 
                }
26704
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26705
 
                NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26706
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
26707
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
26708
 
                if (r->in.local_machine) {
26709
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26710
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26711
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26712
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.local_machine, ndr_charset_length(r->in.local_machine, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26713
 
                }
26714
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26715
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
26716
 
                if (r->in.notify_options) {
26717
 
                        NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26718
 
                }
26719
 
        }
26720
 
        if (flags & NDR_OUT) {
26721
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26722
 
        }
26723
 
        return NDR_ERR_SUCCESS;
26724
 
}
26725
 
 
26726
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26727
 
{
26728
 
        uint32_t _ptr_local_machine;
26729
 
        uint32_t _ptr_notify_options;
26730
 
        TALLOC_CTX *_mem_save_handle_0;
26731
 
        TALLOC_CTX *_mem_save_local_machine_0;
26732
 
        TALLOC_CTX *_mem_save_notify_options_0;
26733
 
        if (flags & NDR_IN) {
26734
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26735
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
26736
 
                }
26737
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26738
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26739
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26740
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26741
 
                NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26742
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
26743
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
26744
 
                if (_ptr_local_machine) {
26745
 
                        NDR_PULL_ALLOC(ndr, r->in.local_machine);
26746
 
                } else {
26747
 
                        r->in.local_machine = NULL;
26748
 
                }
26749
 
                if (r->in.local_machine) {
26750
 
                        _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
26751
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
26752
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
26753
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
26754
 
                        if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
26755
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.local_machine), ndr_get_array_length(ndr, &r->in.local_machine));
26756
 
                        }
26757
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
26758
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.local_machine, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t), CH_UTF16));
26759
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
26760
 
                }
26761
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26762
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
26763
 
                if (_ptr_notify_options) {
26764
 
                        NDR_PULL_ALLOC(ndr, r->in.notify_options);
26765
 
                } else {
26766
 
                        r->in.notify_options = NULL;
26767
 
                }
26768
 
                if (r->in.notify_options) {
26769
 
                        _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26770
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
26771
 
                        NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26772
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
26773
 
                }
26774
 
        }
26775
 
        if (flags & NDR_OUT) {
26776
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26777
 
        }
26778
 
        return NDR_ERR_SUCCESS;
26779
 
}
26780
 
 
26781
 
_PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26782
 
{
26783
 
        ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26784
 
        ndr->depth++;
26785
 
        if (flags & NDR_SET_VALUES) {
26786
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26787
 
        }
26788
 
        if (flags & NDR_IN) {
26789
 
                ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26790
 
                ndr->depth++;
26791
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
26792
 
                ndr->depth++;
26793
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
26794
 
                ndr->depth--;
26795
 
                ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26796
 
                ndr_print_uint32(ndr, "options", r->in.options);
26797
 
                ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
26798
 
                ndr->depth++;
26799
 
                if (r->in.local_machine) {
26800
 
                        ndr_print_string(ndr, "local_machine", r->in.local_machine);
26801
 
                }
26802
 
                ndr->depth--;
26803
 
                ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26804
 
                ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
26805
 
                ndr->depth++;
26806
 
                if (r->in.notify_options) {
26807
 
                        ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
26808
 
                }
26809
 
                ndr->depth--;
26810
 
                ndr->depth--;
26811
 
        }
26812
 
        if (flags & NDR_OUT) {
26813
 
                ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26814
 
                ndr->depth++;
26815
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26816
 
                ndr->depth--;
26817
 
        }
26818
 
        ndr->depth--;
26819
 
}
26820
 
 
26821
 
static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26822
 
{
26823
 
        if (flags & NDR_IN) {
26824
 
                if (r->in.handle == NULL) {
26825
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26826
 
                }
26827
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26828
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
26829
 
                NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26830
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
26831
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26832
 
                NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26833
 
        }
26834
 
        if (flags & NDR_OUT) {
26835
 
                if (r->out.reply_result == NULL) {
26836
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26837
 
                }
26838
 
                NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
26839
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26840
 
        }
26841
 
        return NDR_ERR_SUCCESS;
26842
 
}
26843
 
 
26844
 
static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
26845
 
{
26846
 
        TALLOC_CTX *_mem_save_handle_0;
26847
 
        TALLOC_CTX *_mem_save_reply_result_0;
26848
 
        if (flags & NDR_IN) {
26849
 
                ZERO_STRUCT(r->out);
26850
 
 
26851
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26852
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
26853
 
                }
26854
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26855
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26856
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26857
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26858
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
26859
 
                NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26860
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
26861
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
26862
 
                NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
26863
 
                NDR_PULL_ALLOC(ndr, r->out.reply_result);
26864
 
                ZERO_STRUCTP(r->out.reply_result);
26865
 
        }
26866
 
        if (flags & NDR_OUT) {
26867
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26868
 
                        NDR_PULL_ALLOC(ndr, r->out.reply_result);
26869
 
                }
26870
 
                _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
26871
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
26872
 
                NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
26873
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
26874
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26875
 
        }
26876
 
        return NDR_ERR_SUCCESS;
26877
 
}
26878
 
 
26879
 
_PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
26880
 
{
26881
 
        ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
26882
 
        ndr->depth++;
26883
 
        if (flags & NDR_SET_VALUES) {
26884
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26885
 
        }
26886
 
        if (flags & NDR_IN) {
26887
 
                ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
26888
 
                ndr->depth++;
26889
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
26890
 
                ndr->depth++;
26891
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
26892
 
                ndr->depth--;
26893
 
                ndr_print_uint32(ndr, "color", r->in.color);
26894
 
                ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26895
 
                ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
26896
 
                ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
26897
 
                ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
26898
 
                ndr->depth--;
26899
 
        }
26900
 
        if (flags & NDR_OUT) {
26901
 
                ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
26902
 
                ndr->depth++;
26903
 
                ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
26904
 
                ndr->depth++;
26905
 
                ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
26906
 
                ndr->depth--;
26907
 
                ndr_print_WERROR(ndr, "result", r->out.result);
26908
 
                ndr->depth--;
26909
 
        }
26910
 
        ndr->depth--;
26911
 
}
26912
 
 
26913
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26914
 
{
26915
 
        if (flags & NDR_IN) {
26916
 
                if (r->in.handle == NULL) {
26917
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26918
 
                }
26919
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26920
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
26921
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
26922
 
                if (r->in.options) {
26923
 
                        NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26924
 
                }
26925
 
        }
26926
 
        if (flags & NDR_OUT) {
26927
 
                if (r->out.info == NULL) {
26928
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26929
 
                }
26930
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
26931
 
                if (*r->out.info) {
26932
 
                        NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26933
 
                }
26934
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26935
 
        }
26936
 
        return NDR_ERR_SUCCESS;
26937
 
}
26938
 
 
26939
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
26940
 
{
26941
 
        uint32_t _ptr_options;
26942
 
        uint32_t _ptr_info;
26943
 
        TALLOC_CTX *_mem_save_handle_0;
26944
 
        TALLOC_CTX *_mem_save_options_0;
26945
 
        TALLOC_CTX *_mem_save_info_0;
26946
 
        TALLOC_CTX *_mem_save_info_1;
26947
 
        if (flags & NDR_IN) {
26948
 
                ZERO_STRUCT(r->out);
26949
 
 
26950
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26951
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
26952
 
                }
26953
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26954
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26955
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26956
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26957
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
26958
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
26959
 
                if (_ptr_options) {
26960
 
                        NDR_PULL_ALLOC(ndr, r->in.options);
26961
 
                } else {
26962
 
                        r->in.options = NULL;
26963
 
                }
26964
 
                if (r->in.options) {
26965
 
                        _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26966
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
26967
 
                        NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
26968
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
26969
 
                }
26970
 
                NDR_PULL_ALLOC(ndr, r->out.info);
26971
 
                ZERO_STRUCTP(r->out.info);
26972
 
        }
26973
 
        if (flags & NDR_OUT) {
26974
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26975
 
                        NDR_PULL_ALLOC(ndr, r->out.info);
26976
 
                }
26977
 
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26978
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
26979
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26980
 
                if (_ptr_info) {
26981
 
                        NDR_PULL_ALLOC(ndr, *r->out.info);
26982
 
                } else {
26983
 
                        *r->out.info = NULL;
26984
 
                }
26985
 
                if (*r->out.info) {
26986
 
                        _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
26987
 
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
26988
 
                        NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
26989
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
26990
 
                }
26991
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
26992
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26993
 
        }
26994
 
        return NDR_ERR_SUCCESS;
26995
 
}
26996
 
 
26997
 
_PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
26998
 
{
26999
 
        ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
27000
 
        ndr->depth++;
27001
 
        if (flags & NDR_SET_VALUES) {
27002
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27003
 
        }
27004
 
        if (flags & NDR_IN) {
27005
 
                ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
27006
 
                ndr->depth++;
27007
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
27008
 
                ndr->depth++;
27009
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
27010
 
                ndr->depth--;
27011
 
                ndr_print_uint32(ndr, "change_low", r->in.change_low);
27012
 
                ndr_print_ptr(ndr, "options", r->in.options);
27013
 
                ndr->depth++;
27014
 
                if (r->in.options) {
27015
 
                        ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
27016
 
                }
27017
 
                ndr->depth--;
27018
 
                ndr->depth--;
27019
 
        }
27020
 
        if (flags & NDR_OUT) {
27021
 
                ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
27022
 
                ndr->depth++;
27023
 
                ndr_print_ptr(ndr, "info", r->out.info);
27024
 
                ndr->depth++;
27025
 
                ndr_print_ptr(ndr, "info", *r->out.info);
27026
 
                ndr->depth++;
27027
 
                if (*r->out.info) {
27028
 
                        ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
27029
 
                }
27030
 
                ndr->depth--;
27031
 
                ndr->depth--;
27032
 
                ndr_print_WERROR(ndr, "result", r->out.result);
27033
 
                ndr->depth--;
27034
 
        }
27035
 
        ndr->depth--;
27036
 
}
27037
 
 
27038
 
static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
27039
 
{
27040
 
        if (flags & NDR_IN) {
27041
 
        }
27042
 
        if (flags & NDR_OUT) {
27043
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27044
 
        }
27045
 
        return NDR_ERR_SUCCESS;
27046
 
}
27047
 
 
27048
 
static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
27049
 
{
27050
 
        if (flags & NDR_IN) {
27051
 
        }
27052
 
        if (flags & NDR_OUT) {
27053
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27054
 
        }
27055
 
        return NDR_ERR_SUCCESS;
27056
 
}
27057
 
 
27058
 
_PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
27059
 
{
27060
 
        ndr_print_struct(ndr, name, "spoolss_44");
27061
 
        ndr->depth++;
27062
 
        if (flags & NDR_SET_VALUES) {
27063
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27064
 
        }
27065
 
        if (flags & NDR_IN) {
27066
 
                ndr_print_struct(ndr, "in", "spoolss_44");
27067
 
                ndr->depth++;
27068
 
                ndr->depth--;
27069
 
        }
27070
 
        if (flags & NDR_OUT) {
27071
 
                ndr_print_struct(ndr, "out", "spoolss_44");
27072
 
                ndr->depth++;
27073
 
                ndr_print_WERROR(ndr, "result", r->out.result);
27074
 
                ndr->depth--;
27075
 
        }
27076
 
        ndr->depth--;
27077
 
}
27078
 
 
27079
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
27080
 
{
27081
 
        if (flags & NDR_IN) {
27082
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
27083
 
                if (r->in.printername) {
27084
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27085
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27086
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27087
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27088
 
                }
27089
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
27090
 
                if (r->in.datatype) {
27091
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27092
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27093
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27094
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27095
 
                }
27096
 
                NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27097
 
                NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
27098
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
27099
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27100
 
                NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27101
 
        }
27102
 
        if (flags & NDR_OUT) {
27103
 
                if (r->out.handle == NULL) {
27104
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27105
 
                }
27106
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27107
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27108
 
        }
27109
 
        return NDR_ERR_SUCCESS;
27110
 
}
27111
 
 
27112
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
27113
 
{
27114
 
        uint32_t _ptr_printername;
27115
 
        uint32_t _ptr_datatype;
27116
 
        TALLOC_CTX *_mem_save_printername_0;
27117
 
        TALLOC_CTX *_mem_save_datatype_0;
27118
 
        TALLOC_CTX *_mem_save_handle_0;
27119
 
        if (flags & NDR_IN) {
27120
 
                ZERO_STRUCT(r->out);
27121
 
 
27122
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
27123
 
                if (_ptr_printername) {
27124
 
                        NDR_PULL_ALLOC(ndr, r->in.printername);
27125
 
                } else {
27126
 
                        r->in.printername = NULL;
27127
 
                }
27128
 
                if (r->in.printername) {
27129
 
                        _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27130
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
27131
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
27132
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
27133
 
                        if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
27134
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.printername), ndr_get_array_length(ndr, &r->in.printername));
27135
 
                        }
27136
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
27137
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
27138
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
27139
 
                }
27140
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
27141
 
                if (_ptr_datatype) {
27142
 
                        NDR_PULL_ALLOC(ndr, r->in.datatype);
27143
 
                } else {
27144
 
                        r->in.datatype = NULL;
27145
 
                }
27146
 
                if (r->in.datatype) {
27147
 
                        _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
27148
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
27149
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
27150
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
27151
 
                        if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
27152
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.datatype), ndr_get_array_length(ndr, &r->in.datatype));
27153
 
                        }
27154
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
27155
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
27156
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
27157
 
                }
27158
 
                NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27159
 
                NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
27160
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
27161
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27162
 
                NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27163
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
27164
 
                ZERO_STRUCTP(r->out.handle);
27165
 
        }
27166
 
        if (flags & NDR_OUT) {
27167
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27168
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
27169
 
                }
27170
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27171
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27172
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27173
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27174
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27175
 
        }
27176
 
        return NDR_ERR_SUCCESS;
27177
 
}
27178
 
 
27179
 
_PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
27180
 
{
27181
 
        ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
27182
 
        ndr->depth++;
27183
 
        if (flags & NDR_SET_VALUES) {
27184
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27185
 
        }
27186
 
        if (flags & NDR_IN) {
27187
 
                ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
27188
 
                ndr->depth++;
27189
 
                ndr_print_ptr(ndr, "printername", r->in.printername);
27190
 
                ndr->depth++;
27191
 
                if (r->in.printername) {
27192
 
                        ndr_print_string(ndr, "printername", r->in.printername);
27193
 
                }
27194
 
                ndr->depth--;
27195
 
                ndr_print_ptr(ndr, "datatype", r->in.datatype);
27196
 
                ndr->depth++;
27197
 
                if (r->in.datatype) {
27198
 
                        ndr_print_string(ndr, "datatype", r->in.datatype);
27199
 
                }
27200
 
                ndr->depth--;
27201
 
                ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
27202
 
                ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
27203
 
                ndr_print_uint32(ndr, "level", r->in.level);
27204
 
                ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
27205
 
                ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
27206
 
                ndr->depth--;
27207
 
        }
27208
 
        if (flags & NDR_OUT) {
27209
 
                ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
27210
 
                ndr->depth++;
27211
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
27212
 
                ndr->depth++;
27213
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
27214
 
                ndr->depth--;
27215
 
                ndr_print_WERROR(ndr, "result", r->out.result);
27216
 
                ndr->depth--;
27217
 
        }
27218
 
        ndr->depth--;
27219
 
}
27220
 
 
27221
 
static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
27222
 
{
27223
 
        if (flags & NDR_IN) {
27224
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27225
 
                if (r->in.server) {
27226
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27227
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27228
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27229
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27230
 
                }
27231
 
                if (r->in.info_ctr == NULL) {
27232
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27233
 
                }
27234
 
                NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27235
 
                if (r->in.devmode_ctr == NULL) {
27236
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27237
 
                }
27238
 
                NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27239
 
                if (r->in.secdesc_ctr == NULL) {
27240
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27241
 
                }
27242
 
                NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27243
 
                if (r->in.userlevel_ctr == NULL) {
27244
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27245
 
                }
27246
 
                NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27247
 
        }
27248
 
        if (flags & NDR_OUT) {
27249
 
                if (r->out.handle == NULL) {
27250
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27251
 
                }
27252
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27253
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27254
 
        }
27255
 
        return NDR_ERR_SUCCESS;
27256
 
}
27257
 
 
27258
 
static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
27259
 
{
27260
 
        uint32_t _ptr_server;
27261
 
        TALLOC_CTX *_mem_save_server_0;
27262
 
        TALLOC_CTX *_mem_save_info_ctr_0;
27263
 
        TALLOC_CTX *_mem_save_devmode_ctr_0;
27264
 
        TALLOC_CTX *_mem_save_secdesc_ctr_0;
27265
 
        TALLOC_CTX *_mem_save_userlevel_ctr_0;
27266
 
        TALLOC_CTX *_mem_save_handle_0;
27267
 
        if (flags & NDR_IN) {
27268
 
                ZERO_STRUCT(r->out);
27269
 
 
27270
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27271
 
                if (_ptr_server) {
27272
 
                        NDR_PULL_ALLOC(ndr, r->in.server);
27273
 
                } else {
27274
 
                        r->in.server = NULL;
27275
 
                }
27276
 
                if (r->in.server) {
27277
 
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27278
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27279
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27280
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27281
 
                        if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27282
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
27283
 
                        }
27284
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27285
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27286
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27287
 
                }
27288
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27289
 
                        NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27290
 
                }
27291
 
                _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27292
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27293
 
                NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27294
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27295
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27296
 
                        NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
27297
 
                }
27298
 
                _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27299
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
27300
 
                NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27301
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27302
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27303
 
                        NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
27304
 
                }
27305
 
                _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27306
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
27307
 
                NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27308
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27309
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27310
 
                        NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
27311
 
                }
27312
 
                _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27313
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
27314
 
                NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27315
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27316
 
                NDR_PULL_ALLOC(ndr, r->out.handle);
27317
 
                ZERO_STRUCTP(r->out.handle);
27318
 
        }
27319
 
        if (flags & NDR_OUT) {
27320
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27321
 
                        NDR_PULL_ALLOC(ndr, r->out.handle);
27322
 
                }
27323
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27324
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27325
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27326
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27327
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27328
 
        }
27329
 
        return NDR_ERR_SUCCESS;
27330
 
}
27331
 
 
27332
 
_PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
27333
 
{
27334
 
        ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
27335
 
        ndr->depth++;
27336
 
        if (flags & NDR_SET_VALUES) {
27337
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27338
 
        }
27339
 
        if (flags & NDR_IN) {
27340
 
                ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
27341
 
                ndr->depth++;
27342
 
                ndr_print_ptr(ndr, "server", r->in.server);
27343
 
                ndr->depth++;
27344
 
                if (r->in.server) {
27345
 
                        ndr_print_string(ndr, "server", r->in.server);
27346
 
                }
27347
 
                ndr->depth--;
27348
 
                ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27349
 
                ndr->depth++;
27350
 
                ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27351
 
                ndr->depth--;
27352
 
                ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
27353
 
                ndr->depth++;
27354
 
                ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
27355
 
                ndr->depth--;
27356
 
                ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27357
 
                ndr->depth++;
27358
 
                ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27359
 
                ndr->depth--;
27360
 
                ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27361
 
                ndr->depth++;
27362
 
                ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27363
 
                ndr->depth--;
27364
 
                ndr->depth--;
27365
 
        }
27366
 
        if (flags & NDR_OUT) {
27367
 
                ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
27368
 
                ndr->depth++;
27369
 
                ndr_print_ptr(ndr, "handle", r->out.handle);
27370
 
                ndr->depth++;
27371
 
                ndr_print_policy_handle(ndr, "handle", r->out.handle);
27372
 
                ndr->depth--;
27373
 
                ndr_print_WERROR(ndr, "result", r->out.result);
27374
 
                ndr->depth--;
27375
 
        }
27376
 
        ndr->depth--;
27377
 
}
27378
 
 
27379
 
static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
27380
 
{
27381
 
        if (flags & NDR_IN) {
27382
 
        }
27383
 
        if (flags & NDR_OUT) {
27384
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27385
 
        }
27386
 
        return NDR_ERR_SUCCESS;
27387
 
}
27388
 
 
27389
 
static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
27390
 
{
27391
 
        if (flags & NDR_IN) {
27392
 
        }
27393
 
        if (flags & NDR_OUT) {
27394
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27395
 
        }
27396
 
        return NDR_ERR_SUCCESS;
27397
 
}
27398
 
 
27399
 
_PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
27400
 
{
27401
 
        ndr_print_struct(ndr, name, "spoolss_47");
27402
 
        ndr->depth++;
27403
 
        if (flags & NDR_SET_VALUES) {
27404
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27405
 
        }
27406
 
        if (flags & NDR_IN) {
27407
 
                ndr_print_struct(ndr, "in", "spoolss_47");
27408
 
                ndr->depth++;
27409
 
                ndr->depth--;
27410
 
        }
27411
 
        if (flags & NDR_OUT) {
27412
 
                ndr_print_struct(ndr, "out", "spoolss_47");
27413
 
                ndr->depth++;
27414
 
                ndr_print_WERROR(ndr, "result", r->out.result);
27415
 
                ndr->depth--;
27416
 
        }
27417
 
        ndr->depth--;
27418
 
}
27419
 
 
27420
 
static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
27421
 
{
27422
 
        if (flags & NDR_IN) {
27423
 
                if (r->in.handle == NULL) {
27424
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27425
 
                }
27426
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27427
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
27428
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
27429
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
27430
 
        }
27431
 
        if (flags & NDR_OUT) {
27432
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
27433
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
27434
 
                if (r->out.value_needed == NULL) {
27435
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27436
 
                }
27437
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
27438
 
                if (r->out.type == NULL) {
27439
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27440
 
                }
27441
 
                NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27442
 
                {
27443
 
                        uint32_t _flags_save_uint8 = ndr->flags;
27444
 
                        ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27445
 
                        if (r->out.data == NULL) {
27446
 
                                return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27447
 
                        }
27448
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
27449
 
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
27450
 
                        ndr->flags = _flags_save_uint8;
27451
 
                }
27452
 
                if (r->out.data_needed == NULL) {
27453
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27454
 
                }
27455
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
27456
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27457
 
        }
27458
 
        return NDR_ERR_SUCCESS;
27459
 
}
27460
 
 
27461
 
static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
27462
 
{
27463
 
        TALLOC_CTX *_mem_save_handle_0;
27464
 
        TALLOC_CTX *_mem_save_value_needed_0;
27465
 
        TALLOC_CTX *_mem_save_type_0;
27466
 
        TALLOC_CTX *_mem_save_data_needed_0;
27467
 
        if (flags & NDR_IN) {
27468
 
                ZERO_STRUCT(r->out);
27469
 
 
27470
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27471
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
27472
 
                }
27473
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27474
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27475
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27476
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27477
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
27478
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
27479
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
27480
 
                NDR_PULL_ALLOC(ndr, r->out.value_needed);
27481
 
                ZERO_STRUCTP(r->out.value_needed);
27482
 
                NDR_PULL_ALLOC(ndr, r->out.type);
27483
 
                ZERO_STRUCTP(r->out.type);
27484
 
                NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
27485
 
                memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
27486
 
                NDR_PULL_ALLOC(ndr, r->out.data_needed);
27487
 
                ZERO_STRUCTP(r->out.data_needed);
27488
 
        }
27489
 
        if (flags & NDR_OUT) {
27490
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
27491
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->out.value_name, ndr_get_array_size(ndr, &r->out.value_name), sizeof(uint16_t), CH_UTF16));
27492
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27493
 
                        NDR_PULL_ALLOC(ndr, r->out.value_needed);
27494
 
                }
27495
 
                _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27496
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
27497
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
27498
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
27499
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27500
 
                        NDR_PULL_ALLOC(ndr, r->out.type);
27501
 
                }
27502
 
                _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27503
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27504
 
                NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27505
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27506
 
                {
27507
 
                        uint32_t _flags_save_uint8 = ndr->flags;
27508
 
                        ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27509
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
27510
 
                        if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27511
 
                                NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
27512
 
                        }
27513
 
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
27514
 
                        ndr->flags = _flags_save_uint8;
27515
 
                }
27516
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27517
 
                        NDR_PULL_ALLOC(ndr, r->out.data_needed);
27518
 
                }
27519
 
                _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27520
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
27521
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
27522
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
27523
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27524
 
                if (r->out.value_name) {
27525
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
27526
 
                }
27527
 
                if (r->out.data) {
27528
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
27529
 
                }
27530
 
        }
27531
 
        return NDR_ERR_SUCCESS;
27532
 
}
27533
 
 
27534
 
_PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
27535
 
{
27536
 
        ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
27537
 
        ndr->depth++;
27538
 
        if (flags & NDR_SET_VALUES) {
27539
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27540
 
        }
27541
 
        if (flags & NDR_IN) {
27542
 
                ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
27543
 
                ndr->depth++;
27544
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
27545
 
                ndr->depth++;
27546
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
27547
 
                ndr->depth--;
27548
 
                ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
27549
 
                ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
27550
 
                ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
27551
 
                ndr->depth--;
27552
 
        }
27553
 
        if (flags & NDR_OUT) {
27554
 
                ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
27555
 
                ndr->depth++;
27556
 
                ndr_print_string(ndr, "value_name", r->out.value_name);
27557
 
                ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
27558
 
                ndr->depth++;
27559
 
                ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
27560
 
                ndr->depth--;
27561
 
                ndr_print_ptr(ndr, "type", r->out.type);
27562
 
                ndr->depth++;
27563
 
                ndr_print_winreg_Type(ndr, "type", *r->out.type);
27564
 
                ndr->depth--;
27565
 
                ndr_print_ptr(ndr, "data", r->out.data);
27566
 
                ndr->depth++;
27567
 
                ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
27568
 
                ndr->depth--;
27569
 
                ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
27570
 
                ndr->depth++;
27571
 
                ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
27572
 
                ndr->depth--;
27573
 
                ndr_print_WERROR(ndr, "result", r->out.result);
27574
 
                ndr->depth--;
27575
 
        }
27576
 
        ndr->depth--;
27577
 
}
27578
 
 
27579
 
static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
27580
 
{
27581
 
        if (flags & NDR_IN) {
27582
 
                if (r->in.handle == NULL) {
27583
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27584
 
                }
27585
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27586
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27587
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27588
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27589
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27590
 
        }
27591
 
        if (flags & NDR_OUT) {
27592
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27593
 
        }
27594
 
        return NDR_ERR_SUCCESS;
27595
 
}
27596
 
 
27597
 
static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
27598
 
{
27599
 
        TALLOC_CTX *_mem_save_handle_0;
27600
 
        if (flags & NDR_IN) {
27601
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27602
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
27603
 
                }
27604
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27605
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27606
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27607
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27608
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27609
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27610
 
                if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27611
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
27612
 
                }
27613
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27614
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
27615
 
        }
27616
 
        if (flags & NDR_OUT) {
27617
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27618
 
        }
27619
 
        return NDR_ERR_SUCCESS;
27620
 
}
27621
 
 
27622
 
_PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
27623
 
{
27624
 
        ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
27625
 
        ndr->depth++;
27626
 
        if (flags & NDR_SET_VALUES) {
27627
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27628
 
        }
27629
 
        if (flags & NDR_IN) {
27630
 
                ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
27631
 
                ndr->depth++;
27632
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
27633
 
                ndr->depth++;
27634
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
27635
 
                ndr->depth--;
27636
 
                ndr_print_string(ndr, "value_name", r->in.value_name);
27637
 
                ndr->depth--;
27638
 
        }
27639
 
        if (flags & NDR_OUT) {
27640
 
                ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
27641
 
                ndr->depth++;
27642
 
                ndr_print_WERROR(ndr, "result", r->out.result);
27643
 
                ndr->depth--;
27644
 
        }
27645
 
        ndr->depth--;
27646
 
}
27647
 
 
27648
 
static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
27649
 
{
27650
 
        if (flags & NDR_IN) {
27651
 
        }
27652
 
        if (flags & NDR_OUT) {
27653
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27654
 
        }
27655
 
        return NDR_ERR_SUCCESS;
27656
 
}
27657
 
 
27658
 
static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
27659
 
{
27660
 
        if (flags & NDR_IN) {
27661
 
        }
27662
 
        if (flags & NDR_OUT) {
27663
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27664
 
        }
27665
 
        return NDR_ERR_SUCCESS;
27666
 
}
27667
 
 
27668
 
_PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
27669
 
{
27670
 
        ndr_print_struct(ndr, name, "spoolss_4a");
27671
 
        ndr->depth++;
27672
 
        if (flags & NDR_SET_VALUES) {
27673
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27674
 
        }
27675
 
        if (flags & NDR_IN) {
27676
 
                ndr_print_struct(ndr, "in", "spoolss_4a");
27677
 
                ndr->depth++;
27678
 
                ndr->depth--;
27679
 
        }
27680
 
        if (flags & NDR_OUT) {
27681
 
                ndr_print_struct(ndr, "out", "spoolss_4a");
27682
 
                ndr->depth++;
27683
 
                ndr_print_WERROR(ndr, "result", r->out.result);
27684
 
                ndr->depth--;
27685
 
        }
27686
 
        ndr->depth--;
27687
 
}
27688
 
 
27689
 
static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
27690
 
{
27691
 
        if (flags & NDR_IN) {
27692
 
        }
27693
 
        if (flags & NDR_OUT) {
27694
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27695
 
        }
27696
 
        return NDR_ERR_SUCCESS;
27697
 
}
27698
 
 
27699
 
static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
27700
 
{
27701
 
        if (flags & NDR_IN) {
27702
 
        }
27703
 
        if (flags & NDR_OUT) {
27704
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27705
 
        }
27706
 
        return NDR_ERR_SUCCESS;
27707
 
}
27708
 
 
27709
 
_PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
27710
 
{
27711
 
        ndr_print_struct(ndr, name, "spoolss_4b");
27712
 
        ndr->depth++;
27713
 
        if (flags & NDR_SET_VALUES) {
27714
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27715
 
        }
27716
 
        if (flags & NDR_IN) {
27717
 
                ndr_print_struct(ndr, "in", "spoolss_4b");
27718
 
                ndr->depth++;
27719
 
                ndr->depth--;
27720
 
        }
27721
 
        if (flags & NDR_OUT) {
27722
 
                ndr_print_struct(ndr, "out", "spoolss_4b");
27723
 
                ndr->depth++;
27724
 
                ndr_print_WERROR(ndr, "result", r->out.result);
27725
 
                ndr->depth--;
27726
 
        }
27727
 
        ndr->depth--;
27728
 
}
27729
 
 
27730
 
static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
27731
 
{
27732
 
        if (flags & NDR_IN) {
27733
 
        }
27734
 
        if (flags & NDR_OUT) {
27735
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27736
 
        }
27737
 
        return NDR_ERR_SUCCESS;
27738
 
}
27739
 
 
27740
 
static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
27741
 
{
27742
 
        if (flags & NDR_IN) {
27743
 
        }
27744
 
        if (flags & NDR_OUT) {
27745
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27746
 
        }
27747
 
        return NDR_ERR_SUCCESS;
27748
 
}
27749
 
 
27750
 
_PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
27751
 
{
27752
 
        ndr_print_struct(ndr, name, "spoolss_4c");
27753
 
        ndr->depth++;
27754
 
        if (flags & NDR_SET_VALUES) {
27755
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27756
 
        }
27757
 
        if (flags & NDR_IN) {
27758
 
                ndr_print_struct(ndr, "in", "spoolss_4c");
27759
 
                ndr->depth++;
27760
 
                ndr->depth--;
27761
 
        }
27762
 
        if (flags & NDR_OUT) {
27763
 
                ndr_print_struct(ndr, "out", "spoolss_4c");
27764
 
                ndr->depth++;
27765
 
                ndr_print_WERROR(ndr, "result", r->out.result);
27766
 
                ndr->depth--;
27767
 
        }
27768
 
        ndr->depth--;
27769
 
}
27770
 
 
27771
 
static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
27772
 
{
27773
 
        if (flags & NDR_IN) {
27774
 
                if (r->in.handle == NULL) {
27775
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27776
 
                }
27777
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27778
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27779
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27780
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27781
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27782
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27783
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27784
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27785
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27786
 
                NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27787
 
                if (r->in.data == NULL) {
27788
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27789
 
                }
27790
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
27791
 
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.offered));
27792
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27793
 
        }
27794
 
        if (flags & NDR_OUT) {
27795
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27796
 
        }
27797
 
        return NDR_ERR_SUCCESS;
27798
 
}
27799
 
 
27800
 
static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
27801
 
{
27802
 
        TALLOC_CTX *_mem_save_handle_0;
27803
 
        if (flags & NDR_IN) {
27804
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27805
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
27806
 
                }
27807
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27808
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27809
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27810
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27811
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27812
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27813
 
                if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27814
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
27815
 
                }
27816
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27817
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
27818
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27819
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27820
 
                if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27821
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
27822
 
                }
27823
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27824
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
27825
 
                NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
27826
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
27827
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27828
 
                        NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
27829
 
                }
27830
 
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
27831
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27832
 
                if (r->in.data) {
27833
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.offered));
27834
 
                }
27835
 
        }
27836
 
        if (flags & NDR_OUT) {
27837
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27838
 
        }
27839
 
        return NDR_ERR_SUCCESS;
27840
 
}
27841
 
 
27842
 
_PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
27843
 
{
27844
 
        ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
27845
 
        ndr->depth++;
27846
 
        if (flags & NDR_SET_VALUES) {
27847
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27848
 
        }
27849
 
        if (flags & NDR_IN) {
27850
 
                ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
27851
 
                ndr->depth++;
27852
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
27853
 
                ndr->depth++;
27854
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
27855
 
                ndr->depth--;
27856
 
                ndr_print_string(ndr, "key_name", r->in.key_name);
27857
 
                ndr_print_string(ndr, "value_name", r->in.value_name);
27858
 
                ndr_print_winreg_Type(ndr, "type", r->in.type);
27859
 
                ndr_print_ptr(ndr, "data", r->in.data);
27860
 
                ndr->depth++;
27861
 
                ndr_print_array_uint8(ndr, "data", r->in.data, r->in.offered);
27862
 
                ndr->depth--;
27863
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
27864
 
                ndr->depth--;
27865
 
        }
27866
 
        if (flags & NDR_OUT) {
27867
 
                ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
27868
 
                ndr->depth++;
27869
 
                ndr_print_WERROR(ndr, "result", r->out.result);
27870
 
                ndr->depth--;
27871
 
        }
27872
 
        ndr->depth--;
27873
 
}
27874
 
 
27875
 
static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
27876
 
{
27877
 
        if (flags & NDR_IN) {
27878
 
                if (r->in.handle == NULL) {
27879
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27880
 
                }
27881
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27882
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27883
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27884
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27885
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27886
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27887
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27888
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27889
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27890
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
27891
 
        }
27892
 
        if (flags & NDR_OUT) {
27893
 
                if (r->out.type == NULL) {
27894
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27895
 
                }
27896
 
                NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27897
 
                if (r->out.data == NULL) {
27898
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27899
 
                }
27900
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
27901
 
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.offered));
27902
 
                if (r->out.needed == NULL) {
27903
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27904
 
                }
27905
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27906
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27907
 
        }
27908
 
        return NDR_ERR_SUCCESS;
27909
 
}
27910
 
 
27911
 
static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
27912
 
{
27913
 
        TALLOC_CTX *_mem_save_handle_0;
27914
 
        TALLOC_CTX *_mem_save_type_0;
27915
 
        TALLOC_CTX *_mem_save_needed_0;
27916
 
        if (flags & NDR_IN) {
27917
 
                ZERO_STRUCT(r->out);
27918
 
 
27919
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27920
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
27921
 
                }
27922
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27923
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27924
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27925
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27926
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
27927
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
27928
 
                if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
27929
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
27930
 
                }
27931
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
27932
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
27933
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27934
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27935
 
                if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27936
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
27937
 
                }
27938
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27939
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
27940
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
27941
 
                NDR_PULL_ALLOC(ndr, r->out.type);
27942
 
                ZERO_STRUCTP(r->out.type);
27943
 
                NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.offered);
27944
 
                memset(r->out.data, 0, (r->in.offered) * sizeof(*r->out.data));
27945
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
27946
 
                ZERO_STRUCTP(r->out.needed);
27947
 
        }
27948
 
        if (flags & NDR_OUT) {
27949
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27950
 
                        NDR_PULL_ALLOC(ndr, r->out.type);
27951
 
                }
27952
 
                _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27953
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27954
 
                NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27955
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27956
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
27957
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27958
 
                        NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
27959
 
                }
27960
 
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
27961
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27962
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
27963
 
                }
27964
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27965
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27966
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27967
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27968
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27969
 
                if (r->out.data) {
27970
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.offered));
27971
 
                }
27972
 
        }
27973
 
        return NDR_ERR_SUCCESS;
27974
 
}
27975
 
 
27976
 
_PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
27977
 
{
27978
 
        ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
27979
 
        ndr->depth++;
27980
 
        if (flags & NDR_SET_VALUES) {
27981
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27982
 
        }
27983
 
        if (flags & NDR_IN) {
27984
 
                ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
27985
 
                ndr->depth++;
27986
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
27987
 
                ndr->depth++;
27988
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
27989
 
                ndr->depth--;
27990
 
                ndr_print_string(ndr, "key_name", r->in.key_name);
27991
 
                ndr_print_string(ndr, "value_name", r->in.value_name);
27992
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
27993
 
                ndr->depth--;
27994
 
        }
27995
 
        if (flags & NDR_OUT) {
27996
 
                ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
27997
 
                ndr->depth++;
27998
 
                ndr_print_ptr(ndr, "type", r->out.type);
27999
 
                ndr->depth++;
28000
 
                ndr_print_winreg_Type(ndr, "type", *r->out.type);
28001
 
                ndr->depth--;
28002
 
                ndr_print_ptr(ndr, "data", r->out.data);
28003
 
                ndr->depth++;
28004
 
                ndr_print_array_uint8(ndr, "data", r->out.data, r->in.offered);
28005
 
                ndr->depth--;
28006
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
28007
 
                ndr->depth++;
28008
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
28009
 
                ndr->depth--;
28010
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28011
 
                ndr->depth--;
28012
 
        }
28013
 
        ndr->depth--;
28014
 
}
28015
 
 
28016
 
_PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
28017
 
{
28018
 
        if (flags & NDR_IN) {
28019
 
                if (r->in.handle == NULL) {
28020
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28021
 
                }
28022
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28023
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28024
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28025
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28026
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28027
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28028
 
        }
28029
 
        if (flags & NDR_OUT) {
28030
 
                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
28031
 
                if (r->out.needed == NULL) {
28032
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28033
 
                }
28034
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28035
 
                if (r->out.count == NULL) {
28036
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28037
 
                }
28038
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
28039
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28040
 
        }
28041
 
        return NDR_ERR_SUCCESS;
28042
 
}
28043
 
 
28044
 
_PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
28045
 
{
28046
 
        TALLOC_CTX *_mem_save_handle_0;
28047
 
        TALLOC_CTX *_mem_save_needed_0;
28048
 
        TALLOC_CTX *_mem_save_count_0;
28049
 
        if (flags & NDR_IN) {
28050
 
                ZERO_STRUCT(r->out);
28051
 
 
28052
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28053
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
28054
 
                }
28055
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28056
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28057
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28058
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28059
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28060
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28061
 
                if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28062
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
28063
 
                }
28064
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28065
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
28066
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28067
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
28068
 
                ZERO_STRUCTP(r->out.needed);
28069
 
                NDR_PULL_ALLOC(ndr, r->out.count);
28070
 
                ZERO_STRUCTP(r->out.count);
28071
 
        }
28072
 
        if (flags & NDR_OUT) {
28073
 
                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
28074
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28075
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
28076
 
                }
28077
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28078
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28079
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28080
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28081
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28082
 
                        NDR_PULL_ALLOC(ndr, r->out.count);
28083
 
                }
28084
 
                _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
28085
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
28086
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
28087
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
28088
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28089
 
        }
28090
 
        return NDR_ERR_SUCCESS;
28091
 
}
28092
 
 
28093
 
_PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
28094
 
{
28095
 
        uint32_t cntr_info_0;
28096
 
        if (flags & NDR_IN) {
28097
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
28098
 
        }
28099
 
        if (flags & NDR_OUT) {
28100
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28101
 
                        NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28102
 
                }
28103
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28104
 
                        NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28105
 
                }
28106
 
        }
28107
 
        return NDR_ERR_SUCCESS;
28108
 
}
28109
 
 
28110
 
_PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
28111
 
{
28112
 
        uint32_t cntr_info_0;
28113
 
        TALLOC_CTX *_mem_save_info_0;
28114
 
        if (flags & NDR_IN) {
28115
 
                ZERO_STRUCT(r->out);
28116
 
 
28117
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
28118
 
        }
28119
 
        if (flags & NDR_OUT) {
28120
 
                NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
28121
 
                _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
28122
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
28123
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28124
 
                        NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28125
 
                }
28126
 
                for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28127
 
                        NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28128
 
                }
28129
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
28130
 
        }
28131
 
        return NDR_ERR_SUCCESS;
28132
 
}
28133
 
 
28134
 
_PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
28135
 
{
28136
 
        uint32_t cntr_info_2;
28137
 
        ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
28138
 
        ndr->depth++;
28139
 
        if (flags & NDR_SET_VALUES) {
28140
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28141
 
        }
28142
 
        if (flags & NDR_IN) {
28143
 
                ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
28144
 
                ndr->depth++;
28145
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
28146
 
                ndr->depth++;
28147
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
28148
 
                ndr->depth--;
28149
 
                ndr_print_string(ndr, "key_name", r->in.key_name);
28150
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
28151
 
                ndr->depth--;
28152
 
        }
28153
 
        if (flags & NDR_OUT) {
28154
 
                ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
28155
 
                ndr->depth++;
28156
 
                ndr_print_ptr(ndr, "count", r->out.count);
28157
 
                ndr->depth++;
28158
 
                ndr_print_uint32(ndr, "count", *r->out.count);
28159
 
                ndr->depth--;
28160
 
                ndr_print_ptr(ndr, "info", r->out.info);
28161
 
                ndr->depth++;
28162
 
                ndr_print_ptr(ndr, "info", *r->out.info);
28163
 
                ndr->depth++;
28164
 
                if (*r->out.info) {
28165
 
                        ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
28166
 
                        ndr->depth++;
28167
 
                        for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
28168
 
                                char *idx_2=NULL;
28169
 
                                if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
28170
 
                                        ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
28171
 
                                        free(idx_2);
28172
 
                                }
28173
 
                        }
28174
 
                        ndr->depth--;
28175
 
                }
28176
 
                ndr->depth--;
28177
 
                ndr->depth--;
28178
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
28179
 
                ndr->depth++;
28180
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
28181
 
                ndr->depth--;
28182
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28183
 
                ndr->depth--;
28184
 
        }
28185
 
        ndr->depth--;
28186
 
}
28187
 
 
28188
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
28189
 
{
28190
 
        if (flags & NDR_IN) {
28191
 
                if (r->in.handle == NULL) {
28192
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28193
 
                }
28194
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28195
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28196
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28197
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28198
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28199
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28200
 
        }
28201
 
        if (flags & NDR_OUT) {
28202
 
                if (r->out._ndr_size == NULL) {
28203
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28204
 
                }
28205
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
28206
 
                if (r->out.key_buffer == NULL) {
28207
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28208
 
                }
28209
 
                {
28210
 
                        struct ndr_push *_ndr_key_buffer;
28211
 
                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28212
 
                        NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28213
 
                        NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28214
 
                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28215
 
                }
28216
 
                if (r->out.needed == NULL) {
28217
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28218
 
                }
28219
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28220
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28221
 
        }
28222
 
        return NDR_ERR_SUCCESS;
28223
 
}
28224
 
 
28225
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
28226
 
{
28227
 
        TALLOC_CTX *_mem_save_handle_0;
28228
 
        TALLOC_CTX *_mem_save__ndr_size_0;
28229
 
        TALLOC_CTX *_mem_save_key_buffer_0;
28230
 
        TALLOC_CTX *_mem_save_needed_0;
28231
 
        if (flags & NDR_IN) {
28232
 
                ZERO_STRUCT(r->out);
28233
 
 
28234
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28235
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
28236
 
                }
28237
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28238
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28239
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28240
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28241
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28242
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28243
 
                if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28244
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
28245
 
                }
28246
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28247
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
28248
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28249
 
                NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28250
 
                ZERO_STRUCTP(r->out._ndr_size);
28251
 
                NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28252
 
                ZERO_STRUCTP(r->out.key_buffer);
28253
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
28254
 
                ZERO_STRUCTP(r->out.needed);
28255
 
        }
28256
 
        if (flags & NDR_OUT) {
28257
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28258
 
                        NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28259
 
                }
28260
 
                _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
28261
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
28262
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
28263
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
28264
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28265
 
                        NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28266
 
                }
28267
 
                _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
28268
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
28269
 
                {
28270
 
                        struct ndr_pull *_ndr_key_buffer;
28271
 
                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28272
 
                        NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28273
 
                        NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28274
 
                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28275
 
                }
28276
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
28277
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28278
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
28279
 
                }
28280
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28281
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28282
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28283
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28284
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28285
 
        }
28286
 
        return NDR_ERR_SUCCESS;
28287
 
}
28288
 
 
28289
 
_PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
28290
 
{
28291
 
        ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
28292
 
        ndr->depth++;
28293
 
        if (flags & NDR_SET_VALUES) {
28294
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28295
 
        }
28296
 
        if (flags & NDR_IN) {
28297
 
                ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
28298
 
                ndr->depth++;
28299
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
28300
 
                ndr->depth++;
28301
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
28302
 
                ndr->depth--;
28303
 
                ndr_print_string(ndr, "key_name", r->in.key_name);
28304
 
                ndr_print_uint32(ndr, "offered", r->in.offered);
28305
 
                ndr->depth--;
28306
 
        }
28307
 
        if (flags & NDR_OUT) {
28308
 
                ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
28309
 
                ndr->depth++;
28310
 
                ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
28311
 
                ndr->depth++;
28312
 
                ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
28313
 
                ndr->depth--;
28314
 
                ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
28315
 
                ndr->depth++;
28316
 
                ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
28317
 
                ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
28318
 
                ndr->depth--;
28319
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
28320
 
                ndr->depth++;
28321
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
28322
 
                ndr->depth--;
28323
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28324
 
                ndr->depth--;
28325
 
        }
28326
 
        ndr->depth--;
28327
 
}
28328
 
 
28329
 
static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
28330
 
{
28331
 
        if (flags & NDR_IN) {
28332
 
                if (r->in.handle == NULL) {
28333
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28334
 
                }
28335
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28336
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28337
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28338
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28339
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28340
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28341
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28342
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28343
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.value_name, ndr_charset_length(r->in.value_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28344
 
        }
28345
 
        if (flags & NDR_OUT) {
28346
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28347
 
        }
28348
 
        return NDR_ERR_SUCCESS;
28349
 
}
28350
 
 
28351
 
static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
28352
 
{
28353
 
        TALLOC_CTX *_mem_save_handle_0;
28354
 
        if (flags & NDR_IN) {
28355
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28356
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
28357
 
                }
28358
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28359
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28360
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28361
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28362
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28363
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28364
 
                if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28365
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
28366
 
                }
28367
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28368
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
28369
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28370
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28371
 
                if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28372
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
28373
 
                }
28374
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28375
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.value_name, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t), CH_UTF16));
28376
 
        }
28377
 
        if (flags & NDR_OUT) {
28378
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28379
 
        }
28380
 
        return NDR_ERR_SUCCESS;
28381
 
}
28382
 
 
28383
 
_PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
28384
 
{
28385
 
        ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
28386
 
        ndr->depth++;
28387
 
        if (flags & NDR_SET_VALUES) {
28388
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28389
 
        }
28390
 
        if (flags & NDR_IN) {
28391
 
                ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
28392
 
                ndr->depth++;
28393
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
28394
 
                ndr->depth++;
28395
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
28396
 
                ndr->depth--;
28397
 
                ndr_print_string(ndr, "key_name", r->in.key_name);
28398
 
                ndr_print_string(ndr, "value_name", r->in.value_name);
28399
 
                ndr->depth--;
28400
 
        }
28401
 
        if (flags & NDR_OUT) {
28402
 
                ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
28403
 
                ndr->depth++;
28404
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28405
 
                ndr->depth--;
28406
 
        }
28407
 
        ndr->depth--;
28408
 
}
28409
 
 
28410
 
static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
28411
 
{
28412
 
        if (flags & NDR_IN) {
28413
 
                if (r->in.handle == NULL) {
28414
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28415
 
                }
28416
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28417
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28418
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28419
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28420
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28421
 
        }
28422
 
        if (flags & NDR_OUT) {
28423
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28424
 
        }
28425
 
        return NDR_ERR_SUCCESS;
28426
 
}
28427
 
 
28428
 
static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
28429
 
{
28430
 
        TALLOC_CTX *_mem_save_handle_0;
28431
 
        if (flags & NDR_IN) {
28432
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28433
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
28434
 
                }
28435
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28436
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28437
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28438
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28439
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28440
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28441
 
                if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28442
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.key_name), ndr_get_array_length(ndr, &r->in.key_name));
28443
 
                }
28444
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28445
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
28446
 
        }
28447
 
        if (flags & NDR_OUT) {
28448
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28449
 
        }
28450
 
        return NDR_ERR_SUCCESS;
28451
 
}
28452
 
 
28453
 
_PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
28454
 
{
28455
 
        ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
28456
 
        ndr->depth++;
28457
 
        if (flags & NDR_SET_VALUES) {
28458
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28459
 
        }
28460
 
        if (flags & NDR_IN) {
28461
 
                ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
28462
 
                ndr->depth++;
28463
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
28464
 
                ndr->depth++;
28465
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
28466
 
                ndr->depth--;
28467
 
                ndr_print_string(ndr, "key_name", r->in.key_name);
28468
 
                ndr->depth--;
28469
 
        }
28470
 
        if (flags & NDR_OUT) {
28471
 
                ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
28472
 
                ndr->depth++;
28473
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28474
 
                ndr->depth--;
28475
 
        }
28476
 
        ndr->depth--;
28477
 
}
28478
 
 
28479
 
static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
28480
 
{
28481
 
        if (flags & NDR_IN) {
28482
 
        }
28483
 
        if (flags & NDR_OUT) {
28484
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28485
 
        }
28486
 
        return NDR_ERR_SUCCESS;
28487
 
}
28488
 
 
28489
 
static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
28490
 
{
28491
 
        if (flags & NDR_IN) {
28492
 
        }
28493
 
        if (flags & NDR_OUT) {
28494
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28495
 
        }
28496
 
        return NDR_ERR_SUCCESS;
28497
 
}
28498
 
 
28499
 
_PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
28500
 
{
28501
 
        ndr_print_struct(ndr, name, "spoolss_53");
28502
 
        ndr->depth++;
28503
 
        if (flags & NDR_SET_VALUES) {
28504
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28505
 
        }
28506
 
        if (flags & NDR_IN) {
28507
 
                ndr_print_struct(ndr, "in", "spoolss_53");
28508
 
                ndr->depth++;
28509
 
                ndr->depth--;
28510
 
        }
28511
 
        if (flags & NDR_OUT) {
28512
 
                ndr_print_struct(ndr, "out", "spoolss_53");
28513
 
                ndr->depth++;
28514
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28515
 
                ndr->depth--;
28516
 
        }
28517
 
        ndr->depth--;
28518
 
}
28519
 
 
28520
 
static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28521
 
{
28522
 
        if (flags & NDR_IN) {
28523
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
28524
 
                if (r->in.server) {
28525
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28526
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28527
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28528
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28529
 
                }
28530
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28531
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28532
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28533
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28534
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28535
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28536
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28537
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28538
 
                NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
28539
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
28540
 
        }
28541
 
        if (flags & NDR_OUT) {
28542
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28543
 
        }
28544
 
        return NDR_ERR_SUCCESS;
28545
 
}
28546
 
 
28547
 
static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
28548
 
{
28549
 
        uint32_t _ptr_server;
28550
 
        TALLOC_CTX *_mem_save_server_0;
28551
 
        if (flags & NDR_IN) {
28552
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
28553
 
                if (_ptr_server) {
28554
 
                        NDR_PULL_ALLOC(ndr, r->in.server);
28555
 
                } else {
28556
 
                        r->in.server = NULL;
28557
 
                }
28558
 
                if (r->in.server) {
28559
 
                        _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
28560
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
28561
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
28562
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
28563
 
                        if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
28564
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
28565
 
                        }
28566
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
28567
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
28568
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
28569
 
                }
28570
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
28571
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
28572
 
                if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
28573
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
28574
 
                }
28575
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
28576
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
28577
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
28578
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
28579
 
                if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
28580
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.driver), ndr_get_array_length(ndr, &r->in.driver));
28581
 
                }
28582
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
28583
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
28584
 
                NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
28585
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
28586
 
        }
28587
 
        if (flags & NDR_OUT) {
28588
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28589
 
        }
28590
 
        return NDR_ERR_SUCCESS;
28591
 
}
28592
 
 
28593
 
_PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28594
 
{
28595
 
        ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
28596
 
        ndr->depth++;
28597
 
        if (flags & NDR_SET_VALUES) {
28598
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28599
 
        }
28600
 
        if (flags & NDR_IN) {
28601
 
                ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
28602
 
                ndr->depth++;
28603
 
                ndr_print_ptr(ndr, "server", r->in.server);
28604
 
                ndr->depth++;
28605
 
                if (r->in.server) {
28606
 
                        ndr_print_string(ndr, "server", r->in.server);
28607
 
                }
28608
 
                ndr->depth--;
28609
 
                ndr_print_string(ndr, "architecture", r->in.architecture);
28610
 
                ndr_print_string(ndr, "driver", r->in.driver);
28611
 
                ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
28612
 
                ndr_print_uint32(ndr, "version", r->in.version);
28613
 
                ndr->depth--;
28614
 
        }
28615
 
        if (flags & NDR_OUT) {
28616
 
                ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
28617
 
                ndr->depth++;
28618
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28619
 
                ndr->depth--;
28620
 
        }
28621
 
        ndr->depth--;
28622
 
}
28623
 
 
28624
 
static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
28625
 
{
28626
 
        if (flags & NDR_IN) {
28627
 
        }
28628
 
        if (flags & NDR_OUT) {
28629
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28630
 
        }
28631
 
        return NDR_ERR_SUCCESS;
28632
 
}
28633
 
 
28634
 
static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
28635
 
{
28636
 
        if (flags & NDR_IN) {
28637
 
        }
28638
 
        if (flags & NDR_OUT) {
28639
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28640
 
        }
28641
 
        return NDR_ERR_SUCCESS;
28642
 
}
28643
 
 
28644
 
_PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
28645
 
{
28646
 
        ndr_print_struct(ndr, name, "spoolss_55");
28647
 
        ndr->depth++;
28648
 
        if (flags & NDR_SET_VALUES) {
28649
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28650
 
        }
28651
 
        if (flags & NDR_IN) {
28652
 
                ndr_print_struct(ndr, "in", "spoolss_55");
28653
 
                ndr->depth++;
28654
 
                ndr->depth--;
28655
 
        }
28656
 
        if (flags & NDR_OUT) {
28657
 
                ndr_print_struct(ndr, "out", "spoolss_55");
28658
 
                ndr->depth++;
28659
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28660
 
                ndr->depth--;
28661
 
        }
28662
 
        ndr->depth--;
28663
 
}
28664
 
 
28665
 
static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
28666
 
{
28667
 
        if (flags & NDR_IN) {
28668
 
        }
28669
 
        if (flags & NDR_OUT) {
28670
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28671
 
        }
28672
 
        return NDR_ERR_SUCCESS;
28673
 
}
28674
 
 
28675
 
static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
28676
 
{
28677
 
        if (flags & NDR_IN) {
28678
 
        }
28679
 
        if (flags & NDR_OUT) {
28680
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28681
 
        }
28682
 
        return NDR_ERR_SUCCESS;
28683
 
}
28684
 
 
28685
 
_PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
28686
 
{
28687
 
        ndr_print_struct(ndr, name, "spoolss_56");
28688
 
        ndr->depth++;
28689
 
        if (flags & NDR_SET_VALUES) {
28690
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28691
 
        }
28692
 
        if (flags & NDR_IN) {
28693
 
                ndr_print_struct(ndr, "in", "spoolss_56");
28694
 
                ndr->depth++;
28695
 
                ndr->depth--;
28696
 
        }
28697
 
        if (flags & NDR_OUT) {
28698
 
                ndr_print_struct(ndr, "out", "spoolss_56");
28699
 
                ndr->depth++;
28700
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28701
 
                ndr->depth--;
28702
 
        }
28703
 
        ndr->depth--;
28704
 
}
28705
 
 
28706
 
static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
28707
 
{
28708
 
        if (flags & NDR_IN) {
28709
 
        }
28710
 
        if (flags & NDR_OUT) {
28711
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28712
 
        }
28713
 
        return NDR_ERR_SUCCESS;
28714
 
}
28715
 
 
28716
 
static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
28717
 
{
28718
 
        if (flags & NDR_IN) {
28719
 
        }
28720
 
        if (flags & NDR_OUT) {
28721
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28722
 
        }
28723
 
        return NDR_ERR_SUCCESS;
28724
 
}
28725
 
 
28726
 
_PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
28727
 
{
28728
 
        ndr_print_struct(ndr, name, "spoolss_57");
28729
 
        ndr->depth++;
28730
 
        if (flags & NDR_SET_VALUES) {
28731
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28732
 
        }
28733
 
        if (flags & NDR_IN) {
28734
 
                ndr_print_struct(ndr, "in", "spoolss_57");
28735
 
                ndr->depth++;
28736
 
                ndr->depth--;
28737
 
        }
28738
 
        if (flags & NDR_OUT) {
28739
 
                ndr_print_struct(ndr, "out", "spoolss_57");
28740
 
                ndr->depth++;
28741
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28742
 
                ndr->depth--;
28743
 
        }
28744
 
        ndr->depth--;
28745
 
}
28746
 
 
28747
 
static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
28748
 
{
28749
 
        if (flags & NDR_IN) {
28750
 
                if (r->in.handle == NULL) {
28751
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28752
 
                }
28753
 
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28754
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28755
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28756
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
28757
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.function_name, ndr_charset_length(r->in.function_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28758
 
                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
28759
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
28760
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
28761
 
                if (r->in.status_code == NULL) {
28762
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28763
 
                }
28764
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
28765
 
        }
28766
 
        if (flags & NDR_OUT) {
28767
 
                if (r->out.out_data == NULL) {
28768
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28769
 
                }
28770
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
28771
 
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
28772
 
                if (r->out.needed == NULL) {
28773
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28774
 
                }
28775
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28776
 
                if (r->out.status_code == NULL) {
28777
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28778
 
                }
28779
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
28780
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28781
 
        }
28782
 
        return NDR_ERR_SUCCESS;
28783
 
}
28784
 
 
28785
 
static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
28786
 
{
28787
 
        TALLOC_CTX *_mem_save_handle_0;
28788
 
        TALLOC_CTX *_mem_save_needed_0;
28789
 
        TALLOC_CTX *_mem_save_status_code_0;
28790
 
        if (flags & NDR_IN) {
28791
 
                ZERO_STRUCT(r->out);
28792
 
 
28793
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28794
 
                        NDR_PULL_ALLOC(ndr, r->in.handle);
28795
 
                }
28796
 
                _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28797
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28798
 
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28799
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28800
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
28801
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
28802
 
                if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
28803
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.function_name), ndr_get_array_length(ndr, &r->in.function_name));
28804
 
                }
28805
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
28806
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.function_name, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t), CH_UTF16));
28807
 
                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
28808
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
28809
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
28810
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28811
 
                        NDR_PULL_ALLOC(ndr, r->in.status_code);
28812
 
                }
28813
 
                _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28814
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
28815
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
28816
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28817
 
                NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
28818
 
                memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
28819
 
                NDR_PULL_ALLOC(ndr, r->out.needed);
28820
 
                ZERO_STRUCTP(r->out.needed);
28821
 
                NDR_PULL_ALLOC(ndr, r->out.status_code);
28822
 
                *r->out.status_code = *r->in.status_code;
28823
 
        }
28824
 
        if (flags & NDR_OUT) {
28825
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
28826
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28827
 
                        NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
28828
 
                }
28829
 
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
28830
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28831
 
                        NDR_PULL_ALLOC(ndr, r->out.needed);
28832
 
                }
28833
 
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28834
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28835
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28836
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28837
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28838
 
                        NDR_PULL_ALLOC(ndr, r->out.status_code);
28839
 
                }
28840
 
                _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
28841
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
28842
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
28843
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
28844
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28845
 
                if (r->out.out_data) {
28846
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
28847
 
                }
28848
 
        }
28849
 
        return NDR_ERR_SUCCESS;
28850
 
}
28851
 
 
28852
 
_PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
28853
 
{
28854
 
        ndr_print_struct(ndr, name, "spoolss_XcvData");
28855
 
        ndr->depth++;
28856
 
        if (flags & NDR_SET_VALUES) {
28857
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28858
 
        }
28859
 
        if (flags & NDR_IN) {
28860
 
                ndr_print_struct(ndr, "in", "spoolss_XcvData");
28861
 
                ndr->depth++;
28862
 
                ndr_print_ptr(ndr, "handle", r->in.handle);
28863
 
                ndr->depth++;
28864
 
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
28865
 
                ndr->depth--;
28866
 
                ndr_print_string(ndr, "function_name", r->in.function_name);
28867
 
                ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
28868
 
                ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
28869
 
                ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
28870
 
                ndr_print_ptr(ndr, "status_code", r->in.status_code);
28871
 
                ndr->depth++;
28872
 
                ndr_print_uint32(ndr, "status_code", *r->in.status_code);
28873
 
                ndr->depth--;
28874
 
                ndr->depth--;
28875
 
        }
28876
 
        if (flags & NDR_OUT) {
28877
 
                ndr_print_struct(ndr, "out", "spoolss_XcvData");
28878
 
                ndr->depth++;
28879
 
                ndr_print_ptr(ndr, "out_data", r->out.out_data);
28880
 
                ndr->depth++;
28881
 
                ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
28882
 
                ndr->depth--;
28883
 
                ndr_print_ptr(ndr, "needed", r->out.needed);
28884
 
                ndr->depth++;
28885
 
                ndr_print_uint32(ndr, "needed", *r->out.needed);
28886
 
                ndr->depth--;
28887
 
                ndr_print_ptr(ndr, "status_code", r->out.status_code);
28888
 
                ndr->depth++;
28889
 
                ndr_print_uint32(ndr, "status_code", *r->out.status_code);
28890
 
                ndr->depth--;
28891
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28892
 
                ndr->depth--;
28893
 
        }
28894
 
        ndr->depth--;
28895
 
}
28896
 
 
28897
 
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
28898
 
{
28899
 
        if (flags & NDR_IN) {
28900
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
28901
 
                if (r->in.servername) {
28902
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28903
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28904
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
28905
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28906
 
                }
28907
 
                if (r->in.info_ctr == NULL) {
28908
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28909
 
                }
28910
 
                NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28911
 
                NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
28912
 
        }
28913
 
        if (flags & NDR_OUT) {
28914
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28915
 
        }
28916
 
        return NDR_ERR_SUCCESS;
28917
 
}
28918
 
 
28919
 
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
28920
 
{
28921
 
        uint32_t _ptr_servername;
28922
 
        TALLOC_CTX *_mem_save_servername_0;
28923
 
        TALLOC_CTX *_mem_save_info_ctr_0;
28924
 
        if (flags & NDR_IN) {
28925
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
28926
 
                if (_ptr_servername) {
28927
 
                        NDR_PULL_ALLOC(ndr, r->in.servername);
28928
 
                } else {
28929
 
                        r->in.servername = NULL;
28930
 
                }
28931
 
                if (r->in.servername) {
28932
 
                        _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
28933
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
28934
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
28935
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
28936
 
                        if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
28937
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
28938
 
                        }
28939
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
28940
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
28941
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
28942
 
                }
28943
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28944
 
                        NDR_PULL_ALLOC(ndr, r->in.info_ctr);
28945
 
                }
28946
 
                _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28947
 
                NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
28948
 
                NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28949
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28950
 
                NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
28951
 
        }
28952
 
        if (flags & NDR_OUT) {
28953
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28954
 
        }
28955
 
        return NDR_ERR_SUCCESS;
28956
 
}
28957
 
 
28958
 
_PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
28959
 
{
28960
 
        ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
28961
 
        ndr->depth++;
28962
 
        if (flags & NDR_SET_VALUES) {
28963
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28964
 
        }
28965
 
        if (flags & NDR_IN) {
28966
 
                ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
28967
 
                ndr->depth++;
28968
 
                ndr_print_ptr(ndr, "servername", r->in.servername);
28969
 
                ndr->depth++;
28970
 
                if (r->in.servername) {
28971
 
                        ndr_print_string(ndr, "servername", r->in.servername);
28972
 
                }
28973
 
                ndr->depth--;
28974
 
                ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
28975
 
                ndr->depth++;
28976
 
                ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
28977
 
                ndr->depth--;
28978
 
                ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
28979
 
                ndr->depth--;
28980
 
        }
28981
 
        if (flags & NDR_OUT) {
28982
 
                ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
28983
 
                ndr->depth++;
28984
 
                ndr_print_WERROR(ndr, "result", r->out.result);
28985
 
                ndr->depth--;
28986
 
        }
28987
 
        ndr->depth--;
28988
 
}
28989
 
 
28990
 
static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
28991
 
{
28992
 
        if (flags & NDR_IN) {
28993
 
        }
28994
 
        if (flags & NDR_OUT) {
28995
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28996
 
        }
28997
 
        return NDR_ERR_SUCCESS;
28998
 
}
28999
 
 
29000
 
static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
29001
 
{
29002
 
        if (flags & NDR_IN) {
29003
 
        }
29004
 
        if (flags & NDR_OUT) {
29005
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29006
 
        }
29007
 
        return NDR_ERR_SUCCESS;
29008
 
}
29009
 
 
29010
 
_PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
29011
 
{
29012
 
        ndr_print_struct(ndr, name, "spoolss_5a");
29013
 
        ndr->depth++;
29014
 
        if (flags & NDR_SET_VALUES) {
29015
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29016
 
        }
29017
 
        if (flags & NDR_IN) {
29018
 
                ndr_print_struct(ndr, "in", "spoolss_5a");
29019
 
                ndr->depth++;
29020
 
                ndr->depth--;
29021
 
        }
29022
 
        if (flags & NDR_OUT) {
29023
 
                ndr_print_struct(ndr, "out", "spoolss_5a");
29024
 
                ndr->depth++;
29025
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29026
 
                ndr->depth--;
29027
 
        }
29028
 
        ndr->depth--;
29029
 
}
29030
 
 
29031
 
static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
29032
 
{
29033
 
        if (flags & NDR_IN) {
29034
 
        }
29035
 
        if (flags & NDR_OUT) {
29036
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29037
 
        }
29038
 
        return NDR_ERR_SUCCESS;
29039
 
}
29040
 
 
29041
 
static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
29042
 
{
29043
 
        if (flags & NDR_IN) {
29044
 
        }
29045
 
        if (flags & NDR_OUT) {
29046
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29047
 
        }
29048
 
        return NDR_ERR_SUCCESS;
29049
 
}
29050
 
 
29051
 
_PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
29052
 
{
29053
 
        ndr_print_struct(ndr, name, "spoolss_5b");
29054
 
        ndr->depth++;
29055
 
        if (flags & NDR_SET_VALUES) {
29056
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29057
 
        }
29058
 
        if (flags & NDR_IN) {
29059
 
                ndr_print_struct(ndr, "in", "spoolss_5b");
29060
 
                ndr->depth++;
29061
 
                ndr->depth--;
29062
 
        }
29063
 
        if (flags & NDR_OUT) {
29064
 
                ndr_print_struct(ndr, "out", "spoolss_5b");
29065
 
                ndr->depth++;
29066
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29067
 
                ndr->depth--;
29068
 
        }
29069
 
        ndr->depth--;
29070
 
}
29071
 
 
29072
 
static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
29073
 
{
29074
 
        if (flags & NDR_IN) {
29075
 
        }
29076
 
        if (flags & NDR_OUT) {
29077
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29078
 
        }
29079
 
        return NDR_ERR_SUCCESS;
29080
 
}
29081
 
 
29082
 
static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
29083
 
{
29084
 
        if (flags & NDR_IN) {
29085
 
        }
29086
 
        if (flags & NDR_OUT) {
29087
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29088
 
        }
29089
 
        return NDR_ERR_SUCCESS;
29090
 
}
29091
 
 
29092
 
_PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
29093
 
{
29094
 
        ndr_print_struct(ndr, name, "spoolss_5c");
29095
 
        ndr->depth++;
29096
 
        if (flags & NDR_SET_VALUES) {
29097
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29098
 
        }
29099
 
        if (flags & NDR_IN) {
29100
 
                ndr_print_struct(ndr, "in", "spoolss_5c");
29101
 
                ndr->depth++;
29102
 
                ndr->depth--;
29103
 
        }
29104
 
        if (flags & NDR_OUT) {
29105
 
                ndr_print_struct(ndr, "out", "spoolss_5c");
29106
 
                ndr->depth++;
29107
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29108
 
                ndr->depth--;
29109
 
        }
29110
 
        ndr->depth--;
29111
 
}
29112
 
 
29113
 
static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
29114
 
{
29115
 
        if (flags & NDR_IN) {
29116
 
        }
29117
 
        if (flags & NDR_OUT) {
29118
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29119
 
        }
29120
 
        return NDR_ERR_SUCCESS;
29121
 
}
29122
 
 
29123
 
static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
29124
 
{
29125
 
        if (flags & NDR_IN) {
29126
 
        }
29127
 
        if (flags & NDR_OUT) {
29128
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29129
 
        }
29130
 
        return NDR_ERR_SUCCESS;
29131
 
}
29132
 
 
29133
 
_PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
29134
 
{
29135
 
        ndr_print_struct(ndr, name, "spoolss_5d");
29136
 
        ndr->depth++;
29137
 
        if (flags & NDR_SET_VALUES) {
29138
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29139
 
        }
29140
 
        if (flags & NDR_IN) {
29141
 
                ndr_print_struct(ndr, "in", "spoolss_5d");
29142
 
                ndr->depth++;
29143
 
                ndr->depth--;
29144
 
        }
29145
 
        if (flags & NDR_OUT) {
29146
 
                ndr_print_struct(ndr, "out", "spoolss_5d");
29147
 
                ndr->depth++;
29148
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29149
 
                ndr->depth--;
29150
 
        }
29151
 
        ndr->depth--;
29152
 
}
29153
 
 
29154
 
static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
29155
 
{
29156
 
        if (flags & NDR_IN) {
29157
 
        }
29158
 
        if (flags & NDR_OUT) {
29159
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29160
 
        }
29161
 
        return NDR_ERR_SUCCESS;
29162
 
}
29163
 
 
29164
 
static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
29165
 
{
29166
 
        if (flags & NDR_IN) {
29167
 
        }
29168
 
        if (flags & NDR_OUT) {
29169
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29170
 
        }
29171
 
        return NDR_ERR_SUCCESS;
29172
 
}
29173
 
 
29174
 
_PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
29175
 
{
29176
 
        ndr_print_struct(ndr, name, "spoolss_5e");
29177
 
        ndr->depth++;
29178
 
        if (flags & NDR_SET_VALUES) {
29179
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29180
 
        }
29181
 
        if (flags & NDR_IN) {
29182
 
                ndr_print_struct(ndr, "in", "spoolss_5e");
29183
 
                ndr->depth++;
29184
 
                ndr->depth--;
29185
 
        }
29186
 
        if (flags & NDR_OUT) {
29187
 
                ndr_print_struct(ndr, "out", "spoolss_5e");
29188
 
                ndr->depth++;
29189
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29190
 
                ndr->depth--;
29191
 
        }
29192
 
        ndr->depth--;
29193
 
}
29194
 
 
29195
 
static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
29196
 
{
29197
 
        if (flags & NDR_IN) {
29198
 
        }
29199
 
        if (flags & NDR_OUT) {
29200
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29201
 
        }
29202
 
        return NDR_ERR_SUCCESS;
29203
 
}
29204
 
 
29205
 
static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
29206
 
{
29207
 
        if (flags & NDR_IN) {
29208
 
        }
29209
 
        if (flags & NDR_OUT) {
29210
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29211
 
        }
29212
 
        return NDR_ERR_SUCCESS;
29213
 
}
29214
 
 
29215
 
_PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
29216
 
{
29217
 
        ndr_print_struct(ndr, name, "spoolss_5f");
29218
 
        ndr->depth++;
29219
 
        if (flags & NDR_SET_VALUES) {
29220
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29221
 
        }
29222
 
        if (flags & NDR_IN) {
29223
 
                ndr_print_struct(ndr, "in", "spoolss_5f");
29224
 
                ndr->depth++;
29225
 
                ndr->depth--;
29226
 
        }
29227
 
        if (flags & NDR_OUT) {
29228
 
                ndr_print_struct(ndr, "out", "spoolss_5f");
29229
 
                ndr->depth++;
29230
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29231
 
                ndr->depth--;
29232
 
        }
29233
 
        ndr->depth--;
29234
 
}
29235
 
 
29236
 
static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
29237
 
{
29238
 
        if (flags & NDR_IN) {
29239
 
        }
29240
 
        if (flags & NDR_OUT) {
29241
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29242
 
        }
29243
 
        return NDR_ERR_SUCCESS;
29244
 
}
29245
 
 
29246
 
static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
29247
 
{
29248
 
        if (flags & NDR_IN) {
29249
 
        }
29250
 
        if (flags & NDR_OUT) {
29251
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29252
 
        }
29253
 
        return NDR_ERR_SUCCESS;
29254
 
}
29255
 
 
29256
 
_PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
29257
 
{
29258
 
        ndr_print_struct(ndr, name, "spoolss_60");
29259
 
        ndr->depth++;
29260
 
        if (flags & NDR_SET_VALUES) {
29261
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29262
 
        }
29263
 
        if (flags & NDR_IN) {
29264
 
                ndr_print_struct(ndr, "in", "spoolss_60");
29265
 
                ndr->depth++;
29266
 
                ndr->depth--;
29267
 
        }
29268
 
        if (flags & NDR_OUT) {
29269
 
                ndr_print_struct(ndr, "out", "spoolss_60");
29270
 
                ndr->depth++;
29271
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29272
 
                ndr->depth--;
29273
 
        }
29274
 
        ndr->depth--;
29275
 
}
29276
 
 
29277
 
static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
29278
 
{
29279
 
        if (flags & NDR_IN) {
29280
 
        }
29281
 
        if (flags & NDR_OUT) {
29282
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29283
 
        }
29284
 
        return NDR_ERR_SUCCESS;
29285
 
}
29286
 
 
29287
 
static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
29288
 
{
29289
 
        if (flags & NDR_IN) {
29290
 
        }
29291
 
        if (flags & NDR_OUT) {
29292
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29293
 
        }
29294
 
        return NDR_ERR_SUCCESS;
29295
 
}
29296
 
 
29297
 
_PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
29298
 
{
29299
 
        ndr_print_struct(ndr, name, "spoolss_61");
29300
 
        ndr->depth++;
29301
 
        if (flags & NDR_SET_VALUES) {
29302
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29303
 
        }
29304
 
        if (flags & NDR_IN) {
29305
 
                ndr_print_struct(ndr, "in", "spoolss_61");
29306
 
                ndr->depth++;
29307
 
                ndr->depth--;
29308
 
        }
29309
 
        if (flags & NDR_OUT) {
29310
 
                ndr_print_struct(ndr, "out", "spoolss_61");
29311
 
                ndr->depth++;
29312
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29313
 
                ndr->depth--;
29314
 
        }
29315
 
        ndr->depth--;
29316
 
}
29317
 
 
29318
 
static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
29319
 
{
29320
 
        if (flags & NDR_IN) {
29321
 
        }
29322
 
        if (flags & NDR_OUT) {
29323
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29324
 
        }
29325
 
        return NDR_ERR_SUCCESS;
29326
 
}
29327
 
 
29328
 
static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
29329
 
{
29330
 
        if (flags & NDR_IN) {
29331
 
        }
29332
 
        if (flags & NDR_OUT) {
29333
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29334
 
        }
29335
 
        return NDR_ERR_SUCCESS;
29336
 
}
29337
 
 
29338
 
_PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
29339
 
{
29340
 
        ndr_print_struct(ndr, name, "spoolss_62");
29341
 
        ndr->depth++;
29342
 
        if (flags & NDR_SET_VALUES) {
29343
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29344
 
        }
29345
 
        if (flags & NDR_IN) {
29346
 
                ndr_print_struct(ndr, "in", "spoolss_62");
29347
 
                ndr->depth++;
29348
 
                ndr->depth--;
29349
 
        }
29350
 
        if (flags & NDR_OUT) {
29351
 
                ndr_print_struct(ndr, "out", "spoolss_62");
29352
 
                ndr->depth++;
29353
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29354
 
                ndr->depth--;
29355
 
        }
29356
 
        ndr->depth--;
29357
 
}
29358
 
 
29359
 
static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
29360
 
{
29361
 
        if (flags & NDR_IN) {
29362
 
        }
29363
 
        if (flags & NDR_OUT) {
29364
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29365
 
        }
29366
 
        return NDR_ERR_SUCCESS;
29367
 
}
29368
 
 
29369
 
static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
29370
 
{
29371
 
        if (flags & NDR_IN) {
29372
 
        }
29373
 
        if (flags & NDR_OUT) {
29374
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29375
 
        }
29376
 
        return NDR_ERR_SUCCESS;
29377
 
}
29378
 
 
29379
 
_PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
29380
 
{
29381
 
        ndr_print_struct(ndr, name, "spoolss_63");
29382
 
        ndr->depth++;
29383
 
        if (flags & NDR_SET_VALUES) {
29384
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29385
 
        }
29386
 
        if (flags & NDR_IN) {
29387
 
                ndr_print_struct(ndr, "in", "spoolss_63");
29388
 
                ndr->depth++;
29389
 
                ndr->depth--;
29390
 
        }
29391
 
        if (flags & NDR_OUT) {
29392
 
                ndr_print_struct(ndr, "out", "spoolss_63");
29393
 
                ndr->depth++;
29394
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29395
 
                ndr->depth--;
29396
 
        }
29397
 
        ndr->depth--;
29398
 
}
29399
 
 
29400
 
static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
29401
 
{
29402
 
        if (flags & NDR_IN) {
29403
 
        }
29404
 
        if (flags & NDR_OUT) {
29405
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29406
 
        }
29407
 
        return NDR_ERR_SUCCESS;
29408
 
}
29409
 
 
29410
 
static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
29411
 
{
29412
 
        if (flags & NDR_IN) {
29413
 
        }
29414
 
        if (flags & NDR_OUT) {
29415
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29416
 
        }
29417
 
        return NDR_ERR_SUCCESS;
29418
 
}
29419
 
 
29420
 
_PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
29421
 
{
29422
 
        ndr_print_struct(ndr, name, "spoolss_64");
29423
 
        ndr->depth++;
29424
 
        if (flags & NDR_SET_VALUES) {
29425
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29426
 
        }
29427
 
        if (flags & NDR_IN) {
29428
 
                ndr_print_struct(ndr, "in", "spoolss_64");
29429
 
                ndr->depth++;
29430
 
                ndr->depth--;
29431
 
        }
29432
 
        if (flags & NDR_OUT) {
29433
 
                ndr_print_struct(ndr, "out", "spoolss_64");
29434
 
                ndr->depth++;
29435
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29436
 
                ndr->depth--;
29437
 
        }
29438
 
        ndr->depth--;
29439
 
}
29440
 
 
29441
 
static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
29442
 
{
29443
 
        if (flags & NDR_IN) {
29444
 
        }
29445
 
        if (flags & NDR_OUT) {
29446
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29447
 
        }
29448
 
        return NDR_ERR_SUCCESS;
29449
 
}
29450
 
 
29451
 
static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
29452
 
{
29453
 
        if (flags & NDR_IN) {
29454
 
        }
29455
 
        if (flags & NDR_OUT) {
29456
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29457
 
        }
29458
 
        return NDR_ERR_SUCCESS;
29459
 
}
29460
 
 
29461
 
_PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
29462
 
{
29463
 
        ndr_print_struct(ndr, name, "spoolss_65");
29464
 
        ndr->depth++;
29465
 
        if (flags & NDR_SET_VALUES) {
29466
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29467
 
        }
29468
 
        if (flags & NDR_IN) {
29469
 
                ndr_print_struct(ndr, "in", "spoolss_65");
29470
 
                ndr->depth++;
29471
 
                ndr->depth--;
29472
 
        }
29473
 
        if (flags & NDR_OUT) {
29474
 
                ndr_print_struct(ndr, "out", "spoolss_65");
29475
 
                ndr->depth++;
29476
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29477
 
                ndr->depth--;
29478
 
        }
29479
 
        ndr->depth--;
29480
 
}
29481
 
 
29482
 
static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29483
 
{
29484
 
        uint32_t cntr_core_printer_drivers_1;
29485
 
        if (flags & NDR_IN) {
29486
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29487
 
                if (r->in.servername) {
29488
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29489
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29490
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29491
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29492
 
                }
29493
 
                if (r->in.architecture == NULL) {
29494
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29495
 
                }
29496
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29497
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29498
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29499
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29500
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
29501
 
                if (r->in.core_driver_dependencies == NULL) {
29502
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29503
 
                }
29504
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
29505
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
29506
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29507
 
        }
29508
 
        if (flags & NDR_OUT) {
29509
 
                if (r->out.core_printer_drivers == NULL) {
29510
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29511
 
                }
29512
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29513
 
                for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29514
 
                        NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29515
 
                }
29516
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29517
 
        }
29518
 
        return NDR_ERR_SUCCESS;
29519
 
}
29520
 
 
29521
 
static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
29522
 
{
29523
 
        uint32_t _ptr_servername;
29524
 
        uint32_t cntr_core_printer_drivers_1;
29525
 
        TALLOC_CTX *_mem_save_servername_0;
29526
 
        TALLOC_CTX *_mem_save_core_printer_drivers_1;
29527
 
        if (flags & NDR_IN) {
29528
 
                ZERO_STRUCT(r->out);
29529
 
 
29530
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29531
 
                if (_ptr_servername) {
29532
 
                        NDR_PULL_ALLOC(ndr, r->in.servername);
29533
 
                } else {
29534
 
                        r->in.servername = NULL;
29535
 
                }
29536
 
                if (r->in.servername) {
29537
 
                        _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29538
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29539
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29540
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29541
 
                        if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29542
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
29543
 
                        }
29544
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29545
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29546
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29547
 
                }
29548
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29549
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29550
 
                if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29551
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
29552
 
                }
29553
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29554
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29555
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
29556
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
29557
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.core_driver_dependencies, ndr_get_array_size(ndr, &r->in.core_driver_dependencies), sizeof(uint16_t), CH_UTF16));
29558
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
29559
 
                NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
29560
 
                memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
29561
 
                if (r->in.core_driver_dependencies) {
29562
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
29563
 
                }
29564
 
        }
29565
 
        if (flags & NDR_OUT) {
29566
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
29567
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29568
 
                        NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
29569
 
                }
29570
 
                _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
29571
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
29572
 
                for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29573
 
                        NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29574
 
                }
29575
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
29576
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29577
 
                if (r->out.core_printer_drivers) {
29578
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
29579
 
                }
29580
 
        }
29581
 
        return NDR_ERR_SUCCESS;
29582
 
}
29583
 
 
29584
 
_PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29585
 
{
29586
 
        uint32_t cntr_core_printer_drivers_1;
29587
 
        ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
29588
 
        ndr->depth++;
29589
 
        if (flags & NDR_SET_VALUES) {
29590
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29591
 
        }
29592
 
        if (flags & NDR_IN) {
29593
 
                ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
29594
 
                ndr->depth++;
29595
 
                ndr_print_ptr(ndr, "servername", r->in.servername);
29596
 
                ndr->depth++;
29597
 
                if (r->in.servername) {
29598
 
                        ndr_print_string(ndr, "servername", r->in.servername);
29599
 
                }
29600
 
                ndr->depth--;
29601
 
                ndr_print_ptr(ndr, "architecture", r->in.architecture);
29602
 
                ndr->depth++;
29603
 
                ndr_print_string(ndr, "architecture", r->in.architecture);
29604
 
                ndr->depth--;
29605
 
                ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
29606
 
                ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29607
 
                ndr->depth++;
29608
 
                ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29609
 
                ndr->depth--;
29610
 
                ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
29611
 
                ndr->depth--;
29612
 
        }
29613
 
        if (flags & NDR_OUT) {
29614
 
                ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
29615
 
                ndr->depth++;
29616
 
                ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
29617
 
                ndr->depth++;
29618
 
                ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
29619
 
                ndr->depth++;
29620
 
                for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
29621
 
                        char *idx_1=NULL;
29622
 
                        if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
29623
 
                                ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
29624
 
                                free(idx_1);
29625
 
                        }
29626
 
                }
29627
 
                ndr->depth--;
29628
 
                ndr->depth--;
29629
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29630
 
                ndr->depth--;
29631
 
        }
29632
 
        ndr->depth--;
29633
 
}
29634
 
 
29635
 
static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
29636
 
{
29637
 
        if (flags & NDR_IN) {
29638
 
        }
29639
 
        if (flags & NDR_OUT) {
29640
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29641
 
        }
29642
 
        return NDR_ERR_SUCCESS;
29643
 
}
29644
 
 
29645
 
static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
29646
 
{
29647
 
        if (flags & NDR_IN) {
29648
 
        }
29649
 
        if (flags & NDR_OUT) {
29650
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29651
 
        }
29652
 
        return NDR_ERR_SUCCESS;
29653
 
}
29654
 
 
29655
 
_PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
29656
 
{
29657
 
        ndr_print_struct(ndr, name, "spoolss_67");
29658
 
        ndr->depth++;
29659
 
        if (flags & NDR_SET_VALUES) {
29660
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29661
 
        }
29662
 
        if (flags & NDR_IN) {
29663
 
                ndr_print_struct(ndr, "in", "spoolss_67");
29664
 
                ndr->depth++;
29665
 
                ndr->depth--;
29666
 
        }
29667
 
        if (flags & NDR_OUT) {
29668
 
                ndr_print_struct(ndr, "out", "spoolss_67");
29669
 
                ndr->depth++;
29670
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29671
 
                ndr->depth--;
29672
 
        }
29673
 
        ndr->depth--;
29674
 
}
29675
 
 
29676
 
static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29677
 
{
29678
 
        if (flags & NDR_IN) {
29679
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29680
 
                if (r->in.servername) {
29681
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29682
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29683
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29684
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29685
 
                }
29686
 
                if (r->in.architecture == NULL) {
29687
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29688
 
                }
29689
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29690
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29691
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29692
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29693
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
29694
 
                if (r->in.language) {
29695
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29696
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29697
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29698
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29699
 
                }
29700
 
                if (r->in.package_id == NULL) {
29701
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29702
 
                }
29703
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29704
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29705
 
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29706
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.package_id, ndr_charset_length(r->in.package_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29707
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
29708
 
                if (r->in.driver_package_cab) {
29709
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29710
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29711
 
                }
29712
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29713
 
        }
29714
 
        if (flags & NDR_OUT) {
29715
 
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
29716
 
                if (r->out.driver_package_cab) {
29717
 
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29718
 
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29719
 
                }
29720
 
                if (r->out.required == NULL) {
29721
 
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29722
 
                }
29723
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
29724
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29725
 
        }
29726
 
        return NDR_ERR_SUCCESS;
29727
 
}
29728
 
 
29729
 
static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
29730
 
{
29731
 
        uint32_t _ptr_servername;
29732
 
        uint32_t _ptr_language;
29733
 
        uint32_t _ptr_driver_package_cab;
29734
 
        TALLOC_CTX *_mem_save_servername_0;
29735
 
        TALLOC_CTX *_mem_save_language_0;
29736
 
        TALLOC_CTX *_mem_save_driver_package_cab_0;
29737
 
        TALLOC_CTX *_mem_save_required_0;
29738
 
        if (flags & NDR_IN) {
29739
 
                ZERO_STRUCT(r->out);
29740
 
 
29741
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29742
 
                if (_ptr_servername) {
29743
 
                        NDR_PULL_ALLOC(ndr, r->in.servername);
29744
 
                } else {
29745
 
                        r->in.servername = NULL;
29746
 
                }
29747
 
                if (r->in.servername) {
29748
 
                        _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29749
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29750
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29751
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29752
 
                        if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29753
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
29754
 
                        }
29755
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29756
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29757
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29758
 
                }
29759
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29760
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29761
 
                if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29762
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
29763
 
                }
29764
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29765
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29766
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
29767
 
                if (_ptr_language) {
29768
 
                        NDR_PULL_ALLOC(ndr, r->in.language);
29769
 
                } else {
29770
 
                        r->in.language = NULL;
29771
 
                }
29772
 
                if (r->in.language) {
29773
 
                        _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
29774
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
29775
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
29776
 
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
29777
 
                        if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
29778
 
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.language), ndr_get_array_length(ndr, &r->in.language));
29779
 
                        }
29780
 
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
29781
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
29782
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
29783
 
                }
29784
 
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
29785
 
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
29786
 
                if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
29787
 
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.package_id), ndr_get_array_length(ndr, &r->in.package_id));
29788
 
                }
29789
 
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
29790
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.package_id, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t), CH_UTF16));
29791
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29792
 
                if (_ptr_driver_package_cab) {
29793
 
                        NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
29794
 
                } else {
29795
 
                        r->in.driver_package_cab = NULL;
29796
 
                }
29797
 
                if (r->in.driver_package_cab) {
29798
 
                        _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29799
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
29800
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
29801
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver_package_cab, ndr_get_array_size(ndr, &r->in.driver_package_cab), sizeof(uint16_t), CH_UTF16));
29802
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29803
 
                }
29804
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
29805
 
                NDR_PULL_ALLOC(ndr, r->out.required);
29806
 
                ZERO_STRUCTP(r->out.required);
29807
 
                if (r->in.driver_package_cab) {
29808
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
29809
 
                }
29810
 
        }
29811
 
        if (flags & NDR_OUT) {
29812
 
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
29813
 
                if (_ptr_driver_package_cab) {
29814
 
                        NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
29815
 
                } else {
29816
 
                        r->out.driver_package_cab = NULL;
29817
 
                }
29818
 
                if (r->out.driver_package_cab) {
29819
 
                        _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
29820
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
29821
 
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
29822
 
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->out.driver_package_cab, ndr_get_array_size(ndr, &r->out.driver_package_cab), sizeof(uint16_t), CH_UTF16));
29823
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
29824
 
                }
29825
 
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29826
 
                        NDR_PULL_ALLOC(ndr, r->out.required);
29827
 
                }
29828
 
                _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
29829
 
                NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
29830
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
29831
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
29832
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29833
 
                if (r->out.driver_package_cab) {
29834
 
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
29835
 
                }
29836
 
        }
29837
 
        return NDR_ERR_SUCCESS;
29838
 
}
29839
 
 
29840
 
_PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29841
 
{
29842
 
        ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
29843
 
        ndr->depth++;
29844
 
        if (flags & NDR_SET_VALUES) {
29845
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29846
 
        }
29847
 
        if (flags & NDR_IN) {
29848
 
                ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
29849
 
                ndr->depth++;
29850
 
                ndr_print_ptr(ndr, "servername", r->in.servername);
29851
 
                ndr->depth++;
29852
 
                if (r->in.servername) {
29853
 
                        ndr_print_string(ndr, "servername", r->in.servername);
29854
 
                }
29855
 
                ndr->depth--;
29856
 
                ndr_print_ptr(ndr, "architecture", r->in.architecture);
29857
 
                ndr->depth++;
29858
 
                ndr_print_string(ndr, "architecture", r->in.architecture);
29859
 
                ndr->depth--;
29860
 
                ndr_print_ptr(ndr, "language", r->in.language);
29861
 
                ndr->depth++;
29862
 
                if (r->in.language) {
29863
 
                        ndr_print_string(ndr, "language", r->in.language);
29864
 
                }
29865
 
                ndr->depth--;
29866
 
                ndr_print_ptr(ndr, "package_id", r->in.package_id);
29867
 
                ndr->depth++;
29868
 
                ndr_print_string(ndr, "package_id", r->in.package_id);
29869
 
                ndr->depth--;
29870
 
                ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
29871
 
                ndr->depth++;
29872
 
                if (r->in.driver_package_cab) {
29873
 
                        ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
29874
 
                }
29875
 
                ndr->depth--;
29876
 
                ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
29877
 
                ndr->depth--;
29878
 
        }
29879
 
        if (flags & NDR_OUT) {
29880
 
                ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
29881
 
                ndr->depth++;
29882
 
                ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
29883
 
                ndr->depth++;
29884
 
                if (r->out.driver_package_cab) {
29885
 
                        ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
29886
 
                }
29887
 
                ndr->depth--;
29888
 
                ndr_print_ptr(ndr, "required", r->out.required);
29889
 
                ndr->depth++;
29890
 
                ndr_print_uint32(ndr, "required", *r->out.required);
29891
 
                ndr->depth--;
29892
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29893
 
                ndr->depth--;
29894
 
        }
29895
 
        ndr->depth--;
29896
 
}
29897
 
 
29898
 
static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
29899
 
{
29900
 
        if (flags & NDR_IN) {
29901
 
        }
29902
 
        if (flags & NDR_OUT) {
29903
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29904
 
        }
29905
 
        return NDR_ERR_SUCCESS;
29906
 
}
29907
 
 
29908
 
static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
29909
 
{
29910
 
        if (flags & NDR_IN) {
29911
 
        }
29912
 
        if (flags & NDR_OUT) {
29913
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29914
 
        }
29915
 
        return NDR_ERR_SUCCESS;
29916
 
}
29917
 
 
29918
 
_PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
29919
 
{
29920
 
        ndr_print_struct(ndr, name, "spoolss_69");
29921
 
        ndr->depth++;
29922
 
        if (flags & NDR_SET_VALUES) {
29923
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29924
 
        }
29925
 
        if (flags & NDR_IN) {
29926
 
                ndr_print_struct(ndr, "in", "spoolss_69");
29927
 
                ndr->depth++;
29928
 
                ndr->depth--;
29929
 
        }
29930
 
        if (flags & NDR_OUT) {
29931
 
                ndr_print_struct(ndr, "out", "spoolss_69");
29932
 
                ndr->depth++;
29933
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29934
 
                ndr->depth--;
29935
 
        }
29936
 
        ndr->depth--;
29937
 
}
29938
 
 
29939
 
static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
29940
 
{
29941
 
        if (flags & NDR_IN) {
29942
 
        }
29943
 
        if (flags & NDR_OUT) {
29944
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29945
 
        }
29946
 
        return NDR_ERR_SUCCESS;
29947
 
}
29948
 
 
29949
 
static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
29950
 
{
29951
 
        if (flags & NDR_IN) {
29952
 
        }
29953
 
        if (flags & NDR_OUT) {
29954
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29955
 
        }
29956
 
        return NDR_ERR_SUCCESS;
29957
 
}
29958
 
 
29959
 
_PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
29960
 
{
29961
 
        ndr_print_struct(ndr, name, "spoolss_6a");
29962
 
        ndr->depth++;
29963
 
        if (flags & NDR_SET_VALUES) {
29964
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29965
 
        }
29966
 
        if (flags & NDR_IN) {
29967
 
                ndr_print_struct(ndr, "in", "spoolss_6a");
29968
 
                ndr->depth++;
29969
 
                ndr->depth--;
29970
 
        }
29971
 
        if (flags & NDR_OUT) {
29972
 
                ndr_print_struct(ndr, "out", "spoolss_6a");
29973
 
                ndr->depth++;
29974
 
                ndr_print_WERROR(ndr, "result", r->out.result);
29975
 
                ndr->depth--;
29976
 
        }
29977
 
        ndr->depth--;
29978
 
}
29979
 
 
29980
 
static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
29981
 
{
29982
 
        if (flags & NDR_IN) {
29983
 
        }
29984
 
        if (flags & NDR_OUT) {
29985
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29986
 
        }
29987
 
        return NDR_ERR_SUCCESS;
29988
 
}
29989
 
 
29990
 
static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
29991
 
{
29992
 
        if (flags & NDR_IN) {
29993
 
        }
29994
 
        if (flags & NDR_OUT) {
29995
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29996
 
        }
29997
 
        return NDR_ERR_SUCCESS;
29998
 
}
29999
 
 
30000
 
_PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
30001
 
{
30002
 
        ndr_print_struct(ndr, name, "spoolss_6b");
30003
 
        ndr->depth++;
30004
 
        if (flags & NDR_SET_VALUES) {
30005
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30006
 
        }
30007
 
        if (flags & NDR_IN) {
30008
 
                ndr_print_struct(ndr, "in", "spoolss_6b");
30009
 
                ndr->depth++;
30010
 
                ndr->depth--;
30011
 
        }
30012
 
        if (flags & NDR_OUT) {
30013
 
                ndr_print_struct(ndr, "out", "spoolss_6b");
30014
 
                ndr->depth++;
30015
 
                ndr_print_WERROR(ndr, "result", r->out.result);
30016
 
                ndr->depth--;
30017
 
        }
30018
 
        ndr->depth--;
30019
 
}
30020
 
 
30021
 
static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
30022
 
{
30023
 
        if (flags & NDR_IN) {
30024
 
        }
30025
 
        if (flags & NDR_OUT) {
30026
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30027
 
        }
30028
 
        return NDR_ERR_SUCCESS;
30029
 
}
30030
 
 
30031
 
static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
30032
 
{
30033
 
        if (flags & NDR_IN) {
30034
 
        }
30035
 
        if (flags & NDR_OUT) {
30036
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30037
 
        }
30038
 
        return NDR_ERR_SUCCESS;
30039
 
}
30040
 
 
30041
 
_PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
30042
 
{
30043
 
        ndr_print_struct(ndr, name, "spoolss_6c");
30044
 
        ndr->depth++;
30045
 
        if (flags & NDR_SET_VALUES) {
30046
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30047
 
        }
30048
 
        if (flags & NDR_IN) {
30049
 
                ndr_print_struct(ndr, "in", "spoolss_6c");
30050
 
                ndr->depth++;
30051
 
                ndr->depth--;
30052
 
        }
30053
 
        if (flags & NDR_OUT) {
30054
 
                ndr_print_struct(ndr, "out", "spoolss_6c");
30055
 
                ndr->depth++;
30056
 
                ndr_print_WERROR(ndr, "result", r->out.result);
30057
 
                ndr->depth--;
30058
 
        }
30059
 
        ndr->depth--;
30060
 
}
30061
 
 
30062
 
static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
30063
 
{
30064
 
        if (flags & NDR_IN) {
30065
 
        }
30066
 
        if (flags & NDR_OUT) {
30067
 
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30068
 
        }
30069
 
        return NDR_ERR_SUCCESS;
30070
 
}
30071
 
 
30072
 
static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
30073
 
{
30074
 
        if (flags & NDR_IN) {
30075
 
        }
30076
 
        if (flags & NDR_OUT) {
30077
 
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30078
 
        }
30079
 
        return NDR_ERR_SUCCESS;
30080
 
}
30081
 
 
30082
 
_PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
30083
 
{
30084
 
        ndr_print_struct(ndr, name, "spoolss_6d");
30085
 
        ndr->depth++;
30086
 
        if (flags & NDR_SET_VALUES) {
30087
 
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30088
 
        }
30089
 
        if (flags & NDR_IN) {
30090
 
                ndr_print_struct(ndr, "in", "spoolss_6d");
30091
 
                ndr->depth++;
30092
 
                ndr->depth--;
30093
 
        }
30094
 
        if (flags & NDR_OUT) {
30095
 
                ndr_print_struct(ndr, "out", "spoolss_6d");
30096
 
                ndr->depth++;
30097
 
                ndr_print_WERROR(ndr, "result", r->out.result);
30098
 
                ndr->depth--;
30099
 
        }
30100
 
        ndr->depth--;
30101
 
}
30102
 
 
30103
 
static const struct ndr_interface_call spoolss_calls[] = {
30104
 
        {
30105
 
                "spoolss_EnumPrinters",
30106
 
                sizeof(struct spoolss_EnumPrinters),
30107
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
30108
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
30109
 
                (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
30110
 
                false,
30111
 
        },
30112
 
        {
30113
 
                "spoolss_OpenPrinter",
30114
 
                sizeof(struct spoolss_OpenPrinter),
30115
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
30116
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
30117
 
                (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
30118
 
                false,
30119
 
        },
30120
 
        {
30121
 
                "spoolss_SetJob",
30122
 
                sizeof(struct spoolss_SetJob),
30123
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
30124
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
30125
 
                (ndr_print_function_t) ndr_print_spoolss_SetJob,
30126
 
                false,
30127
 
        },
30128
 
        {
30129
 
                "spoolss_GetJob",
30130
 
                sizeof(struct spoolss_GetJob),
30131
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
30132
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
30133
 
                (ndr_print_function_t) ndr_print_spoolss_GetJob,
30134
 
                false,
30135
 
        },
30136
 
        {
30137
 
                "spoolss_EnumJobs",
30138
 
                sizeof(struct spoolss_EnumJobs),
30139
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
30140
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
30141
 
                (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
30142
 
                false,
30143
 
        },
30144
 
        {
30145
 
                "spoolss_AddPrinter",
30146
 
                sizeof(struct spoolss_AddPrinter),
30147
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
30148
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
30149
 
                (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
30150
 
                false,
30151
 
        },
30152
 
        {
30153
 
                "spoolss_DeletePrinter",
30154
 
                sizeof(struct spoolss_DeletePrinter),
30155
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
30156
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
30157
 
                (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
30158
 
                false,
30159
 
        },
30160
 
        {
30161
 
                "spoolss_SetPrinter",
30162
 
                sizeof(struct spoolss_SetPrinter),
30163
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
30164
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
30165
 
                (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
30166
 
                false,
30167
 
        },
30168
 
        {
30169
 
                "spoolss_GetPrinter",
30170
 
                sizeof(struct spoolss_GetPrinter),
30171
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
30172
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
30173
 
                (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
30174
 
                false,
30175
 
        },
30176
 
        {
30177
 
                "spoolss_AddPrinterDriver",
30178
 
                sizeof(struct spoolss_AddPrinterDriver),
30179
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
30180
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
30181
 
                (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
30182
 
                false,
30183
 
        },
30184
 
        {
30185
 
                "spoolss_EnumPrinterDrivers",
30186
 
                sizeof(struct spoolss_EnumPrinterDrivers),
30187
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
30188
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
30189
 
                (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
30190
 
                false,
30191
 
        },
30192
 
        {
30193
 
                "spoolss_GetPrinterDriver",
30194
 
                sizeof(struct spoolss_GetPrinterDriver),
30195
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
30196
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
30197
 
                (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
30198
 
                false,
30199
 
        },
30200
 
        {
30201
 
                "spoolss_GetPrinterDriverDirectory",
30202
 
                sizeof(struct spoolss_GetPrinterDriverDirectory),
30203
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
30204
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
30205
 
                (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
30206
 
                false,
30207
 
        },
30208
 
        {
30209
 
                "spoolss_DeletePrinterDriver",
30210
 
                sizeof(struct spoolss_DeletePrinterDriver),
30211
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
30212
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
30213
 
                (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
30214
 
                false,
30215
 
        },
30216
 
        {
30217
 
                "spoolss_AddPrintProcessor",
30218
 
                sizeof(struct spoolss_AddPrintProcessor),
30219
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
30220
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
30221
 
                (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
30222
 
                false,
30223
 
        },
30224
 
        {
30225
 
                "spoolss_EnumPrintProcessors",
30226
 
                sizeof(struct spoolss_EnumPrintProcessors),
30227
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
30228
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
30229
 
                (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
30230
 
                false,
30231
 
        },
30232
 
        {
30233
 
                "spoolss_GetPrintProcessorDirectory",
30234
 
                sizeof(struct spoolss_GetPrintProcessorDirectory),
30235
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
30236
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
30237
 
                (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
30238
 
                false,
30239
 
        },
30240
 
        {
30241
 
                "spoolss_StartDocPrinter",
30242
 
                sizeof(struct spoolss_StartDocPrinter),
30243
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
30244
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
30245
 
                (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
30246
 
                false,
30247
 
        },
30248
 
        {
30249
 
                "spoolss_StartPagePrinter",
30250
 
                sizeof(struct spoolss_StartPagePrinter),
30251
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
30252
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
30253
 
                (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
30254
 
                false,
30255
 
        },
30256
 
        {
30257
 
                "spoolss_WritePrinter",
30258
 
                sizeof(struct spoolss_WritePrinter),
30259
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
30260
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
30261
 
                (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
30262
 
                false,
30263
 
        },
30264
 
        {
30265
 
                "spoolss_EndPagePrinter",
30266
 
                sizeof(struct spoolss_EndPagePrinter),
30267
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
30268
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
30269
 
                (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
30270
 
                false,
30271
 
        },
30272
 
        {
30273
 
                "spoolss_AbortPrinter",
30274
 
                sizeof(struct spoolss_AbortPrinter),
30275
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
30276
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
30277
 
                (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
30278
 
                false,
30279
 
        },
30280
 
        {
30281
 
                "spoolss_ReadPrinter",
30282
 
                sizeof(struct spoolss_ReadPrinter),
30283
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
30284
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
30285
 
                (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
30286
 
                false,
30287
 
        },
30288
 
        {
30289
 
                "spoolss_EndDocPrinter",
30290
 
                sizeof(struct spoolss_EndDocPrinter),
30291
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
30292
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
30293
 
                (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
30294
 
                false,
30295
 
        },
30296
 
        {
30297
 
                "spoolss_AddJob",
30298
 
                sizeof(struct spoolss_AddJob),
30299
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
30300
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
30301
 
                (ndr_print_function_t) ndr_print_spoolss_AddJob,
30302
 
                false,
30303
 
        },
30304
 
        {
30305
 
                "spoolss_ScheduleJob",
30306
 
                sizeof(struct spoolss_ScheduleJob),
30307
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
30308
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
30309
 
                (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
30310
 
                false,
30311
 
        },
30312
 
        {
30313
 
                "spoolss_GetPrinterData",
30314
 
                sizeof(struct spoolss_GetPrinterData),
30315
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
30316
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
30317
 
                (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
30318
 
                false,
30319
 
        },
30320
 
        {
30321
 
                "spoolss_SetPrinterData",
30322
 
                sizeof(struct spoolss_SetPrinterData),
30323
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
30324
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
30325
 
                (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
30326
 
                false,
30327
 
        },
30328
 
        {
30329
 
                "spoolss_WaitForPrinterChange",
30330
 
                sizeof(struct spoolss_WaitForPrinterChange),
30331
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
30332
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
30333
 
                (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
30334
 
                false,
30335
 
        },
30336
 
        {
30337
 
                "spoolss_ClosePrinter",
30338
 
                sizeof(struct spoolss_ClosePrinter),
30339
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
30340
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
30341
 
                (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
30342
 
                false,
30343
 
        },
30344
 
        {
30345
 
                "spoolss_AddForm",
30346
 
                sizeof(struct spoolss_AddForm),
30347
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
30348
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
30349
 
                (ndr_print_function_t) ndr_print_spoolss_AddForm,
30350
 
                false,
30351
 
        },
30352
 
        {
30353
 
                "spoolss_DeleteForm",
30354
 
                sizeof(struct spoolss_DeleteForm),
30355
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
30356
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
30357
 
                (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
30358
 
                false,
30359
 
        },
30360
 
        {
30361
 
                "spoolss_GetForm",
30362
 
                sizeof(struct spoolss_GetForm),
30363
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
30364
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
30365
 
                (ndr_print_function_t) ndr_print_spoolss_GetForm,
30366
 
                false,
30367
 
        },
30368
 
        {
30369
 
                "spoolss_SetForm",
30370
 
                sizeof(struct spoolss_SetForm),
30371
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
30372
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
30373
 
                (ndr_print_function_t) ndr_print_spoolss_SetForm,
30374
 
                false,
30375
 
        },
30376
 
        {
30377
 
                "spoolss_EnumForms",
30378
 
                sizeof(struct spoolss_EnumForms),
30379
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
30380
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
30381
 
                (ndr_print_function_t) ndr_print_spoolss_EnumForms,
30382
 
                false,
30383
 
        },
30384
 
        {
30385
 
                "spoolss_EnumPorts",
30386
 
                sizeof(struct spoolss_EnumPorts),
30387
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
30388
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
30389
 
                (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
30390
 
                false,
30391
 
        },
30392
 
        {
30393
 
                "spoolss_EnumMonitors",
30394
 
                sizeof(struct spoolss_EnumMonitors),
30395
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
30396
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
30397
 
                (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
30398
 
                false,
30399
 
        },
30400
 
        {
30401
 
                "spoolss_AddPort",
30402
 
                sizeof(struct spoolss_AddPort),
30403
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
30404
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
30405
 
                (ndr_print_function_t) ndr_print_spoolss_AddPort,
30406
 
                false,
30407
 
        },
30408
 
        {
30409
 
                "spoolss_ConfigurePort",
30410
 
                sizeof(struct spoolss_ConfigurePort),
30411
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
30412
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
30413
 
                (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
30414
 
                false,
30415
 
        },
30416
 
        {
30417
 
                "spoolss_DeletePort",
30418
 
                sizeof(struct spoolss_DeletePort),
30419
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
30420
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
30421
 
                (ndr_print_function_t) ndr_print_spoolss_DeletePort,
30422
 
                false,
30423
 
        },
30424
 
        {
30425
 
                "spoolss_CreatePrinterIC",
30426
 
                sizeof(struct spoolss_CreatePrinterIC),
30427
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
30428
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
30429
 
                (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
30430
 
                false,
30431
 
        },
30432
 
        {
30433
 
                "spoolss_PlayGDIScriptOnPrinterIC",
30434
 
                sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
30435
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
30436
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
30437
 
                (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
30438
 
                false,
30439
 
        },
30440
 
        {
30441
 
                "spoolss_DeletePrinterIC",
30442
 
                sizeof(struct spoolss_DeletePrinterIC),
30443
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
30444
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
30445
 
                (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
30446
 
                false,
30447
 
        },
30448
 
        {
30449
 
                "spoolss_AddPrinterConnection",
30450
 
                sizeof(struct spoolss_AddPrinterConnection),
30451
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
30452
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
30453
 
                (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
30454
 
                false,
30455
 
        },
30456
 
        {
30457
 
                "spoolss_DeletePrinterConnection",
30458
 
                sizeof(struct spoolss_DeletePrinterConnection),
30459
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
30460
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
30461
 
                (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
30462
 
                false,
30463
 
        },
30464
 
        {
30465
 
                "spoolss_PrinterMessageBox",
30466
 
                sizeof(struct spoolss_PrinterMessageBox),
30467
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
30468
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
30469
 
                (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
30470
 
                false,
30471
 
        },
30472
 
        {
30473
 
                "spoolss_AddMonitor",
30474
 
                sizeof(struct spoolss_AddMonitor),
30475
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
30476
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
30477
 
                (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
30478
 
                false,
30479
 
        },
30480
 
        {
30481
 
                "spoolss_DeleteMonitor",
30482
 
                sizeof(struct spoolss_DeleteMonitor),
30483
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
30484
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
30485
 
                (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
30486
 
                false,
30487
 
        },
30488
 
        {
30489
 
                "spoolss_DeletePrintProcessor",
30490
 
                sizeof(struct spoolss_DeletePrintProcessor),
30491
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
30492
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
30493
 
                (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
30494
 
                false,
30495
 
        },
30496
 
        {
30497
 
                "spoolss_AddPrintProvidor",
30498
 
                sizeof(struct spoolss_AddPrintProvidor),
30499
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
30500
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
30501
 
                (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
30502
 
                false,
30503
 
        },
30504
 
        {
30505
 
                "spoolss_DeletePrintProvidor",
30506
 
                sizeof(struct spoolss_DeletePrintProvidor),
30507
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
30508
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
30509
 
                (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
30510
 
                false,
30511
 
        },
30512
 
        {
30513
 
                "spoolss_EnumPrintProcDataTypes",
30514
 
                sizeof(struct spoolss_EnumPrintProcDataTypes),
30515
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
30516
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
30517
 
                (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
30518
 
                false,
30519
 
        },
30520
 
        {
30521
 
                "spoolss_ResetPrinter",
30522
 
                sizeof(struct spoolss_ResetPrinter),
30523
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
30524
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
30525
 
                (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
30526
 
                false,
30527
 
        },
30528
 
        {
30529
 
                "spoolss_GetPrinterDriver2",
30530
 
                sizeof(struct spoolss_GetPrinterDriver2),
30531
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
30532
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
30533
 
                (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
30534
 
                false,
30535
 
        },
30536
 
        {
30537
 
                "spoolss_FindFirstPrinterChangeNotification",
30538
 
                sizeof(struct spoolss_FindFirstPrinterChangeNotification),
30539
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
30540
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
30541
 
                (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
30542
 
                false,
30543
 
        },
30544
 
        {
30545
 
                "spoolss_FindNextPrinterChangeNotification",
30546
 
                sizeof(struct spoolss_FindNextPrinterChangeNotification),
30547
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
30548
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
30549
 
                (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
30550
 
                false,
30551
 
        },
30552
 
        {
30553
 
                "spoolss_FindClosePrinterNotify",
30554
 
                sizeof(struct spoolss_FindClosePrinterNotify),
30555
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
30556
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
30557
 
                (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
30558
 
                false,
30559
 
        },
30560
 
        {
30561
 
                "spoolss_RouterFindFirstPrinterChangeNotificationOld",
30562
 
                sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
30563
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30564
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30565
 
                (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30566
 
                false,
30567
 
        },
30568
 
        {
30569
 
                "spoolss_ReplyOpenPrinter",
30570
 
                sizeof(struct spoolss_ReplyOpenPrinter),
30571
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
30572
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
30573
 
                (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
30574
 
                false,
30575
 
        },
30576
 
        {
30577
 
                "spoolss_RouterReplyPrinter",
30578
 
                sizeof(struct spoolss_RouterReplyPrinter),
30579
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
30580
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
30581
 
                (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
30582
 
                false,
30583
 
        },
30584
 
        {
30585
 
                "spoolss_ReplyClosePrinter",
30586
 
                sizeof(struct spoolss_ReplyClosePrinter),
30587
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
30588
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
30589
 
                (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
30590
 
                false,
30591
 
        },
30592
 
        {
30593
 
                "spoolss_AddPortEx",
30594
 
                sizeof(struct spoolss_AddPortEx),
30595
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
30596
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
30597
 
                (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
30598
 
                false,
30599
 
        },
30600
 
        {
30601
 
                "spoolss_RouterFindFirstPrinterChangeNotification",
30602
 
                sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
30603
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
30604
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
30605
 
                (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
30606
 
                false,
30607
 
        },
30608
 
        {
30609
 
                "spoolss_SpoolerInit",
30610
 
                sizeof(struct spoolss_SpoolerInit),
30611
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
30612
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
30613
 
                (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
30614
 
                false,
30615
 
        },
30616
 
        {
30617
 
                "spoolss_ResetPrinterEx",
30618
 
                sizeof(struct spoolss_ResetPrinterEx),
30619
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
30620
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
30621
 
                (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
30622
 
                false,
30623
 
        },
30624
 
        {
30625
 
                "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
30626
 
                sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
30627
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30628
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30629
 
                (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30630
 
                false,
30631
 
        },
30632
 
        {
30633
 
                "spoolss_RouterReplyPrinterEx",
30634
 
                sizeof(struct spoolss_RouterReplyPrinterEx),
30635
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
30636
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
30637
 
                (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
30638
 
                false,
30639
 
        },
30640
 
        {
30641
 
                "spoolss_RouterRefreshPrinterChangeNotify",
30642
 
                sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
30643
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
30644
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
30645
 
                (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
30646
 
                false,
30647
 
        },
30648
 
        {
30649
 
                "spoolss_44",
30650
 
                sizeof(struct spoolss_44),
30651
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_44,
30652
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
30653
 
                (ndr_print_function_t) ndr_print_spoolss_44,
30654
 
                false,
30655
 
        },
30656
 
        {
30657
 
                "spoolss_OpenPrinterEx",
30658
 
                sizeof(struct spoolss_OpenPrinterEx),
30659
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
30660
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
30661
 
                (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
30662
 
                false,
30663
 
        },
30664
 
        {
30665
 
                "spoolss_AddPrinterEx",
30666
 
                sizeof(struct spoolss_AddPrinterEx),
30667
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
30668
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
30669
 
                (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
30670
 
                false,
30671
 
        },
30672
 
        {
30673
 
                "spoolss_47",
30674
 
                sizeof(struct spoolss_47),
30675
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_47,
30676
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
30677
 
                (ndr_print_function_t) ndr_print_spoolss_47,
30678
 
                false,
30679
 
        },
30680
 
        {
30681
 
                "spoolss_EnumPrinterData",
30682
 
                sizeof(struct spoolss_EnumPrinterData),
30683
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
30684
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
30685
 
                (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
30686
 
                false,
30687
 
        },
30688
 
        {
30689
 
                "spoolss_DeletePrinterData",
30690
 
                sizeof(struct spoolss_DeletePrinterData),
30691
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
30692
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
30693
 
                (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
30694
 
                false,
30695
 
        },
30696
 
        {
30697
 
                "spoolss_4a",
30698
 
                sizeof(struct spoolss_4a),
30699
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
30700
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
30701
 
                (ndr_print_function_t) ndr_print_spoolss_4a,
30702
 
                false,
30703
 
        },
30704
 
        {
30705
 
                "spoolss_4b",
30706
 
                sizeof(struct spoolss_4b),
30707
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
30708
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
30709
 
                (ndr_print_function_t) ndr_print_spoolss_4b,
30710
 
                false,
30711
 
        },
30712
 
        {
30713
 
                "spoolss_4c",
30714
 
                sizeof(struct spoolss_4c),
30715
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
30716
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
30717
 
                (ndr_print_function_t) ndr_print_spoolss_4c,
30718
 
                false,
30719
 
        },
30720
 
        {
30721
 
                "spoolss_SetPrinterDataEx",
30722
 
                sizeof(struct spoolss_SetPrinterDataEx),
30723
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
30724
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
30725
 
                (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
30726
 
                false,
30727
 
        },
30728
 
        {
30729
 
                "spoolss_GetPrinterDataEx",
30730
 
                sizeof(struct spoolss_GetPrinterDataEx),
30731
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
30732
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
30733
 
                (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
30734
 
                false,
30735
 
        },
30736
 
        {
30737
 
                "spoolss_EnumPrinterDataEx",
30738
 
                sizeof(struct spoolss_EnumPrinterDataEx),
30739
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
30740
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
30741
 
                (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
30742
 
                false,
30743
 
        },
30744
 
        {
30745
 
                "spoolss_EnumPrinterKey",
30746
 
                sizeof(struct spoolss_EnumPrinterKey),
30747
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
30748
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
30749
 
                (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
30750
 
                false,
30751
 
        },
30752
 
        {
30753
 
                "spoolss_DeletePrinterDataEx",
30754
 
                sizeof(struct spoolss_DeletePrinterDataEx),
30755
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
30756
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
30757
 
                (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
30758
 
                false,
30759
 
        },
30760
 
        {
30761
 
                "spoolss_DeletePrinterKey",
30762
 
                sizeof(struct spoolss_DeletePrinterKey),
30763
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
30764
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
30765
 
                (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
30766
 
                false,
30767
 
        },
30768
 
        {
30769
 
                "spoolss_53",
30770
 
                sizeof(struct spoolss_53),
30771
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_53,
30772
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
30773
 
                (ndr_print_function_t) ndr_print_spoolss_53,
30774
 
                false,
30775
 
        },
30776
 
        {
30777
 
                "spoolss_DeletePrinterDriverEx",
30778
 
                sizeof(struct spoolss_DeletePrinterDriverEx),
30779
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
30780
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
30781
 
                (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
30782
 
                false,
30783
 
        },
30784
 
        {
30785
 
                "spoolss_55",
30786
 
                sizeof(struct spoolss_55),
30787
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_55,
30788
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
30789
 
                (ndr_print_function_t) ndr_print_spoolss_55,
30790
 
                false,
30791
 
        },
30792
 
        {
30793
 
                "spoolss_56",
30794
 
                sizeof(struct spoolss_56),
30795
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_56,
30796
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
30797
 
                (ndr_print_function_t) ndr_print_spoolss_56,
30798
 
                false,
30799
 
        },
30800
 
        {
30801
 
                "spoolss_57",
30802
 
                sizeof(struct spoolss_57),
30803
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_57,
30804
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
30805
 
                (ndr_print_function_t) ndr_print_spoolss_57,
30806
 
                false,
30807
 
        },
30808
 
        {
30809
 
                "spoolss_XcvData",
30810
 
                sizeof(struct spoolss_XcvData),
30811
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
30812
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
30813
 
                (ndr_print_function_t) ndr_print_spoolss_XcvData,
30814
 
                false,
30815
 
        },
30816
 
        {
30817
 
                "spoolss_AddPrinterDriverEx",
30818
 
                sizeof(struct spoolss_AddPrinterDriverEx),
30819
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
30820
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
30821
 
                (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
30822
 
                false,
30823
 
        },
30824
 
        {
30825
 
                "spoolss_5a",
30826
 
                sizeof(struct spoolss_5a),
30827
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
30828
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
30829
 
                (ndr_print_function_t) ndr_print_spoolss_5a,
30830
 
                false,
30831
 
        },
30832
 
        {
30833
 
                "spoolss_5b",
30834
 
                sizeof(struct spoolss_5b),
30835
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
30836
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
30837
 
                (ndr_print_function_t) ndr_print_spoolss_5b,
30838
 
                false,
30839
 
        },
30840
 
        {
30841
 
                "spoolss_5c",
30842
 
                sizeof(struct spoolss_5c),
30843
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
30844
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
30845
 
                (ndr_print_function_t) ndr_print_spoolss_5c,
30846
 
                false,
30847
 
        },
30848
 
        {
30849
 
                "spoolss_5d",
30850
 
                sizeof(struct spoolss_5d),
30851
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
30852
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
30853
 
                (ndr_print_function_t) ndr_print_spoolss_5d,
30854
 
                false,
30855
 
        },
30856
 
        {
30857
 
                "spoolss_5e",
30858
 
                sizeof(struct spoolss_5e),
30859
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
30860
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
30861
 
                (ndr_print_function_t) ndr_print_spoolss_5e,
30862
 
                false,
30863
 
        },
30864
 
        {
30865
 
                "spoolss_5f",
30866
 
                sizeof(struct spoolss_5f),
30867
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
30868
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
30869
 
                (ndr_print_function_t) ndr_print_spoolss_5f,
30870
 
                false,
30871
 
        },
30872
 
        {
30873
 
                "spoolss_60",
30874
 
                sizeof(struct spoolss_60),
30875
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_60,
30876
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
30877
 
                (ndr_print_function_t) ndr_print_spoolss_60,
30878
 
                false,
30879
 
        },
30880
 
        {
30881
 
                "spoolss_61",
30882
 
                sizeof(struct spoolss_61),
30883
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_61,
30884
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
30885
 
                (ndr_print_function_t) ndr_print_spoolss_61,
30886
 
                false,
30887
 
        },
30888
 
        {
30889
 
                "spoolss_62",
30890
 
                sizeof(struct spoolss_62),
30891
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_62,
30892
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
30893
 
                (ndr_print_function_t) ndr_print_spoolss_62,
30894
 
                false,
30895
 
        },
30896
 
        {
30897
 
                "spoolss_63",
30898
 
                sizeof(struct spoolss_63),
30899
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_63,
30900
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
30901
 
                (ndr_print_function_t) ndr_print_spoolss_63,
30902
 
                false,
30903
 
        },
30904
 
        {
30905
 
                "spoolss_64",
30906
 
                sizeof(struct spoolss_64),
30907
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_64,
30908
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
30909
 
                (ndr_print_function_t) ndr_print_spoolss_64,
30910
 
                false,
30911
 
        },
30912
 
        {
30913
 
                "spoolss_65",
30914
 
                sizeof(struct spoolss_65),
30915
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_65,
30916
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
30917
 
                (ndr_print_function_t) ndr_print_spoolss_65,
30918
 
                false,
30919
 
        },
30920
 
        {
30921
 
                "spoolss_GetCorePrinterDrivers",
30922
 
                sizeof(struct spoolss_GetCorePrinterDrivers),
30923
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
30924
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
30925
 
                (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
30926
 
                false,
30927
 
        },
30928
 
        {
30929
 
                "spoolss_67",
30930
 
                sizeof(struct spoolss_67),
30931
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_67,
30932
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
30933
 
                (ndr_print_function_t) ndr_print_spoolss_67,
30934
 
                false,
30935
 
        },
30936
 
        {
30937
 
                "spoolss_GetPrinterDriverPackagePath",
30938
 
                sizeof(struct spoolss_GetPrinterDriverPackagePath),
30939
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
30940
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
30941
 
                (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
30942
 
                false,
30943
 
        },
30944
 
        {
30945
 
                "spoolss_69",
30946
 
                sizeof(struct spoolss_69),
30947
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_69,
30948
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
30949
 
                (ndr_print_function_t) ndr_print_spoolss_69,
30950
 
                false,
30951
 
        },
30952
 
        {
30953
 
                "spoolss_6a",
30954
 
                sizeof(struct spoolss_6a),
30955
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
30956
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
30957
 
                (ndr_print_function_t) ndr_print_spoolss_6a,
30958
 
                false,
30959
 
        },
30960
 
        {
30961
 
                "spoolss_6b",
30962
 
                sizeof(struct spoolss_6b),
30963
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
30964
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
30965
 
                (ndr_print_function_t) ndr_print_spoolss_6b,
30966
 
                false,
30967
 
        },
30968
 
        {
30969
 
                "spoolss_6c",
30970
 
                sizeof(struct spoolss_6c),
30971
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
30972
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
30973
 
                (ndr_print_function_t) ndr_print_spoolss_6c,
30974
 
                false,
30975
 
        },
30976
 
        {
30977
 
                "spoolss_6d",
30978
 
                sizeof(struct spoolss_6d),
30979
 
                (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
30980
 
                (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
30981
 
                (ndr_print_function_t) ndr_print_spoolss_6d,
30982
 
                false,
30983
 
        },
30984
 
        { NULL, 0, NULL, NULL, NULL, false }
30985
 
};
30986
 
 
30987
 
static const char * const spoolss_endpoint_strings[] = {
30988
 
        "ncacn_np:[\\pipe\\spoolss]", 
30989
 
};
30990
 
 
30991
 
static const struct ndr_interface_string_array spoolss_endpoints = {
30992
 
        .count  = 1,
30993
 
        .names  = spoolss_endpoint_strings
30994
 
};
30995
 
 
30996
 
static const char * const spoolss_authservice_strings[] = {
30997
 
        "host", 
30998
 
};
30999
 
 
31000
 
static const struct ndr_interface_string_array spoolss_authservices = {
31001
 
        .count  = 1,
31002
 
        .names  = spoolss_authservice_strings
31003
 
};
31004
 
 
31005
 
 
31006
 
const struct ndr_interface_table ndr_table_spoolss = {
31007
 
        .name           = "spoolss",
31008
 
        .syntax_id      = {
31009
 
                {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
31010
 
                NDR_SPOOLSS_VERSION
31011
 
        },
31012
 
        .helpstring     = NDR_SPOOLSS_HELPSTRING,
31013
 
        .num_calls      = 110,
31014
 
        .calls          = spoolss_calls,
31015
 
        .endpoints      = &spoolss_endpoints,
31016
 
        .authservices   = &spoolss_authservices
31017
 
};
31018