source: branches/samba-3.5.x/librpc/ndr/ndr_spoolss_buf.c

Last change on this file was 596, checked in by Herwig Bauernfeind, 14 years ago

Samba 3.5: Update trunk to 3.5.8
File size: 50.1 KB
Line 
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*/
213enum 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
225enum 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
237uint32_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*/
245enum 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
259enum 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
273uint32_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*/
281enum 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
293enum 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
305uint32_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*/
313enum 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
323enum 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
333uint32_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*/
341enum 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
351enum 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
361uint32_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*/
369enum 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
379enum 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
389uint32_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*/
397enum 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
409enum 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
421uint32_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*/
430enum 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
442enum 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
454uint32_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
464enum 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
501enum 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
554uint32_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
560uint32_t _ndr_size_spoolss_DeviceMode(struct spoolss_DeviceMode *devmode, struct smb_iconv_convenience *ic, uint32_t flags)
561{
562 if (!devmode) return 0;
563 return ndr_size_spoolss_DeviceMode(devmode,ic,flags);
564}
565
566_PUBLIC_ size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, struct smb_iconv_convenience *ic, 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, ic);
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 }
643 if (ndr_flags & NDR_BUFFERS) {
644 {
645 uint32_t _flags_save_string = ndr->flags;
646 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
647 if (r->driver_name) {
648 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
649 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
650 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
651 }
652 ndr->flags = _flags_save_string;
653 }
654 {
655 uint32_t _flags_save_string = ndr->flags;
656 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
657 if (r->architecture) {
658 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
659 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
660 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
661 }
662 ndr->flags = _flags_save_string;
663 }
664 if (r->file_info) {
665 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->file_info));
666#if 0
667 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_count));
668#endif
669 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
670 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
671 }
672 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
673 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
674 }
675 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->file_info));
676 }
677 {
678 uint32_t _flags_save_string = ndr->flags;
679 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
680 if (r->monitor_name) {
681 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
682 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
683 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
684 }
685 ndr->flags = _flags_save_string;
686 }
687 {
688 uint32_t _flags_save_string = ndr->flags;
689 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
690 if (r->default_datatype) {
691 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
692 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
693 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
694 }
695 ndr->flags = _flags_save_string;
696 }
697 {
698 uint32_t _flags_save_string_array = ndr->flags;
699 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
700 if (r->previous_names) {
701 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
702 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
703 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
704 }
705 ndr->flags = _flags_save_string_array;
706 }
707 {
708 uint32_t _flags_save_string = ndr->flags;
709 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
710 if (r->manufacturer_name) {
711 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
712 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
713 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
714 }
715 ndr->flags = _flags_save_string;
716 }
717 {
718 uint32_t _flags_save_string = ndr->flags;
719 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
720 if (r->manufacturer_url) {
721 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
722 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
723 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
724 }
725 ndr->flags = _flags_save_string;
726 }
727 {
728 uint32_t _flags_save_string = ndr->flags;
729 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
730 if (r->hardware_id) {
731 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
732 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
733 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
734 }
735 ndr->flags = _flags_save_string;
736 }
737 {
738 uint32_t _flags_save_string = ndr->flags;
739 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
740 if (r->provider) {
741 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
742 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
743 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
744 }
745 ndr->flags = _flags_save_string;
746 }
747 }
748 return NDR_ERR_SUCCESS;
749}
750
751_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo101(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo101 *r)
752{
753 uint32_t _ptr_driver_name;
754 TALLOC_CTX *_mem_save_driver_name_0;
755 uint32_t _ptr_architecture;
756 TALLOC_CTX *_mem_save_architecture_0;
757 uint32_t _ptr_file_info;
758 uint32_t cntr_file_info_1;
759 TALLOC_CTX *_mem_save_file_info_0;
760 TALLOC_CTX *_mem_save_file_info_1;
761 uint32_t _ptr_monitor_name;
762 TALLOC_CTX *_mem_save_monitor_name_0;
763 uint32_t _ptr_default_datatype;
764 TALLOC_CTX *_mem_save_default_datatype_0;
765 uint32_t _ptr_previous_names;
766 TALLOC_CTX *_mem_save_previous_names_0;
767 uint32_t _ptr_manufacturer_name;
768 TALLOC_CTX *_mem_save_manufacturer_name_0;
769 uint32_t _ptr_manufacturer_url;
770 TALLOC_CTX *_mem_save_manufacturer_url_0;
771 uint32_t _ptr_hardware_id;
772 TALLOC_CTX *_mem_save_hardware_id_0;
773 uint32_t _ptr_provider;
774 TALLOC_CTX *_mem_save_provider_0;
775 if (ndr_flags & NDR_SCALARS) {
776 NDR_CHECK(ndr_pull_align(ndr, 8));
777 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
778 {
779 uint32_t _flags_save_string = ndr->flags;
780 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
781 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
782 if (_ptr_driver_name) {
783 NDR_PULL_ALLOC(ndr, r->driver_name);
784 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
785 } else {
786 r->driver_name = NULL;
787 }
788 ndr->flags = _flags_save_string;
789 }
790 {
791 uint32_t _flags_save_string = ndr->flags;
792 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
793 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
794 if (_ptr_architecture) {
795 NDR_PULL_ALLOC(ndr, r->architecture);
796 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
797 } else {
798 r->architecture = NULL;
799 }
800 ndr->flags = _flags_save_string;
801 }
802 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_info));
803 if (_ptr_file_info) {
804 NDR_PULL_ALLOC(ndr, r->file_info);
805 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_info, _ptr_file_info));
806 } else {
807 r->file_info = NULL;
808 }
809 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_count));
810 {
811 uint32_t _flags_save_string = ndr->flags;
812 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
813 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
814 if (_ptr_monitor_name) {
815 NDR_PULL_ALLOC(ndr, r->monitor_name);
816 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
817 } else {
818 r->monitor_name = NULL;
819 }
820 ndr->flags = _flags_save_string;
821 }
822 {
823 uint32_t _flags_save_string = ndr->flags;
824 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
825 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
826 if (_ptr_default_datatype) {
827 NDR_PULL_ALLOC(ndr, r->default_datatype);
828 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
829 } else {
830 r->default_datatype = NULL;
831 }
832 ndr->flags = _flags_save_string;
833 }
834 {
835 uint32_t _flags_save_string_array = ndr->flags;
836 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
837 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
838 if (_ptr_previous_names) {
839 NDR_PULL_ALLOC(ndr, r->previous_names);
840 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
841 } else {
842 r->previous_names = NULL;
843 }
844 ndr->flags = _flags_save_string_array;
845 }
846 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
847 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
848 {
849 uint32_t _flags_save_string = ndr->flags;
850 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
851 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
852 if (_ptr_manufacturer_name) {
853 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
854 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
855 } else {
856 r->manufacturer_name = NULL;
857 }
858 ndr->flags = _flags_save_string;
859 }
860 {
861 uint32_t _flags_save_string = ndr->flags;
862 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
863 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
864 if (_ptr_manufacturer_url) {
865 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
866 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
867 } else {
868 r->manufacturer_url = NULL;
869 }
870 ndr->flags = _flags_save_string;
871 }
872 {
873 uint32_t _flags_save_string = ndr->flags;
874 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
875 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
876 if (_ptr_hardware_id) {
877 NDR_PULL_ALLOC(ndr, r->hardware_id);
878 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
879 } else {
880 r->hardware_id = NULL;
881 }
882 ndr->flags = _flags_save_string;
883 }
884 {
885 uint32_t _flags_save_string = ndr->flags;
886 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
887 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
888 if (_ptr_provider) {
889 NDR_PULL_ALLOC(ndr, r->provider);
890 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
891 } else {
892 r->provider = NULL;
893 }
894 ndr->flags = _flags_save_string;
895 }
896 }
897 if (ndr_flags & NDR_BUFFERS) {
898 {
899 uint32_t _flags_save_string = ndr->flags;
900 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
901 if (r->driver_name) {
902 uint32_t _relative_save_offset;
903 _relative_save_offset = ndr->offset;
904 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
905 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
906 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
907 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
908 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
909 ndr->offset = _relative_save_offset;
910 }
911 ndr->flags = _flags_save_string;
912 }
913 {
914 uint32_t _flags_save_string = ndr->flags;
915 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
916 if (r->architecture) {
917 uint32_t _relative_save_offset;
918 _relative_save_offset = ndr->offset;
919 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
920 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
921 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
922 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
923 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
924 ndr->offset = _relative_save_offset;
925 }
926 ndr->flags = _flags_save_string;
927 }
928 if (r->file_info) {
929 uint32_t _relative_save_offset;
930 _relative_save_offset = ndr->offset;
931 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_info));
932 _mem_save_file_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
933 NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
934#if 0
935 NDR_CHECK(ndr_pull_array_size(ndr, &r->file_info));
936#else
937 NDR_CHECK(ndr_token_store(ndr, &ndr->array_size_list, &r->file_info, r->file_count));
938#endif
939 NDR_PULL_ALLOC_N(ndr, r->file_info, ndr_get_array_size(ndr, &r->file_info));
940 _mem_save_file_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
941 NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
942 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
943 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
944 }
945 for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
946 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
947 }
948 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_1, 0);
949 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_0, 0);
950 ndr->offset = _relative_save_offset;
951 }
952 {
953 uint32_t _flags_save_string = ndr->flags;
954 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
955 if (r->monitor_name) {
956 uint32_t _relative_save_offset;
957 _relative_save_offset = ndr->offset;
958 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
959 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
960 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
961 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
962 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
963 ndr->offset = _relative_save_offset;
964 }
965 ndr->flags = _flags_save_string;
966 }
967 {
968 uint32_t _flags_save_string = ndr->flags;
969 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
970 if (r->default_datatype) {
971 uint32_t _relative_save_offset;
972 _relative_save_offset = ndr->offset;
973 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
974 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
975 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
976 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
977 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
978 ndr->offset = _relative_save_offset;
979 }
980 ndr->flags = _flags_save_string;
981 }
982 {
983 uint32_t _flags_save_string_array = ndr->flags;
984 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
985 if (r->previous_names) {
986 uint32_t _relative_save_offset;
987 _relative_save_offset = ndr->offset;
988 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
989 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
990 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
991 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
992 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
993 ndr->offset = _relative_save_offset;
994 }
995 ndr->flags = _flags_save_string_array;
996 }
997 {
998 uint32_t _flags_save_string = ndr->flags;
999 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1000 if (r->manufacturer_name) {
1001 uint32_t _relative_save_offset;
1002 _relative_save_offset = ndr->offset;
1003 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
1004 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1005 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
1006 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
1007 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
1008 ndr->offset = _relative_save_offset;
1009 }
1010 ndr->flags = _flags_save_string;
1011 }
1012 {
1013 uint32_t _flags_save_string = ndr->flags;
1014 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1015 if (r->manufacturer_url) {
1016 uint32_t _relative_save_offset;
1017 _relative_save_offset = ndr->offset;
1018 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
1019 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
1020 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
1021 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
1022 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
1023 ndr->offset = _relative_save_offset;
1024 }
1025 ndr->flags = _flags_save_string;
1026 }
1027 {
1028 uint32_t _flags_save_string = ndr->flags;
1029 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1030 if (r->hardware_id) {
1031 uint32_t _relative_save_offset;
1032 _relative_save_offset = ndr->offset;
1033 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
1034 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
1035 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
1036 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
1037 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
1038 ndr->offset = _relative_save_offset;
1039 }
1040 ndr->flags = _flags_save_string;
1041 }
1042 {
1043 uint32_t _flags_save_string = ndr->flags;
1044 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1045 if (r->provider) {
1046 uint32_t _relative_save_offset;
1047 _relative_save_offset = ndr->offset;
1048 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
1049 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
1050 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
1051 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
1052 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
1053 ndr->offset = _relative_save_offset;
1054 }
1055 ndr->flags = _flags_save_string;
1056 }
1057 if (r->file_info) {
1058 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->file_info, r->file_count));
1059 }
1060 }
1061 return NDR_ERR_SUCCESS;
1062}
1063
1064void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, const union spoolss_Field *r)
1065{
1066 int level;
1067 level = ndr_print_get_switch_value(ndr, r);
1068 ndr_print_union(ndr, name, level, "spoolss_Field");
1069 switch (level) {
1070 case PRINTER_NOTIFY_TYPE:
1071 ndr_print_spoolss_PrintNotifyField(ndr, "field", r->field);
1072 break;
1073
1074 case JOB_NOTIFY_TYPE:
1075 ndr_print_spoolss_JobNotifyField(ndr, "field", r->field);
1076 break;
1077
1078 default:
1079 ndr_print_uint16(ndr, "field", r->field);
1080 break;
1081
1082 }
1083}
1084
1085_PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
1086{
1087 if (!r) {
1088 return 0;
1089 }
1090 return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
1091}
1092
1093void ndr_print_spoolss_security_descriptor(struct ndr_print *ndr, const char *name, const struct security_descriptor *r)
1094{
1095 ndr_print_security_descriptor(ndr, name, r);
1096}
1097
1098enum ndr_err_code ndr_pull_spoolss_security_descriptor(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor *r)
1099{
1100 uint32_t _flags_save_STRUCT = ndr->flags;
1101 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NO_RELATIVE_REVERSE);
1102 NDR_CHECK(ndr_pull_security_descriptor(ndr, ndr_flags, r));
1103 ndr->flags = _flags_save_STRUCT;
1104 return NDR_ERR_SUCCESS;
1105}
1106
1107enum ndr_err_code ndr_push_spoolss_security_descriptor(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor *r)
1108{
1109 {
1110 uint32_t _flags_save_STRUCT = ndr->flags;
1111 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN|LIBNDR_FLAG_NO_RELATIVE_REVERSE);
1112 if (ndr_flags & NDR_SCALARS) {
1113 NDR_CHECK(ndr_push_align(ndr, 5));
1114 NDR_CHECK(ndr_push_security_descriptor_revision(ndr, NDR_SCALARS, r->revision));
1115 NDR_CHECK(ndr_push_security_descriptor_type(ndr, NDR_SCALARS, r->type));
1116 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->owner_sid));
1117 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->group_sid));
1118 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sacl));
1119 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dacl));
1120 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1121 }
1122 if (ndr_flags & NDR_BUFFERS) {
1123 if (r->sacl) {
1124 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sacl));
1125 NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->sacl));
1126 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sacl));
1127 }
1128 if (r->dacl) {
1129 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dacl));
1130 NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->dacl));
1131 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dacl));
1132 }
1133 if (r->owner_sid) {
1134 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->owner_sid));
1135 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->owner_sid));
1136 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->owner_sid));
1137 }
1138 if (r->group_sid) {
1139 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->group_sid));
1140 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->group_sid));
1141 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->group_sid));
1142 }
1143 }
1144 ndr->flags = _flags_save_STRUCT;
1145 }
1146 return NDR_ERR_SUCCESS;
1147}
1148
1149_PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
1150{
1151 if (ndr_flags & NDR_SCALARS) {
1152 NDR_CHECK(ndr_push_align(ndr, 5));
1153 {
1154 uint32_t _flags_save_string = ndr->flags;
1155 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1156 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
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_push_relative_ptr1(ndr, r->printername));
1163 ndr->flags = _flags_save_string;
1164 }
1165 {
1166 uint32_t _flags_save_string = ndr->flags;
1167 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1168 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
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_push_relative_ptr1(ndr, r->portname));
1175 ndr->flags = _flags_save_string;
1176 }
1177 {
1178 uint32_t _flags_save_string = ndr->flags;
1179 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1180 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1181 ndr->flags = _flags_save_string;
1182 }
1183 {
1184 uint32_t _flags_save_string = ndr->flags;
1185 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1186 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1187 ndr->flags = _flags_save_string;
1188 }
1189 {
1190 uint32_t _flags_save_string = ndr->flags;
1191 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1192 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1193 ndr->flags = _flags_save_string;
1194 }
1195 {
1196 uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1197 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1198 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1199 ndr->flags = _flags_save_spoolss_DeviceMode;
1200 }
1201 {
1202 uint32_t _flags_save_string = ndr->flags;
1203 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1204 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1205 ndr->flags = _flags_save_string;
1206 }
1207 {
1208 uint32_t _flags_save_string = ndr->flags;
1209 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1210 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1211 ndr->flags = _flags_save_string;
1212 }
1213 {
1214 uint32_t _flags_save_string = ndr->flags;
1215 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1216 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1217 ndr->flags = _flags_save_string;
1218 }
1219 {
1220 uint32_t _flags_save_string = ndr->flags;
1221 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1222 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1223 ndr->flags = _flags_save_string;
1224 }
1225 {
1226 uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1227 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1228 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1229 ndr->flags = _flags_save_spoolss_security_descriptor;
1230 }
1231 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1232 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1233 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1234 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1235 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1236 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1237 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1238 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1239 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1240 }
1241 if (ndr_flags & NDR_BUFFERS) {
1242 {
1243 uint32_t _flags_save_string = ndr->flags;
1244 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1245 if (r->servername) {
1246 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
1247 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1248 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
1249 }
1250 ndr->flags = _flags_save_string;
1251 }
1252 {
1253 uint32_t _flags_save_string = ndr->flags;
1254 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1255 if (r->printername) {
1256 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
1257 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1258 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
1259 }
1260 ndr->flags = _flags_save_string;
1261 }
1262 {
1263 uint32_t _flags_save_string = ndr->flags;
1264 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1265 if (r->sharename) {
1266 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sharename));
1267 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1268 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sharename));
1269 }
1270 ndr->flags = _flags_save_string;
1271 }
1272 {
1273 uint32_t _flags_save_string = ndr->flags;
1274 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1275 if (r->portname) {
1276 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
1277 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1278 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
1279 }
1280 ndr->flags = _flags_save_string;
1281 }
1282 {
1283 uint32_t _flags_save_string = ndr->flags;
1284 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1285 if (r->drivername) {
1286 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->drivername));
1287 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1288 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->drivername));
1289 }
1290 ndr->flags = _flags_save_string;
1291 }
1292 {
1293 uint32_t _flags_save_string = ndr->flags;
1294 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1295 if (r->comment) {
1296 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
1297 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1298 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
1299 }
1300 ndr->flags = _flags_save_string;
1301 }
1302 {
1303 uint32_t _flags_save_string = ndr->flags;
1304 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1305 if (r->location) {
1306 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->location));
1307 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1308 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->location));
1309 }
1310 ndr->flags = _flags_save_string;
1311 }
1312 {
1313 uint32_t _flags_save_string = ndr->flags;
1314 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1315 if (r->sepfile) {
1316 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sepfile));
1317 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1318 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sepfile));
1319 }
1320 ndr->flags = _flags_save_string;
1321 }
1322 {
1323 uint32_t _flags_save_string = ndr->flags;
1324 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1325 if (r->printprocessor) {
1326 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printprocessor));
1327 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1328 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printprocessor));
1329 }
1330 ndr->flags = _flags_save_string;
1331 }
1332 {
1333 uint32_t _flags_save_string = ndr->flags;
1334 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1335 if (r->datatype) {
1336 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->datatype));
1337 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1338 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->datatype));
1339 }
1340 ndr->flags = _flags_save_string;
1341 }
1342 {
1343 uint32_t _flags_save_string = ndr->flags;
1344 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1345 if (r->parameters) {
1346 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
1347 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1348 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
1349 }
1350 ndr->flags = _flags_save_string;
1351 }
1352 {
1353 uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1354 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1355 if (r->devmode) {
1356 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
1357 {
1358 struct ndr_push *_ndr_devmode;
1359 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1360 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1361 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1362 }
1363 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
1364 }
1365 ndr->flags = _flags_save_spoolss_DeviceMode;
1366 }
1367 {
1368 uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1369 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1370 if (r->secdesc) {
1371 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
1372 {
1373 struct ndr_push *_ndr_secdesc;
1374 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1375 NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1376 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1377 }
1378 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
1379 }
1380 ndr->flags = _flags_save_spoolss_security_descriptor;
1381 }
1382 }
1383 return NDR_ERR_SUCCESS;
1384}
1385
1386_PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
1387{
1388 struct tm tm;
1389 time_t t;
1390 char *str;
1391
1392 tm.tm_sec = r->second;
1393 tm.tm_min = r->minute;
1394 tm.tm_hour = r->hour;
1395 tm.tm_mday = r->day;
1396 tm.tm_mon = r->month - 1;
1397 tm.tm_year = r->year - 1900;
1398 tm.tm_wday = r->day_of_week;
1399 tm.tm_yday = 0;
1400 tm.tm_isdst = -1;
1401
1402 t = mktime(&tm);
1403
1404 str = timestring(ndr, t);
1405
1406 ndr_print_struct(ndr, name, "spoolss_Time");
1407 ndr->depth++;
1408 ndr_print_string(ndr, "", str);
1409 ndr->depth--;
1410 talloc_free(str);
1411}
1412
1413_PUBLIC_ uint32_t ndr_spoolss_PrinterEnumValues_align(enum winreg_Type type)
1414{
1415 switch(type) {
1416 case REG_NONE:
1417 return 0;
1418 case REG_SZ:
1419 return LIBNDR_FLAG_ALIGN2;
1420 case REG_EXPAND_SZ:
1421 return LIBNDR_FLAG_ALIGN2;
1422 case REG_BINARY:
1423 return 0;
1424 case REG_DWORD:
1425 return LIBNDR_FLAG_ALIGN4;
1426 case REG_DWORD_BIG_ENDIAN:
1427 return LIBNDR_FLAG_ALIGN4;
1428 case REG_LINK:
1429 return 0;
1430 case REG_MULTI_SZ:
1431 return LIBNDR_FLAG_ALIGN2;
1432 case REG_RESOURCE_LIST:
1433 return LIBNDR_FLAG_ALIGN2;
1434 case REG_FULL_RESOURCE_DESCRIPTOR:
1435 return LIBNDR_FLAG_ALIGN4;
1436 case REG_RESOURCE_REQUIREMENTS_LIST:
1437 return LIBNDR_FLAG_ALIGN2;
1438 case REG_QWORD:
1439 return LIBNDR_FLAG_ALIGN8;
1440 }
1441
1442 return 0;
1443}
Note: See TracBrowser for help on using the repository browser.