?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-spoolss: remove old spoolss_GetPrinterData.
[Samba/gbeck.git] / source3 / rpc_parse / parse_spoolss.c
bloba7d69f67efad15eaf4b667f9b194d99e9aa55aa2
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-2000,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
6 * Copyright (C) Jean François Micouleau 1998-2000,
7 * Copyright (C) Gerald Carter 2000-2002,
8 * Copyright (C) Tim Potter 2001-2002.
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 #include "includes.h"
25
26 #undef DBGC_CLASS
27 #define DBGC_CLASS DBGC_RPC_PARSE
28
29
30 /*******************************************************************
31 This should be moved in a more generic lib.
32 ********************************************************************/
33
34 bool spoolss_io_system_time(const char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
35 {
36 if(!prs_uint16("year", ps, depth, &systime->year))
37 return False;
38 if(!prs_uint16("month", ps, depth, &systime->month))
39 return False;
40 if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
41 return False;
42 if(!prs_uint16("day", ps, depth, &systime->day))
43 return False;
44 if(!prs_uint16("hour", ps, depth, &systime->hour))
45 return False;
46 if(!prs_uint16("minute", ps, depth, &systime->minute))
47 return False;
48 if(!prs_uint16("second", ps, depth, &systime->second))
49 return False;
50 if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
51 return False;
52
53 return True;
54 }
55
56 /*******************************************************************
57 ********************************************************************/
58
59 bool make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
60 {
61 systime->year=unixtime->tm_year+1900;
62 systime->month=unixtime->tm_mon+1;
63 systime->dayofweek=unixtime->tm_wday;
64 systime->day=unixtime->tm_mday;
65 systime->hour=unixtime->tm_hour;
66 systime->minute=unixtime->tm_min;
67 systime->second=unixtime->tm_sec;
68 systime->milliseconds=0;
69
70 return True;
71 }
72
73 /*******************************************************************
74 * read or write a DEVICEMODE struct.
75 * on reading allocate memory for the private member
76 ********************************************************************/
77
78 #define DM_NUM_OPTIONAL_FIELDS 8
79
80 bool spoolss_io_devmode(const char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
81 {
82 int available_space; /* size of the device mode left to parse */
83 /* only important on unmarshalling */
84 int i = 0;
85 uint16 *unistr_buffer;
86 int j;
87
88 struct optional_fields {
89 fstring name;
90 uint32* field;
91 } opt_fields[DM_NUM_OPTIONAL_FIELDS] = {
92 { "icmmethod", NULL },
93 { "icmintent", NULL },
94 { "mediatype", NULL },
95 { "dithertype", NULL },
96 { "reserved1", NULL },
97 { "reserved2", NULL },
98 { "panningwidth", NULL },
99 { "panningheight", NULL }
100 };
101
102 /* assign at run time to keep non-gcc compilers happy */
103
104 opt_fields[0].field = &devmode->icmmethod;
105 opt_fields[1].field = &devmode->icmintent;
106 opt_fields[2].field = &devmode->mediatype;
107 opt_fields[3].field = &devmode->dithertype;
108 opt_fields[4].field = &devmode->reserved1;
109 opt_fields[5].field = &devmode->reserved2;
110 opt_fields[6].field = &devmode->panningwidth;
111 opt_fields[7].field = &devmode->panningheight;
112
113
114 prs_debug(ps, depth, desc, "spoolss_io_devmode");
115 depth++;
116
117 if (UNMARSHALLING(ps)) {
118 devmode->devicename.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
119 if (devmode->devicename.buffer == NULL)
120 return False;
121 unistr_buffer = devmode->devicename.buffer;
122 }
123 else {
124 /* devicename is a static sized string but the buffer we set is not */
125 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
126 memset( unistr_buffer, 0x0, MAXDEVICENAME );
127 for ( j=0; devmode->devicename.buffer[j]; j++ )
128 unistr_buffer[j] = devmode->devicename.buffer[j];
129 }
130
131 if (!prs_uint16uni(True,"devicename", ps, depth, unistr_buffer, MAXDEVICENAME))
132 return False;
133
134 if (!prs_uint16("specversion", ps, depth, &devmode->specversion))
135 return False;
136
137 if (!prs_uint16("driverversion", ps, depth, &devmode->driverversion))
138 return False;
139 if (!prs_uint16("size", ps, depth, &devmode->size))
140 return False;
141 if (!prs_uint16("driverextra", ps, depth, &devmode->driverextra))
142 return False;
143 if (!prs_uint32("fields", ps, depth, &devmode->fields))
144 return False;
145 if (!prs_uint16("orientation", ps, depth, &devmode->orientation))
146 return False;
147 if (!prs_uint16("papersize", ps, depth, &devmode->papersize))
148 return False;
149 if (!prs_uint16("paperlength", ps, depth, &devmode->paperlength))
150 return False;
151 if (!prs_uint16("paperwidth", ps, depth, &devmode->paperwidth))
152 return False;
153 if (!prs_uint16("scale", ps, depth, &devmode->scale))
154 return False;
155 if (!prs_uint16("copies", ps, depth, &devmode->copies))
156 return False;
157 if (!prs_uint16("defaultsource", ps, depth, &devmode->defaultsource))
158 return False;
159 if (!prs_uint16("printquality", ps, depth, &devmode->printquality))
160 return False;
161 if (!prs_uint16("color", ps, depth, &devmode->color))
162 return False;
163 if (!prs_uint16("duplex", ps, depth, &devmode->duplex))
164 return False;
165 if (!prs_uint16("yresolution", ps, depth, &devmode->yresolution))
166 return False;
167 if (!prs_uint16("ttoption", ps, depth, &devmode->ttoption))
168 return False;
169 if (!prs_uint16("collate", ps, depth, &devmode->collate))
170 return False;
171
172 if (UNMARSHALLING(ps)) {
173 devmode->formname.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
174 if (devmode->formname.buffer == NULL)
175 return False;
176 unistr_buffer = devmode->formname.buffer;
177 }
178 else {
179 /* devicename is a static sized string but the buffer we set is not */
180 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
181 memset( unistr_buffer, 0x0, MAXDEVICENAME );
182 for ( j=0; devmode->formname.buffer[j]; j++ )
183 unistr_buffer[j] = devmode->formname.buffer[j];
184 }
185
186 if (!prs_uint16uni(True, "formname", ps, depth, unistr_buffer, MAXDEVICENAME))
187 return False;
188 if (!prs_uint16("logpixels", ps, depth, &devmode->logpixels))
189 return False;
190 if (!prs_uint32("bitsperpel", ps, depth, &devmode->bitsperpel))
191 return False;
192 if (!prs_uint32("pelswidth", ps, depth, &devmode->pelswidth))
193 return False;
194 if (!prs_uint32("pelsheight", ps, depth, &devmode->pelsheight))
195 return False;
196 if (!prs_uint32("displayflags", ps, depth, &devmode->displayflags))
197 return False;
198 if (!prs_uint32("displayfrequency", ps, depth, &devmode->displayfrequency))
199 return False;
200 /*
201 * every device mode I've ever seen on the wire at least has up
202 * to the displayfrequency field. --jerry (05-09-2002)
203 */
204
205 /* add uint32's + uint16's + two UNICODE strings */
206
207 available_space = devmode->size - (sizeof(uint32)*6 + sizeof(uint16)*18 + sizeof(uint16)*64);
208
209 /* Sanity check - we only have uint32's left tp parse */
210
211 if ( available_space && ((available_space % sizeof(uint32)) != 0) ) {
212 DEBUG(0,("spoolss_io_devmode: available_space [%d] no in multiple of 4 bytes (size = %d)!\n",
213 available_space, devmode->size));
214 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
215 return False;
216 }
217
218 /*
219 * Conditional parsing. Assume that the DeviceMode has been
220 * zero'd by the caller.
221 */
222
223 while ((available_space > 0) && (i < DM_NUM_OPTIONAL_FIELDS))
224 {
225 DEBUG(11, ("spoolss_io_devmode: [%d] bytes left to parse in devmode\n", available_space));
226 if (!prs_uint32(opt_fields[i].name, ps, depth, opt_fields[i].field))
227 return False;
228 available_space -= sizeof(uint32);
229 i++;
230 }
231
232 /* Sanity Check - we should no available space at this point unless
233 MS changes the device mode structure */
234
235 if (available_space) {
236 DEBUG(0,("spoolss_io_devmode: I've parsed all I know and there is still stuff left|\n"));
237 DEBUG(0,("spoolss_io_devmode: available_space = [%d], devmode_size = [%d]!\n",
238 available_space, devmode->size));
239 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
240 return False;
241 }
242
243
244 if (devmode->driverextra!=0) {
245 if (UNMARSHALLING(ps)) {
246 devmode->dev_private=PRS_ALLOC_MEM(ps, uint8, devmode->driverextra);
247 if(devmode->dev_private == NULL)
248 return False;
249 DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for dev_private\n",devmode->driverextra));
250 }
251
252 DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of dev_private\n",devmode->driverextra));
253 if (!prs_uint8s(False, "dev_private", ps, depth,
254 devmode->dev_private, devmode->driverextra))
255 return False;
256 }
257
258 return True;
259 }
260
261 /*******************************************************************
262 * return the length of a uint32 (obvious, but the code is clean)
263 ********************************************************************/
264
265 static uint32 size_of_uint32(uint32 *value)
266 {
267 return (sizeof(*value));
268 }
269
270 /*******************************************************************
271 return the size required by a struct in the stream
272 ********************************************************************/
273 uint32 spoolss_size_printer_enum_values(PRINTER_ENUM_VALUES *p)
274 {
275 uint32 size = 0;
276
277 if (!p)
278 return 0;
279
280 /* uint32(offset) + uint32(length) + length) */
281 size += (size_of_uint32(&p->value_len)*2) + p->value_len;
282 size += (size_of_uint32(&p->data_len)*2) + p->data_len + (p->data_len%2) ;
283
284 size += size_of_uint32(&p->type);
285
286 return size;
287 }
288
289 /*******************************************************************
290 make a BUFFER5 struct from a uint16*
291 ******************************************************************/
292
293 bool make_spoolss_buffer5(TALLOC_CTX *mem_ctx, BUFFER5 *buf5, uint32 len, uint16 *src)
294 {
295
296 buf5->buf_len = len;
297 if (src) {
298 if (len) {
299 if((buf5->buffer=(uint16*)TALLOC_MEMDUP(mem_ctx, src, sizeof(uint16)*len)) == NULL) {
300 DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
301 return False;
302 }
303 } else {
304 buf5->buffer = NULL;
305 }
306 } else {
307 buf5->buffer=NULL;
308 }
309
310 return True;
311 }
312
313 /*******************************************************************
314 ********************************************************************/
315
316 bool spoolss_io_r_enumprinterdata(const char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth)
317 {
318 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata");
319 depth++;
320
321 if(!prs_align(ps))
322 return False;
323 if(!prs_uint32("valuesize", ps, depth, &r_u->valuesize))
324 return False;
325
326 if (UNMARSHALLING(ps) && r_u->valuesize) {
327 r_u->value = PRS_ALLOC_MEM(ps, uint16, r_u->valuesize);
328 if (!r_u->value) {
329 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata value\n"));
330 return False;
331 }
332 }
333
334 if(!prs_uint16uni(False, "value", ps, depth, r_u->value, r_u->valuesize ))
335 return False;
336
337 if(!prs_align(ps))
338 return False;
339
340 if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
341 return False;
342
343 if(!prs_uint32("type", ps, depth, &r_u->type))
344 return False;
345
346 if(!prs_uint32("datasize", ps, depth, &r_u->datasize))
347 return False;
348
349 if (UNMARSHALLING(ps) && r_u->datasize) {
350 r_u->data = PRS_ALLOC_MEM(ps, uint8, r_u->datasize);
351 if (!r_u->data) {
352 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata data\n"));
353 return False;
354 }
355 }
356
357 if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
358 return False;
359 if(!prs_align(ps))
360 return False;
361
362 if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
363 return False;
364 if(!prs_werror("status", ps, depth, &r_u->status))
365 return False;
366
367 return True;
368 }
369
370 /*******************************************************************
371 ********************************************************************/
372
373 bool spoolss_io_q_enumprinterdata(const char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
374 {
375 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
376 depth++;
377
378 if(!prs_align(ps))
379 return False;
380 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
381 return False;
382 if(!prs_uint32("index", ps, depth, &q_u->index))
383 return False;
384 if(!prs_uint32("valuesize", ps, depth, &q_u->valuesize))
385 return False;
386 if(!prs_uint32("datasize", ps, depth, &q_u->datasize))
387 return False;
388
389 return True;
390 }
391
392 /*******************************************************************
393 ********************************************************************/
394
395 bool make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u,
396 const POLICY_HND *hnd,
397 uint32 idx, uint32 valuelen, uint32 datalen)
398 {
399 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
400 q_u->index=idx;
401 q_u->valuesize=valuelen;
402 q_u->datasize=datalen;
403
404 return True;
405 }
406
407 /*******************************************************************
408 ********************************************************************/
409
410 bool make_spoolss_q_enumprinterdataex(SPOOL_Q_ENUMPRINTERDATAEX *q_u,
411 const POLICY_HND *hnd, const char *key,
412 uint32 size)
413 {
414 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
415 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
416 q_u->size = size;
417
418 return True;
419 }
420
421 /*******************************************************************
422 ********************************************************************/
423 bool make_spoolss_q_setprinterdata(SPOOL_Q_SETPRINTERDATA *q_u, const POLICY_HND *hnd,
424 char* value, uint32 data_type, char* data, uint32 data_size)
425 {
426 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
427 q_u->type = data_type;
428 init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
429
430 q_u->max_len = q_u->real_len = data_size;
431 q_u->data = (unsigned char *)data;
432
433 return True;
434 }
435
436 /*******************************************************************
437 ********************************************************************/
438
439 bool spoolss_io_q_setprinterdata(const char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
440 {
441 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
442 depth++;
443
444 if(!prs_align(ps))
445 return False;
446 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
447 return False;
448 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
449 return False;
450
451 if(!prs_align(ps))
452 return False;
453
454 if(!prs_uint32("type", ps, depth, &q_u->type))
455 return False;
456
457 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
458 return False;
459
460 switch (q_u->type)
461 {
462 case REG_SZ:
463 case REG_BINARY:
464 case REG_DWORD:
465 case REG_MULTI_SZ:
466 if (q_u->max_len) {
467 if (UNMARSHALLING(ps))
468 q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
469 if(q_u->data == NULL)
470 return False;
471 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
472 return False;
473 }
474 if(!prs_align(ps))
475 return False;
476 break;
477 }
478
479 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
480 return False;
481
482 return True;
483 }
484
485 /*******************************************************************
486 ********************************************************************/
487
488 bool spoolss_io_r_setprinterdata(const char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
489 {
490 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
491 depth++;
492
493 if(!prs_align(ps))
494 return False;
495 if(!prs_werror("status", ps, depth, &r_u->status))
496 return False;
497
498 return True;
499 }
500
501 /*******************************************************************
502 * read a structure.
503 ********************************************************************/
504 bool make_spoolss_q_enumprinterkey(SPOOL_Q_ENUMPRINTERKEY *q_u,
505 POLICY_HND *hnd, const char *key,
506 uint32 size)
507 {
508 DEBUG(5,("make_spoolss_q_enumprinterkey\n"));
509
510 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
511 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
512 q_u->size = size;
513
514 return True;
515 }
516
517 /*******************************************************************
518 * read a structure.
519 ********************************************************************/
520
521 bool spoolss_io_q_enumprinterkey(const char *desc, SPOOL_Q_ENUMPRINTERKEY *q_u, prs_struct *ps, int depth)
522 {
523 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterkey");
524 depth++;
525
526 if(!prs_align(ps))
527 return False;
528 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
529 return False;
530
531 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
532 return False;
533
534 if(!prs_align(ps))
535 return False;
536
537 if(!prs_uint32("size", ps, depth, &q_u->size))
538 return False;
539
540 return True;
541 }
542
543 /*******************************************************************
544 * write a structure.
545 ********************************************************************/
546
547 bool spoolss_io_r_enumprinterkey(const char *desc, SPOOL_R_ENUMPRINTERKEY *r_u, prs_struct *ps, int depth)
548 {
549 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterkey");
550 depth++;
551
552 if(!prs_align(ps))
553 return False;
554
555 if (!smb_io_buffer5("", &r_u->keys, ps, depth))
556 return False;
557
558 if(!prs_align(ps))
559 return False;
560
561 if(!prs_uint32("needed", ps, depth, &r_u->needed))
562 return False;
563
564 if(!prs_werror("status", ps, depth, &r_u->status))
565 return False;
566
567 return True;
568 }
569
570 /*******************************************************************
571 * read a structure.
572 ********************************************************************/
573
574 bool spoolss_io_q_enumprinterdataex(const char *desc, SPOOL_Q_ENUMPRINTERDATAEX *q_u, prs_struct *ps, int depth)
575 {
576 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdataex");
577 depth++;
578
579 if(!prs_align(ps))
580 return False;
581 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
582 return False;
583
584 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
585 return False;
586
587 if(!prs_align(ps))
588 return False;
589
590 if(!prs_uint32("size", ps, depth, &q_u->size))
591 return False;
592
593 return True;
594 }
595
596 /*******************************************************************
597 ********************************************************************/
598
599 static bool spoolss_io_printer_enum_values_ctr(const char *desc, prs_struct *ps,
600 PRINTER_ENUM_VALUES_CTR *ctr, int depth)
601 {
602 int i;
603 uint32 valuename_offset,
604 data_offset,
605 current_offset;
606 const uint32 basic_unit = 20; /* size of static portion of enum_values */
607
608 prs_debug(ps, depth, desc, "spoolss_io_printer_enum_values_ctr");
609 depth++;
610
611 /*
612 * offset data begins at 20 bytes per structure * size_of_array.
613 * Don't forget the uint32 at the beginning
614 * */
615
616 current_offset = basic_unit * ctr->size_of_array;
617
618 /* first loop to write basic enum_value information */
619
620 if (UNMARSHALLING(ps) && ctr->size_of_array) {
621 ctr->values = PRS_ALLOC_MEM(ps, PRINTER_ENUM_VALUES, ctr->size_of_array);
622 if (!ctr->values)
623 return False;
624 }
625
626 for (i=0; i<ctr->size_of_array; i++) {
627 uint32 base_offset, return_offset;
628
629 base_offset = prs_offset(ps);
630
631 valuename_offset = current_offset;
632 if (!prs_uint32("valuename_offset", ps, depth, &valuename_offset))
633 return False;
634
635 /* Read or write the value. */
636
637 return_offset = prs_offset(ps);
638
639 if (!prs_set_offset(ps, base_offset + valuename_offset)) {
640 return False;
641 }
642
643 if (!prs_unistr("valuename", ps, depth, &ctr->values[i].valuename))
644 return False;
645
646 /* And go back. */
647 if (!prs_set_offset(ps, return_offset))
648 return False;
649
650 if (!prs_uint32("value_len", ps, depth, &ctr->values[i].value_len))
651 return False;
652
653 if (!prs_uint32("type", ps, depth, &ctr->values[i].type))
654 return False;
655
656 data_offset = ctr->values[i].value_len + valuename_offset;
657
658 if (!prs_uint32("data_offset", ps, depth, &data_offset))
659 return False;
660
661 if (!prs_uint32("data_len", ps, depth, &ctr->values[i].data_len))
662 return False;
663
664 /* Read or write the data. */
665
666 return_offset = prs_offset(ps);
667
668 if (!prs_set_offset(ps, base_offset + data_offset)) {
669 return False;
670 }
671
672 if ( ctr->values[i].data_len ) {
673 if ( UNMARSHALLING(ps) ) {
674 ctr->values[i].data = PRS_ALLOC_MEM(ps, uint8, ctr->values[i].data_len);
675 if (!ctr->values[i].data)
676 return False;
677 }
678 if (!prs_uint8s(False, "data", ps, depth, ctr->values[i].data, ctr->values[i].data_len))
679 return False;
680 }
681
682 current_offset = data_offset + ctr->values[i].data_len - basic_unit;
683 /* account for 2 byte alignment */
684 current_offset += (current_offset % 2);
685
686 /* Remember how far we got. */
687 data_offset = prs_offset(ps);
688
689 /* And go back. */
690 if (!prs_set_offset(ps, return_offset))
691 return False;
692
693 }
694
695 /* Go to the last data offset we got to. */
696
697 if (!prs_set_offset(ps, data_offset))
698 return False;
699
700 /* And ensure we're 2 byte aligned. */
701
702 if ( !prs_align_uint16(ps) )
703 return False;
704
705 return True;
706 }
707
708 /*******************************************************************
709 * write a structure.
710 ********************************************************************/
711
712 bool spoolss_io_r_enumprinterdataex(const char *desc, SPOOL_R_ENUMPRINTERDATAEX *r_u, prs_struct *ps, int depth)
713 {
714 uint32 data_offset, end_offset;
715 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdataex");
716 depth++;
717
718 if(!prs_align(ps))
719 return False;
720
721 if (!prs_uint32("size", ps, depth, &r_u->ctr.size))
722 return False;
723
724 data_offset = prs_offset(ps);
725
726 if (!prs_set_offset(ps, data_offset + r_u->ctr.size))
727 return False;
728
729 if(!prs_align(ps))
730 return False;
731
732 if(!prs_uint32("needed", ps, depth, &r_u->needed))
733 return False;
734
735 if(!prs_uint32("returned", ps, depth, &r_u->returned))
736 return False;
737
738 if(!prs_werror("status", ps, depth, &r_u->status))
739 return False;
740
741 r_u->ctr.size_of_array = r_u->returned;
742
743 end_offset = prs_offset(ps);
744
745 if (!prs_set_offset(ps, data_offset))
746 return False;
747
748 if (r_u->ctr.size)
749 if (!spoolss_io_printer_enum_values_ctr("", ps, &r_u->ctr, depth ))
750 return False;
751
752 if (!prs_set_offset(ps, end_offset))
753 return False;
754 return True;
755 }
WIP