?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
spoolss: hand-marshall the spoolss_StringArray2 struct for spoolss_EnumPrinterKey.
[Samba/ekacnet.git] / librpc / ndr / ndr_spoolss_buf.c
blob4965b5d709faf721170526f24c84fd41e6dfa621
1 /*
2 Unix SMB/CIFS implementation.
3
4 routines for marshalling/unmarshalling spoolss subcontext buffer structures
5
6 Copyright (C) Andrew Tridgell 2003
7 Copyright (C) Tim Potter 2003
8 Copyright (C) Guenther Deschner 2009
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 */
23
24
25 #include "includes.h"
26 #include "librpc/gen_ndr/ndr_spoolss.h"
27 #if (_SAMBA_BUILD_ >= 4)
28 #include "param/param.h"
29 #endif
30
31 #define NDR_SPOOLSS_PUSH_ENUM_IN(fn) do { \
32 if (!r->in.buffer && r->in.offered != 0) {\
33 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
34 "SPOOLSS Buffer: r->in.offered[%u] but there's no buffer",\
35 (unsigned)r->in.offered);\
36 } else if (r->in.buffer && r->in.buffer->length != r->in.offered) {\
37 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
38 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of r->in.buffer[%u]",\
39 (unsigned)r->in.offered, (unsigned)r->in.buffer->length);\
40 }\
41 _r.in.level = r->in.level;\
42 _r.in.buffer = r->in.buffer;\
43 _r.in.offered = r->in.offered;\
44 NDR_CHECK(ndr_push__##fn(ndr, flags, &_r));\
45 } while(0)
46
47 #define NDR_SPOOLSS_PUSH_ENUM_OUT(fn) do { \
48 struct ndr_push *_ndr_info;\
49 _r.in.level = r->in.level;\
50 _r.in.buffer = r->in.buffer;\
51 _r.in.offered = r->in.offered;\
52 _r.out.info = NULL;\
53 _r.out.needed = r->out.needed;\
54 _r.out.count = r->out.count;\
55 _r.out.result = r->out.result;\
56 if (r->out.info && *r->out.info && !r->in.buffer) {\
57 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
58 "SPOOLSS Buffer: *r->out.info but there's no r->in.buffer");\
59 }\
60 if (r->in.buffer) {\
61 DATA_BLOB _data_blob_info;\
62 _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);\
63 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);\
64 _ndr_info->flags= ndr->flags;\
65 if (r->out.info) {\
66 struct __##fn __r;\
67 __r.in.level = r->in.level;\
68 __r.in.count = *r->out.count;\
69 __r.out.info = *r->out.info;\
70 NDR_CHECK(ndr_push___##fn(_ndr_info, flags, &__r)); \
71 }\
72 if (r->in.offered > _ndr_info->offset) {\
73 uint32_t _padding_len = r->in.offered - _ndr_info->offset;\
74 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));\
75 } else if (r->in.offered < _ndr_info->offset) {\
76 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
77 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of out buffer[%u]!",\
78 (unsigned)r->in.offered, (unsigned)_ndr_info->offset);\
79 }\
80 _data_blob_info = ndr_push_blob(_ndr_info);\
81 _r.out.info = &_data_blob_info;\
82 }\
83 NDR_CHECK(ndr_push__##fn(ndr, flags, &_r));\
84 } while(0)
85
86 #define NDR_SPOOLSS_PUSH_ENUM(fn,in,out) do { \
87 struct _##fn _r;\
88 if (flags & NDR_IN) {\
89 in;\
90 NDR_SPOOLSS_PUSH_ENUM_IN(fn);\
91 }\
92 if (flags & NDR_OUT) {\
93 out;\
94 NDR_SPOOLSS_PUSH_ENUM_OUT(fn);\
95 }\
96 } while(0)
97
98 #define NDR_SPOOLSS_PULL_ENUM_IN(fn) do { \
99 ZERO_STRUCT(r->out);\
100 NDR_CHECK(ndr_pull__##fn(ndr, flags, &_r));\
101 r->in.level = _r.in.level;\
102 r->in.buffer = _r.in.buffer;\
103 r->in.offered = _r.in.offered;\
104 r->out.needed = _r.out.needed;\
105 r->out.count = _r.out.count;\
106 if (!r->in.buffer && r->in.offered != 0) {\
107 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,\
108 "SPOOLSS Buffer: r->in.offered[%u] but there's no buffer",\
109 (unsigned)r->in.offered);\
110 } else if (r->in.buffer && r->in.buffer->length != r->in.offered) {\
111 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,\
112 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of r->in.buffer[%u]",\
113 (unsigned)r->in.offered, (unsigned)r->in.buffer->length);\
114 }\
115 NDR_PULL_ALLOC(ndr, r->out.info);\
116 ZERO_STRUCTP(r->out.info);\
117 } while(0)
118
119 #define NDR_SPOOLSS_PULL_ENUM_OUT(fn) do { \
120 _r.in.level = r->in.level;\
121 _r.in.buffer = r->in.buffer;\
122 _r.in.offered = r->in.offered;\
123 _r.out.needed = r->out.needed;\
124 _r.out.count = r->out.count;\
125 NDR_CHECK(ndr_pull__##fn(ndr, flags, &_r));\
126 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\
127 NDR_PULL_ALLOC(ndr, r->out.info);\
128 }\
129 *r->out.info = NULL;\
130 r->out.needed = _r.out.needed;\
131 r->out.count = _r.out.count;\
132 r->out.result = _r.out.result;\
133 if (_r.out.info) {\
134 struct ndr_pull *_ndr_info;\
135 NDR_PULL_ALLOC(ndr, *r->out.info);\
136 _ndr_info = ndr_pull_init_blob(_r.out.info, *r->out.info, ndr->iconv_convenience);\
137 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);\
138 _ndr_info->flags= ndr->flags;\
139 if (r->in.offered != _ndr_info->data_size) {\
140 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,\
141 "SPOOLSS Buffer: offered[%u] doesn't match length of buffer[%u]",\
142 (unsigned)r->in.offered, (unsigned)_ndr_info->data_size);\
143 }\
144 if (*r->out.needed <= _ndr_info->data_size) {\
145 struct __##fn __r;\
146 __r.in.level = r->in.level;\
147 __r.in.count = *r->out.count;\
148 __r.out.info = NULL;\
149 NDR_CHECK(ndr_pull___##fn(_ndr_info, flags, &__r));\
150 *r->out.info = __r.out.info;\
151 }\
152 }\
153 } while(0)
154
155 #define NDR_SPOOLSS_PULL_ENUM(fn,in,out) do { \
156 struct _##fn _r;\
157 if (flags & NDR_IN) {\
158 out;\
159 NDR_SPOOLSS_PULL_ENUM_IN(fn);\
160 in;\
161 }\
162 if (flags & NDR_OUT) {\
163 out;\
164 NDR_SPOOLSS_PULL_ENUM_OUT(fn);\
165 }\
166 } while(0)
167
168 #define _NDR_CHECK_UINT32(call) do {\
169 enum ndr_err_code _ndr_err; \
170 _ndr_err = call; \
171 if (!NDR_ERR_CODE_IS_SUCCESS(_ndr_err)) { \
172 return 0; \
173 }\
174 } while (0)
175
176 /* TODO: set _ndr_info->flags correct */
177 #define NDR_SPOOLSS_SIZE_ENUM_LEVEL(fn) do { \
178 struct __##fn __r;\
179 DATA_BLOB _data_blob_info;\
180 struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx, iconv_convenience);\
181 if (!_ndr_info) return 0;\
182 _ndr_info->flags|=0;\
183 __r.in.level = level;\
184 __r.in.count = count;\
185 __r.out.info = info;\
186 _NDR_CHECK_UINT32(ndr_push___##fn(_ndr_info, NDR_OUT, &__r)); \
187 _data_blob_info = ndr_push_blob(_ndr_info);\
188 return _data_blob_info.length;\
189 } while(0)
190
191 /* TODO: set _ndr_info->flags correct */
192 #define NDR_SPOOLSS_SIZE_ENUM(fn) do { \
193 struct __##fn __r;\
194 DATA_BLOB _data_blob_info;\
195 struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx, iconv_convenience);\
196 if (!_ndr_info) return 0;\
197 _ndr_info->flags|=0;\
198 __r.in.count = count;\
199 __r.out.info = info;\
200 _NDR_CHECK_UINT32(ndr_push___##fn(_ndr_info, NDR_OUT, &__r)); \
201 _data_blob_info = ndr_push_blob(_ndr_info);\
202 return _data_blob_info.length;\
203 } while(0)
204
205
206 /*
207 spoolss_EnumPrinters
208 */
209 enum ndr_err_code ndr_push_spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinters *r)
210 {
211 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinters,{
212 _r.in.flags = r->in.flags;
213 _r.in.server = r->in.server;
214 },{
215 _r.in.flags = r->in.flags;
216 _r.in.server = r->in.server;
217 });
218 return NDR_ERR_SUCCESS;
219 }
220
221 enum ndr_err_code ndr_pull_spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinters *r)
222 {
223 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinters,{
224 r->in.flags = _r.in.flags;
225 r->in.server = _r.in.server;
226 },{
227 _r.in.flags = r->in.flags;
228 _r.in.server = r->in.server;
229 });
230 return NDR_ERR_SUCCESS;
231 }
232
233 uint32_t ndr_size_spoolss_EnumPrinters_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_PrinterInfo *info)
234 {
235 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrinters);
236 }
237
238 /*
239 spoolss_EnumJobs
240 */
241 enum ndr_err_code ndr_push_spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct spoolss_EnumJobs *r)
242 {
243 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumJobs,{
244 _r.in.handle = r->in.handle;
245 _r.in.firstjob = r->in.firstjob;
246 _r.in.numjobs = r->in.numjobs;
247 },{
248 _r.in.handle = r->in.handle;
249 _r.in.firstjob = r->in.firstjob;
250 _r.in.numjobs = r->in.numjobs;
251 });
252 return NDR_ERR_SUCCESS;
253 }
254
255 enum ndr_err_code ndr_pull_spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct spoolss_EnumJobs *r)
256 {
257 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumJobs,{
258 r->in.handle = _r.in.handle;
259 r->in.firstjob = _r.in.firstjob;
260 r->in.numjobs = _r.in.numjobs;
261 },{
262 _r.in.handle = r->in.handle;
263 _r.in.firstjob = r->in.firstjob;
264 _r.in.numjobs = r->in.numjobs;
265 });
266 return NDR_ERR_SUCCESS;
267 }
268
269 uint32_t ndr_size_spoolss_EnumJobs_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_JobInfo *info)
270 {
271 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumJobs);
272 }
273
274 /*
275 spoolss_EnumPrinterDrivers
276 */
277 enum ndr_err_code ndr_push_spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDrivers *r)
278 {
279 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinterDrivers,{
280 _r.in.server = r->in.server;
281 _r.in.environment = r->in.environment;
282 },{
283 _r.in.server = r->in.server;
284 _r.in.environment = r->in.environment;
285 });
286 return NDR_ERR_SUCCESS;
287 }
288
289 enum ndr_err_code ndr_pull_spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDrivers *r)
290 {
291 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinterDrivers,{
292 r->in.server = _r.in.server;
293 r->in.environment = _r.in.environment;
294 },{
295 _r.in.server = r->in.server;
296 _r.in.environment = r->in.environment;
297 });
298 return NDR_ERR_SUCCESS;
299 }
300
301 uint32_t ndr_size_spoolss_EnumPrinterDrivers_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_DriverInfo *info)
302 {
303 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers);
304 }
305
306 /*
307 spoolss_EnumForms
308 */
309 enum ndr_err_code ndr_push_spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct spoolss_EnumForms *r)
310 {
311 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumForms,{
312 _r.in.handle = r->in.handle;
313 },{
314 _r.in.handle = r->in.handle;
315 });
316 return NDR_ERR_SUCCESS;
317 }
318
319 enum ndr_err_code ndr_pull_spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct spoolss_EnumForms *r)
320 {
321 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumForms,{
322 r->in.handle = _r.in.handle;
323 },{
324 _r.in.handle = r->in.handle;
325 });
326 return NDR_ERR_SUCCESS;
327 }
328
329 uint32_t ndr_size_spoolss_EnumForms_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_FormInfo *info)
330 {
331 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumForms);
332 }
333
334 /*
335 spoolss_EnumPorts
336 */
337 enum ndr_err_code ndr_push_spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct spoolss_EnumPorts *r)
338 {
339 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPorts,{
340 _r.in.servername= r->in.servername;
341 },{
342 _r.in.servername= r->in.servername;
343 });
344 return NDR_ERR_SUCCESS;
345 }
346
347 enum ndr_err_code ndr_pull_spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct spoolss_EnumPorts *r)
348 {
349 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPorts,{
350 r->in.servername= _r.in.servername;
351 },{
352 _r.in.servername= r->in.servername;
353 });
354 return NDR_ERR_SUCCESS;
355 }
356
357 uint32_t ndr_size_spoolss_EnumPorts_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_PortInfo *info)
358 {
359 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPorts);
360 }
361
362 /*
363 spoolss_EnumMonitors
364 */
365 enum ndr_err_code ndr_push_spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct spoolss_EnumMonitors *r)
366 {
367 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumMonitors,{
368 _r.in.servername= r->in.servername;
369 },{
370 _r.in.servername= r->in.servername;
371 });
372 return NDR_ERR_SUCCESS;
373 }
374
375 enum ndr_err_code ndr_pull_spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct spoolss_EnumMonitors *r)
376 {
377 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumMonitors,{
378 r->in.servername= _r.in.servername;
379 },{
380 _r.in.servername= r->in.servername;
381 });
382 return NDR_ERR_SUCCESS;
383 }
384
385 uint32_t ndr_size_spoolss_EnumMonitors_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_MonitorInfo *info)
386 {
387 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumMonitors);
388 }
389
390 /*
391 spoolss_EnumPrintProcessors
392 */
393 enum ndr_err_code ndr_push_spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcessors *r)
394 {
395 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrintProcessors,{
396 _r.in.servername = r->in.servername;
397 _r.in.environment = r->in.environment;
398 },{
399 _r.in.servername = r->in.servername;
400 _r.in.environment = r->in.environment;
401 });
402 return NDR_ERR_SUCCESS;
403 }
404
405 enum ndr_err_code ndr_pull_spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcessors *r)
406 {
407 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrintProcessors,{
408 r->in.servername = _r.in.servername;
409 r->in.environment = _r.in.environment;
410 },{
411 _r.in.servername = r->in.servername;
412 _r.in.environment = r->in.environment;
413 });
414 return NDR_ERR_SUCCESS;
415 }
416
417 uint32_t ndr_size_spoolss_EnumPrintProcessors_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
418 uint32_t level, uint32_t count, union spoolss_PrintProcessorInfo *info)
419 {
420 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcessors);
421 }
422
423 /*
424 spoolss_EnumPrintProcessors
425 */
426 enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
427 {
428 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrintProcDataTypes,{
429 _r.in.servername = r->in.servername;
430 _r.in.print_processor_name = r->in.print_processor_name;
431 },{
432 _r.in.servername = r->in.servername;
433 _r.in.print_processor_name = r->in.print_processor_name;
434 });
435 return NDR_ERR_SUCCESS;
436 }
437
438 enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
439 {
440 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrintProcDataTypes,{
441 r->in.servername = _r.in.servername;
442 r->in.print_processor_name = _r.in.print_processor_name;
443 },{
444 _r.in.servername = r->in.servername;
445 _r.in.print_processor_name = r->in.print_processor_name;
446 });
447 return NDR_ERR_SUCCESS;
448 }
449
450 uint32_t ndr_size_spoolss_EnumPrintProcDataTypes_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
451 uint32_t level, uint32_t count, union spoolss_PrintProcDataTypesInfo *info)
452 {
453 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcDataTypes);
454 }
455
456 /*
457 spoolss_EnumPrinterDataEx
458 */
459
460 enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
461 {
462 struct _spoolss_EnumPrinterDataEx _r;
463 if (flags & NDR_IN) {
464 _r.in.handle = r->in.handle;
465 _r.in.key_name = r->in.key_name;
466 _r.in.offered = r->in.offered;
467 NDR_CHECK(ndr_push__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
468 }
469 if (flags & NDR_OUT) {
470 struct ndr_push *_ndr_info;
471 _r.in.handle = r->in.handle;
472 _r.in.key_name = r->in.key_name;
473 _r.in.offered = r->in.offered;
474 _r.out.count = r->out.count;
475 _r.out.needed = r->out.needed;
476 _r.out.result = r->out.result;
477 _r.out.info = data_blob(NULL, 0);
478 if (r->in.offered >= *r->out.needed) {
479 struct __spoolss_EnumPrinterDataEx __r;
480 _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
481 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
482 _ndr_info->flags= ndr->flags;
483 __r.in.count = *r->out.count;
484 __r.out.info = *r->out.info;
485 NDR_CHECK(ndr_push___spoolss_EnumPrinterDataEx(_ndr_info, flags, &__r));
486 if (r->in.offered > _ndr_info->offset) {
487 uint32_t _padding_len = r->in.offered - _ndr_info->offset;
488 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));
489 }
490 _r.out.info = ndr_push_blob(_ndr_info);
491 }
492 NDR_CHECK(ndr_push__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
493 }
494 return NDR_ERR_SUCCESS;
495 }
496
497 enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
498 {
499 struct _spoolss_EnumPrinterDataEx _r;
500 if (flags & NDR_IN) {
501 _r.in.handle = r->in.handle;
502 _r.in.key_name = r->in.key_name;
503 ZERO_STRUCT(r->out);
504 NDR_CHECK(ndr_pull__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
505 r->in.handle = _r.in.handle;
506 r->in.key_name = _r.in.key_name;
507 r->in.offered = _r.in.offered;
508 r->out.needed = _r.out.needed;
509 r->out.count = _r.out.count;
510 NDR_PULL_ALLOC(ndr, r->out.info);
511 ZERO_STRUCTP(r->out.info);
512 }
513 if (flags & NDR_OUT) {
514 _r.in.handle = r->in.handle;
515 _r.in.key_name = r->in.key_name;
516 _r.in.offered = r->in.offered;
517 _r.out.count = r->out.count;
518 _r.out.needed = r->out.needed;
519 NDR_CHECK(ndr_pull__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
520 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
521 NDR_PULL_ALLOC(ndr, r->out.info);
522 }
523 *r->out.info = NULL;
524 r->out.needed = _r.out.needed;
525 r->out.count = _r.out.count;
526 r->out.result = _r.out.result;
527 if (_r.out.info.length) {
528 struct ndr_pull *_ndr_info;
529 NDR_PULL_ALLOC(ndr, *r->out.info);
530 _ndr_info = ndr_pull_init_blob(&_r.out.info, *r->out.info, ndr->iconv_convenience);
531 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
532 _ndr_info->flags= ndr->flags;
533 if (r->in.offered != _ndr_info->data_size) {
534 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
535 "SPOOLSS Buffer: offered[%u] doesn't match length of buffer[%u]",
536 (unsigned)r->in.offered, (unsigned)_ndr_info->data_size);
537 }
538 if (*r->out.needed <= _ndr_info->data_size) {
539 struct __spoolss_EnumPrinterDataEx __r;
540 __r.in.count = *r->out.count;
541 __r.out.info = NULL;
542 NDR_CHECK(ndr_pull___spoolss_EnumPrinterDataEx(_ndr_info, flags, &__r));
543 *r->out.info = __r.out.info;
544 }
545 }
546 }
547 return NDR_ERR_SUCCESS;
548 }
549
550 uint32_t ndr_size_spoolss_EnumPrinterDataEx_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
551 uint32_t count, struct spoolss_PrinterEnumValues *info)
552 {
553 NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrinterDataEx);
554 }
555
556 /*
557 spoolss_GetPrinterData
558 */
559 enum ndr_err_code ndr_push_spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterData *r)
560 {
561 struct _spoolss_GetPrinterData _r;
562 if (flags & NDR_IN) {
563 _r.in.handle = r->in.handle;
564 _r.in.value_name= r->in.value_name;
565 _r.in.offered = r->in.offered;
566 NDR_CHECK(ndr_push__spoolss_GetPrinterData(ndr, flags, &_r));
567 }
568 if (flags & NDR_OUT) {
569 struct ndr_push *_ndr_info;
570 DATA_BLOB blob = data_blob(NULL, 0);
571 _r.in.handle = r->in.handle;
572 _r.in.value_name= r->in.value_name;
573 _r.in.offered = r->in.offered;
574 _r.out.type = r->out.type;
575 _r.out.data = &blob;
576 _r.out.needed = r->out.needed;
577 _r.out.result = r->out.result;
578 {
579 struct __spoolss_GetPrinterData __r;
580 DATA_BLOB _blob;
581 _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
582 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
583 _ndr_info->flags= ndr->flags;
584 __r.in.type = *r->out.type;
585 __r.out.data = r->out.data;
586 NDR_CHECK(ndr_push___spoolss_GetPrinterData(_ndr_info, flags, &__r));
587 if (r->in.offered > _ndr_info->offset) {
588 uint32_t _padding_len = r->in.offered - _ndr_info->offset;
589 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));
590 }
591 _blob = ndr_push_blob(_ndr_info);
592 _r.out.data = &_blob;
593 }
594 NDR_CHECK(ndr_push__spoolss_GetPrinterData(ndr, flags, &_r));
595 }
596 return NDR_ERR_SUCCESS;
597 }
598
599 enum ndr_err_code ndr_pull_spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterData *r)
600 {
601 struct _spoolss_GetPrinterData _r;
602 if (flags & NDR_IN) {
603 DATA_BLOB blob = data_blob(NULL,0);
604 ZERO_STRUCT(r->out);
605
606 _r.in.handle = r->in.handle;
607 _r.in.value_name= r->in.value_name;
608 _r.in.offered = r->in.offered;
609 _r.out.type = r->out.type;
610 _r.out.data = &blob;
611 _r.out.needed = r->out.needed;
612 NDR_CHECK(ndr_pull__spoolss_GetPrinterData(ndr, flags, &_r));
613 r->in.handle = _r.in.handle;
614 r->in.value_name= _r.in.value_name;
615 r->in.offered = _r.in.offered;
616 r->out.needed = _r.out.needed;
617 }
618 if (flags & NDR_OUT) {
619 DATA_BLOB blob = data_blob_talloc(ndr,NULL,0);
620 _r.in.handle = r->in.handle;
621 _r.in.value_name= r->in.value_name;
622 _r.in.offered = r->in.offered;
623 _r.out.type = r->out.type;
624 _r.out.data = &blob;
625 _r.out.needed = r->out.needed;
626 _r.out.result = r->out.result;
627 NDR_CHECK(ndr_pull__spoolss_GetPrinterData(ndr, flags, &_r));
628 r->out.type = _r.out.type;
629 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
630 NDR_PULL_ALLOC(ndr, r->out.data);
631 }
632 ZERO_STRUCTP(r->out.data);
633 r->out.needed = _r.out.needed;
634 r->out.result = _r.out.result;
635 if (_r.out.data && _r.out.data->length != r->in.offered) {
636 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
637 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of out buffer[%u]",
638 (unsigned)r->in.offered, (unsigned)_r.out.data->length);
639 }
640 if (_r.out.data && _r.out.data->length > 0 && *r->out.needed <= _r.out.data->length) {
641 struct __spoolss_GetPrinterData __r;
642 struct ndr_pull *_ndr_data = ndr_pull_init_blob(_r.out.data, ndr, ndr->iconv_convenience);
643 NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
644 _ndr_data->flags= ndr->flags;
645 __r.in.type = *r->out.type;
646 __r.out.data = r->out.data;
647 NDR_CHECK(ndr_pull___spoolss_GetPrinterData(_ndr_data, flags, &__r));
648 r->out.data = __r.out.data;
649 } else {
650 *r->out.type = REG_NONE;
651 }
652 }
653 return NDR_ERR_SUCCESS;
654 }
655
656 /*
657 spoolss_SetPrinterData
658 */
659 enum ndr_err_code ndr_push_spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterData *r)
660 {
661 struct _spoolss_SetPrinterData _r;
662 if (flags & NDR_IN) {
663 struct ndr_push *_ndr_data;
664 struct __spoolss_SetPrinterData __r;
665 DATA_BLOB _data_blob_data;
666
667 _ndr_data = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
668 NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
669 _ndr_data->flags= ndr->flags;
670
671 __r.in.type = r->in.type;
672 __r.out.data = discard_const_p(union spoolss_PrinterData, &r->in.data);
673 NDR_CHECK(ndr_push___spoolss_SetPrinterData(_ndr_data, NDR_OUT, &__r));
674 _data_blob_data = ndr_push_blob(_ndr_data);
675
676 _r.in.handle = r->in.handle;
677 _r.in.value_name= r->in.value_name;
678 _r.in.type = r->in.type;
679 _r.in.data = _data_blob_data;
680 _r.in._offered = _data_blob_data.length;
681 _r.out.result = r->out.result;
682 NDR_CHECK(ndr_push__spoolss_SetPrinterData(ndr, flags, &_r));
683 }
684 if (flags & NDR_OUT) {
685 _r.in.handle = r->in.handle;
686 _r.in.value_name= r->in.value_name;
687 _r.in.type = r->in.type;
688 _r.in.data = data_blob(NULL,0),
689 _r.in._offered = r->in._offered;
690 _r.out.result = r->out.result;
691 NDR_CHECK(ndr_push__spoolss_SetPrinterData(ndr, flags, &_r));
692 }
693 return NDR_ERR_SUCCESS;
694 }
695
696 uint32_t _ndr_size_spoolss_DeviceMode(struct spoolss_DeviceMode *devmode, struct smb_iconv_convenience *ic, uint32_t flags)
697 {
698 if (!devmode) return 0;
699 return ndr_size_spoolss_DeviceMode(devmode,ic,flags);
700 }
701
702 _PUBLIC_ size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, struct smb_iconv_convenience *ic, int flags)
703 {
704 if (!r) {
705 return 4;
706 }
707
708 return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_StringArray, ic);
709 }
710
711 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray2 *r)
712 {
713 if (ndr_flags & NDR_SCALARS) {
714 uint32_t _ndr_size;
715 _ndr_size = ndr_size_spoolss_StringArray2(r, ndr->iconv_convenience, ndr->flags);
716 NDR_CHECK(ndr_push_align(ndr, 4));
717 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size));
718 if (_ndr_size > 0) {
719 uint32_t _flags_save_string_array = ndr->flags;
720 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
721 {
722 struct ndr_push *_ndr_string;
723 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_string, 0, _ndr_size * 2));
724 NDR_CHECK(ndr_push_string_array(_ndr_string, NDR_SCALARS, r->string));
725 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_string, 0, _ndr_size * 2));
726 }
727 ndr->flags = _flags_save_string_array;
728 }
729 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
730 }
731 if (ndr_flags & NDR_BUFFERS) {
732 }
733 return NDR_ERR_SUCCESS;
734 }
735
736 _PUBLIC_ size_t ndr_size_spoolss_StringArray2(const struct spoolss_StringArray2 *r, struct smb_iconv_convenience *ic, int flags)
737 {
738 uint32_t i;
739
740 if (!r || !r->string) {
741 return 0;
742 }
743
744 for (i=0; r->string[i]; i++) {
745 ;;
746 }
747
748 return (ndr_size_string_array(r->string, i, LIBNDR_FLAG_STR_NULLTERM) + 1);
749 }
750
751 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray2 *r)
752 {
753 if (ndr_flags & NDR_SCALARS) {
754 NDR_CHECK(ndr_pull_align(ndr, 4));
755 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
756 if (r->_ndr_size) {
757 uint32_t _flags_save_string_array = ndr->flags;
758 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
759 {
760 struct ndr_pull *_ndr_string;
761 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_string, 0, r->_ndr_size * 2));
762 NDR_CHECK(ndr_pull_string_array(_ndr_string, NDR_SCALARS, &r->string));
763 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_string, 0, r->_ndr_size * 2));
764 }
765 ndr->flags = _flags_save_string_array;
766 } else {
767 r->string = NULL;
768 }
769 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
770 }
771 if (ndr_flags & NDR_BUFFERS) {
772 }
773 return NDR_ERR_SUCCESS;
774 }
775
776 /* hand marshall as pidl cannot (yet) generate a relative pointer to a fixed array of
777 * structs */
778
779 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo101(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo101 *r)
780 {
781 uint32_t cntr_file_info_1;
782 if (ndr_flags & NDR_SCALARS) {
783 NDR_CHECK(ndr_push_align(ndr, 8));
784 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
785 {
786 uint32_t _flags_save_string = ndr->flags;
787 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
788 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
789 ndr->flags = _flags_save_string;
790 }
791 {
792 uint32_t _flags_save_string = ndr->flags;
793 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
794 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
795 ndr->flags = _flags_save_string;
796 }
797 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_info));
798 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_count));
799 {
800 uint32_t _flags_save_string = ndr->flags;
801 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
802 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
803 ndr->flags = _flags_save_string;
804 }
805 {
806 uint32_t _flags_save_string = ndr->flags;
807 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
808 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
809 ndr->flags = _flags_save_string;
810 }
811 {
812 uint32_t _flags_save_string_array = ndr->flags;
813 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
814 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
815 ndr->flags = _flags_save_string_array;
816 }
817 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
818 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
819 {
820 uint32_t _flags_save_string = ndr->flags;
821 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
822 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
823 ndr->flags = _flags_save_string;
824 }
825 {
826 uint32_t _flags_save_string = ndr->flags;
827 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
828 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
829 ndr->flags = _flags_save_string;
830 }
831 {
832 uint32_t _flags_save_string = ndr->flags;
833 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
834 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
835 ndr->flags = _flags_save_string;
836 }
837 {
838 uint32_t _flags_save_string = ndr->flags;
839 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
840 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
841 ndr->flags = _flags_save_string;
842 }
843 }
844 if (ndr_flags & NDR_BUFFERS) {
845 {
846 uint32_t _flags_save_string = ndr->flags;
847 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
848 if (r->driver_name) {
849 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
850 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
851 }
852 ndr->flags = _flags_save_string;
853 }
854 {
855 uint32_t _flags_save_string = ndr->flags;
856 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
857 if (r->architecture) {
858 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
859 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
860 }
861 ndr->flags = _flags_save_string;
862 }
863 if (r->file_info) {
864 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_info));
865 #if 0
866 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_count));
867 #endif
868 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
869 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
870 }
871 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
872 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
873 }
874 }
875 {
876 uint32_t _flags_save_string = ndr->flags;
877 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
878 if (r->monitor_name) {
879 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
880 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
881 }
882 ndr->flags = _flags_save_string;
883 }
884 {
885 uint32_t _flags_save_string = ndr->flags;
886 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
887 if (r->default_datatype) {
888 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
889 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
890 }
891 ndr->flags = _flags_save_string;
892 }
893 {
894 uint32_t _flags_save_string_array = ndr->flags;
895 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
896 if (r->previous_names) {
897 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
898 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
899 }
900 ndr->flags = _flags_save_string_array;
901 }
902 {
903 uint32_t _flags_save_string = ndr->flags;
904 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
905 if (r->manufacturer_name) {
906 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
907 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
908 }
909 ndr->flags = _flags_save_string;
910 }
911 {
912 uint32_t _flags_save_string = ndr->flags;
913 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
914 if (r->manufacturer_url) {
915 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
916 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
917 }
918 ndr->flags = _flags_save_string;
919 }
920 {
921 uint32_t _flags_save_string = ndr->flags;
922 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
923 if (r->hardware_id) {
924 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
925 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
926 }
927 ndr->flags = _flags_save_string;
928 }
929 {
930 uint32_t _flags_save_string = ndr->flags;
931 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
932 if (r->provider) {
933 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
934 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
935 }
936 ndr->flags = _flags_save_string;
937 }
938 }
939 return NDR_ERR_SUCCESS;
940 }
941
942 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo101(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo101 *r)
943 {
944 uint32_t _ptr_driver_name;
945 TALLOC_CTX *_mem_save_driver_name_0;
946 uint32_t _ptr_architecture;
947 TALLOC_CTX *_mem_save_architecture_0;
948 uint32_t _ptr_file_info;
949 uint32_t cntr_file_info_1;
950 TALLOC_CTX *_mem_save_file_info_0;
951 TALLOC_CTX *_mem_save_file_info_1;
952 uint32_t _ptr_monitor_name;
953 TALLOC_CTX *_mem_save_monitor_name_0;
954 uint32_t _ptr_default_datatype;
955 TALLOC_CTX *_mem_save_default_datatype_0;
956 uint32_t _ptr_previous_names;
957 TALLOC_CTX *_mem_save_previous_names_0;
958 uint32_t _ptr_manufacturer_name;
959 TALLOC_CTX *_mem_save_manufacturer_name_0;
960 uint32_t _ptr_manufacturer_url;
961 TALLOC_CTX *_mem_save_manufacturer_url_0;
962 uint32_t _ptr_hardware_id;
963 TALLOC_CTX *_mem_save_hardware_id_0;
964 uint32_t _ptr_provider;
965 TALLOC_CTX *_mem_save_provider_0;
966 if (ndr_flags & NDR_SCALARS) {
967 NDR_CHECK(ndr_pull_align(ndr, 8));
968 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
969 {
970 uint32_t _flags_save_string = ndr->flags;
971 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
972 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
973 if (_ptr_driver_name) {
974 NDR_PULL_ALLOC(ndr, r->driver_name);
975 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
976 } else {
977 r->driver_name = NULL;
978 }
979 ndr->flags = _flags_save_string;
980 }
981 {
982 uint32_t _flags_save_string = ndr->flags;
983 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
984 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
985 if (_ptr_architecture) {
986 NDR_PULL_ALLOC(ndr, r->architecture);
987 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
988 } else {
989 r->architecture = NULL;
990 }
991 ndr->flags = _flags_save_string;
992 }
993 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_info));
994 if (_ptr_file_info) {
995 NDR_PULL_ALLOC(ndr, r->file_info);
996 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_info, _ptr_file_info));
997 } else {
998 r->file_info = NULL;
999 }
1000 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_count));
1001 {
1002 uint32_t _flags_save_string = ndr->flags;
1003 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1004 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
1005 if (_ptr_monitor_name) {
1006 NDR_PULL_ALLOC(ndr, r->monitor_name);
1007 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
1008 } else {
1009 r->monitor_name = NULL;
1010 }
1011 ndr->flags = _flags_save_string;
1012 }
1013 {
1014 uint32_t _flags_save_string = ndr->flags;
1015 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1016 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
1017 if (_ptr_default_datatype) {
1018 NDR_PULL_ALLOC(ndr, r->default_datatype);
1019 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
1020 } else {
1021 r->default_datatype = NULL;
1022 }
1023 ndr->flags = _flags_save_string;
1024 }
1025 {
1026 uint32_t _flags_save_string_array = ndr->flags;
1027 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1028 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
1029 if (_ptr_previous_names) {
1030 NDR_PULL_ALLOC(ndr, r->previous_names);
1031 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
1032 } else {
1033 r->previous_names = NULL;
1034 }
1035 ndr->flags = _flags_save_string_array;
1036 }
1037 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
1038 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
1039 {
1040 uint32_t _flags_save_string = ndr->flags;
1041 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1042 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
1043 if (_ptr_manufacturer_name) {
1044 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
1045 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
1046 } else {
1047 r->manufacturer_name = NULL;
1048 }
1049 ndr->flags = _flags_save_string;
1050 }
1051 {
1052 uint32_t _flags_save_string = ndr->flags;
1053 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1054 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
1055 if (_ptr_manufacturer_url) {
1056 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
1057 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
1058 } else {
1059 r->manufacturer_url = NULL;
1060 }
1061 ndr->flags = _flags_save_string;
1062 }
1063 {
1064 uint32_t _flags_save_string = ndr->flags;
1065 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1066 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
1067 if (_ptr_hardware_id) {
1068 NDR_PULL_ALLOC(ndr, r->hardware_id);
1069 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
1070 } else {
1071 r->hardware_id = NULL;
1072 }
1073 ndr->flags = _flags_save_string;
1074 }
1075 {
1076 uint32_t _flags_save_string = ndr->flags;
1077 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1078 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
1079 if (_ptr_provider) {
1080 NDR_PULL_ALLOC(ndr, r->provider);
1081 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
1082 } else {
1083 r->provider = NULL;
1084 }
1085 ndr->flags = _flags_save_string;
1086 }
1087 }
1088 if (ndr_flags & NDR_BUFFERS) {
1089 {
1090 uint32_t _flags_save_string = ndr->flags;
1091 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1092 if (r->driver_name) {
1093 uint32_t _relative_save_offset;
1094 _relative_save_offset = ndr->offset;
1095 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
1096 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1097 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
1098 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
1099 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
1100 ndr->offset = _relative_save_offset;
1101 }
1102 ndr->flags = _flags_save_string;
1103 }
1104 {
1105 uint32_t _flags_save_string = ndr->flags;
1106 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1107 if (r->architecture) {
1108 uint32_t _relative_save_offset;
1109 _relative_save_offset = ndr->offset;
1110 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
1111 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
1112 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
1113 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
1114 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
1115 ndr->offset = _relative_save_offset;
1116 }
1117 ndr->flags = _flags_save_string;
1118 }
1119 if (r->file_info) {
1120 uint32_t _relative_save_offset;
1121 _relative_save_offset = ndr->offset;
1122 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_info));
1123 _mem_save_file_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1124 NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1125 #if 0
1126 NDR_CHECK(ndr_pull_array_size(ndr, &r->file_info));
1127 #else
1128 NDR_CHECK(ndr_token_store(ndr, &ndr->array_size_list, &r->file_info, r->file_count));
1129 #endif
1130 NDR_PULL_ALLOC_N(ndr, r->file_info, ndr_get_array_size(ndr, &r->file_info));
1131 _mem_save_file_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
1132 NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1133 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1134 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
1135 }
1136 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1137 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
1138 }
1139 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_1, 0);
1140 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_0, 0);
1141 ndr->offset = _relative_save_offset;
1142 }
1143 {
1144 uint32_t _flags_save_string = ndr->flags;
1145 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1146 if (r->monitor_name) {
1147 uint32_t _relative_save_offset;
1148 _relative_save_offset = ndr->offset;
1149 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
1150 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1151 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
1152 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
1153 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
1154 ndr->offset = _relative_save_offset;
1155 }
1156 ndr->flags = _flags_save_string;
1157 }
1158 {
1159 uint32_t _flags_save_string = ndr->flags;
1160 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1161 if (r->default_datatype) {
1162 uint32_t _relative_save_offset;
1163 _relative_save_offset = ndr->offset;
1164 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
1165 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1166 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
1167 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
1168 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
1169 ndr->offset = _relative_save_offset;
1170 }
1171 ndr->flags = _flags_save_string;
1172 }
1173 {
1174 uint32_t _flags_save_string_array = ndr->flags;
1175 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1176 if (r->previous_names) {
1177 uint32_t _relative_save_offset;
1178 _relative_save_offset = ndr->offset;
1179 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
1180 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
1181 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
1182 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
1183 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
1184 ndr->offset = _relative_save_offset;
1185 }
1186 ndr->flags = _flags_save_string_array;
1187 }
1188 {
1189 uint32_t _flags_save_string = ndr->flags;
1190 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1191 if (r->manufacturer_name) {
1192 uint32_t _relative_save_offset;
1193 _relative_save_offset = ndr->offset;
1194 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
1195 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1196 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
1197 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
1198 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
1199 ndr->offset = _relative_save_offset;
1200 }
1201 ndr->flags = _flags_save_string;
1202 }
1203 {
1204 uint32_t _flags_save_string = ndr->flags;
1205 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1206 if (r->manufacturer_url) {
1207 uint32_t _relative_save_offset;
1208 _relative_save_offset = ndr->offset;
1209 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
1210 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
1211 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
1212 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
1213 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
1214 ndr->offset = _relative_save_offset;
1215 }
1216 ndr->flags = _flags_save_string;
1217 }
1218 {
1219 uint32_t _flags_save_string = ndr->flags;
1220 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1221 if (r->hardware_id) {
1222 uint32_t _relative_save_offset;
1223 _relative_save_offset = ndr->offset;
1224 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
1225 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
1226 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
1227 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
1228 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
1229 ndr->offset = _relative_save_offset;
1230 }
1231 ndr->flags = _flags_save_string;
1232 }
1233 {
1234 uint32_t _flags_save_string = ndr->flags;
1235 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1236 if (r->provider) {
1237 uint32_t _relative_save_offset;
1238 _relative_save_offset = ndr->offset;
1239 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
1240 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
1241 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
1242 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
1243 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
1244 ndr->offset = _relative_save_offset;
1245 }
1246 ndr->flags = _flags_save_string;
1247 }
1248 if (r->file_info) {
1249 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->file_info, r->file_count));
1250 }
1251 }
1252 return NDR_ERR_SUCCESS;
1253 }
1254
1255 void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, const union spoolss_Field *r)
1256 {
1257 int level;
1258 level = ndr_print_get_switch_value(ndr, r);
1259 ndr_print_union(ndr, name, level, "spoolss_Field");
1260 switch (level) {
1261 case PRINTER_NOTIFY_TYPE:
1262 ndr_print_spoolss_PrintNotifyField(ndr, "field", r->field);
1263 break;
1264
1265 case JOB_NOTIFY_TYPE:
1266 ndr_print_spoolss_JobNotifyField(ndr, "field", r->field);
1267 break;
1268
1269 default:
1270 ndr_print_uint16(ndr, "field", r->field);
1271 break;
1272
1273 }
1274 }
1275