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