?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: Avoid calling cli_alloc_mid twice in cli_smb_req_iov_send
[Samba.git] / librpc / ndr / ndr_spoolss_buf.c
blob8d977c8f92becf965a753ef2086ffed5e8fa7ec2
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 #include "librpc/gen_ndr/ndr_security.h"
28 #if (_SAMBA_BUILD_ >= 4)
29 #include "param/param.h"
30 #endif
31
32 #define NDR_SPOOLSS_PUSH_ENUM_IN(fn) do { \
33 if (!r->in.buffer && r->in.offered != 0) {\
34 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
35 "SPOOLSS Buffer: r->in.offered[%u] but there's no buffer",\
36 (unsigned)r->in.offered);\
37 } else if (r->in.buffer && r->in.buffer->length != r->in.offered) {\
38 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
39 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of r->in.buffer[%u]",\
40 (unsigned)r->in.offered, (unsigned)r->in.buffer->length);\
41 }\
42 _r.in.level = r->in.level;\
43 _r.in.buffer = r->in.buffer;\
44 _r.in.offered = r->in.offered;\
45 NDR_CHECK(ndr_push__##fn(ndr, flags, &_r));\
46 } while(0)
47
48 #define NDR_SPOOLSS_PUSH_ENUM_OUT(fn) do { \
49 struct ndr_push *_ndr_info;\
50 _r.in.level = r->in.level;\
51 _r.in.buffer = r->in.buffer;\
52 _r.in.offered = r->in.offered;\
53 _r.out.info = NULL;\
54 _r.out.needed = r->out.needed;\
55 _r.out.count = r->out.count;\
56 _r.out.result = r->out.result;\
57 if (r->out.info && *r->out.info && !r->in.buffer) {\
58 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
59 "SPOOLSS Buffer: *r->out.info but there's no r->in.buffer");\
60 }\
61 if (r->in.buffer) {\
62 DATA_BLOB _data_blob_info;\
63 _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);\
64 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);\
65 _ndr_info->flags= ndr->flags;\
66 if (r->out.info) {\
67 struct ndr_push *_subndr_info;\
68 struct __##fn __r;\
69 __r.in.level = r->in.level;\
70 __r.in.count = *r->out.count;\
71 __r.out.info = *r->out.info;\
72 NDR_CHECK(ndr_push_subcontext_start(_ndr_info, &_subndr_info, 0, r->in.offered));\
73 NDR_CHECK(ndr_push___##fn(_subndr_info, flags, &__r)); \
74 NDR_CHECK(ndr_push_subcontext_end(_ndr_info, _subndr_info, 0, r->in.offered));\
75 }\
76 if (r->in.offered > _ndr_info->offset) {\
77 uint32_t _padding_len = r->in.offered - _ndr_info->offset;\
78 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));\
79 } else if (r->in.offered < _ndr_info->offset) {\
80 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
81 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of out buffer[%u]!",\
82 (unsigned)r->in.offered, (unsigned)_ndr_info->offset);\
83 }\
84 _data_blob_info = ndr_push_blob(_ndr_info);\
85 _r.out.info = &_data_blob_info;\
86 }\
87 NDR_CHECK(ndr_push__##fn(ndr, flags, &_r));\
88 } while(0)
89
90 #define NDR_SPOOLSS_PUSH_ENUM(fn,in,out) do { \
91 struct _##fn _r;\
92 if (flags & NDR_IN) {\
93 in;\
94 NDR_SPOOLSS_PUSH_ENUM_IN(fn);\
95 }\
96 if (flags & NDR_OUT) {\
97 out;\
98 NDR_SPOOLSS_PUSH_ENUM_OUT(fn);\
99 }\
100 } while(0)
101
102 #define NDR_SPOOLSS_PULL_ENUM_IN(fn) do { \
103 ZERO_STRUCT(r->out);\
104 NDR_CHECK(ndr_pull__##fn(ndr, flags, &_r));\
105 r->in.level = _r.in.level;\
106 r->in.buffer = _r.in.buffer;\
107 r->in.offered = _r.in.offered;\
108 r->out.needed = _r.out.needed;\
109 r->out.count = _r.out.count;\
110 if (!r->in.buffer && r->in.offered != 0) {\
111 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,\
112 "SPOOLSS Buffer: r->in.offered[%u] but there's no buffer",\
113 (unsigned)r->in.offered);\
114 } else if (r->in.buffer && r->in.buffer->length != r->in.offered) {\
115 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,\
116 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of r->in.buffer[%u]",\
117 (unsigned)r->in.offered, (unsigned)r->in.buffer->length);\
118 }\
119 NDR_PULL_ALLOC(ndr, r->out.info);\
120 ZERO_STRUCTP(r->out.info);\
121 } while(0)
122
123 #define NDR_SPOOLSS_PULL_ENUM_OUT(fn) do { \
124 _r.in.level = r->in.level;\
125 _r.in.buffer = r->in.buffer;\
126 _r.in.offered = r->in.offered;\
127 _r.out.needed = r->out.needed;\
128 _r.out.count = r->out.count;\
129 NDR_CHECK(ndr_pull__##fn(ndr, flags, &_r));\
130 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\
131 NDR_PULL_ALLOC(ndr, r->out.info);\
132 }\
133 *r->out.info = NULL;\
134 r->out.needed = _r.out.needed;\
135 r->out.count = _r.out.count;\
136 r->out.result = _r.out.result;\
137 if (_r.out.info) {\
138 struct ndr_pull *_ndr_info;\
139 NDR_PULL_ALLOC(ndr, *r->out.info);\
140 _ndr_info = ndr_pull_init_blob(_r.out.info, *r->out.info, ndr->iconv_convenience);\
141 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);\
142 _ndr_info->flags= ndr->flags;\
143 if (r->in.offered != _ndr_info->data_size) {\
144 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,\
145 "SPOOLSS Buffer: offered[%u] doesn't match length of buffer[%u]",\
146 (unsigned)r->in.offered, (unsigned)_ndr_info->data_size);\
147 }\
148 if (*r->out.needed <= _ndr_info->data_size) {\
149 struct __##fn __r;\
150 __r.in.level = r->in.level;\
151 __r.in.count = *r->out.count;\
152 __r.out.info = NULL;\
153 NDR_CHECK(ndr_pull___##fn(_ndr_info, flags, &__r));\
154 *r->out.info = __r.out.info;\
155 }\
156 }\
157 } while(0)
158
159 #define NDR_SPOOLSS_PULL_ENUM(fn,in,out) do { \
160 struct _##fn _r;\
161 if (flags & NDR_IN) {\
162 out;\
163 NDR_SPOOLSS_PULL_ENUM_IN(fn);\
164 in;\
165 }\
166 if (flags & NDR_OUT) {\
167 out;\
168 NDR_SPOOLSS_PULL_ENUM_OUT(fn);\
169 }\
170 } while(0)
171
172 #define _NDR_CHECK_UINT32(call) do {\
173 enum ndr_err_code _ndr_err; \
174 _ndr_err = call; \
175 if (!NDR_ERR_CODE_IS_SUCCESS(_ndr_err)) { \
176 return 0; \
177 }\
178 } while (0)
179
180 /* TODO: set _ndr_info->flags correct */
181 #define NDR_SPOOLSS_SIZE_ENUM_LEVEL(fn) do { \
182 struct __##fn __r;\
183 DATA_BLOB _data_blob_info;\
184 struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx, iconv_convenience);\
185 if (!_ndr_info) return 0;\
186 _ndr_info->flags|=LIBNDR_FLAG_NO_NDR_SIZE;\
187 __r.in.level = level;\
188 __r.in.count = count;\
189 __r.out.info = info;\
190 _NDR_CHECK_UINT32(ndr_push___##fn(_ndr_info, NDR_OUT, &__r)); \
191 _data_blob_info = ndr_push_blob(_ndr_info);\
192 return _data_blob_info.length;\
193 } while(0)
194
195 /* TODO: set _ndr_info->flags correct */
196 #define NDR_SPOOLSS_SIZE_ENUM(fn) do { \
197 struct __##fn __r;\
198 DATA_BLOB _data_blob_info;\
199 struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx, iconv_convenience);\
200 if (!_ndr_info) return 0;\
201 _ndr_info->flags|=LIBNDR_FLAG_NO_NDR_SIZE;\
202 __r.in.count = count;\
203 __r.out.info = info;\
204 _NDR_CHECK_UINT32(ndr_push___##fn(_ndr_info, NDR_OUT, &__r)); \
205 _data_blob_info = ndr_push_blob(_ndr_info);\
206 return _data_blob_info.length;\
207 } while(0)
208
209
210 /*
211 spoolss_EnumPrinters
212 */
213 enum ndr_err_code ndr_push_spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinters *r)
214 {
215 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinters,{
216 _r.in.flags = r->in.flags;
217 _r.in.server = r->in.server;
218 },{
219 _r.in.flags = r->in.flags;
220 _r.in.server = r->in.server;
221 });
222 return NDR_ERR_SUCCESS;
223 }
224
225 enum ndr_err_code ndr_pull_spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinters *r)
226 {
227 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinters,{
228 r->in.flags = _r.in.flags;
229 r->in.server = _r.in.server;
230 },{
231 _r.in.flags = r->in.flags;
232 _r.in.server = r->in.server;
233 });
234 return NDR_ERR_SUCCESS;
235 }
236
237 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)
238 {
239 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrinters);
240 }
241
242 /*
243 spoolss_EnumJobs
244 */
245 enum ndr_err_code ndr_push_spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct spoolss_EnumJobs *r)
246 {
247 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumJobs,{
248 _r.in.handle = r->in.handle;
249 _r.in.firstjob = r->in.firstjob;
250 _r.in.numjobs = r->in.numjobs;
251 },{
252 _r.in.handle = r->in.handle;
253 _r.in.firstjob = r->in.firstjob;
254 _r.in.numjobs = r->in.numjobs;
255 });
256 return NDR_ERR_SUCCESS;
257 }
258
259 enum ndr_err_code ndr_pull_spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct spoolss_EnumJobs *r)
260 {
261 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumJobs,{
262 r->in.handle = _r.in.handle;
263 r->in.firstjob = _r.in.firstjob;
264 r->in.numjobs = _r.in.numjobs;
265 },{
266 _r.in.handle = r->in.handle;
267 _r.in.firstjob = r->in.firstjob;
268 _r.in.numjobs = r->in.numjobs;
269 });
270 return NDR_ERR_SUCCESS;
271 }
272
273 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)
274 {
275 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumJobs);
276 }
277
278 /*
279 spoolss_EnumPrinterDrivers
280 */
281 enum ndr_err_code ndr_push_spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDrivers *r)
282 {
283 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinterDrivers,{
284 _r.in.server = r->in.server;
285 _r.in.environment = r->in.environment;
286 },{
287 _r.in.server = r->in.server;
288 _r.in.environment = r->in.environment;
289 });
290 return NDR_ERR_SUCCESS;
291 }
292
293 enum ndr_err_code ndr_pull_spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDrivers *r)
294 {
295 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinterDrivers,{
296 r->in.server = _r.in.server;
297 r->in.environment = _r.in.environment;
298 },{
299 _r.in.server = r->in.server;
300 _r.in.environment = r->in.environment;
301 });
302 return NDR_ERR_SUCCESS;
303 }
304
305 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)
306 {
307 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers);
308 }
309
310 /*
311 spoolss_EnumForms
312 */
313 enum ndr_err_code ndr_push_spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct spoolss_EnumForms *r)
314 {
315 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumForms,{
316 _r.in.handle = r->in.handle;
317 },{
318 _r.in.handle = r->in.handle;
319 });
320 return NDR_ERR_SUCCESS;
321 }
322
323 enum ndr_err_code ndr_pull_spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct spoolss_EnumForms *r)
324 {
325 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumForms,{
326 r->in.handle = _r.in.handle;
327 },{
328 _r.in.handle = r->in.handle;
329 });
330 return NDR_ERR_SUCCESS;
331 }
332
333 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)
334 {
335 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumForms);
336 }
337
338 /*
339 spoolss_EnumPorts
340 */
341 enum ndr_err_code ndr_push_spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct spoolss_EnumPorts *r)
342 {
343 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPorts,{
344 _r.in.servername= r->in.servername;
345 },{
346 _r.in.servername= r->in.servername;
347 });
348 return NDR_ERR_SUCCESS;
349 }
350
351 enum ndr_err_code ndr_pull_spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct spoolss_EnumPorts *r)
352 {
353 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPorts,{
354 r->in.servername= _r.in.servername;
355 },{
356 _r.in.servername= r->in.servername;
357 });
358 return NDR_ERR_SUCCESS;
359 }
360
361 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)
362 {
363 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPorts);
364 }
365
366 /*
367 spoolss_EnumMonitors
368 */
369 enum ndr_err_code ndr_push_spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct spoolss_EnumMonitors *r)
370 {
371 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumMonitors,{
372 _r.in.servername= r->in.servername;
373 },{
374 _r.in.servername= r->in.servername;
375 });
376 return NDR_ERR_SUCCESS;
377 }
378
379 enum ndr_err_code ndr_pull_spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct spoolss_EnumMonitors *r)
380 {
381 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumMonitors,{
382 r->in.servername= _r.in.servername;
383 },{
384 _r.in.servername= r->in.servername;
385 });
386 return NDR_ERR_SUCCESS;
387 }
388
389 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)
390 {
391 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumMonitors);
392 }
393
394 /*
395 spoolss_EnumPrintProcessors
396 */
397 enum ndr_err_code ndr_push_spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcessors *r)
398 {
399 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrintProcessors,{
400 _r.in.servername = r->in.servername;
401 _r.in.environment = r->in.environment;
402 },{
403 _r.in.servername = r->in.servername;
404 _r.in.environment = r->in.environment;
405 });
406 return NDR_ERR_SUCCESS;
407 }
408
409 enum ndr_err_code ndr_pull_spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcessors *r)
410 {
411 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrintProcessors,{
412 r->in.servername = _r.in.servername;
413 r->in.environment = _r.in.environment;
414 },{
415 _r.in.servername = r->in.servername;
416 _r.in.environment = r->in.environment;
417 });
418 return NDR_ERR_SUCCESS;
419 }
420
421 uint32_t ndr_size_spoolss_EnumPrintProcessors_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
422 uint32_t level, uint32_t count, union spoolss_PrintProcessorInfo *info)
423 {
424 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcessors);
425 }
426
427 /*
428 spoolss_EnumPrintProcessors
429 */
430 enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
431 {
432 NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrintProcDataTypes,{
433 _r.in.servername = r->in.servername;
434 _r.in.print_processor_name = r->in.print_processor_name;
435 },{
436 _r.in.servername = r->in.servername;
437 _r.in.print_processor_name = r->in.print_processor_name;
438 });
439 return NDR_ERR_SUCCESS;
440 }
441
442 enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
443 {
444 NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrintProcDataTypes,{
445 r->in.servername = _r.in.servername;
446 r->in.print_processor_name = _r.in.print_processor_name;
447 },{
448 _r.in.servername = r->in.servername;
449 _r.in.print_processor_name = r->in.print_processor_name;
450 });
451 return NDR_ERR_SUCCESS;
452 }
453
454 uint32_t ndr_size_spoolss_EnumPrintProcDataTypes_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
455 uint32_t level, uint32_t count, union spoolss_PrintProcDataTypesInfo *info)
456 {
457 NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcDataTypes);
458 }
459
460 /*
461 spoolss_EnumPrinterDataEx
462 */
463
464 enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
465 {
466 struct _spoolss_EnumPrinterDataEx _r;
467 if (flags & NDR_IN) {
468 _r.in.handle = r->in.handle;
469 _r.in.key_name = r->in.key_name;
470 _r.in.offered = r->in.offered;
471 NDR_CHECK(ndr_push__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
472 }
473 if (flags & NDR_OUT) {
474 struct ndr_push *_ndr_info;
475 _r.in.handle = r->in.handle;
476 _r.in.key_name = r->in.key_name;
477 _r.in.offered = r->in.offered;
478 _r.out.count = r->out.count;
479 _r.out.needed = r->out.needed;
480 _r.out.result = r->out.result;
481 _r.out.info = data_blob(NULL, 0);
482 if (r->in.offered >= *r->out.needed) {
483 struct __spoolss_EnumPrinterDataEx __r;
484 _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
485 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
486 _ndr_info->flags= ndr->flags;
487 __r.in.count = *r->out.count;
488 __r.out.info = *r->out.info;
489 NDR_CHECK(ndr_push___spoolss_EnumPrinterDataEx(_ndr_info, flags, &__r));
490 if (r->in.offered > _ndr_info->offset) {
491 uint32_t _padding_len = r->in.offered - _ndr_info->offset;
492 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));
493 }
494 _r.out.info = ndr_push_blob(_ndr_info);
495 }
496 NDR_CHECK(ndr_push__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
497 }
498 return NDR_ERR_SUCCESS;
499 }
500
501 enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
502 {
503 struct _spoolss_EnumPrinterDataEx _r;
504 if (flags & NDR_IN) {
505 _r.in.handle = r->in.handle;
506 _r.in.key_name = r->in.key_name;
507 ZERO_STRUCT(r->out);
508 NDR_CHECK(ndr_pull__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
509 r->in.handle = _r.in.handle;
510 r->in.key_name = _r.in.key_name;
511 r->in.offered = _r.in.offered;
512 r->out.needed = _r.out.needed;
513 r->out.count = _r.out.count;
514 NDR_PULL_ALLOC(ndr, r->out.info);
515 ZERO_STRUCTP(r->out.info);
516 }
517 if (flags & NDR_OUT) {
518 _r.in.handle = r->in.handle;
519 _r.in.key_name = r->in.key_name;
520 _r.in.offered = r->in.offered;
521 _r.out.count = r->out.count;
522 _r.out.needed = r->out.needed;
523 NDR_CHECK(ndr_pull__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
524 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
525 NDR_PULL_ALLOC(ndr, r->out.info);
526 }
527 *r->out.info = NULL;
528 r->out.needed = _r.out.needed;
529 r->out.count = _r.out.count;
530 r->out.result = _r.out.result;
531 if (_r.out.info.length) {
532 struct ndr_pull *_ndr_info;
533 NDR_PULL_ALLOC(ndr, *r->out.info);
534 _ndr_info = ndr_pull_init_blob(&_r.out.info, *r->out.info, ndr->iconv_convenience);
535 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
536 _ndr_info->flags= ndr->flags;
537 if (r->in.offered != _ndr_info->data_size) {
538 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
539 "SPOOLSS Buffer: offered[%u] doesn't match length of buffer[%u]",
540 (unsigned)r->in.offered, (unsigned)_ndr_info->data_size);
541 }
542 if (*r->out.needed <= _ndr_info->data_size) {
543 struct __spoolss_EnumPrinterDataEx __r;
544 __r.in.count = *r->out.count;
545 __r.out.info = NULL;
546 NDR_CHECK(ndr_pull___spoolss_EnumPrinterDataEx(_ndr_info, flags, &__r));
547 *r->out.info = __r.out.info;
548 }
549 }
550 }
551 return NDR_ERR_SUCCESS;
552 }
553
554 uint32_t ndr_size_spoolss_EnumPrinterDataEx_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
555 uint32_t count, struct spoolss_PrinterEnumValues *info)
556 {
557 NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrinterDataEx);
558 }
559
560 /*
561 spoolss_GetPrinterData
562 */
563 enum ndr_err_code ndr_push_spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterData *r)
564 {
565 struct _spoolss_GetPrinterData _r;
566 if (flags & NDR_IN) {
567 _r.in.handle = r->in.handle;
568 _r.in.value_name= r->in.value_name;
569 _r.in.offered = r->in.offered;
570 NDR_CHECK(ndr_push__spoolss_GetPrinterData(ndr, flags, &_r));
571 }
572 if (flags & NDR_OUT) {
573 struct ndr_push *_ndr_info;
574 DATA_BLOB blob = data_blob(NULL, 0);
575 _r.in.handle = r->in.handle;
576 _r.in.value_name= r->in.value_name;
577 _r.in.offered = r->in.offered;
578 _r.out.type = r->out.type;
579 _r.out.data = &blob;
580 _r.out.needed = r->out.needed;
581 _r.out.result = r->out.result;
582 {
583 struct __spoolss_GetPrinterData __r;
584 DATA_BLOB _blob;
585 _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
586 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
587 _ndr_info->flags= ndr->flags;
588 __r.in.type = *r->out.type;
589 __r.out.data = r->out.data;
590 NDR_CHECK(ndr_push___spoolss_GetPrinterData(_ndr_info, flags, &__r));
591 if (r->in.offered > _ndr_info->offset) {
592 uint32_t _padding_len = r->in.offered - _ndr_info->offset;
593 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));
594 }
595 _blob = ndr_push_blob(_ndr_info);
596 _r.out.data = &_blob;
597 }
598 NDR_CHECK(ndr_push__spoolss_GetPrinterData(ndr, flags, &_r));
599 }
600 return NDR_ERR_SUCCESS;
601 }
602
603 enum ndr_err_code ndr_pull_spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterData *r)
604 {
605 struct _spoolss_GetPrinterData _r;
606 if (flags & NDR_IN) {
607 DATA_BLOB blob = data_blob(NULL,0);
608 ZERO_STRUCT(r->out);
609
610 _r.in.handle = r->in.handle;
611 _r.in.value_name= r->in.value_name;
612 _r.in.offered = r->in.offered;
613 _r.out.type = r->out.type;
614 _r.out.data = &blob;
615 _r.out.needed = r->out.needed;
616 NDR_CHECK(ndr_pull__spoolss_GetPrinterData(ndr, flags, &_r));
617 r->in.handle = _r.in.handle;
618 r->in.value_name= _r.in.value_name;
619 r->in.offered = _r.in.offered;
620 r->out.needed = _r.out.needed;
621 }
622 if (flags & NDR_OUT) {
623 DATA_BLOB blob = data_blob_talloc(ndr,NULL,0);
624 _r.in.handle = r->in.handle;
625 _r.in.value_name= r->in.value_name;
626 _r.in.offered = r->in.offered;
627 _r.out.type = r->out.type;
628 _r.out.data = &blob;
629 _r.out.needed = r->out.needed;
630 _r.out.result = r->out.result;
631 NDR_CHECK(ndr_pull__spoolss_GetPrinterData(ndr, flags, &_r));
632 r->out.type = _r.out.type;
633 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
634 NDR_PULL_ALLOC(ndr, r->out.data);
635 }
636 ZERO_STRUCTP(r->out.data);
637 r->out.needed = _r.out.needed;
638 r->out.result = _r.out.result;
639 if (_r.out.data && _r.out.data->length != r->in.offered) {
640 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
641 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of out buffer[%u]",
642 (unsigned)r->in.offered, (unsigned)_r.out.data->length);
643 }
644 if (_r.out.data && _r.out.data->length > 0 && *r->out.needed <= _r.out.data->length) {
645 struct __spoolss_GetPrinterData __r;
646 struct ndr_pull *_ndr_data = ndr_pull_init_blob(_r.out.data, ndr, ndr->iconv_convenience);
647 NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
648 _ndr_data->flags= ndr->flags;
649 __r.in.type = *r->out.type;
650 __r.out.data = r->out.data;
651 NDR_CHECK(ndr_pull___spoolss_GetPrinterData(_ndr_data, flags, &__r));
652 r->out.data = __r.out.data;
653 } else {
654 *r->out.type = REG_NONE;
655 }
656 }
657 return NDR_ERR_SUCCESS;
658 }
659
660 /*
661 spoolss_SetPrinterData
662 */
663 enum ndr_err_code ndr_push_spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterData *r)
664 {
665 struct _spoolss_SetPrinterData _r;
666 if (flags & NDR_IN) {
667 struct ndr_push *_ndr_data;
668 struct __spoolss_SetPrinterData __r;
669 DATA_BLOB _data_blob_data;
670
671 _ndr_data = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
672 NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
673 _ndr_data->flags= ndr->flags;
674
675 __r.in.type = r->in.type;
676 __r.out.data = discard_const_p(union spoolss_PrinterData, &r->in.data);
677 NDR_CHECK(ndr_push___spoolss_SetPrinterData(_ndr_data, NDR_OUT, &__r));
678 _data_blob_data = ndr_push_blob(_ndr_data);
679
680 _r.in.handle = r->in.handle;
681 _r.in.value_name= r->in.value_name;
682 _r.in.type = r->in.type;
683 _r.in.data = _data_blob_data;
684 _r.in._offered = _data_blob_data.length;
685 _r.out.result = r->out.result;
686 NDR_CHECK(ndr_push__spoolss_SetPrinterData(ndr, flags, &_r));
687 }
688 if (flags & NDR_OUT) {
689 _r.in.handle = r->in.handle;
690 _r.in.value_name= r->in.value_name;
691 _r.in.type = r->in.type;
692 _r.in.data = data_blob(NULL,0),
693 _r.in._offered = r->in._offered;
694 _r.out.result = r->out.result;
695 NDR_CHECK(ndr_push__spoolss_SetPrinterData(ndr, flags, &_r));
696 }
697 return NDR_ERR_SUCCESS;
698 }
699
700 /*
701 spoolss_GetPrinterDataEx
702 */
703 enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
704 {
705 struct _spoolss_GetPrinterDataEx _r;
706 if (flags & NDR_IN) {
707 _r.in.handle = r->in.handle;
708 _r.in.key_name = r->in.key_name;
709 _r.in.value_name= r->in.value_name;
710 _r.in.offered = r->in.offered;
711 NDR_CHECK(ndr_push__spoolss_GetPrinterDataEx(ndr, flags, &_r));
712 }
713 if (flags & NDR_OUT) {
714 struct ndr_push *_ndr_info;
715 DATA_BLOB blob = data_blob(NULL, 0);
716 _r.in.handle = r->in.handle;
717 _r.in.key_name = r->in.key_name;
718 _r.in.value_name= r->in.value_name;
719 _r.in.offered = r->in.offered;
720 _r.out.type = r->out.type;
721 _r.out.data = &blob;
722 _r.out.needed = r->out.needed;
723 _r.out.result = r->out.result;
724 {
725 struct __spoolss_GetPrinterDataEx __r;
726 DATA_BLOB _blob;
727 _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
728 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
729 _ndr_info->flags= ndr->flags;
730 __r.in.type = *r->out.type;
731 __r.out.data = r->out.data;
732 NDR_CHECK(ndr_push___spoolss_GetPrinterDataEx(_ndr_info, flags, &__r));
733 if (r->in.offered > _ndr_info->offset) {
734 uint32_t _padding_len = r->in.offered - _ndr_info->offset;
735 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));
736 }
737 _blob = ndr_push_blob(_ndr_info);
738 _r.out.data = &_blob;
739 }
740 NDR_CHECK(ndr_push__spoolss_GetPrinterDataEx(ndr, flags, &_r));
741 }
742 return NDR_ERR_SUCCESS;
743 }
744
745 enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
746 {
747 struct _spoolss_GetPrinterDataEx _r;
748 if (flags & NDR_IN) {
749 DATA_BLOB blob = data_blob(NULL,0);
750 ZERO_STRUCT(r->out);
751
752 _r.in.handle = r->in.handle;
753 _r.in.key_name = r->in.key_name;
754 _r.in.value_name= r->in.value_name;
755 _r.in.offered = r->in.offered;
756 _r.out.type = r->out.type;
757 _r.out.data = &blob;
758 _r.out.needed = r->out.needed;
759 NDR_CHECK(ndr_pull__spoolss_GetPrinterDataEx(ndr, flags, &_r));
760 r->in.handle = _r.in.handle;
761 r->in.key_name = _r.in.key_name;
762 r->in.value_name= _r.in.value_name;
763 r->in.offered = _r.in.offered;
764 r->out.needed = _r.out.needed;
765 }
766 if (flags & NDR_OUT) {
767 DATA_BLOB blob = data_blob_talloc(ndr,NULL,0);
768 _r.in.handle = r->in.handle;
769 _r.in.key_name = r->in.key_name;
770 _r.in.value_name= r->in.value_name;
771 _r.in.offered = r->in.offered;
772 _r.out.type = r->out.type;
773 _r.out.data = &blob;
774 _r.out.needed = r->out.needed;
775 _r.out.result = r->out.result;
776 NDR_CHECK(ndr_pull__spoolss_GetPrinterDataEx(ndr, flags, &_r));
777 r->out.type = _r.out.type;
778 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
779 NDR_PULL_ALLOC(ndr, r->out.data);
780 }
781 ZERO_STRUCTP(r->out.data);
782 r->out.needed = _r.out.needed;
783 r->out.result = _r.out.result;
784 if (_r.out.data && _r.out.data->length != r->in.offered) {
785 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
786 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of out buffer[%u]",
787 (unsigned)r->in.offered, (unsigned)_r.out.data->length);
788 }
789 if (_r.out.data && _r.out.data->length > 0 && *r->out.needed <= _r.out.data->length) {
790 struct __spoolss_GetPrinterDataEx __r;
791 struct ndr_pull *_ndr_data = ndr_pull_init_blob(_r.out.data, ndr, ndr->iconv_convenience);
792 NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
793 _ndr_data->flags= ndr->flags;
794 __r.in.type = *r->out.type;
795 __r.out.data = r->out.data;
796 NDR_CHECK(ndr_pull___spoolss_GetPrinterDataEx(_ndr_data, flags, &__r));
797 r->out.data = __r.out.data;
798 } else {
799 *r->out.type = REG_NONE;
800 }
801 }
802 return NDR_ERR_SUCCESS;
803 }
804
805 /*
806 spoolss_SetPrinterDataEx
807 */
808 enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
809 {
810 struct _spoolss_SetPrinterDataEx _r;
811 if (flags & NDR_IN) {
812 struct ndr_push *_ndr_data;
813 struct __spoolss_SetPrinterDataEx __r;
814 DATA_BLOB _data_blob_data;
815
816 _ndr_data = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
817 NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
818 _ndr_data->flags= ndr->flags;
819
820 __r.in.type = r->in.type;
821 __r.out.data = discard_const_p(union spoolss_PrinterData, &r->in.data);
822 NDR_CHECK(ndr_push___spoolss_SetPrinterDataEx(_ndr_data, NDR_OUT, &__r));
823 _data_blob_data = ndr_push_blob(_ndr_data);
824
825 _r.in.handle = r->in.handle;
826 _r.in.key_name = r->in.key_name;
827 _r.in.value_name= r->in.value_name;
828 _r.in.type = r->in.type;
829 _r.in.data = _data_blob_data;
830 _r.in._offered = _data_blob_data.length;
831 _r.out.result = r->out.result;
832 NDR_CHECK(ndr_push__spoolss_SetPrinterDataEx(ndr, flags, &_r));
833 }
834 if (flags & NDR_OUT) {
835 _r.in.handle = r->in.handle;
836 _r.in.key_name = r->in.key_name;
837 _r.in.value_name= r->in.value_name;
838 _r.in.type = r->in.type;
839 _r.in.data = data_blob(NULL,0),
840 _r.in._offered = r->in._offered;
841 _r.out.result = r->out.result;
842 NDR_CHECK(ndr_push__spoolss_SetPrinterDataEx(ndr, flags, &_r));
843 }
844 return NDR_ERR_SUCCESS;
845 }
846
847 uint32_t _ndr_size_spoolss_DeviceMode(struct spoolss_DeviceMode *devmode, struct smb_iconv_convenience *ic, uint32_t flags)
848 {
849 if (!devmode) return 0;
850 return ndr_size_spoolss_DeviceMode(devmode,ic,flags);
851 }
852
853 _PUBLIC_ size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, struct smb_iconv_convenience *ic, int flags)
854 {
855 if (!r) {
856 return 4;
857 }
858
859 return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_StringArray, ic);
860 }
861
862 /* hand marshall as pidl cannot (yet) generate a relative pointer to a fixed array of
863 * structs */
864
865 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo101(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo101 *r)
866 {
867 uint32_t cntr_file_info_1;
868 if (ndr_flags & NDR_SCALARS) {
869 NDR_CHECK(ndr_push_align(ndr, 8));
870 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
871 {
872 uint32_t _flags_save_string = ndr->flags;
873 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
874 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
875 ndr->flags = _flags_save_string;
876 }
877 {
878 uint32_t _flags_save_string = ndr->flags;
879 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
880 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
881 ndr->flags = _flags_save_string;
882 }
883 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_info));
884 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_count));
885 {
886 uint32_t _flags_save_string = ndr->flags;
887 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
888 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
889 ndr->flags = _flags_save_string;
890 }
891 {
892 uint32_t _flags_save_string = ndr->flags;
893 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
894 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
895 ndr->flags = _flags_save_string;
896 }
897 {
898 uint32_t _flags_save_string_array = ndr->flags;
899 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
900 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
901 ndr->flags = _flags_save_string_array;
902 }
903 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
904 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
905 {
906 uint32_t _flags_save_string = ndr->flags;
907 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
908 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
909 ndr->flags = _flags_save_string;
910 }
911 {
912 uint32_t _flags_save_string = ndr->flags;
913 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
914 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
915 ndr->flags = _flags_save_string;
916 }
917 {
918 uint32_t _flags_save_string = ndr->flags;
919 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
920 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
921 ndr->flags = _flags_save_string;
922 }
923 {
924 uint32_t _flags_save_string = ndr->flags;
925 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
926 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
927 ndr->flags = _flags_save_string;
928 }
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_uint32(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 }
1184 if (ndr_flags & NDR_BUFFERS) {
1185 {
1186 uint32_t _flags_save_string = ndr->flags;
1187 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1188 if (r->driver_name) {
1189 uint32_t _relative_save_offset;
1190 _relative_save_offset = ndr->offset;
1191 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
1192 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1193 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
1194 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
1195 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
1196 ndr->offset = _relative_save_offset;
1197 }
1198 ndr->flags = _flags_save_string;
1199 }
1200 {
1201 uint32_t _flags_save_string = ndr->flags;
1202 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1203 if (r->architecture) {
1204 uint32_t _relative_save_offset;
1205 _relative_save_offset = ndr->offset;
1206 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
1207 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
1208 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
1209 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
1210 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
1211 ndr->offset = _relative_save_offset;
1212 }
1213 ndr->flags = _flags_save_string;
1214 }
1215 if (r->file_info) {
1216 uint32_t _relative_save_offset;
1217 _relative_save_offset = ndr->offset;
1218 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_info));
1219 _mem_save_file_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1220 NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1221 #if 0
1222 NDR_CHECK(ndr_pull_array_size(ndr, &r->file_info));
1223 #else
1224 NDR_CHECK(ndr_token_store(ndr, &ndr->array_size_list, &r->file_info, r->file_count));
1225 #endif
1226 NDR_PULL_ALLOC_N(ndr, r->file_info, ndr_get_array_size(ndr, &r->file_info));
1227 _mem_save_file_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
1228 NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1229 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1230 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
1231 }
1232 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1233 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
1234 }
1235 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_1, 0);
1236 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_0, 0);
1237 ndr->offset = _relative_save_offset;
1238 }
1239 {
1240 uint32_t _flags_save_string = ndr->flags;
1241 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1242 if (r->monitor_name) {
1243 uint32_t _relative_save_offset;
1244 _relative_save_offset = ndr->offset;
1245 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
1246 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1247 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
1248 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
1249 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
1250 ndr->offset = _relative_save_offset;
1251 }
1252 ndr->flags = _flags_save_string;
1253 }
1254 {
1255 uint32_t _flags_save_string = ndr->flags;
1256 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1257 if (r->default_datatype) {
1258 uint32_t _relative_save_offset;
1259 _relative_save_offset = ndr->offset;
1260 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
1261 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1262 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
1263 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
1264 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
1265 ndr->offset = _relative_save_offset;
1266 }
1267 ndr->flags = _flags_save_string;
1268 }
1269 {
1270 uint32_t _flags_save_string_array = ndr->flags;
1271 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1272 if (r->previous_names) {
1273 uint32_t _relative_save_offset;
1274 _relative_save_offset = ndr->offset;
1275 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
1276 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
1277 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
1278 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
1279 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
1280 ndr->offset = _relative_save_offset;
1281 }
1282 ndr->flags = _flags_save_string_array;
1283 }
1284 {
1285 uint32_t _flags_save_string = ndr->flags;
1286 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1287 if (r->manufacturer_name) {
1288 uint32_t _relative_save_offset;
1289 _relative_save_offset = ndr->offset;
1290 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
1291 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1292 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
1293 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
1294 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
1295 ndr->offset = _relative_save_offset;
1296 }
1297 ndr->flags = _flags_save_string;
1298 }
1299 {
1300 uint32_t _flags_save_string = ndr->flags;
1301 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1302 if (r->manufacturer_url) {
1303 uint32_t _relative_save_offset;
1304 _relative_save_offset = ndr->offset;
1305 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
1306 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
1307 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
1308 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
1309 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
1310 ndr->offset = _relative_save_offset;
1311 }
1312 ndr->flags = _flags_save_string;
1313 }
1314 {
1315 uint32_t _flags_save_string = ndr->flags;
1316 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1317 if (r->hardware_id) {
1318 uint32_t _relative_save_offset;
1319 _relative_save_offset = ndr->offset;
1320 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
1321 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
1322 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
1323 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
1324 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
1325 ndr->offset = _relative_save_offset;
1326 }
1327 ndr->flags = _flags_save_string;
1328 }
1329 {
1330 uint32_t _flags_save_string = ndr->flags;
1331 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1332 if (r->provider) {
1333 uint32_t _relative_save_offset;
1334 _relative_save_offset = ndr->offset;
1335 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
1336 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
1337 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
1338 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
1339 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
1340 ndr->offset = _relative_save_offset;
1341 }
1342 ndr->flags = _flags_save_string;
1343 }
1344 if (r->file_info) {
1345 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->file_info, r->file_count));
1346 }
1347 }
1348 return NDR_ERR_SUCCESS;
1349 }
1350
1351 void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, const union spoolss_Field *r)
1352 {
1353 int level;
1354 level = ndr_print_get_switch_value(ndr, r);
1355 ndr_print_union(ndr, name, level, "spoolss_Field");
1356 switch (level) {
1357 case PRINTER_NOTIFY_TYPE:
1358 ndr_print_spoolss_PrintNotifyField(ndr, "field", r->field);
1359 break;
1360
1361 case JOB_NOTIFY_TYPE:
1362 ndr_print_spoolss_JobNotifyField(ndr, "field", r->field);
1363 break;
1364
1365 default:
1366 ndr_print_uint16(ndr, "field", r->field);
1367 break;
1368
1369 }
1370 }
1371
1372 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
1373 {
1374 if (!r) {
1375 return 0;
1376 }
1377 return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
1378 }
1379
1380 void ndr_print_spoolss_security_descriptor(struct ndr_print *ndr, const char *name, const struct security_descriptor *r)
1381 {
1382 ndr_print_security_descriptor(ndr, name, r);
1383 }
1384
1385 enum ndr_err_code ndr_pull_spoolss_security_descriptor(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor *r)
1386 {
1387 uint32_t _flags_save_STRUCT = ndr->flags;
1388 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NO_RELATIVE_REVERSE);
1389 NDR_CHECK(ndr_pull_security_descriptor(ndr, ndr_flags, r));
1390 ndr->flags = _flags_save_STRUCT;
1391 return NDR_ERR_SUCCESS;
1392 }
1393
1394 enum ndr_err_code ndr_push_spoolss_security_descriptor(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor *r)
1395 {
1396 {
1397 uint32_t _flags_save_STRUCT = ndr->flags;
1398 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN|LIBNDR_FLAG_NO_RELATIVE_REVERSE);
1399 if (ndr_flags & NDR_SCALARS) {
1400 NDR_CHECK(ndr_push_align(ndr, 5));
1401 NDR_CHECK(ndr_push_security_descriptor_revision(ndr, NDR_SCALARS, r->revision));
1402 NDR_CHECK(ndr_push_security_descriptor_type(ndr, NDR_SCALARS, r->type));
1403 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->owner_sid));
1404 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->group_sid));
1405 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sacl));
1406 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dacl));
1407 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1408 }
1409 if (ndr_flags & NDR_BUFFERS) {
1410 if (r->sacl) {
1411 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sacl));
1412 NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->sacl));
1413 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sacl));
1414 }
1415 if (r->dacl) {
1416 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dacl));
1417 NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->dacl));
1418 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dacl));
1419 }
1420 if (r->owner_sid) {
1421 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->owner_sid));
1422 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->owner_sid));
1423 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->owner_sid));
1424 }
1425 if (r->group_sid) {
1426 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->group_sid));
1427 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->group_sid));
1428 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->group_sid));
1429 }
1430 }
1431 ndr->flags = _flags_save_STRUCT;
1432 }
1433 return NDR_ERR_SUCCESS;
1434 }
1435
1436 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
1437 {
1438 if (ndr_flags & NDR_SCALARS) {
1439 NDR_CHECK(ndr_push_align(ndr, 5));
1440 {
1441 uint32_t _flags_save_string = ndr->flags;
1442 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1443 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1444 ndr->flags = _flags_save_string;
1445 }
1446 {
1447 uint32_t _flags_save_string = ndr->flags;
1448 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1449 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1450 ndr->flags = _flags_save_string;
1451 }
1452 {
1453 uint32_t _flags_save_string = ndr->flags;
1454 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1455 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1456 ndr->flags = _flags_save_string;
1457 }
1458 {
1459 uint32_t _flags_save_string = ndr->flags;
1460 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1461 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1462 ndr->flags = _flags_save_string;
1463 }
1464 {
1465 uint32_t _flags_save_string = ndr->flags;
1466 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1467 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1468 ndr->flags = _flags_save_string;
1469 }
1470 {
1471 uint32_t _flags_save_string = ndr->flags;
1472 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1473 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1474 ndr->flags = _flags_save_string;
1475 }
1476 {
1477 uint32_t _flags_save_string = ndr->flags;
1478 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1479 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1480 ndr->flags = _flags_save_string;
1481 }
1482 {
1483 uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1484 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1485 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1486 ndr->flags = _flags_save_spoolss_DeviceMode;
1487 }
1488 {
1489 uint32_t _flags_save_string = ndr->flags;
1490 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1491 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1492 ndr->flags = _flags_save_string;
1493 }
1494 {
1495 uint32_t _flags_save_string = ndr->flags;
1496 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1497 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1498 ndr->flags = _flags_save_string;
1499 }
1500 {
1501 uint32_t _flags_save_string = ndr->flags;
1502 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1503 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1504 ndr->flags = _flags_save_string;
1505 }
1506 {
1507 uint32_t _flags_save_string = ndr->flags;
1508 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1509 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1510 ndr->flags = _flags_save_string;
1511 }
1512 {
1513 uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1514 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1515 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1516 ndr->flags = _flags_save_spoolss_security_descriptor;
1517 }
1518 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1519 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1520 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1521 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1522 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1523 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1524 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1525 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1526 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1527 }
1528 if (ndr_flags & NDR_BUFFERS) {
1529 {
1530 uint32_t _flags_save_string = ndr->flags;
1531 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1532 if (r->servername) {
1533 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
1534 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1535 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
1536 }
1537 ndr->flags = _flags_save_string;
1538 }
1539 {
1540 uint32_t _flags_save_string = ndr->flags;
1541 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1542 if (r->printername) {
1543 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
1544 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1545 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
1546 }
1547 ndr->flags = _flags_save_string;
1548 }
1549 {
1550 uint32_t _flags_save_string = ndr->flags;
1551 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1552 if (r->sharename) {
1553 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sharename));
1554 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1555 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sharename));
1556 }
1557 ndr->flags = _flags_save_string;
1558 }
1559 {
1560 uint32_t _flags_save_string = ndr->flags;
1561 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1562 if (r->portname) {
1563 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
1564 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1565 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
1566 }
1567 ndr->flags = _flags_save_string;
1568 }
1569 {
1570 uint32_t _flags_save_string = ndr->flags;
1571 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1572 if (r->drivername) {
1573 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->drivername));
1574 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1575 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->drivername));
1576 }
1577 ndr->flags = _flags_save_string;
1578 }
1579 {
1580 uint32_t _flags_save_string = ndr->flags;
1581 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1582 if (r->comment) {
1583 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
1584 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1585 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
1586 }
1587 ndr->flags = _flags_save_string;
1588 }
1589 {
1590 uint32_t _flags_save_string = ndr->flags;
1591 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1592 if (r->location) {
1593 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->location));
1594 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1595 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->location));
1596 }
1597 ndr->flags = _flags_save_string;
1598 }
1599 {
1600 uint32_t _flags_save_string = ndr->flags;
1601 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1602 if (r->sepfile) {
1603 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sepfile));
1604 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1605 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sepfile));
1606 }
1607 ndr->flags = _flags_save_string;
1608 }
1609 {
1610 uint32_t _flags_save_string = ndr->flags;
1611 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1612 if (r->printprocessor) {
1613 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printprocessor));
1614 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1615 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printprocessor));
1616 }
1617 ndr->flags = _flags_save_string;
1618 }
1619 {
1620 uint32_t _flags_save_string = ndr->flags;
1621 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1622 if (r->datatype) {
1623 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->datatype));
1624 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1625 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->datatype));
1626 }
1627 ndr->flags = _flags_save_string;
1628 }
1629 {
1630 uint32_t _flags_save_string = ndr->flags;
1631 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1632 if (r->parameters) {
1633 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
1634 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1635 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
1636 }
1637 ndr->flags = _flags_save_string;
1638 }
1639 {
1640 uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1641 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1642 if (r->devmode) {
1643 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
1644 {
1645 struct ndr_push *_ndr_devmode;
1646 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1647 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1648 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1649 }
1650 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
1651 }
1652 ndr->flags = _flags_save_spoolss_DeviceMode;
1653 }
1654 {
1655 uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1656 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1657 if (r->secdesc) {
1658 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
1659 {
1660 struct ndr_push *_ndr_secdesc;
1661 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1662 NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1663 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1664 }
1665 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
1666 }
1667 ndr->flags = _flags_save_spoolss_security_descriptor;
1668 }
1669 }
1670 return NDR_ERR_SUCCESS;
1671 }
Samba GIT mirror