?  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/bb.git] / librpc / ndr / ndr_spoolss_buf.c
blob783f20b50f1084a7b5b64140d1ace57ce5cb757c
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 }
929 if (ndr_flags & NDR_BUFFERS) {
930 {
931 uint32_t _flags_save_string = ndr->flags;
932 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
933 if (r->driver_name) {
934 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
935 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
936 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
937 }
938 ndr->flags = _flags_save_string;
939 }
940 {
941 uint32_t _flags_save_string = ndr->flags;
942 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
943 if (r->architecture) {
944 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
945 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
946 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
947 }
948 ndr->flags = _flags_save_string;
949 }
950 if (r->file_info) {
951 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->file_info));
952 #if 0
953 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_count));
954 #endif
955 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
956 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
957 }
958 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
959 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
960 }
961 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->file_info));
962 }
963 {
964 uint32_t _flags_save_string = ndr->flags;
965 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
966 if (r->monitor_name) {
967 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
968 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
969 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
970 }
971 ndr->flags = _flags_save_string;
972 }
973 {
974 uint32_t _flags_save_string = ndr->flags;
975 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
976 if (r->default_datatype) {
977 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
978 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
979 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
980 }
981 ndr->flags = _flags_save_string;
982 }
983 {
984 uint32_t _flags_save_string_array = ndr->flags;
985 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
986 if (r->previous_names) {
987 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
988 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
989 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
990 }
991 ndr->flags = _flags_save_string_array;
992 }
993 {
994 uint32_t _flags_save_string = ndr->flags;
995 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
996 if (r->manufacturer_name) {
997 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
998 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
999 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
1000 }
1001 ndr->flags = _flags_save_string;
1002 }
1003 {
1004 uint32_t _flags_save_string = ndr->flags;
1005 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1006 if (r->manufacturer_url) {
1007 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
1008 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
1009 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
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 if (r->hardware_id) {
1017 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
1018 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
1019 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
1020 }
1021 ndr->flags = _flags_save_string;
1022 }
1023 {
1024 uint32_t _flags_save_string = ndr->flags;
1025 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1026 if (r->provider) {
1027 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
1028 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
1029 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
1030 }
1031 ndr->flags = _flags_save_string;
1032 }
1033 }
1034 return NDR_ERR_SUCCESS;
1035 }
1036
1037 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo101(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo101 *r)
1038 {
1039 uint32_t _ptr_driver_name;
1040 TALLOC_CTX *_mem_save_driver_name_0;
1041 uint32_t _ptr_architecture;
1042 TALLOC_CTX *_mem_save_architecture_0;
1043 uint32_t _ptr_file_info;
1044 uint32_t cntr_file_info_1;
1045 TALLOC_CTX *_mem_save_file_info_0;
1046 TALLOC_CTX *_mem_save_file_info_1;
1047 uint32_t _ptr_monitor_name;
1048 TALLOC_CTX *_mem_save_monitor_name_0;
1049 uint32_t _ptr_default_datatype;
1050 TALLOC_CTX *_mem_save_default_datatype_0;
1051 uint32_t _ptr_previous_names;
1052 TALLOC_CTX *_mem_save_previous_names_0;
1053 uint32_t _ptr_manufacturer_name;
1054 TALLOC_CTX *_mem_save_manufacturer_name_0;
1055 uint32_t _ptr_manufacturer_url;
1056 TALLOC_CTX *_mem_save_manufacturer_url_0;
1057 uint32_t _ptr_hardware_id;
1058 TALLOC_CTX *_mem_save_hardware_id_0;
1059 uint32_t _ptr_provider;
1060 TALLOC_CTX *_mem_save_provider_0;
1061 if (ndr_flags & NDR_SCALARS) {
1062 NDR_CHECK(ndr_pull_align(ndr, 8));
1063 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
1064 {
1065 uint32_t _flags_save_string = ndr->flags;
1066 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1067 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
1068 if (_ptr_driver_name) {
1069 NDR_PULL_ALLOC(ndr, r->driver_name);
1070 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
1071 } else {
1072 r->driver_name = NULL;
1073 }
1074 ndr->flags = _flags_save_string;
1075 }
1076 {
1077 uint32_t _flags_save_string = ndr->flags;
1078 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1079 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
1080 if (_ptr_architecture) {
1081 NDR_PULL_ALLOC(ndr, r->architecture);
1082 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
1083 } else {
1084 r->architecture = NULL;
1085 }
1086 ndr->flags = _flags_save_string;
1087 }
1088 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_info));
1089 if (_ptr_file_info) {
1090 NDR_PULL_ALLOC(ndr, r->file_info);
1091 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_info, _ptr_file_info));
1092 } else {
1093 r->file_info = NULL;
1094 }
1095 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_count));
1096 {
1097 uint32_t _flags_save_string = ndr->flags;
1098 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1099 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
1100 if (_ptr_monitor_name) {
1101 NDR_PULL_ALLOC(ndr, r->monitor_name);
1102 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
1103 } else {
1104 r->monitor_name = NULL;
1105 }
1106 ndr->flags = _flags_save_string;
1107 }
1108 {
1109 uint32_t _flags_save_string = ndr->flags;
1110 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1111 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
1112 if (_ptr_default_datatype) {
1113 NDR_PULL_ALLOC(ndr, r->default_datatype);
1114 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
1115 } else {
1116 r->default_datatype = NULL;
1117 }
1118 ndr->flags = _flags_save_string;
1119 }
1120 {
1121 uint32_t _flags_save_string_array = ndr->flags;
1122 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1123 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
1124 if (_ptr_previous_names) {
1125 NDR_PULL_ALLOC(ndr, r->previous_names);
1126 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
1127 } else {
1128 r->previous_names = NULL;
1129 }
1130 ndr->flags = _flags_save_string_array;
1131 }
1132 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
1133 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
1134 {
1135 uint32_t _flags_save_string = ndr->flags;
1136 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1137 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
1138 if (_ptr_manufacturer_name) {
1139 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
1140 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
1141 } else {
1142 r->manufacturer_name = NULL;
1143 }
1144 ndr->flags = _flags_save_string;
1145 }
1146 {
1147 uint32_t _flags_save_string = ndr->flags;
1148 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1149 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
1150 if (_ptr_manufacturer_url) {
1151 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
1152 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
1153 } else {
1154 r->manufacturer_url = NULL;
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 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
1162 if (_ptr_hardware_id) {
1163 NDR_PULL_ALLOC(ndr, r->hardware_id);
1164 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
1165 } else {
1166 r->hardware_id = NULL;
1167 }
1168 ndr->flags = _flags_save_string;
1169 }
1170 {
1171 uint32_t _flags_save_string = ndr->flags;
1172 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1173 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
1174 if (_ptr_provider) {
1175 NDR_PULL_ALLOC(ndr, r->provider);
1176 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
1177 } else {
1178 r->provider = NULL;
1179 }
1180 ndr->flags = _flags_save_string;
1181 }
1182 }
1183 if (ndr_flags & NDR_BUFFERS) {
1184 {
1185 uint32_t _flags_save_string = ndr->flags;
1186 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1187 if (r->driver_name) {
1188 uint32_t _relative_save_offset;
1189 _relative_save_offset = ndr->offset;
1190 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
1191 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1192 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
1193 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
1194 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
1195 ndr->offset = _relative_save_offset;
1196 }
1197 ndr->flags = _flags_save_string;
1198 }
1199 {
1200 uint32_t _flags_save_string = ndr->flags;
1201 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1202 if (r->architecture) {
1203 uint32_t _relative_save_offset;
1204 _relative_save_offset = ndr->offset;
1205 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
1206 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
1207 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
1208 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
1209 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
1210 ndr->offset = _relative_save_offset;
1211 }
1212 ndr->flags = _flags_save_string;
1213 }
1214 if (r->file_info) {
1215 uint32_t _relative_save_offset;
1216 _relative_save_offset = ndr->offset;
1217 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_info));
1218 _mem_save_file_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1219 NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1220 #if 0
1221 NDR_CHECK(ndr_pull_array_size(ndr, &r->file_info));
1222 #else
1223 NDR_CHECK(ndr_token_store(ndr, &ndr->array_size_list, &r->file_info, r->file_count));
1224 #endif
1225 NDR_PULL_ALLOC_N(ndr, r->file_info, ndr_get_array_size(ndr, &r->file_info));
1226 _mem_save_file_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
1227 NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1228 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1229 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
1230 }
1231 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1232 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
1233 }
1234 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_1, 0);
1235 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_0, 0);
1236 ndr->offset = _relative_save_offset;
1237 }
1238 {
1239 uint32_t _flags_save_string = ndr->flags;
1240 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1241 if (r->monitor_name) {
1242 uint32_t _relative_save_offset;
1243 _relative_save_offset = ndr->offset;
1244 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
1245 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1246 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
1247 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
1248 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
1249 ndr->offset = _relative_save_offset;
1250 }
1251 ndr->flags = _flags_save_string;
1252 }
1253 {
1254 uint32_t _flags_save_string = ndr->flags;
1255 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1256 if (r->default_datatype) {
1257 uint32_t _relative_save_offset;
1258 _relative_save_offset = ndr->offset;
1259 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
1260 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1261 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
1262 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
1263 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
1264 ndr->offset = _relative_save_offset;
1265 }
1266 ndr->flags = _flags_save_string;
1267 }
1268 {
1269 uint32_t _flags_save_string_array = ndr->flags;
1270 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1271 if (r->previous_names) {
1272 uint32_t _relative_save_offset;
1273 _relative_save_offset = ndr->offset;
1274 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
1275 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
1276 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
1277 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
1278 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
1279 ndr->offset = _relative_save_offset;
1280 }
1281 ndr->flags = _flags_save_string_array;
1282 }
1283 {
1284 uint32_t _flags_save_string = ndr->flags;
1285 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1286 if (r->manufacturer_name) {
1287 uint32_t _relative_save_offset;
1288 _relative_save_offset = ndr->offset;
1289 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
1290 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1291 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
1292 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
1293 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
1294 ndr->offset = _relative_save_offset;
1295 }
1296 ndr->flags = _flags_save_string;
1297 }
1298 {
1299 uint32_t _flags_save_string = ndr->flags;
1300 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1301 if (r->manufacturer_url) {
1302 uint32_t _relative_save_offset;
1303 _relative_save_offset = ndr->offset;
1304 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
1305 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
1306 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
1307 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
1308 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
1309 ndr->offset = _relative_save_offset;
1310 }
1311 ndr->flags = _flags_save_string;
1312 }
1313 {
1314 uint32_t _flags_save_string = ndr->flags;
1315 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1316 if (r->hardware_id) {
1317 uint32_t _relative_save_offset;
1318 _relative_save_offset = ndr->offset;
1319 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
1320 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
1321 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
1322 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
1323 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
1324 ndr->offset = _relative_save_offset;
1325 }
1326 ndr->flags = _flags_save_string;
1327 }
1328 {
1329 uint32_t _flags_save_string = ndr->flags;
1330 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1331 if (r->provider) {
1332 uint32_t _relative_save_offset;
1333 _relative_save_offset = ndr->offset;
1334 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
1335 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
1336 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
1337 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
1338 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
1339 ndr->offset = _relative_save_offset;
1340 }
1341 ndr->flags = _flags_save_string;
1342 }
1343 if (r->file_info) {
1344 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->file_info, r->file_count));
1345 }
1346 }
1347 return NDR_ERR_SUCCESS;
1348 }
1349
1350 void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, const union spoolss_Field *r)
1351 {
1352 int level;
1353 level = ndr_print_get_switch_value(ndr, r);
1354 ndr_print_union(ndr, name, level, "spoolss_Field");
1355 switch (level) {
1356 case PRINTER_NOTIFY_TYPE:
1357 ndr_print_spoolss_PrintNotifyField(ndr, "field", r->field);
1358 break;
1359
1360 case JOB_NOTIFY_TYPE:
1361 ndr_print_spoolss_JobNotifyField(ndr, "field", r->field);
1362 break;
1363
1364 default:
1365 ndr_print_uint16(ndr, "field", r->field);
1366 break;
1367
1368 }
1369 }
1370
1371 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
1372 {
1373 if (!r) {
1374 return 0;
1375 }
1376 return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
1377 }
1378