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