?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merging spoolss code between branches. SPOOLSS_RESETPRINTER
[Samba.git] / source / rpc_parse / parse_spoolss.c
blobecd2c7e12c57faed7c54790234e50585eaf87960
1 /*
2 * Unix SMB/Netbios implementation.
3 * Version 1.9.
4 * RPC Pipe client / server routines
5 * Copyright (C) Andrew Tridgell 1992-2000,
6 * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
7 * Copyright (C) Jean François Micouleau 1998-2000,
8 * Copyright (C) Gerald Carter 2000,
9 * Copyright (C) Tim Potter 2001.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 #include "includes.h"
27
28 /*******************************************************************
29 return the length of a UNISTR string.
30 ********************************************************************/
31
32 static uint32 str_len_uni(UNISTR *source)
33 {
34 uint32 i=0;
35
36 if (!source->buffer)
37 return 0;
38
39 while (source->buffer[i])
40 i++;
41
42 return i;
43 }
44
45 /*******************************************************************
46 This should be moved in a more generic lib.
47 ********************************************************************/
48
49 static BOOL spoolss_io_system_time(char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
50 {
51 if(!prs_uint16("year", ps, depth, &systime->year))
52 return False;
53 if(!prs_uint16("month", ps, depth, &systime->month))
54 return False;
55 if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
56 return False;
57 if(!prs_uint16("day", ps, depth, &systime->day))
58 return False;
59 if(!prs_uint16("hour", ps, depth, &systime->hour))
60 return False;
61 if(!prs_uint16("minute", ps, depth, &systime->minute))
62 return False;
63 if(!prs_uint16("second", ps, depth, &systime->second))
64 return False;
65 if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
66 return False;
67
68 return True;
69 }
70
71 /*******************************************************************
72 ********************************************************************/
73
74 BOOL make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
75 {
76 systime->year=unixtime->tm_year+1900;
77 systime->month=unixtime->tm_mon+1;
78 systime->dayofweek=unixtime->tm_wday;
79 systime->day=unixtime->tm_mday;
80 systime->hour=unixtime->tm_hour;
81 systime->minute=unixtime->tm_min;
82 systime->second=unixtime->tm_sec;
83 systime->milliseconds=0;
84
85 return True;
86 }
87
88 /*******************************************************************
89 reads or writes an DOC_INFO structure.
90 ********************************************************************/
91
92 static BOOL smb_io_doc_info_1(char *desc, DOC_INFO_1 *info_1, prs_struct *ps, int depth)
93 {
94 if (info_1 == NULL) return False;
95
96 prs_debug(ps, depth, desc, "smb_io_doc_info_1");
97 depth++;
98
99 if(!prs_align(ps))
100 return False;
101
102 if(!prs_uint32("p_docname", ps, depth, &info_1->p_docname))
103 return False;
104 if(!prs_uint32("p_outputfile", ps, depth, &info_1->p_outputfile))
105 return False;
106 if(!prs_uint32("p_datatype", ps, depth, &info_1->p_datatype))
107 return False;
108
109 if(!smb_io_unistr2("", &info_1->docname, info_1->p_docname, ps, depth))
110 return False;
111 if(!smb_io_unistr2("", &info_1->outputfile, info_1->p_outputfile, ps, depth))
112 return False;
113 if(!smb_io_unistr2("", &info_1->datatype, info_1->p_datatype, ps, depth))
114 return False;
115
116 return True;
117 }
118
119 /*******************************************************************
120 reads or writes an DOC_INFO structure.
121 ********************************************************************/
122
123 static BOOL smb_io_doc_info(char *desc, DOC_INFO *info, prs_struct *ps, int depth)
124 {
125 uint32 useless_ptr=0;
126
127 if (info == NULL) return False;
128
129 prs_debug(ps, depth, desc, "smb_io_doc_info");
130 depth++;
131
132 if(!prs_align(ps))
133 return False;
134
135 if(!prs_uint32("switch_value", ps, depth, &info->switch_value))
136 return False;
137
138 if(!prs_uint32("doc_info_X ptr", ps, depth, &useless_ptr))
139 return False;
140
141 switch (info->switch_value)
142 {
143 case 1:
144 if(!smb_io_doc_info_1("",&info->doc_info_1, ps, depth))
145 return False;
146 break;
147 case 2:
148 /*
149 this is just a placeholder
150
151 MSDN July 1998 says doc_info_2 is only on
152 Windows 95, and as Win95 doesn't do RPC to print
153 this case is nearly impossible
154
155 Maybe one day with Windows for dishwasher 2037 ...
156
157 */
158 /* smb_io_doc_info_2("",&info->doc_info_2, ps, depth); */
159 break;
160 default:
161 DEBUG(0,("Something is obviously wrong somewhere !\n"));
162 break;
163 }
164
165 return True;
166 }
167
168 /*******************************************************************
169 reads or writes an DOC_INFO_CONTAINER structure.
170 ********************************************************************/
171
172 static BOOL smb_io_doc_info_container(char *desc, DOC_INFO_CONTAINER *cont, prs_struct *ps, int depth)
173 {
174 if (cont == NULL) return False;
175
176 prs_debug(ps, depth, desc, "smb_io_doc_info_container");
177 depth++;
178
179 if(!prs_align(ps))
180 return False;
181
182 if(!prs_uint32("level", ps, depth, &cont->level))
183 return False;
184
185 if(!smb_io_doc_info("",&cont->docinfo, ps, depth))
186 return False;
187
188 return True;
189 }
190
191 /*******************************************************************
192 reads or writes an NOTIFY OPTION TYPE structure.
193 ********************************************************************/
194
195 /* NOTIFY_OPTION_TYPE and NOTIFY_OPTION_TYPE_DATA are really one
196 structure. The _TYPE structure is really the deferred referrants (i.e
197 the notify fields array) of the _TYPE structure. -tpot */
198
199 static BOOL smb_io_notify_option_type(char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
200 {
201 prs_debug(ps, depth, desc, "smb_io_notify_option_type");
202 depth++;
203
204 if (!prs_align(ps))
205 return False;
206
207 if(!prs_uint16("type", ps, depth, &type->type))
208 return False;
209 if(!prs_uint16("reserved0", ps, depth, &type->reserved0))
210 return False;
211 if(!prs_uint32("reserved1", ps, depth, &type->reserved1))
212 return False;
213 if(!prs_uint32("reserved2", ps, depth, &type->reserved2))
214 return False;
215 if(!prs_uint32("count", ps, depth, &type->count))
216 return False;
217 if(!prs_uint32("fields_ptr", ps, depth, &type->fields_ptr))
218 return False;
219
220 return True;
221 }
222
223 /*******************************************************************
224 reads or writes an NOTIFY OPTION TYPE DATA.
225 ********************************************************************/
226
227 static BOOL smb_io_notify_option_type_data(char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
228 {
229 int i;
230
231 prs_debug(ps, depth, desc, "smb_io_notify_option_type_data");
232 depth++;
233
234 /* if there are no fields just return */
235 if (type->fields_ptr==0)
236 return True;
237
238 if(!prs_align(ps))
239 return False;
240
241 if(!prs_uint32("count2", ps, depth, &type->count2))
242 return False;
243
244 if (type->count2 != type->count)
245 DEBUG(4,("What a mess, count was %x now is %x !\n", type->count, type->count2));
246
247 /* parse the option type data */
248 for(i=0;i<type->count2;i++)
249 if(!prs_uint16("fields",ps,depth,&type->fields[i]))
250 return False;
251 return True;
252 }
253
254 /*******************************************************************
255 reads or writes an NOTIFY OPTION structure.
256 ********************************************************************/
257
258 static BOOL smb_io_notify_option_type_ctr(char *desc, SPOOL_NOTIFY_OPTION_TYPE_CTR *ctr , prs_struct *ps, int depth)
259 {
260 int i;
261
262 prs_debug(ps, depth, desc, "smb_io_notify_option_type_ctr");
263 depth++;
264
265 if(!prs_uint32("count", ps, depth, &ctr->count))
266 return False;
267
268 /* reading */
269 if (UNMARSHALLING(ps))
270 if((ctr->type=(SPOOL_NOTIFY_OPTION_TYPE *)prs_alloc_mem(ps,ctr->count*sizeof(SPOOL_NOTIFY_OPTION_TYPE))) == NULL)
271 return False;
272
273 /* the option type struct */
274 for(i=0;i<ctr->count;i++)
275 if(!smb_io_notify_option_type("", &ctr->type[i] , ps, depth))
276 return False;
277
278 /* the type associated with the option type struct */
279 for(i=0;i<ctr->count;i++)
280 if(!smb_io_notify_option_type_data("", &ctr->type[i] , ps, depth))
281 return False;
282
283 return True;
284 }
285
286 /*******************************************************************
287 reads or writes an NOTIFY OPTION structure.
288 ********************************************************************/
289
290 static BOOL smb_io_notify_option(char *desc, SPOOL_NOTIFY_OPTION *option, prs_struct *ps, int depth)
291 {
292 prs_debug(ps, depth, desc, "smb_io_notify_option");
293 depth++;
294
295 if(!prs_uint32("version", ps, depth, &option->version))
296 return False;
297 if(!prs_uint32("flags", ps, depth, &option->flags))
298 return False;
299 if(!prs_uint32("count", ps, depth, &option->count))
300 return False;
301 if(!prs_uint32("option_type_ptr", ps, depth, &option->option_type_ptr))
302 return False;
303
304 /* marshalling or unmarshalling, that would work */
305 if (option->option_type_ptr!=0) {
306 if(!smb_io_notify_option_type_ctr("", &option->ctr ,ps, depth))
307 return False;
308 }
309 else {
310 option->ctr.type=NULL;
311 option->ctr.count=0;
312 }
313
314 return True;
315 }
316
317 /*******************************************************************
318 reads or writes an NOTIFY INFO DATA structure.
319 ********************************************************************/
320
321 static BOOL smb_io_notify_info_data(char *desc,SPOOL_NOTIFY_INFO_DATA *data, prs_struct *ps, int depth)
322 {
323 uint32 useless_ptr=0xADDE0FF0;
324
325 uint32 how_many_words;
326 BOOL isvalue;
327 uint32 x;
328
329 prs_debug(ps, depth, desc, "smb_io_notify_info_data");
330 depth++;
331
332 how_many_words=data->size;
333 if (how_many_words==POINTER) {
334 how_many_words=TWO_VALUE;
335 }
336
337 isvalue=data->enc_type;
338
339 if(!prs_align(ps))
340 return False;
341 if(!prs_uint16("type", ps, depth, &data->type))
342 return False;
343 if(!prs_uint16("field", ps, depth, &data->field))
344 return False;
345 /*prs_align(ps);*/
346
347 if(!prs_uint32("how many words", ps, depth, &how_many_words))
348 return False;
349 if(!prs_uint32("id", ps, depth, &data->id))
350 return False;
351 if(!prs_uint32("how many words", ps, depth, &how_many_words))
352 return False;
353
354
355 /*prs_align(ps);*/
356
357 if (isvalue==True) {
358 if(!prs_uint32("value[0]", ps, depth, &data->notify_data.value[0]))
359 return False;
360 if(!prs_uint32("value[1]", ps, depth, &data->notify_data.value[1]))
361 return False;
362 /*prs_align(ps);*/
363 } else {
364 /* it's a string */
365 /* length in ascii including \0 */
366 x=2*(data->notify_data.data.length+1);
367 if(!prs_uint32("string length", ps, depth, &x ))
368 return False;
369 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
370 return False;
371 /*prs_align(ps);*/
372 }
373
374 return True;
375 }
376
377 /*******************************************************************
378 reads or writes an NOTIFY INFO DATA structure.
379 ********************************************************************/
380
381 BOOL smb_io_notify_info_data_strings(char *desc,SPOOL_NOTIFY_INFO_DATA *data,
382 prs_struct *ps, int depth)
383 {
384 uint32 x;
385 BOOL isvalue;
386
387 prs_debug(ps, depth, desc, "smb_io_notify_info_data_strings");
388 depth++;
389
390 if(!prs_align(ps))
391 return False;
392
393 isvalue=data->enc_type;
394
395 if (isvalue==False) {
396 /* length of string in unicode include \0 */
397 x=data->notify_data.data.length+1;
398 if(!prs_uint32("string length", ps, depth, &x ))
399 return False;
400 if (MARSHALLING(ps)) {
401 /* These are already in little endian format. Don't byte swap. */
402 if (x == 1) {
403
404 /* No memory allocated for this string
405 therefore following the data.string
406 pointer is a bad idea. Use a pointer to
407 the uint32 length union member to
408 provide a source for a unicode NULL */
409
410 if(!prs_uint8s(True,"string",ps,depth, (uint8 *)&data->notify_data.data.length,x*2))
411 return False;
412 } else {
413 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
414 return False;
415 }
416 } else {
417
418 /* Tallocate memory for string */
419
420 data->notify_data.data.string = (uint16 *)prs_alloc_mem(ps, x * 2);
421 if (!data->notify_data.data.string)
422 return False;
423
424 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
425 return False;
426 }
427 }
428 #if 0 /* JERRY */
429
430 /* Win2k does not seem to put this parse align here */
431
432 if(!prs_align(ps))
433 return False;
434 #endif
435
436 return True;
437 }
438
439 /*******************************************************************
440 reads or writes an NOTIFY INFO structure.
441 ********************************************************************/
442
443 static BOOL smb_io_notify_info(char *desc, SPOOL_NOTIFY_INFO *info, prs_struct *ps, int depth)
444 {
445 int i;
446
447 prs_debug(ps, depth, desc, "smb_io_notify_info");
448 depth++;
449
450 if(!prs_align(ps))
451 return False;
452
453 if(!prs_uint32("count", ps, depth, &info->count))
454 return False;
455 if(!prs_uint32("version", ps, depth, &info->version))
456 return False;
457 if(!prs_uint32("flags", ps, depth, &info->flags))
458 return False;
459 if(!prs_uint32("count", ps, depth, &info->count))
460 return False;
461
462 for (i=0;i<info->count;i++) {
463 if(!smb_io_notify_info_data(desc, &info->data[i], ps, depth))
464 return False;
465 }
466
467 /* now do the strings at the end of the stream */
468 for (i=0;i<info->count;i++) {
469 if(!smb_io_notify_info_data_strings(desc, &info->data[i], ps, depth))
470 return False;
471 }
472
473 return True;
474 }
475
476 /*******************************************************************
477 ********************************************************************/
478
479 static BOOL spool_io_user_level_1(char *desc, SPOOL_USER_1 *q_u, prs_struct *ps, int depth)
480 {
481 prs_debug(ps, depth, desc, "");
482 depth++;
483
484 /* reading */
485 if (UNMARSHALLING(ps))
486 ZERO_STRUCTP(q_u);
487
488 if (!prs_align(ps))
489 return False;
490 if (!prs_uint32("size", ps, depth, &q_u->size))
491 return False;
492 if (!prs_uint32("client_name_ptr", ps, depth, &q_u->client_name_ptr))
493 return False;
494 if (!prs_uint32("user_name_ptr", ps, depth, &q_u->user_name_ptr))
495 return False;
496 if (!prs_uint32("build", ps, depth, &q_u->build))
497 return False;
498 if (!prs_uint32("major", ps, depth, &q_u->major))
499 return False;
500 if (!prs_uint32("minor", ps, depth, &q_u->minor))
501 return False;
502 if (!prs_uint32("processor", ps, depth, &q_u->processor))
503 return False;
504
505 if (!smb_io_unistr2("", &q_u->client_name, q_u->client_name_ptr, ps, depth))
506 return False;
507 if (!prs_align(ps))
508 return False;
509 if (!smb_io_unistr2("", &q_u->user_name, q_u->user_name_ptr, ps, depth))
510 return False;
511
512 return True;
513 }
514
515 /*******************************************************************
516 ********************************************************************/
517
518 static BOOL spool_io_user_level(char *desc, SPOOL_USER_CTR *q_u, prs_struct *ps, int depth)
519 {
520 if (q_u==NULL)
521 return False;
522
523 prs_debug(ps, depth, desc, "spool_io_user_level");
524 depth++;
525
526 if (!prs_align(ps))
527 return False;
528 if (!prs_uint32("level", ps, depth, &q_u->level))
529 return False;
530 if (!prs_uint32("ptr", ps, depth, &q_u->ptr))
531 return False;
532
533 switch (q_u->level) {
534 case 1:
535 if (!spool_io_user_level_1("", &q_u->user1, ps, depth))
536 return False;
537 break;
538 default:
539 return False;
540 }
541
542 return True;
543 }
544
545 /*******************************************************************
546 * read or write a DEVICEMODE struct.
547 * on reading allocate memory for the private member
548 ********************************************************************/
549
550 BOOL spoolss_io_devmode(char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
551 {
552 prs_debug(ps, depth, desc, "spoolss_io_devmode");
553 depth++;
554
555 if (UNMARSHALLING(ps)) {
556 devmode->devicename.buffer = (uint16 *)prs_alloc_mem(ps, 32 * sizeof(uint16) );
557 if (devmode->devicename.buffer == NULL)
558 return False;
559 }
560
561 if (!prs_uint16uni(True,"devicename", ps, depth, devmode->devicename.buffer, 32))
562 return False;
563 if (!prs_uint16("specversion", ps, depth, &devmode->specversion))
564 return False;
565 if (!prs_uint16("driverversion", ps, depth, &devmode->driverversion))
566 return False;
567 if (!prs_uint16("size", ps, depth, &devmode->size))
568 return False;
569 if (!prs_uint16("driverextra", ps, depth, &devmode->driverextra))
570 return False;
571 if (!prs_uint32("fields", ps, depth, &devmode->fields))
572 return False;
573 if (!prs_uint16("orientation", ps, depth, &devmode->orientation))
574 return False;
575 if (!prs_uint16("papersize", ps, depth, &devmode->papersize))
576 return False;
577 if (!prs_uint16("paperlength", ps, depth, &devmode->paperlength))
578 return False;
579 if (!prs_uint16("paperwidth", ps, depth, &devmode->paperwidth))
580 return False;
581 if (!prs_uint16("scale", ps, depth, &devmode->scale))
582 return False;
583 if (!prs_uint16("copies", ps, depth, &devmode->copies))
584 return False;
585 if (!prs_uint16("defaultsource", ps, depth, &devmode->defaultsource))
586 return False;
587 if (!prs_uint16("printquality", ps, depth, &devmode->printquality))
588 return False;
589 if (!prs_uint16("color", ps, depth, &devmode->color))
590 return False;
591 if (!prs_uint16("duplex", ps, depth, &devmode->duplex))
592 return False;
593 if (!prs_uint16("yresolution", ps, depth, &devmode->yresolution))
594 return False;
595 if (!prs_uint16("ttoption", ps, depth, &devmode->ttoption))
596 return False;
597 if (!prs_uint16("collate", ps, depth, &devmode->collate))
598 return False;
599
600 if (UNMARSHALLING(ps)) {
601 devmode->formname.buffer = (uint16 *)prs_alloc_mem(ps, 32 * sizeof(uint16) );
602 if (devmode->formname.buffer == NULL)
603 return False;
604 }
605
606 if (!prs_uint16uni(True, "formname", ps, depth, devmode->formname.buffer, 32))
607 return False;
608 if (!prs_uint16("logpixels", ps, depth, &devmode->logpixels))
609 return False;
610 if (!prs_uint32("bitsperpel", ps, depth, &devmode->bitsperpel))
611 return False;
612 if (!prs_uint32("pelswidth", ps, depth, &devmode->pelswidth))
613 return False;
614 if (!prs_uint32("pelsheight", ps, depth, &devmode->pelsheight))
615 return False;
616 if (!prs_uint32("displayflags", ps, depth, &devmode->displayflags))
617 return False;
618 if (!prs_uint32("displayfrequency", ps, depth, &devmode->displayfrequency))
619 return False;
620 if (!prs_uint32("icmmethod", ps, depth, &devmode->icmmethod))
621 return False;
622 if (!prs_uint32("icmintent", ps, depth, &devmode->icmintent))
623 return False;
624 if (!prs_uint32("mediatype", ps, depth, &devmode->mediatype))
625 return False;
626 if (!prs_uint32("dithertype", ps, depth, &devmode->dithertype))
627 return False;
628 if (!prs_uint32("reserved1", ps, depth, &devmode->reserved1))
629 return False;
630 if (!prs_uint32("reserved2", ps, depth, &devmode->reserved2))
631 return False;
632 if (!prs_uint32("panningwidth", ps, depth, &devmode->panningwidth))
633 return False;
634 if (!prs_uint32("panningheight", ps, depth, &devmode->panningheight))
635 return False;
636
637 if (devmode->driverextra!=0) {
638 if (UNMARSHALLING(ps)) {
639 devmode->private=(uint8 *)prs_alloc_mem(ps, devmode->driverextra*sizeof(uint8));
640 if(devmode->private == NULL)
641 return False;
642 DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for private\n",devmode->driverextra));
643 }
644
645 DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of private\n",devmode->driverextra));
646 if (!prs_uint8s(False, "private", ps, depth,
647 devmode->private, devmode->driverextra))
648 return False;
649 }
650
651 return True;
652 }
653
654 /*******************************************************************
655 Read or write a DEVICEMODE container
656 ********************************************************************/
657
658 static BOOL spoolss_io_devmode_cont(char *desc, DEVMODE_CTR *dm_c, prs_struct *ps, int depth)
659 {
660 if (dm_c==NULL)
661 return False;
662
663 prs_debug(ps, depth, desc, "spoolss_io_devmode_cont");
664 depth++;
665
666 if(!prs_align(ps))
667 return False;
668
669 if (!prs_uint32("size", ps, depth, &dm_c->size))
670 return False;
671
672 if (!prs_uint32("devmode_ptr", ps, depth, &dm_c->devmode_ptr))
673 return False;
674
675 if (dm_c->size==0 || dm_c->devmode_ptr==0) {
676 if (UNMARSHALLING(ps))
677 /* if while reading there is no DEVMODE ... */
678 dm_c->devmode=NULL;
679 return True;
680 }
681
682 /* so we have a DEVICEMODE to follow */
683 if (UNMARSHALLING(ps)) {
684 DEBUG(9,("Allocating memory for spoolss_io_devmode\n"));
685 dm_c->devmode=(DEVICEMODE *)prs_alloc_mem(ps,sizeof(DEVICEMODE));
686 if(dm_c->devmode == NULL)
687 return False;
688 }
689
690 /* this is bad code, shouldn't be there */
691 if (!prs_uint32("size", ps, depth, &dm_c->size))
692 return False;
693
694 if (!spoolss_io_devmode(desc, ps, depth, dm_c->devmode))
695 return False;
696
697 return True;
698 }
699
700 /*******************************************************************
701 ********************************************************************/
702
703 static BOOL spoolss_io_printer_default(char *desc, PRINTER_DEFAULT *pd, prs_struct *ps, int depth)
704 {
705 if (pd==NULL)
706 return False;
707
708 prs_debug(ps, depth, desc, "spoolss_io_printer_default");
709 depth++;
710
711 if (!prs_uint32("datatype_ptr", ps, depth, &pd->datatype_ptr))
712 return False;
713
714 if (!smb_io_unistr2("datatype", &pd->datatype, pd->datatype_ptr, ps,depth))
715 return False;
716
717 if (!prs_align(ps))
718 return False;
719
720 if (!spoolss_io_devmode_cont("", &pd->devmode_cont, ps, depth))
721 return False;
722
723 if (!prs_uint32("access_required", ps, depth, &pd->access_required))
724 return False;
725
726 return True;
727 }
728
729 /*******************************************************************
730 * init a structure.
731 ********************************************************************/
732
733 BOOL make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX *q_u,
734 const fstring printername,
735 const fstring datatype,
736 uint32 access_required,
737 const fstring clientname,
738 const fstring user_name)
739 {
740 DEBUG(5,("make_spoolss_q_open_printer_ex\n"));
741 q_u->printername_ptr = (printername!=NULL)?1:0;
742 init_unistr2(&q_u->printername, printername, strlen(printername)+1);
743
744 q_u->printer_default.datatype_ptr = 0;
745 /*
746 q_u->printer_default.datatype_ptr = (datatype!=NULL)?1:0;
747 init_unistr2(&q_u->printer_default.datatype, datatype, strlen(datatype));
748 */
749 q_u->printer_default.devmode_cont.size=0;
750 q_u->printer_default.devmode_cont.devmode_ptr=0;
751 q_u->printer_default.devmode_cont.devmode=NULL;
752 q_u->printer_default.access_required=access_required;
753 q_u->user_switch=1;
754 q_u->user_ctr.level=1;
755 q_u->user_ctr.ptr=1;
756 q_u->user_ctr.user1.size=strlen(clientname)+strlen(user_name)+10;
757 q_u->user_ctr.user1.client_name_ptr = (clientname!=NULL)?1:0;
758 q_u->user_ctr.user1.user_name_ptr = (user_name!=NULL)?1:0;
759 q_u->user_ctr.user1.build=1381;
760 q_u->user_ctr.user1.major=2;
761 q_u->user_ctr.user1.minor=0;
762 q_u->user_ctr.user1.processor=0;
763 init_unistr2(&q_u->user_ctr.user1.client_name, clientname, strlen(clientname)+1);
764 init_unistr2(&q_u->user_ctr.user1.user_name, user_name, strlen(user_name)+1);
765
766 return True;
767 }
768
769 /*******************************************************************
770 * init a structure.
771 ********************************************************************/
772
773 BOOL make_spoolss_q_addprinterex(
774 TALLOC_CTX *mem_ctx,
775 SPOOL_Q_ADDPRINTEREX *q_u,
776 const char *srv_name,
777 const char* clientname,
778 const char* user_name,
779 uint32 level,
780 PRINTER_INFO_CTR *ctr)
781 {
782 DEBUG(5,("make_spoolss_q_addprinterex\n"));
783
784 if (!ctr) return False;
785
786 ZERO_STRUCTP(q_u);
787
788 q_u->server_name_ptr = (srv_name!=NULL)?1:0;
789 init_unistr2(&q_u->server_name, srv_name, strlen(srv_name));
790
791 q_u->level = level;
792
793 q_u->info.level = level;
794 q_u->info.info_ptr = (ctr->printers_2!=NULL)?1:0;
795 switch (level) {
796 case 2:
797 /* init q_u->info.info2 from *info */
798 if (!make_spoolss_printer_info_2(mem_ctx, &q_u->info.info_2, ctr->printers_2)) {
799 DEBUG(0,("make_spoolss_q_addprinterex: Unable to fill SPOOL_Q_ADDPRINTEREX struct!\n"));
800 return False;
801 }
802 break;
803 default :
804 break;
805 }
806
807 q_u->user_switch=1;
808
809 q_u->user_ctr.level=1;
810 q_u->user_ctr.ptr=1;
811 q_u->user_ctr.user1.client_name_ptr = (clientname!=NULL)?1:0;
812 q_u->user_ctr.user1.user_name_ptr = (user_name!=NULL)?1:0;
813 q_u->user_ctr.user1.build=1381;
814 q_u->user_ctr.user1.major=2;
815 q_u->user_ctr.user1.minor=0;
816 q_u->user_ctr.user1.processor=0;
817 init_unistr2(&q_u->user_ctr.user1.client_name, clientname, strlen(clientname)+1);
818 init_unistr2(&q_u->user_ctr.user1.user_name, user_name, strlen(user_name)+1);
819 q_u->user_ctr.user1.size=q_u->user_ctr.user1.user_name.uni_str_len +
820 q_u->user_ctr.user1.client_name.uni_str_len + 2;
821
822 return True;
823 }
824
825 /*******************************************************************
826 create a SPOOL_PRINTER_INFO_2 stuct from a PRINTER_INFO_2 struct
827 *******************************************************************/
828
829 BOOL make_spoolss_printer_info_2(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_2 **spool_info2,
830 PRINTER_INFO_2 *info)
831 {
832
833 SPOOL_PRINTER_INFO_LEVEL_2 *inf;
834
835 /* allocate the necessary memory */
836 if (!(inf=(SPOOL_PRINTER_INFO_LEVEL_2*)talloc(mem_ctx, sizeof(SPOOL_PRINTER_INFO_LEVEL_2)))) {
837 DEBUG(0,("make_spoolss_printer_info_2: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_2 sruct!\n"));
838 return False;
839 }
840
841 inf->servername_ptr = (info->servername.buffer!=NULL)?1:0;
842 inf->printername_ptr = (info->printername.buffer!=NULL)?1:0;
843 inf->sharename_ptr = (info->sharename.buffer!=NULL)?1:0;
844 inf->portname_ptr = (info->portname.buffer!=NULL)?1:0;
845 inf->drivername_ptr = (info->drivername.buffer!=NULL)?1:0;
846 inf->comment_ptr = (info->comment.buffer!=NULL)?1:0;
847 inf->location_ptr = (info->location.buffer!=NULL)?1:0;
848 inf->devmode_ptr = (info->devmode!=NULL)?1:0;
849 inf->sepfile_ptr = (info->sepfile.buffer!=NULL)?1:0;
850 inf->printprocessor_ptr = (info->printprocessor.buffer!=NULL)?1:0;
851 inf->datatype_ptr = (info->datatype.buffer!=NULL)?1:0;
852 inf->parameters_ptr = (info->parameters.buffer!=NULL)?1:0;
853 inf->secdesc_ptr = (info->secdesc!=NULL)?1:0;
854 inf->attributes = info->attributes;
855 inf->priority = info->priority;
856 inf->default_priority = info->defaultpriority;
857 inf->starttime = info->starttime;
858 inf->untiltime = info->untiltime;
859 inf->cjobs = info->cjobs;
860 inf->averageppm = info->averageppm;
861 init_unistr2_from_unistr(&inf->servername, &info->servername);
862 init_unistr2_from_unistr(&inf->printername, &info->printername);
863 init_unistr2_from_unistr(&inf->sharename, &info->sharename);
864 init_unistr2_from_unistr(&inf->portname, &info->portname);
865 init_unistr2_from_unistr(&inf->drivername, &info->drivername);
866 init_unistr2_from_unistr(&inf->comment, &info->comment);
867 init_unistr2_from_unistr(&inf->location, &info->location);
868 init_unistr2_from_unistr(&inf->sepfile, &info->sepfile);
869 init_unistr2_from_unistr(&inf->printprocessor, &info->printprocessor);
870 init_unistr2_from_unistr(&inf->datatype, &info->datatype);
871 init_unistr2_from_unistr(&inf->parameters, &info->parameters);
872 init_unistr2_from_unistr(&inf->datatype, &info->datatype);
873
874 *spool_info2 = inf;
875
876 return True;
877 }
878
879 /*******************************************************************
880 * read a structure.
881 * called from spoolss_q_open_printer_ex (srv_spoolss.c)
882 ********************************************************************/
883
884 BOOL spoolss_io_q_open_printer_ex(char *desc, SPOOL_Q_OPEN_PRINTER_EX *q_u, prs_struct *ps, int depth)
885 {
886 if (q_u == NULL)
887 return False;
888
889 prs_debug(ps, depth, desc, "spoolss_io_q_open_printer_ex");
890 depth++;
891
892 if (!prs_align(ps))
893 return False;
894
895 if (!prs_uint32("printername_ptr", ps, depth, &q_u->printername_ptr))
896 return False;
897 if (!smb_io_unistr2("", &q_u->printername, q_u->printername_ptr, ps,depth))
898 return False;
899
900 if (!prs_align(ps))
901 return False;
902
903 if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth))
904 return False;
905
906 if (!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
907 return False;
908 if (!spool_io_user_level("", &q_u->user_ctr, ps, depth))
909 return False;
910
911 return True;
912 }
913
914 /*******************************************************************
915 * init a structure.
916 ********************************************************************/
917 BOOL make_spoolss_q_deleteprinterdriver(
918 TALLOC_CTX *mem_ctx,
919 SPOOL_Q_DELETEPRINTERDRIVER *q_u,
920 const char *server,
921 const char* arch,
922 const char* driver
923 )
924 {
925 DEBUG(5,("make_spoolss_q_deleteprinterdriver\n"));
926
927 q_u->server_ptr = (server!=NULL)?1:0;
928
929 /* these must be NULL terminated or else NT4 will
930 complain about invalid parameters --jerry */
931 init_unistr2(&q_u->server, server, strlen(server)+1);
932 init_unistr2(&q_u->arch, arch, strlen(arch)+1);
933 init_unistr2(&q_u->driver, driver, strlen(driver)+1);
934
935
936 return True;
937 }
938
939 /*******************************************************************
940 * write a structure.
941 * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
942 * called from spoolss_open_printer_ex (cli_spoolss.c)
943 ********************************************************************/
944
945 BOOL spoolss_io_r_open_printer_ex(char *desc, SPOOL_R_OPEN_PRINTER_EX *r_u, prs_struct *ps, int depth)
946 {
947 if (r_u == NULL) return False;
948
949 prs_debug(ps, depth, desc, "spoolss_io_r_open_printer_ex");
950 depth++;
951
952 if (!prs_align(ps))
953 return False;
954
955 if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
956 return False;
957
958 if (!prs_werror("status code", ps, depth, &(r_u->status)))
959 return False;
960
961 return True;
962 }
963
964 /*******************************************************************
965 * make a structure.
966 ********************************************************************/
967
968 BOOL make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u,
969 const POLICY_HND *handle,
970 UNISTR2 *valuename, uint32 size)
971 {
972 if (q_u == NULL) return False;
973
974 DEBUG(5,("make_spoolss_q_getprinterdata\n"));
975
976 q_u->handle = *handle;
977 copy_unistr2(&q_u->valuename, valuename);
978 q_u->size = size;
979
980 return True;
981 }
982
983 /*******************************************************************
984 * read a structure.
985 * called from spoolss_q_getprinterdata (srv_spoolss.c)
986 ********************************************************************/
987
988 BOOL spoolss_io_q_getprinterdata(char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_struct *ps, int depth)
989 {
990 if (q_u == NULL)
991 return False;
992
993 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdata");
994 depth++;
995
996 if (!prs_align(ps))
997 return False;
998 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
999 return False;
1000 if (!prs_align(ps))
1001 return False;
1002 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1003 return False;
1004 if (!prs_align(ps))
1005 return False;
1006 if (!prs_uint32("size", ps, depth, &q_u->size))
1007 return False;
1008
1009 return True;
1010 }
1011
1012 /*******************************************************************
1013 * read a structure.
1014 * called from spoolss_q_deleteprinterdata (srv_spoolss.c)
1015 ********************************************************************/
1016
1017 BOOL spoolss_io_q_deleteprinterdata(char *desc, SPOOL_Q_DELETEPRINTERDATA *q_u, prs_struct *ps, int depth)
1018 {
1019 if (q_u == NULL)
1020 return False;
1021
1022 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdata");
1023 depth++;
1024
1025 if (!prs_align(ps))
1026 return False;
1027 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1028 return False;
1029 if (!prs_align(ps))
1030 return False;
1031 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1032 return False;
1033
1034 return True;
1035 }
1036
1037 /*******************************************************************
1038 * write a structure.
1039 * called from spoolss_r_deleteprinterdata (srv_spoolss.c)
1040 ********************************************************************/
1041
1042 BOOL spoolss_io_r_deleteprinterdata(char *desc, SPOOL_R_DELETEPRINTERDATA *r_u, prs_struct *ps, int depth)
1043 {
1044 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdata");
1045 depth++;
1046 if(!prs_werror("status", ps, depth, &r_u->status))
1047 return False;
1048
1049 return True;
1050 }
1051
1052 /*******************************************************************
1053 * write a structure.
1054 * called from spoolss_r_getprinterdata (srv_spoolss.c)
1055 ********************************************************************/
1056
1057 BOOL spoolss_io_r_getprinterdata(char *desc, SPOOL_R_GETPRINTERDATA *r_u, prs_struct *ps, int depth)
1058 {
1059 if (r_u == NULL)
1060 return False;
1061
1062 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdata");
1063 depth++;
1064
1065 if (!prs_align(ps))
1066 return False;
1067 if (!prs_uint32("type", ps, depth, &r_u->type))
1068 return False;
1069 if (!prs_uint32("size", ps, depth, &r_u->size))
1070 return False;
1071
1072 if (!prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size))
1073 return False;
1074
1075 if (!prs_align(ps))
1076 return False;
1077
1078 if (!prs_uint32("needed", ps, depth, &r_u->needed))
1079 return False;
1080 if (!prs_werror("status", ps, depth, &r_u->status))
1081 return False;
1082
1083 return True;
1084 }
1085
1086 /*******************************************************************
1087 * make a structure.
1088 ********************************************************************/
1089
1090 BOOL make_spoolss_q_closeprinter(SPOOL_Q_CLOSEPRINTER *q_u, POLICY_HND *hnd)
1091 {
1092 if (q_u == NULL) return False;
1093
1094 DEBUG(5,("make_spoolss_q_closeprinter\n"));
1095
1096 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
1097
1098 return True;
1099 }
1100
1101 /*******************************************************************
1102 * read a structure.
1103 * called from static spoolss_q_abortprinter (srv_spoolss.c)
1104 * called from spoolss_abortprinter (cli_spoolss.c)
1105 ********************************************************************/
1106
1107 BOOL spoolss_io_q_abortprinter(char *desc, SPOOL_Q_ABORTPRINTER *q_u, prs_struct *ps, int depth)
1108 {
1109 if (q_u == NULL) return False;
1110
1111 prs_debug(ps, depth, desc, "spoolss_io_q_abortprinter");
1112 depth++;
1113
1114 if (!prs_align(ps))
1115 return False;
1116
1117 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1118 return False;
1119
1120 return True;
1121 }
1122
1123 /*******************************************************************
1124 * write a structure.
1125 * called from spoolss_r_abortprinter (srv_spoolss.c)
1126 ********************************************************************/
1127
1128 BOOL spoolss_io_r_abortprinter(char *desc, SPOOL_R_ABORTPRINTER *r_u, prs_struct *ps, int depth)
1129 {
1130 prs_debug(ps, depth, desc, "spoolss_io_r_abortprinter");
1131 depth++;
1132 if(!prs_werror("status", ps, depth, &r_u->status))
1133 return False;
1134
1135 return True;
1136 }
1137
1138 /*******************************************************************
1139 * read a structure.
1140 * called from static spoolss_q_deleteprinter (srv_spoolss.c)
1141 * called from spoolss_deleteprinter (cli_spoolss.c)
1142 ********************************************************************/
1143
1144 BOOL spoolss_io_q_deleteprinter(char *desc, SPOOL_Q_DELETEPRINTER *q_u, prs_struct *ps, int depth)
1145 {
1146 if (q_u == NULL) return False;
1147
1148 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinter");
1149 depth++;
1150
1151 if (!prs_align(ps))
1152 return False;
1153
1154 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1155 return False;
1156
1157 return True;
1158 }
1159
1160 /*******************************************************************
1161 * write a structure.
1162 * called from static spoolss_r_deleteprinter (srv_spoolss.c)
1163 * called from spoolss_deleteprinter (cli_spoolss.c)
1164 ********************************************************************/
1165
1166 BOOL spoolss_io_r_deleteprinter(char *desc, SPOOL_R_DELETEPRINTER *r_u, prs_struct *ps, int depth)
1167 {
1168 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinter");
1169 depth++;
1170
1171 if (!prs_align(ps))
1172 return False;
1173
1174 if (!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
1175 return False;
1176 if (!prs_werror("status", ps, depth, &r_u->status))
1177 return False;
1178
1179 return True;
1180 }
1181
1182
1183 /*******************************************************************
1184 * read a structure.
1185 * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1186 * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1187 ********************************************************************/
1188
1189 BOOL spoolss_io_q_deleteprinterdriver(char *desc, SPOOL_Q_DELETEPRINTERDRIVER *q_u, prs_struct *ps, int depth)
1190 {
1191 if (q_u == NULL) return False;
1192
1193 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriver");
1194 depth++;
1195
1196 if (!prs_align(ps))
1197 return False;
1198
1199 if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
1200 return False;
1201 if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
1202 return False;
1203 if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
1204 return False;
1205 if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
1206 return False;
1207
1208
1209 return True;
1210 }
1211
1212
1213 /*******************************************************************
1214 * write a structure.
1215 ********************************************************************/
1216 BOOL spoolss_io_r_deleteprinterdriver(char *desc, SPOOL_R_DELETEPRINTERDRIVER *r_u, prs_struct *ps, int depth)
1217 {
1218 if (r_u == NULL) return False;
1219
1220 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriver");
1221 depth++;
1222
1223 if (!prs_align(ps))
1224 return False;
1225
1226 if (!prs_werror("status", ps, depth, &r_u->status))
1227 return False;
1228
1229 return True;
1230 }
1231
1232
1233
1234 /*******************************************************************
1235 * read a structure.
1236 * called from static spoolss_q_closeprinter (srv_spoolss.c)
1237 * called from spoolss_closeprinter (cli_spoolss.c)
1238 ********************************************************************/
1239
1240 BOOL spoolss_io_q_closeprinter(char *desc, SPOOL_Q_CLOSEPRINTER *q_u, prs_struct *ps, int depth)
1241 {
1242 if (q_u == NULL) return False;
1243
1244 prs_debug(ps, depth, desc, "spoolss_io_q_closeprinter");
1245 depth++;
1246
1247 if (!prs_align(ps))
1248 return False;
1249
1250 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1251 return False;
1252
1253 return True;
1254 }
1255
1256 /*******************************************************************
1257 * write a structure.
1258 * called from static spoolss_r_closeprinter (srv_spoolss.c)
1259 * called from spoolss_closeprinter (cli_spoolss.c)
1260 ********************************************************************/
1261
1262 BOOL spoolss_io_r_closeprinter(char *desc, SPOOL_R_CLOSEPRINTER *r_u, prs_struct *ps, int depth)
1263 {
1264 prs_debug(ps, depth, desc, "spoolss_io_r_closeprinter");
1265 depth++;
1266
1267 if (!prs_align(ps))
1268 return False;
1269
1270 if (!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
1271 return False;
1272 if (!prs_werror("status", ps, depth, &r_u->status))
1273 return False;
1274
1275 return True;
1276 }
1277
1278 /*******************************************************************
1279 * read a structure.
1280 * called from spoolss_q_startdocprinter (srv_spoolss.c)
1281 ********************************************************************/
1282
1283 BOOL spoolss_io_q_startdocprinter(char *desc, SPOOL_Q_STARTDOCPRINTER *q_u, prs_struct *ps, int depth)
1284 {
1285 if (q_u == NULL) return False;
1286
1287 prs_debug(ps, depth, desc, "spoolss_io_q_startdocprinter");
1288 depth++;
1289
1290 if(!prs_align(ps))
1291 return False;
1292
1293 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1294 return False;
1295
1296 if(!smb_io_doc_info_container("",&q_u->doc_info_container, ps, depth))
1297 return False;
1298
1299 return True;
1300 }
1301
1302 /*******************************************************************
1303 * write a structure.
1304 * called from spoolss_r_startdocprinter (srv_spoolss.c)
1305 ********************************************************************/
1306
1307 BOOL spoolss_io_r_startdocprinter(char *desc, SPOOL_R_STARTDOCPRINTER *r_u, prs_struct *ps, int depth)
1308 {
1309 prs_debug(ps, depth, desc, "spoolss_io_r_startdocprinter");
1310 depth++;
1311 if(!prs_uint32("jobid", ps, depth, &r_u->jobid))
1312 return False;
1313 if(!prs_werror("status", ps, depth, &r_u->status))
1314 return False;
1315
1316 return True;
1317 }
1318
1319 /*******************************************************************
1320 * read a structure.
1321 * called from spoolss_q_enddocprinter (srv_spoolss.c)
1322 ********************************************************************/
1323
1324 BOOL spoolss_io_q_enddocprinter(char *desc, SPOOL_Q_ENDDOCPRINTER *q_u, prs_struct *ps, int depth)
1325 {
1326 if (q_u == NULL) return False;
1327
1328 prs_debug(ps, depth, desc, "spoolss_io_q_enddocprinter");
1329 depth++;
1330
1331 if(!prs_align(ps))
1332 return False;
1333
1334 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1335 return False;
1336
1337 return True;
1338 }
1339
1340 /*******************************************************************
1341 * write a structure.
1342 * called from spoolss_r_enddocprinter (srv_spoolss.c)
1343 ********************************************************************/
1344
1345 BOOL spoolss_io_r_enddocprinter(char *desc, SPOOL_R_ENDDOCPRINTER *r_u, prs_struct *ps, int depth)
1346 {
1347 prs_debug(ps, depth, desc, "spoolss_io_r_enddocprinter");
1348 depth++;
1349 if(!prs_werror("status", ps, depth, &r_u->status))
1350 return False;
1351
1352 return True;
1353 }
1354
1355 /*******************************************************************
1356 * read a structure.
1357 * called from spoolss_q_startpageprinter (srv_spoolss.c)
1358 ********************************************************************/
1359
1360 BOOL spoolss_io_q_startpageprinter(char *desc, SPOOL_Q_STARTPAGEPRINTER *q_u, prs_struct *ps, int depth)
1361 {
1362 if (q_u == NULL) return False;
1363
1364 prs_debug(ps, depth, desc, "spoolss_io_q_startpageprinter");
1365 depth++;
1366
1367 if(!prs_align(ps))
1368 return False;
1369
1370 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1371 return False;
1372
1373 return True;
1374 }
1375
1376 /*******************************************************************
1377 * write a structure.
1378 * called from spoolss_r_startpageprinter (srv_spoolss.c)
1379 ********************************************************************/
1380
1381 BOOL spoolss_io_r_startpageprinter(char *desc, SPOOL_R_STARTPAGEPRINTER *r_u, prs_struct *ps, int depth)
1382 {
1383 prs_debug(ps, depth, desc, "spoolss_io_r_startpageprinter");
1384 depth++;
1385 if(!prs_werror("status", ps, depth, &r_u->status))
1386 return False;
1387
1388 return True;
1389 }
1390
1391 /*******************************************************************
1392 * read a structure.
1393 * called from spoolss_q_endpageprinter (srv_spoolss.c)
1394 ********************************************************************/
1395
1396 BOOL spoolss_io_q_endpageprinter(char *desc, SPOOL_Q_ENDPAGEPRINTER *q_u, prs_struct *ps, int depth)
1397 {
1398 if (q_u == NULL) return False;
1399
1400 prs_debug(ps, depth, desc, "spoolss_io_q_endpageprinter");
1401 depth++;
1402
1403 if(!prs_align(ps))
1404 return False;
1405
1406 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1407 return False;
1408
1409 return True;
1410 }
1411
1412 /*******************************************************************
1413 * write a structure.
1414 * called from spoolss_r_endpageprinter (srv_spoolss.c)
1415 ********************************************************************/
1416
1417 BOOL spoolss_io_r_endpageprinter(char *desc, SPOOL_R_ENDPAGEPRINTER *r_u, prs_struct *ps, int depth)
1418 {
1419 prs_debug(ps, depth, desc, "spoolss_io_r_endpageprinter");
1420 depth++;
1421 if(!prs_werror("status", ps, depth, &r_u->status))
1422 return False;
1423
1424 return True;
1425 }
1426
1427 /*******************************************************************
1428 * read a structure.
1429 * called from spoolss_q_writeprinter (srv_spoolss.c)
1430 ********************************************************************/
1431
1432 BOOL spoolss_io_q_writeprinter(char *desc, SPOOL_Q_WRITEPRINTER *q_u, prs_struct *ps, int depth)
1433 {
1434 if (q_u == NULL) return False;
1435
1436 prs_debug(ps, depth, desc, "spoolss_io_q_writeprinter");
1437 depth++;
1438
1439 if(!prs_align(ps))
1440 return False;
1441
1442 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1443 return False;
1444 if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size))
1445 return False;
1446
1447 if (q_u->buffer_size!=0)
1448 {
1449 if (UNMARSHALLING(ps))
1450 q_u->buffer=(uint8 *)prs_alloc_mem(ps,q_u->buffer_size*sizeof(uint8));
1451 if(q_u->buffer == NULL)
1452 return False;
1453 if(!prs_uint8s(True, "buffer", ps, depth, q_u->buffer, q_u->buffer_size))
1454 return False;
1455 }
1456 if(!prs_align(ps))
1457 return False;
1458 if(!prs_uint32("buffer_size2", ps, depth, &q_u->buffer_size2))
1459 return False;
1460
1461 return True;
1462 }
1463
1464 /*******************************************************************
1465 * write a structure.
1466 * called from spoolss_r_writeprinter (srv_spoolss.c)
1467 ********************************************************************/
1468
1469 BOOL spoolss_io_r_writeprinter(char *desc, SPOOL_R_WRITEPRINTER *r_u, prs_struct *ps, int depth)
1470 {
1471 prs_debug(ps, depth, desc, "spoolss_io_r_writeprinter");
1472 depth++;
1473 if(!prs_uint32("buffer_written", ps, depth, &r_u->buffer_written))
1474 return False;
1475 if(!prs_werror("status", ps, depth, &r_u->status))
1476 return False;
1477
1478 return True;
1479 }
1480
1481 /*******************************************************************
1482 * read a structure.
1483 * called from spoolss_q_rffpcnex (srv_spoolss.c)
1484 ********************************************************************/
1485
1486 BOOL spoolss_io_q_rffpcnex(char *desc, SPOOL_Q_RFFPCNEX *q_u, prs_struct *ps, int depth)
1487 {
1488 prs_debug(ps, depth, desc, "spoolss_io_q_rffpcnex");
1489 depth++;
1490
1491 if(!prs_align(ps))
1492 return False;
1493
1494 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1495 return False;
1496 if(!prs_uint32("flags", ps, depth, &q_u->flags))
1497 return False;
1498 if(!prs_uint32("options", ps, depth, &q_u->options))
1499 return False;
1500 if(!prs_uint32("localmachine_ptr", ps, depth, &q_u->localmachine_ptr))
1501 return False;
1502 if(!smb_io_unistr2("localmachine", &q_u->localmachine, q_u->localmachine_ptr, ps, depth))
1503 return False;
1504
1505 if(!prs_align(ps))
1506 return False;
1507
1508 if(!prs_uint32("printerlocal", ps, depth, &q_u->printerlocal))
1509 return False;
1510
1511 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1512 return False;
1513
1514 if (q_u->option_ptr!=0) {
1515
1516 if (UNMARSHALLING(ps))
1517 if((q_u->option=(SPOOL_NOTIFY_OPTION *)prs_alloc_mem(ps,sizeof(SPOOL_NOTIFY_OPTION))) == NULL)
1518 return False;
1519
1520 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1521 return False;
1522 }
1523
1524 return True;
1525 }
1526
1527 /*******************************************************************
1528 * write a structure.
1529 * called from spoolss_r_rffpcnex (srv_spoolss.c)
1530 ********************************************************************/
1531
1532 BOOL spoolss_io_r_rffpcnex(char *desc, SPOOL_R_RFFPCNEX *r_u, prs_struct *ps, int depth)
1533 {
1534 prs_debug(ps, depth, desc, "spoolss_io_r_rffpcnex");
1535 depth++;
1536
1537 if(!prs_werror("status", ps, depth, &r_u->status))
1538 return False;
1539
1540 return True;
1541 }
1542
1543 /*******************************************************************
1544 * read a structure.
1545 * called from spoolss_q_rfnpcnex (srv_spoolss.c)
1546 ********************************************************************/
1547
1548 BOOL spoolss_io_q_rfnpcnex(char *desc, SPOOL_Q_RFNPCNEX *q_u, prs_struct *ps, int depth)
1549 {
1550 prs_debug(ps, depth, desc, "spoolss_io_q_rfnpcnex");
1551 depth++;
1552
1553 if(!prs_align(ps))
1554 return False;
1555
1556 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1557 return False;
1558
1559 if(!prs_uint32("change", ps, depth, &q_u->change))
1560 return False;
1561
1562 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1563 return False;
1564
1565 if (q_u->option_ptr!=0) {
1566
1567 if (UNMARSHALLING(ps))
1568 if((q_u->option=(SPOOL_NOTIFY_OPTION *)prs_alloc_mem(ps,sizeof(SPOOL_NOTIFY_OPTION))) == NULL)
1569 return False;
1570
1571 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1572 return False;
1573 }
1574
1575 return True;
1576 }
1577
1578 /*******************************************************************
1579 * write a structure.
1580 * called from spoolss_r_rfnpcnex (srv_spoolss.c)
1581 ********************************************************************/
1582
1583 BOOL spoolss_io_r_rfnpcnex(char *desc, SPOOL_R_RFNPCNEX *r_u, prs_struct *ps, int depth)
1584 {
1585 prs_debug(ps, depth, desc, "spoolss_io_r_rfnpcnex");
1586 depth++;
1587
1588 if(!prs_align(ps))
1589 return False;
1590
1591 if (!prs_uint32("info_ptr", ps, depth, &r_u->info_ptr))
1592 return False;
1593
1594 if(!smb_io_notify_info("notify info", &r_u->info ,ps,depth))
1595 return False;
1596
1597 if(!prs_align(ps))
1598 return False;
1599 if(!prs_werror("status", ps, depth, &r_u->status))
1600 return False;
1601
1602 return True;
1603 }
1604
1605 /*******************************************************************
1606 * return the length of a uint16 (obvious, but the code is clean)
1607 ********************************************************************/
1608
1609 static uint32 size_of_uint16(uint16 *value)
1610 {
1611 return (sizeof(*value));
1612 }
1613
1614 /*******************************************************************
1615 * return the length of a uint32 (obvious, but the code is clean)
1616 ********************************************************************/
1617
1618 static uint32 size_of_uint32(uint32 *value)
1619 {
1620 return (sizeof(*value));
1621 }
1622
1623 /*******************************************************************
1624 * return the length of a NTTIME (obvious, but the code is clean)
1625 ********************************************************************/
1626
1627 static uint32 size_of_nttime(NTTIME *value)
1628 {
1629 return (sizeof(*value));
1630 }
1631
1632 /*******************************************************************
1633 * return the length of a UNICODE string in number of char, includes:
1634 * - the leading zero
1635 * - the relative pointer size
1636 ********************************************************************/
1637
1638 static uint32 size_of_relative_string(UNISTR *string)
1639 {
1640 uint32 size=0;
1641
1642 size=str_len_uni(string); /* the string length */
1643 size=size+1; /* add the leading zero */
1644 size=size*2; /* convert in char */
1645 /* Ensure size is 4 byte multiple (prs_align is being called...). */
1646 size += ((4 - (size & 3)) & 3);
1647 size=size+4; /* add the size of the ptr */
1648
1649 return size;
1650 }
1651
1652 /*******************************************************************
1653 * return the length of a uint32 (obvious, but the code is clean)
1654 ********************************************************************/
1655
1656 static uint32 size_of_device_mode(DEVICEMODE *devmode)
1657 {
1658 if (devmode==NULL)
1659 return (4);
1660 else
1661 return (4+devmode->size+devmode->driverextra);
1662 }
1663
1664 /*******************************************************************
1665 * return the length of a uint32 (obvious, but the code is clean)
1666 ********************************************************************/
1667
1668 static uint32 size_of_systemtime(SYSTEMTIME *systime)
1669 {
1670 if (systime==NULL)
1671 return (4);
1672 else
1673 return (sizeof(SYSTEMTIME) +4);
1674 }
1675
1676 /*******************************************************************
1677 * write a UNICODE string.
1678 * used by all the RPC structs passing a buffer
1679 ********************************************************************/
1680
1681 static BOOL spoolss_smb_io_unistr(char *desc, UNISTR *uni, prs_struct *ps, int depth)
1682 {
1683 if (uni == NULL)
1684 return False;
1685
1686 prs_debug(ps, depth, desc, "spoolss_smb_io_unistr");
1687 depth++;
1688
1689 /* there should be no align here as it can mess up
1690 parsing a NEW_BUFFER->prs */
1691 #if 0 /* JERRY */
1692 if (!prs_align(ps))
1693 return False;
1694 #endif
1695
1696 if (!prs_unistr("unistr", ps, depth, uni))
1697 return False;
1698
1699 return True;
1700 }
1701
1702 /*******************************************************************
1703 * write a UNICODE string and its relative pointer.
1704 * used by all the RPC structs passing a buffer
1705 *
1706 * As I'm a nice guy, I'm forcing myself to explain this code.
1707 * MS did a good job in the overall spoolss code except in some
1708 * functions where they are passing the API buffer directly in the
1709 * RPC request/reply. That's to maintain compatiility at the API level.
1710 * They could have done it the good way the first time.
1711 *
1712 * So what happen is: the strings are written at the buffer's end,
1713 * in the reverse order of the original structure. Some pointers to
1714 * the strings are also in the buffer. Those are relative to the
1715 * buffer's start.
1716 *
1717 * If you don't understand or want to change that function,
1718 * first get in touch with me: jfm@samba.org
1719 *
1720 ********************************************************************/
1721
1722 static BOOL smb_io_relstr(char *desc, NEW_BUFFER *buffer, int depth, UNISTR *string)
1723 {
1724 prs_struct *ps=&buffer->prs;
1725
1726 if (MARSHALLING(ps)) {
1727 uint32 struct_offset = prs_offset(ps);
1728 uint32 relative_offset;
1729
1730 buffer->string_at_end -= (size_of_relative_string(string) - 4);
1731 if(!prs_set_offset(ps, buffer->string_at_end))
1732 return False;
1733 if (!prs_align(ps))
1734 return False;
1735 buffer->string_at_end = prs_offset(ps);
1736
1737 /* write the string */
1738 if (!smb_io_unistr(desc, string, ps, depth))
1739 return False;
1740
1741 if(!prs_set_offset(ps, struct_offset))
1742 return False;
1743
1744 relative_offset=buffer->string_at_end - buffer->struct_start;
1745 /* write its offset */
1746 if (!prs_uint32("offset", ps, depth, &relative_offset))
1747 return False;
1748 }
1749 else {
1750 uint32 old_offset;
1751
1752 /* read the offset */
1753 if (!prs_uint32("offset", ps, depth, &(buffer->string_at_end)))
1754 return False;
1755
1756 old_offset = prs_offset(ps);
1757 if(!prs_set_offset(ps, buffer->string_at_end+buffer->struct_start))
1758 return False;
1759
1760 /* read the string */
1761 if (!spoolss_smb_io_unistr(desc, string, ps, depth))
1762 return False;
1763
1764 if(!prs_set_offset(ps, old_offset))
1765 return False;
1766 }
1767 return True;
1768 }
1769
1770 /*******************************************************************
1771 * write a array of UNICODE strings and its relative pointer.
1772 * used by 2 RPC structs
1773 ********************************************************************/
1774
1775 static BOOL smb_io_relarraystr(char *desc, NEW_BUFFER *buffer, int depth, uint16 **string)
1776 {
1777 UNISTR chaine;
1778
1779 prs_struct *ps=&buffer->prs;
1780
1781 if (MARSHALLING(ps)) {
1782 uint32 struct_offset = prs_offset(ps);
1783 uint32 relative_offset;
1784 uint16 *p;
1785 uint16 *q;
1786 uint16 zero=0;
1787 p=*string;
1788 q=*string;
1789
1790 /* first write the last 0 */
1791 buffer->string_at_end -= 2;
1792 if(!prs_set_offset(ps, buffer->string_at_end))
1793 return False;
1794
1795 if(!prs_uint16("leading zero", ps, depth, &zero))
1796 return False;
1797
1798 while (p && (*p!=0)) {
1799 while (*q!=0)
1800 q++;
1801
1802 /* Yes this should be malloc not talloc. Don't change. */
1803
1804 chaine.buffer = malloc((q-p+1)*sizeof(uint16));
1805 if (chaine.buffer == NULL)
1806 return False;
1807
1808 memcpy(chaine.buffer, p, (q-p+1)*sizeof(uint16));
1809
1810 buffer->string_at_end -= (q-p+1)*sizeof(uint16);
1811
1812 if(!prs_set_offset(ps, buffer->string_at_end)) {
1813 SAFE_FREE(chaine.buffer);
1814 return False;
1815 }
1816
1817 /* write the string */
1818 if (!spoolss_smb_io_unistr(desc, &chaine, ps, depth)) {
1819 SAFE_FREE(chaine.buffer);
1820 return False;
1821 }
1822 q++;
1823 p=q;
1824
1825 SAFE_FREE(chaine.buffer);
1826 }
1827
1828 if(!prs_set_offset(ps, struct_offset))
1829 return False;
1830
1831 relative_offset=buffer->string_at_end - buffer->struct_start;
1832 /* write its offset */
1833 if (!prs_uint32("offset", ps, depth, &relative_offset))
1834 return False;
1835
1836 } else {
1837
1838 /* UNMARSHALLING */
1839
1840 uint32 old_offset;
1841 uint16 *chaine2=NULL;
1842 int l_chaine=0;
1843 int l_chaine2=0;
1844 size_t realloc_size = 0;
1845
1846 *string=NULL;
1847
1848 /* read the offset */
1849 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
1850 return False;
1851
1852 old_offset = prs_offset(ps);
1853 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
1854 return False;
1855
1856 do {
1857 if (!spoolss_smb_io_unistr(desc, &chaine, ps, depth))
1858 return False;
1859
1860 l_chaine=str_len_uni(&chaine);
1861
1862 /* we're going to add two more bytes here in case this
1863 is the last string in the array and we need to add
1864 an extra NULL for termination */
1865 if (l_chaine > 0)
1866 {
1867 uint16 *tc2;
1868
1869 realloc_size = (l_chaine2+l_chaine+2)*sizeof(uint16);
1870
1871 /* Yes this should be realloc - it's freed below. JRA */
1872
1873 if((tc2=(uint16 *)Realloc(chaine2, realloc_size)) == NULL) {
1874 SAFE_FREE(chaine2);
1875 return False;
1876 }
1877 else chaine2 = tc2;
1878 memcpy(chaine2+l_chaine2, chaine.buffer, (l_chaine+1)*sizeof(uint16));
1879 l_chaine2+=l_chaine+1;
1880 }
1881
1882 } while(l_chaine!=0);
1883
1884 /* the end should be bould NULL terminated so add
1885 the second one here */
1886 if (chaine2)
1887 {
1888 chaine2[l_chaine2] = '\0';
1889 *string=(uint16 *)talloc_memdup(prs_get_mem_context(ps),chaine2,realloc_size);
1890 SAFE_FREE(chaine2);
1891 }
1892
1893 if(!prs_set_offset(ps, old_offset))
1894 return False;
1895 }
1896 return True;
1897 }
1898
1899 /*******************************************************************
1900 Parse a DEVMODE structure and its relative pointer.
1901 ********************************************************************/
1902
1903 static BOOL smb_io_relsecdesc(char *desc, NEW_BUFFER *buffer, int depth, SEC_DESC **secdesc)
1904 {
1905 prs_struct *ps= &buffer->prs;
1906
1907 prs_debug(ps, depth, desc, "smb_io_relsecdesc");
1908 depth++;
1909
1910 if (MARSHALLING(ps)) {
1911 uint32 struct_offset = prs_offset(ps);
1912 uint32 relative_offset;
1913
1914 if (! *secdesc) {
1915 relative_offset = 0;
1916 if (!prs_uint32("offset", ps, depth, &relative_offset))
1917 return False;
1918 return True;
1919 }
1920
1921 if (*secdesc != NULL) {
1922 buffer->string_at_end -= sec_desc_size(*secdesc);
1923
1924 if(!prs_set_offset(ps, buffer->string_at_end))
1925 return False;
1926 /* write the secdesc */
1927 if (!sec_io_desc(desc, secdesc, ps, depth))
1928 return False;
1929
1930 if(!prs_set_offset(ps, struct_offset))
1931 return False;
1932 }
1933
1934 relative_offset=buffer->string_at_end - buffer->struct_start;
1935 /* write its offset */
1936
1937 if (!prs_uint32("offset", ps, depth, &relative_offset))
1938 return False;
1939 } else {
1940 uint32 old_offset;
1941
1942 /* read the offset */
1943 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
1944 return False;
1945
1946 old_offset = prs_offset(ps);
1947 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
1948 return False;
1949
1950 /* read the sd */
1951 if (!sec_io_desc(desc, secdesc, ps, depth))
1952 return False;
1953
1954 if(!prs_set_offset(ps, old_offset))
1955 return False;
1956 }
1957 return True;
1958 }
1959
1960 /*******************************************************************
1961 Parse a DEVMODE structure and its relative pointer.
1962 ********************************************************************/
1963
1964 static BOOL smb_io_reldevmode(char *desc, NEW_BUFFER *buffer, int depth, DEVICEMODE **devmode)
1965 {
1966 prs_struct *ps=&buffer->prs;
1967
1968 prs_debug(ps, depth, desc, "smb_io_reldevmode");
1969 depth++;
1970
1971 if (MARSHALLING(ps)) {
1972 uint32 struct_offset = prs_offset(ps);
1973 uint32 relative_offset;
1974
1975 if (*devmode == NULL) {
1976 relative_offset=0;
1977 if (!prs_uint32("offset", ps, depth, &relative_offset))
1978 return False;
1979 DEBUG(8, ("boing, the devmode was NULL\n"));
1980
1981 return True;
1982 }
1983
1984 buffer->string_at_end -= ((*devmode)->size + (*devmode)->driverextra);
1985
1986 if(!prs_set_offset(ps, buffer->string_at_end))
1987 return False;
1988
1989 /* write the DEVMODE */
1990 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
1991 return False;
1992
1993 if(!prs_set_offset(ps, struct_offset))
1994 return False;
1995
1996 relative_offset=buffer->string_at_end - buffer->struct_start;
1997 /* write its offset */
1998 if (!prs_uint32("offset", ps, depth, &relative_offset))
1999 return False;
2000 }
2001 else {
2002 uint32 old_offset;
2003
2004 /* read the offset */
2005 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
2006 return False;
2007
2008 old_offset = prs_offset(ps);
2009 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
2010 return False;
2011
2012 /* read the string */
2013 if((*devmode=(DEVICEMODE *)prs_alloc_mem(ps,sizeof(DEVICEMODE))) == NULL)
2014 return False;
2015 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
2016 return False;
2017
2018 if(!prs_set_offset(ps, old_offset))
2019 return False;
2020 }
2021 return True;
2022 }
2023
2024 /*******************************************************************
2025 Parse a PRINTER_INFO_0 structure.
2026 ********************************************************************/
2027
2028 BOOL smb_io_printer_info_0(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_0 *info, int depth)
2029 {
2030 prs_struct *ps=&buffer->prs;
2031
2032 prs_debug(ps, depth, desc, "smb_io_printer_info_0");
2033 depth++;
2034
2035 buffer->struct_start=prs_offset(ps);
2036
2037 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2038 return False;
2039 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2040 return False;
2041
2042 if(!prs_uint32("cjobs", ps, depth, &info->cjobs))
2043 return False;
2044 if(!prs_uint32("total_jobs", ps, depth, &info->total_jobs))
2045 return False;
2046 if(!prs_uint32("total_bytes", ps, depth, &info->total_bytes))
2047 return False;
2048
2049 if(!prs_uint16("year", ps, depth, &info->year))
2050 return False;
2051 if(!prs_uint16("month", ps, depth, &info->month))
2052 return False;
2053 if(!prs_uint16("dayofweek", ps, depth, &info->dayofweek))
2054 return False;
2055 if(!prs_uint16("day", ps, depth, &info->day))
2056 return False;
2057 if(!prs_uint16("hour", ps, depth, &info->hour))
2058 return False;
2059 if(!prs_uint16("minute", ps, depth, &info->minute))
2060 return False;
2061 if(!prs_uint16("second", ps, depth, &info->second))
2062 return False;
2063 if(!prs_uint16("milliseconds", ps, depth, &info->milliseconds))
2064 return False;
2065
2066 if(!prs_uint32("global_counter", ps, depth, &info->global_counter))
2067 return False;
2068 if(!prs_uint32("total_pages", ps, depth, &info->total_pages))
2069 return False;
2070
2071 if(!prs_uint16("major_version", ps, depth, &info->major_version))
2072 return False;
2073 if(!prs_uint16("build_version", ps, depth, &info->build_version))
2074 return False;
2075 if(!prs_uint32("unknown7", ps, depth, &info->unknown7))
2076 return False;
2077 if(!prs_uint32("unknown8", ps, depth, &info->unknown8))
2078 return False;
2079 if(!prs_uint32("unknown9", ps, depth, &info->unknown9))
2080 return False;
2081 if(!prs_uint32("session_counter", ps, depth, &info->session_counter))
2082 return False;
2083 if(!prs_uint32("unknown11", ps, depth, &info->unknown11))
2084 return False;
2085 if(!prs_uint32("printer_errors", ps, depth, &info->printer_errors))
2086 return False;
2087 if(!prs_uint32("unknown13", ps, depth, &info->unknown13))
2088 return False;
2089 if(!prs_uint32("unknown14", ps, depth, &info->unknown14))
2090 return False;
2091 if(!prs_uint32("unknown15", ps, depth, &info->unknown15))
2092 return False;
2093 if(!prs_uint32("unknown16", ps, depth, &info->unknown16))
2094 return False;
2095 if(!prs_uint32("change_id", ps, depth, &info->change_id))
2096 return False;
2097 if(!prs_uint32("unknown18", ps, depth, &info->unknown18))
2098 return False;
2099 if(!prs_uint32("status" , ps, depth, &info->status))
2100 return False;
2101 if(!prs_uint32("unknown20", ps, depth, &info->unknown20))
2102 return False;
2103 if(!prs_uint32("c_setprinter", ps, depth, &info->c_setprinter))
2104 return False;
2105 if(!prs_uint16("unknown22", ps, depth, &info->unknown22))
2106 return False;
2107 if(!prs_uint16("unknown23", ps, depth, &info->unknown23))
2108 return False;
2109 if(!prs_uint16("unknown24", ps, depth, &info->unknown24))
2110 return False;
2111 if(!prs_uint16("unknown25", ps, depth, &info->unknown25))
2112 return False;
2113 if(!prs_uint16("unknown26", ps, depth, &info->unknown26))
2114 return False;
2115 if(!prs_uint16("unknown27", ps, depth, &info->unknown27))
2116 return False;
2117 if(!prs_uint16("unknown28", ps, depth, &info->unknown28))
2118 return False;
2119 if(!prs_uint16("unknown29", ps, depth, &info->unknown29))
2120 return False;
2121
2122 return True;
2123 }
2124
2125 /*******************************************************************
2126 Parse a PRINTER_INFO_1 structure.
2127 ********************************************************************/
2128
2129 BOOL smb_io_printer_info_1(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_1 *info, int depth)
2130 {
2131 prs_struct *ps=&buffer->prs;
2132
2133 prs_debug(ps, depth, desc, "smb_io_printer_info_1");
2134 depth++;
2135
2136 buffer->struct_start=prs_offset(ps);
2137
2138 if (!prs_uint32("flags", ps, depth, &info->flags))
2139 return False;
2140 if (!smb_io_relstr("description", buffer, depth, &info->description))
2141 return False;
2142 if (!smb_io_relstr("name", buffer, depth, &info->name))
2143 return False;
2144 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2145 return False;
2146
2147 return True;
2148 }
2149
2150 /*******************************************************************
2151 Parse a PRINTER_INFO_2 structure.
2152 ********************************************************************/
2153
2154 BOOL smb_io_printer_info_2(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_2 *info, int depth)
2155 {
2156 prs_struct *ps=&buffer->prs;
2157
2158 prs_debug(ps, depth, desc, "smb_io_printer_info_2");
2159 depth++;
2160
2161 buffer->struct_start=prs_offset(ps);
2162
2163 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2164 return False;
2165 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2166 return False;
2167 if (!smb_io_relstr("sharename", buffer, depth, &info->sharename))
2168 return False;
2169 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2170 return False;
2171 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2172 return False;
2173 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2174 return False;
2175 if (!smb_io_relstr("location", buffer, depth, &info->location))
2176 return False;
2177
2178 /* NT parses the DEVMODE at the end of the struct */
2179 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2180 return False;
2181
2182 if (!smb_io_relstr("sepfile", buffer, depth, &info->sepfile))
2183 return False;
2184 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2185 return False;
2186 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2187 return False;
2188 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2189 return False;
2190
2191 if (!smb_io_relsecdesc("secdesc", buffer, depth, &info->secdesc))
2192 return False;
2193
2194 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2195 return False;
2196 if (!prs_uint32("priority", ps, depth, &info->priority))
2197 return False;
2198 if (!prs_uint32("defpriority", ps, depth, &info->defaultpriority))
2199 return False;
2200 if (!prs_uint32("starttime", ps, depth, &info->starttime))
2201 return False;
2202 if (!prs_uint32("untiltime", ps, depth, &info->untiltime))
2203 return False;
2204 if (!prs_uint32("status", ps, depth, &info->status))
2205 return False;
2206 if (!prs_uint32("jobs", ps, depth, &info->cjobs))
2207 return False;
2208 if (!prs_uint32("averageppm", ps, depth, &info->averageppm))
2209 return False;
2210
2211 #if 0 /* JFMTEST */
2212 if (!prs_uint32_post("secdesc_ptr", ps, depth, NULL, sec_offset, info->secdesc ? prs_offset(ps)-buffer->struct_start : 0 ))
2213 return False;
2214
2215 if (!sec_io_desc("secdesc", &info->secdesc, ps, depth))
2216 return False;
2217 #endif
2218 return True;
2219 }
2220
2221 /*******************************************************************
2222 Parse a PRINTER_INFO_3 structure.
2223 ********************************************************************/
2224
2225 BOOL smb_io_printer_info_3(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_3 *info, int depth)
2226 {
2227 prs_struct *ps=&buffer->prs;
2228
2229 prs_debug(ps, depth, desc, "smb_io_printer_info_3");
2230 depth++;
2231
2232 buffer->struct_start=prs_offset(ps);
2233
2234 if (!prs_uint32("flags", ps, depth, &info->flags))
2235 return False;
2236 if (!sec_io_desc("sec_desc", &info->secdesc, ps, depth))
2237 return False;
2238
2239 return True;
2240 }
2241
2242 /*******************************************************************
2243 Parse a PRINTER_INFO_4 structure.
2244 ********************************************************************/
2245
2246 BOOL smb_io_printer_info_4(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_4 *info, int depth)
2247 {
2248 prs_struct *ps=&buffer->prs;
2249
2250 prs_debug(ps, depth, desc, "smb_io_printer_info_4");
2251 depth++;
2252
2253 buffer->struct_start=prs_offset(ps);
2254
2255 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2256 return False;
2257 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2258 return False;
2259 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2260 return False;
2261 return True;
2262 }
2263
2264 /*******************************************************************
2265 Parse a PRINTER_INFO_5 structure.
2266 ********************************************************************/
2267
2268 BOOL smb_io_printer_info_5(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_5 *info, int depth)
2269 {
2270 prs_struct *ps=&buffer->prs;
2271
2272 prs_debug(ps, depth, desc, "smb_io_printer_info_5");
2273 depth++;
2274
2275 buffer->struct_start=prs_offset(ps);
2276
2277 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2278 return False;
2279 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2280 return False;
2281 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2282 return False;
2283 if (!prs_uint32("device_not_selected_timeout", ps, depth, &info->device_not_selected_timeout))
2284 return False;
2285 if (!prs_uint32("transmission_retry_timeout", ps, depth, &info->transmission_retry_timeout))
2286 return False;
2287 return True;
2288 }
2289
2290 /*******************************************************************
2291 Parse a PORT_INFO_1 structure.
2292 ********************************************************************/
2293
2294 BOOL smb_io_port_info_1(char *desc, NEW_BUFFER *buffer, PORT_INFO_1 *info, int depth)
2295 {
2296 prs_struct *ps=&buffer->prs;
2297
2298 prs_debug(ps, depth, desc, "smb_io_port_info_1");
2299 depth++;
2300
2301 buffer->struct_start=prs_offset(ps);
2302
2303 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2304 return False;
2305
2306 return True;
2307 }
2308
2309 /*******************************************************************
2310 Parse a PORT_INFO_2 structure.
2311 ********************************************************************/
2312
2313 BOOL smb_io_port_info_2(char *desc, NEW_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2314 {
2315 prs_struct *ps=&buffer->prs;
2316
2317 prs_debug(ps, depth, desc, "smb_io_port_info_2");
2318 depth++;
2319
2320 buffer->struct_start=prs_offset(ps);
2321
2322 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2323 return False;
2324 if (!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2325 return False;
2326 if (!smb_io_relstr("description", buffer, depth, &info->description))
2327 return False;
2328 if (!prs_uint32("port_type", ps, depth, &info->port_type))
2329 return False;
2330 if (!prs_uint32("reserved", ps, depth, &info->reserved))
2331 return False;
2332
2333 return True;
2334 }
2335
2336 /*******************************************************************
2337 Parse a DRIVER_INFO_1 structure.
2338 ********************************************************************/
2339
2340 BOOL smb_io_printer_driver_info_1(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_1 *info, int depth)
2341 {
2342 prs_struct *ps=&buffer->prs;
2343
2344 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_1");
2345 depth++;
2346
2347 buffer->struct_start=prs_offset(ps);
2348
2349 if (!smb_io_relstr("name", buffer, depth, &info->name))
2350 return False;
2351
2352 return True;
2353 }
2354
2355 /*******************************************************************
2356 Parse a DRIVER_INFO_2 structure.
2357 ********************************************************************/
2358
2359 BOOL smb_io_printer_driver_info_2(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_2 *info, int depth)
2360 {
2361 prs_struct *ps=&buffer->prs;
2362
2363 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_2");
2364 depth++;
2365
2366 buffer->struct_start=prs_offset(ps);
2367
2368 if (!prs_uint32("version", ps, depth, &info->version))
2369 return False;
2370 if (!smb_io_relstr("name", buffer, depth, &info->name))
2371 return False;
2372 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2373 return False;
2374 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2375 return False;
2376 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2377 return False;
2378 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2379 return False;
2380
2381 return True;
2382 }
2383
2384 /*******************************************************************
2385 Parse a DRIVER_INFO_3 structure.
2386 ********************************************************************/
2387
2388 BOOL smb_io_printer_driver_info_3(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_3 *info, int depth)
2389 {
2390 prs_struct *ps=&buffer->prs;
2391
2392 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_3");
2393 depth++;
2394
2395 buffer->struct_start=prs_offset(ps);
2396
2397 if (!prs_uint32("version", ps, depth, &info->version))
2398 return False;
2399 if (!smb_io_relstr("name", buffer, depth, &info->name))
2400 return False;
2401 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2402 return False;
2403 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2404 return False;
2405 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2406 return False;
2407 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2408 return False;
2409 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2410 return False;
2411
2412 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2413 return False;
2414
2415 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2416 return False;
2417 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2418 return False;
2419
2420 return True;
2421 }
2422
2423 /*******************************************************************
2424 Parse a DRIVER_INFO_6 structure.
2425 ********************************************************************/
2426
2427 BOOL smb_io_printer_driver_info_6(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_6 *info, int depth)
2428 {
2429 prs_struct *ps=&buffer->prs;
2430
2431 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_6");
2432 depth++;
2433
2434 buffer->struct_start=prs_offset(ps);
2435
2436 if (!prs_uint32("version", ps, depth, &info->version))
2437 return False;
2438 if (!smb_io_relstr("name", buffer, depth, &info->name))
2439 return False;
2440 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2441 return False;
2442 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2443 return False;
2444 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2445 return False;
2446 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2447 return False;
2448 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2449 return False;
2450
2451 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2452 return False;
2453
2454 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2455 return False;
2456 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2457 return False;
2458
2459 if (!smb_io_relarraystr("previousdrivernames", buffer, depth, &info->previousdrivernames))
2460 return False;
2461
2462 if (!prs_uint32("date.low", ps, depth, &info->driver_date.low))
2463 return False;
2464 if (!prs_uint32("date.high", ps, depth, &info->driver_date.high))
2465 return False;
2466
2467 if (!prs_uint32("padding", ps, depth, &info->padding))
2468 return False;
2469
2470 if (!prs_uint32("driver_version_low", ps, depth, &info->driver_version_low))
2471 return False;
2472
2473 if (!prs_uint32("driver_version_high", ps, depth, &info->driver_version_high))
2474 return False;
2475
2476 if (!smb_io_relstr("mfgname", buffer, depth, &info->mfgname))
2477 return False;
2478 if (!smb_io_relstr("oem_url", buffer, depth, &info->oem_url))
2479 return False;
2480 if (!smb_io_relstr("hardware_id", buffer, depth, &info->hardware_id))
2481 return False;
2482 if (!smb_io_relstr("provider", buffer, depth, &info->provider))
2483 return False;
2484
2485 return True;
2486 }
2487
2488 /*******************************************************************
2489 Parse a JOB_INFO_1 structure.
2490 ********************************************************************/
2491
2492 BOOL smb_io_job_info_1(char *desc, NEW_BUFFER *buffer, JOB_INFO_1 *info, int depth)
2493 {
2494 prs_struct *ps=&buffer->prs;
2495
2496 prs_debug(ps, depth, desc, "smb_io_job_info_1");
2497 depth++;
2498
2499 buffer->struct_start=prs_offset(ps);
2500
2501 if (!prs_uint32("jobid", ps, depth, &info->jobid))
2502 return False;
2503 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2504 return False;
2505 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2506 return False;
2507 if (!smb_io_relstr("username", buffer, depth, &info->username))
2508 return False;
2509 if (!smb_io_relstr("document", buffer, depth, &info->document))
2510 return False;
2511 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2512 return False;
2513 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2514 return False;
2515 if (!prs_uint32("status", ps, depth, &info->status))
2516 return False;
2517 if (!prs_uint32("priority", ps, depth, &info->priority))
2518 return False;
2519 if (!prs_uint32("position", ps, depth, &info->position))
2520 return False;
2521 if (!prs_uint32("totalpages", ps, depth, &info->totalpages))
2522 return False;
2523 if (!prs_uint32("pagesprinted", ps, depth, &info->pagesprinted))
2524 return False;
2525 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted))
2526 return False;
2527
2528 return True;
2529 }
2530
2531 /*******************************************************************
2532 Parse a JOB_INFO_2 structure.
2533 ********************************************************************/
2534
2535 BOOL smb_io_job_info_2(char *desc, NEW_BUFFER *buffer, JOB_INFO_2 *info, int depth)
2536 {
2537 uint32 pipo=0;
2538 prs_struct *ps=&buffer->prs;
2539
2540 prs_debug(ps, depth, desc, "smb_io_job_info_2");
2541 depth++;
2542
2543 buffer->struct_start=prs_offset(ps);
2544
2545 if (!prs_uint32("jobid",ps, depth, &info->jobid))
2546 return False;
2547 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2548 return False;
2549 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2550 return False;
2551 if (!smb_io_relstr("username", buffer, depth, &info->username))
2552 return False;
2553 if (!smb_io_relstr("document", buffer, depth, &info->document))
2554 return False;
2555 if (!smb_io_relstr("notifyname", buffer, depth, &info->notifyname))
2556 return False;
2557 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2558 return False;
2559
2560 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2561 return False;
2562 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2563 return False;
2564 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2565 return False;
2566 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2567 return False;
2568 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2569 return False;
2570
2571 /* SEC_DESC sec_desc;*/
2572 if (!prs_uint32("Hack! sec desc", ps, depth, &pipo))
2573 return False;
2574
2575 if (!prs_uint32("status",ps, depth, &info->status))
2576 return False;
2577 if (!prs_uint32("priority",ps, depth, &info->priority))
2578 return False;
2579 if (!prs_uint32("position",ps, depth, &info->position))
2580 return False;
2581 if (!prs_uint32("starttime",ps, depth, &info->starttime))
2582 return False;
2583 if (!prs_uint32("untiltime",ps, depth, &info->untiltime))
2584 return False;
2585 if (!prs_uint32("totalpages",ps, depth, &info->totalpages))
2586 return False;
2587 if (!prs_uint32("size",ps, depth, &info->size))
2588 return False;
2589 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted) )
2590 return False;
2591 if (!prs_uint32("timeelapsed",ps, depth, &info->timeelapsed))
2592 return False;
2593 if (!prs_uint32("pagesprinted",ps, depth, &info->pagesprinted))
2594 return False;
2595
2596 return True;
2597 }
2598
2599 /*******************************************************************
2600 ********************************************************************/
2601
2602 BOOL smb_io_form_1(char *desc, NEW_BUFFER *buffer, FORM_1 *info, int depth)
2603 {
2604 prs_struct *ps=&buffer->prs;
2605
2606 prs_debug(ps, depth, desc, "smb_io_form_1");
2607 depth++;
2608
2609 buffer->struct_start=prs_offset(ps);
2610
2611 if (!prs_uint32("flag", ps, depth, &info->flag))
2612 return False;
2613
2614 if (!smb_io_relstr("name", buffer, depth, &info->name))
2615 return False;
2616
2617 if (!prs_uint32("width", ps, depth, &info->width))
2618 return False;
2619 if (!prs_uint32("length", ps, depth, &info->length))
2620 return False;
2621 if (!prs_uint32("left", ps, depth, &info->left))
2622 return False;
2623 if (!prs_uint32("top", ps, depth, &info->top))
2624 return False;
2625 if (!prs_uint32("right", ps, depth, &info->right))
2626 return False;
2627 if (!prs_uint32("bottom", ps, depth, &info->bottom))
2628 return False;
2629
2630 return True;
2631 }
2632
2633 /*******************************************************************
2634 Read/write a BUFFER struct.
2635 ********************************************************************/
2636
2637 static BOOL spoolss_io_buffer(char *desc, prs_struct *ps, int depth, NEW_BUFFER **pp_buffer)
2638 {
2639 NEW_BUFFER *buffer = *pp_buffer;
2640
2641 prs_debug(ps, depth, desc, "spoolss_io_buffer");
2642 depth++;
2643
2644 if (UNMARSHALLING(ps))
2645 buffer = *pp_buffer = (NEW_BUFFER *)prs_alloc_mem(ps, sizeof(NEW_BUFFER));
2646
2647 if (buffer == NULL)
2648 return False;
2649
2650 if (!prs_uint32("ptr", ps, depth, &buffer->ptr))
2651 return False;
2652
2653 /* reading */
2654 if (UNMARSHALLING(ps)) {
2655 buffer->size=0;
2656 buffer->string_at_end=0;
2657
2658 if (buffer->ptr==0) {
2659 /*
2660 * JRA. I'm not sure if the data in here is in big-endian format if
2661 * the client is big-endian. Leave as default (little endian) for now.
2662 */
2663
2664 if (!prs_init(&buffer->prs, 0, prs_get_mem_context(ps), UNMARSHALL))
2665 return False;
2666 return True;
2667 }
2668
2669 if (!prs_uint32("size", ps, depth, &buffer->size))
2670 return False;
2671
2672 /*
2673 * JRA. I'm not sure if the data in here is in big-endian format if
2674 * the client is big-endian. Leave as default (little endian) for now.
2675 */
2676
2677 if (!prs_init(&buffer->prs, buffer->size, prs_get_mem_context(ps), UNMARSHALL))
2678 return False;
2679
2680 if (!prs_append_some_prs_data(&buffer->prs, ps, prs_offset(ps), buffer->size))
2681 return False;
2682
2683 if (!prs_set_offset(&buffer->prs, 0))
2684 return False;
2685
2686 if (!prs_set_offset(ps, buffer->size+prs_offset(ps)))
2687 return False;
2688
2689 buffer->string_at_end=buffer->size;
2690
2691 return True;
2692 }
2693 else {
2694 BOOL ret = False;
2695
2696 /* writing */
2697 if (buffer->ptr==0) {
2698 /* We have finished with the data in buffer->prs - free it. */
2699 prs_mem_free(&buffer->prs);
2700 return True;
2701 }
2702
2703 if (!prs_uint32("size", ps, depth, &buffer->size))
2704 goto out;
2705
2706 if (!prs_append_some_prs_data(ps, &buffer->prs, 0, buffer->size))
2707 goto out;
2708
2709 ret = True;
2710 out:
2711
2712 /* We have finished with the data in buffer->prs - free it. */
2713 prs_mem_free(&buffer->prs);
2714
2715 return ret;
2716 }
2717 }
2718
2719 /*******************************************************************
2720 move a BUFFER from the query to the reply.
2721 As the data pointers in NEW_BUFFER are malloc'ed, not talloc'ed,
2722 this is ok. This is an OPTIMIZATION and is not strictly neccessary.
2723 Clears the memory to zero also.
2724 ********************************************************************/
2725
2726 void spoolss_move_buffer(NEW_BUFFER *src, NEW_BUFFER **dest)
2727 {
2728 prs_switch_type(&src->prs, MARSHALL);
2729 if(!prs_set_offset(&src->prs, 0))
2730 return;
2731 prs_force_dynamic(&src->prs);
2732 prs_mem_clear(&src->prs);
2733 *dest=src;
2734 }
2735
2736 /*******************************************************************
2737 Get the size of a BUFFER struct.
2738 ********************************************************************/
2739
2740 uint32 new_get_buffer_size(NEW_BUFFER *buffer)
2741 {
2742 return (buffer->size);
2743 }
2744
2745 /*******************************************************************
2746 Parse a DRIVER_DIRECTORY_1 structure.
2747 ********************************************************************/
2748
2749 BOOL smb_io_driverdir_1(char *desc, NEW_BUFFER *buffer, DRIVER_DIRECTORY_1 *info, int depth)
2750 {
2751 prs_struct *ps=&buffer->prs;
2752
2753 prs_debug(ps, depth, desc, "smb_io_driverdir_1");
2754 depth++;
2755
2756 buffer->struct_start=prs_offset(ps);
2757
2758 if (!smb_io_unistr(desc, &info->name, ps, depth))
2759 return False;
2760
2761 return True;
2762 }
2763
2764 /*******************************************************************
2765 Parse a PORT_INFO_1 structure.
2766 ********************************************************************/
2767
2768 BOOL smb_io_port_1(char *desc, NEW_BUFFER *buffer, PORT_INFO_1 *info, int depth)
2769 {
2770 prs_struct *ps=&buffer->prs;
2771
2772 prs_debug(ps, depth, desc, "smb_io_port_1");
2773 depth++;
2774
2775 buffer->struct_start=prs_offset(ps);
2776
2777 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2778 return False;
2779
2780 return True;
2781 }
2782
2783 /*******************************************************************
2784 Parse a PORT_INFO_2 structure.
2785 ********************************************************************/
2786
2787 BOOL smb_io_port_2(char *desc, NEW_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2788 {
2789 prs_struct *ps=&buffer->prs;
2790
2791 prs_debug(ps, depth, desc, "smb_io_port_2");
2792 depth++;
2793
2794 buffer->struct_start=prs_offset(ps);
2795
2796 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2797 return False;
2798 if(!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2799 return False;
2800 if(!smb_io_relstr("description", buffer, depth, &info->description))
2801 return False;
2802 if(!prs_uint32("port_type", ps, depth, &info->port_type))
2803 return False;
2804 if(!prs_uint32("reserved", ps, depth, &info->reserved))
2805 return False;
2806
2807 return True;
2808 }
2809
2810 /*******************************************************************
2811 ********************************************************************/
2812
2813 BOOL smb_io_printprocessor_info_1(char *desc, NEW_BUFFER *buffer, PRINTPROCESSOR_1 *info, int depth)
2814 {
2815 prs_struct *ps=&buffer->prs;
2816
2817 prs_debug(ps, depth, desc, "smb_io_printprocessor_info_1");
2818 depth++;
2819
2820 buffer->struct_start=prs_offset(ps);
2821
2822 if (smb_io_relstr("name", buffer, depth, &info->name))
2823 return False;
2824
2825 return True;
2826 }
2827
2828 /*******************************************************************
2829 ********************************************************************/
2830
2831 BOOL smb_io_printprocdatatype_info_1(char *desc, NEW_BUFFER *buffer, PRINTPROCDATATYPE_1 *info, int depth)
2832 {
2833 prs_struct *ps=&buffer->prs;
2834
2835 prs_debug(ps, depth, desc, "smb_io_printprocdatatype_info_1");
2836 depth++;
2837
2838 buffer->struct_start=prs_offset(ps);
2839
2840 if (smb_io_relstr("name", buffer, depth, &info->name))
2841 return False;
2842
2843 return True;
2844 }
2845
2846 /*******************************************************************
2847 ********************************************************************/
2848
2849 BOOL smb_io_printmonitor_info_1(char *desc, NEW_BUFFER *buffer, PRINTMONITOR_1 *info, int depth)
2850 {
2851 prs_struct *ps=&buffer->prs;
2852
2853 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_1");
2854 depth++;
2855
2856 buffer->struct_start=prs_offset(ps);
2857
2858 if (!smb_io_relstr("name", buffer, depth, &info->name))
2859 return False;
2860
2861 return True;
2862 }
2863
2864 /*******************************************************************
2865 ********************************************************************/
2866
2867 BOOL smb_io_printmonitor_info_2(char *desc, NEW_BUFFER *buffer, PRINTMONITOR_2 *info, int depth)
2868 {
2869 prs_struct *ps=&buffer->prs;
2870
2871 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_2");
2872 depth++;
2873
2874 buffer->struct_start=prs_offset(ps);
2875
2876 if (!smb_io_relstr("name", buffer, depth, &info->name))
2877 return False;
2878 if (!smb_io_relstr("environment", buffer, depth, &info->environment))
2879 return False;
2880 if (!smb_io_relstr("dll_name", buffer, depth, &info->dll_name))
2881 return False;
2882
2883 return True;
2884 }
2885
2886 /*******************************************************************
2887 return the size required by a struct in the stream
2888 ********************************************************************/
2889
2890 uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
2891 {
2892 int size=0;
2893
2894 size+=size_of_relative_string( &info->printername );
2895 size+=size_of_relative_string( &info->servername );
2896
2897 size+=size_of_uint32( &info->cjobs);
2898 size+=size_of_uint32( &info->total_jobs);
2899 size+=size_of_uint32( &info->total_bytes);
2900
2901 size+=size_of_uint16( &info->year);
2902 size+=size_of_uint16( &info->month);
2903 size+=size_of_uint16( &info->dayofweek);
2904 size+=size_of_uint16( &info->day);
2905 size+=size_of_uint16( &info->hour);
2906 size+=size_of_uint16( &info->minute);
2907 size+=size_of_uint16( &info->second);
2908 size+=size_of_uint16( &info->milliseconds);
2909
2910 size+=size_of_uint32( &info->global_counter);
2911 size+=size_of_uint32( &info->total_pages);
2912
2913 size+=size_of_uint16( &info->major_version);
2914 size+=size_of_uint16( &info->build_version);
2915
2916 size+=size_of_uint32( &info->unknown7);
2917 size+=size_of_uint32( &info->unknown8);
2918 size+=size_of_uint32( &info->unknown9);
2919 size+=size_of_uint32( &info->session_counter);
2920 size+=size_of_uint32( &info->unknown11);
2921 size+=size_of_uint32( &info->printer_errors);
2922 size+=size_of_uint32( &info->unknown13);
2923 size+=size_of_uint32( &info->unknown14);
2924 size+=size_of_uint32( &info->unknown15);
2925 size+=size_of_uint32( &info->unknown16);
2926 size+=size_of_uint32( &info->change_id);
2927 size+=size_of_uint32( &info->unknown18);
2928 size+=size_of_uint32( &info->status);
2929 size+=size_of_uint32( &info->unknown20);
2930 size+=size_of_uint32( &info->c_setprinter);
2931
2932 size+=size_of_uint16( &info->unknown22);
2933 size+=size_of_uint16( &info->unknown23);
2934 size+=size_of_uint16( &info->unknown24);
2935 size+=size_of_uint16( &info->unknown25);
2936 size+=size_of_uint16( &info->unknown26);
2937 size+=size_of_uint16( &info->unknown27);
2938 size+=size_of_uint16( &info->unknown28);
2939 size+=size_of_uint16( &info->unknown29);
2940
2941 return size;
2942 }
2943
2944 /*******************************************************************
2945 return the size required by a struct in the stream
2946 ********************************************************************/
2947
2948 uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
2949 {
2950 int size=0;
2951
2952 size+=size_of_uint32( &info->flags );
2953 size+=size_of_relative_string( &info->description );
2954 size+=size_of_relative_string( &info->name );
2955 size+=size_of_relative_string( &info->comment );
2956
2957 return size;
2958 }
2959
2960 /*******************************************************************
2961 return the size required by a struct in the stream
2962 ********************************************************************/
2963
2964 uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
2965 {
2966 uint32 size=0;
2967
2968 size += 4;
2969 /* JRA !!!! TESTME - WHAT ABOUT prs_align.... !!! */
2970 size += sec_desc_size( info->secdesc );
2971
2972 size+=size_of_device_mode( info->devmode );
2973
2974 size+=size_of_relative_string( &info->servername );
2975 size+=size_of_relative_string( &info->printername );
2976 size+=size_of_relative_string( &info->sharename );
2977 size+=size_of_relative_string( &info->portname );
2978 size+=size_of_relative_string( &info->drivername );
2979 size+=size_of_relative_string( &info->comment );
2980 size+=size_of_relative_string( &info->location );
2981
2982 size+=size_of_relative_string( &info->sepfile );
2983 size+=size_of_relative_string( &info->printprocessor );
2984 size+=size_of_relative_string( &info->datatype );
2985 size+=size_of_relative_string( &info->parameters );
2986
2987 size+=size_of_uint32( &info->attributes );
2988 size+=size_of_uint32( &info->priority );
2989 size+=size_of_uint32( &info->defaultpriority );
2990 size+=size_of_uint32( &info->starttime );
2991 size+=size_of_uint32( &info->untiltime );
2992 size+=size_of_uint32( &info->status );
2993 size+=size_of_uint32( &info->cjobs );
2994 size+=size_of_uint32( &info->averageppm );
2995 return size;
2996 }
2997
2998 /*******************************************************************
2999 return the size required by a struct in the stream
3000 ********************************************************************/
3001
3002 uint32 spoolss_size_printer_info_4(PRINTER_INFO_4 *info)
3003 {
3004 uint32 size=0;
3005
3006 size+=size_of_relative_string( &info->printername );
3007 size+=size_of_relative_string( &info->servername );
3008
3009 size+=size_of_uint32( &info->attributes );
3010 return size;
3011 }
3012
3013 /*******************************************************************
3014 return the size required by a struct in the stream
3015 ********************************************************************/
3016
3017 uint32 spoolss_size_printer_info_5(PRINTER_INFO_5 *info)
3018 {
3019 uint32 size=0;
3020
3021 size+=size_of_relative_string( &info->printername );
3022 size+=size_of_relative_string( &info->portname );
3023
3024 size+=size_of_uint32( &info->attributes );
3025 size+=size_of_uint32( &info->device_not_selected_timeout );
3026 size+=size_of_uint32( &info->transmission_retry_timeout );
3027 return size;
3028 }
3029
3030
3031 /*******************************************************************
3032 return the size required by a struct in the stream
3033 ********************************************************************/
3034
3035 uint32 spoolss_size_printer_info_3(PRINTER_INFO_3 *info)
3036 {
3037 /* The 4 is for the self relative pointer.. */
3038 /* JRA !!!! TESTME - WHAT ABOUT prs_align.... !!! */
3039 return 4 + (uint32)sec_desc_size( info->secdesc );
3040 }
3041
3042 /*******************************************************************
3043 return the size required by a struct in the stream
3044 ********************************************************************/
3045
3046 uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
3047 {
3048 int size=0;
3049 size+=size_of_relative_string( &info->name );
3050
3051 return size;
3052 }
3053
3054 /*******************************************************************
3055 return the size required by a struct in the stream
3056 ********************************************************************/
3057
3058 uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
3059 {
3060 int size=0;
3061 size+=size_of_uint32( &info->version );
3062 size+=size_of_relative_string( &info->name );
3063 size+=size_of_relative_string( &info->architecture );
3064 size+=size_of_relative_string( &info->driverpath );
3065 size+=size_of_relative_string( &info->datafile );
3066 size+=size_of_relative_string( &info->configfile );
3067
3068 return size;
3069 }
3070
3071 /*******************************************************************
3072 return the size required by a string array.
3073 ********************************************************************/
3074
3075 uint32 spoolss_size_string_array(uint16 *string)
3076 {
3077 uint32 i = 0;
3078
3079 if (string) {
3080 for (i=0; (string[i]!=0x0000) || (string[i+1]!=0x0000); i++);
3081 }
3082 i=i+2; /* to count all chars including the leading zero */
3083 i=2*i; /* because we need the value in bytes */
3084 i=i+4; /* the offset pointer size */
3085
3086 return i;
3087 }
3088
3089 /*******************************************************************
3090 return the size required by a struct in the stream
3091 ********************************************************************/
3092
3093 uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
3094 {
3095 int size=0;
3096
3097 size+=size_of_uint32( &info->version );
3098 size+=size_of_relative_string( &info->name );
3099 size+=size_of_relative_string( &info->architecture );
3100 size+=size_of_relative_string( &info->driverpath );
3101 size+=size_of_relative_string( &info->datafile );
3102 size+=size_of_relative_string( &info->configfile );
3103 size+=size_of_relative_string( &info->helpfile );
3104 size+=size_of_relative_string( &info->monitorname );
3105 size+=size_of_relative_string( &info->defaultdatatype );
3106
3107 size+=spoolss_size_string_array(info->dependentfiles);
3108
3109 return size;
3110 }
3111
3112 /*******************************************************************
3113 return the size required by a struct in the stream
3114 ********************************************************************/
3115
3116 uint32 spoolss_size_printer_driver_info_6(DRIVER_INFO_6 *info)
3117 {
3118 uint32 size=0;
3119
3120 size+=size_of_uint32( &info->version );
3121 size+=size_of_relative_string( &info->name );
3122 size+=size_of_relative_string( &info->architecture );
3123 size+=size_of_relative_string( &info->driverpath );
3124 size+=size_of_relative_string( &info->datafile );
3125 size+=size_of_relative_string( &info->configfile );
3126 size+=size_of_relative_string( &info->helpfile );
3127
3128 size+=spoolss_size_string_array(info->dependentfiles);
3129
3130 size+=size_of_relative_string( &info->monitorname );
3131 size+=size_of_relative_string( &info->defaultdatatype );
3132
3133 size+=spoolss_size_string_array(info->previousdrivernames);
3134
3135 size+=size_of_nttime(&info->driver_date);
3136 size+=size_of_uint32( &info->padding );
3137 size+=size_of_uint32( &info->driver_version_low );
3138 size+=size_of_uint32( &info->driver_version_high );
3139 size+=size_of_relative_string( &info->mfgname );
3140 size+=size_of_relative_string( &info->oem_url );
3141 size+=size_of_relative_string( &info->hardware_id );
3142 size+=size_of_relative_string( &info->provider );
3143
3144 return size;
3145 }
3146
3147 /*******************************************************************
3148 return the size required by a struct in the stream
3149 ********************************************************************/
3150
3151 uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
3152 {
3153 int size=0;
3154 size+=size_of_uint32( &info->jobid );
3155 size+=size_of_relative_string( &info->printername );
3156 size+=size_of_relative_string( &info->machinename );
3157 size+=size_of_relative_string( &info->username );
3158 size+=size_of_relative_string( &info->document );
3159 size+=size_of_relative_string( &info->datatype );
3160 size+=size_of_relative_string( &info->text_status );
3161 size+=size_of_uint32( &info->status );
3162 size+=size_of_uint32( &info->priority );
3163 size+=size_of_uint32( &info->position );
3164 size+=size_of_uint32( &info->totalpages );
3165 size+=size_of_uint32( &info->pagesprinted );
3166 size+=size_of_systemtime( &info->submitted );
3167
3168 return size;
3169 }
3170
3171 /*******************************************************************
3172 return the size required by a struct in the stream
3173 ********************************************************************/
3174
3175 uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
3176 {
3177 int size=0;
3178
3179 size+=4; /* size of sec desc ptr */
3180
3181 size+=size_of_uint32( &info->jobid );
3182 size+=size_of_relative_string( &info->printername );
3183 size+=size_of_relative_string( &info->machinename );
3184 size+=size_of_relative_string( &info->username );
3185 size+=size_of_relative_string( &info->document );
3186 size+=size_of_relative_string( &info->notifyname );
3187 size+=size_of_relative_string( &info->datatype );
3188 size+=size_of_relative_string( &info->printprocessor );
3189 size+=size_of_relative_string( &info->parameters );
3190 size+=size_of_relative_string( &info->drivername );
3191 size+=size_of_device_mode( info->devmode );
3192 size+=size_of_relative_string( &info->text_status );
3193 /* SEC_DESC sec_desc;*/
3194 size+=size_of_uint32( &info->status );
3195 size+=size_of_uint32( &info->priority );
3196 size+=size_of_uint32( &info->position );
3197 size+=size_of_uint32( &info->starttime );
3198 size+=size_of_uint32( &info->untiltime );
3199 size+=size_of_uint32( &info->totalpages );
3200 size+=size_of_uint32( &info->size );
3201 size+=size_of_systemtime( &info->submitted );
3202 size+=size_of_uint32( &info->timeelapsed );
3203 size+=size_of_uint32( &info->pagesprinted );
3204
3205 return size;
3206 }
3207
3208 /*******************************************************************
3209 return the size required by a struct in the stream
3210 ********************************************************************/
3211
3212 uint32 spoolss_size_form_1(FORM_1 *info)
3213 {
3214 int size=0;
3215
3216 size+=size_of_uint32( &info->flag );
3217 size+=size_of_relative_string( &info->name );
3218 size+=size_of_uint32( &info->width );
3219 size+=size_of_uint32( &info->length );
3220 size+=size_of_uint32( &info->left );
3221 size+=size_of_uint32( &info->top );
3222 size+=size_of_uint32( &info->right );
3223 size+=size_of_uint32( &info->bottom );
3224
3225 return size;
3226 }
3227
3228 /*******************************************************************
3229 return the size required by a struct in the stream
3230 ********************************************************************/
3231
3232 uint32 spoolss_size_port_info_1(PORT_INFO_1 *info)
3233 {
3234 int size=0;
3235
3236 size+=size_of_relative_string( &info->port_name );
3237
3238 return size;
3239 }
3240
3241 /*******************************************************************
3242 return the size required by a struct in the stream
3243 ********************************************************************/
3244
3245 uint32 spoolss_size_driverdir_info_1(DRIVER_DIRECTORY_1 *info)
3246 {
3247 int size=0;
3248
3249 size=str_len_uni(&info->name); /* the string length */
3250 size=size+1; /* add the leading zero */
3251 size=size*2; /* convert in char */
3252
3253 return size;
3254 }
3255
3256 /*******************************************************************
3257 return the size required by a struct in the stream
3258 ********************************************************************/
3259
3260 uint32 spoolss_size_printprocessordirectory_info_1(PRINTPROCESSOR_DIRECTORY_1 *info)
3261 {
3262 int size=0;
3263
3264 size=str_len_uni(&info->name); /* the string length */
3265 size=size+1; /* add the leading zero */
3266 size=size*2; /* convert in char */
3267
3268 return size;
3269 }
3270
3271 /*******************************************************************
3272 return the size required by a struct in the stream
3273 ********************************************************************/
3274
3275 uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
3276 {
3277 int size=0;
3278
3279 size+=size_of_relative_string( &info->port_name );
3280 size+=size_of_relative_string( &info->monitor_name );
3281 size+=size_of_relative_string( &info->description );
3282
3283 size+=size_of_uint32( &info->port_type );
3284 size+=size_of_uint32( &info->reserved );
3285
3286 return size;
3287 }
3288
3289 /*******************************************************************
3290 return the size required by a struct in the stream
3291 ********************************************************************/
3292
3293 uint32 spoolss_size_printprocessor_info_1(PRINTPROCESSOR_1 *info)
3294 {
3295 int size=0;
3296 size+=size_of_relative_string( &info->name );
3297
3298 return size;
3299 }
3300
3301 /*******************************************************************
3302 return the size required by a struct in the stream
3303 ********************************************************************/
3304
3305 uint32 spoolss_size_printprocdatatype_info_1(PRINTPROCDATATYPE_1 *info)
3306 {
3307 int size=0;
3308 size+=size_of_relative_string( &info->name );
3309
3310 return size;
3311 }
3312
3313 /*******************************************************************
3314 return the size required by a struct in the stream
3315 ********************************************************************/
3316 uint32 spoolss_size_printer_enum_values(PRINTER_ENUM_VALUES *p)
3317 {
3318 uint32 size = 0;
3319
3320 if (!p)
3321 return 0;
3322
3323 /* uint32(offset) + uint32(length) + length) */
3324 size += (size_of_uint32(&p->value_len)*2) + p->value_len;
3325 size += (size_of_uint32(&p->data_len)*2) + p->data_len;
3326
3327 size += size_of_uint32(&p->type);
3328
3329 return size;
3330 }
3331
3332 /*******************************************************************
3333 return the size required by a struct in the stream
3334 ********************************************************************/
3335
3336 uint32 spoolss_size_printmonitor_info_1(PRINTMONITOR_1 *info)
3337 {
3338 int size=0;
3339 size+=size_of_relative_string( &info->name );
3340
3341 return size;
3342 }
3343
3344 /*******************************************************************
3345 return the size required by a struct in the stream
3346 ********************************************************************/
3347
3348 uint32 spoolss_size_printmonitor_info_2(PRINTMONITOR_2 *info)
3349 {
3350 int size=0;
3351 size+=size_of_relative_string( &info->name);
3352 size+=size_of_relative_string( &info->environment);
3353 size+=size_of_relative_string( &info->dll_name);
3354
3355 return size;
3356 }
3357
3358 /*******************************************************************
3359 * init a structure.
3360 ********************************************************************/
3361
3362 BOOL make_spoolss_q_getprinterdriver2(SPOOL_Q_GETPRINTERDRIVER2 *q_u,
3363 const POLICY_HND *hnd,
3364 const fstring architecture,
3365 uint32 level, uint32 clientmajor, uint32 clientminor,
3366 NEW_BUFFER *buffer, uint32 offered)
3367 {
3368 if (q_u == NULL)
3369 return False;
3370
3371 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3372
3373 init_buf_unistr2(&q_u->architecture, &q_u->architecture_ptr, architecture);
3374
3375 q_u->level=level;
3376 q_u->clientmajorversion=clientmajor;
3377 q_u->clientminorversion=clientminor;
3378
3379 q_u->buffer=buffer;
3380 q_u->offered=offered;
3381
3382 return True;
3383 }
3384
3385 /*******************************************************************
3386 * read a structure.
3387 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3388 ********************************************************************/
3389
3390 BOOL spoolss_io_q_getprinterdriver2(char *desc, SPOOL_Q_GETPRINTERDRIVER2 *q_u, prs_struct *ps, int depth)
3391 {
3392 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriver2");
3393 depth++;
3394
3395 if(!prs_align(ps))
3396 return False;
3397
3398 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3399 return False;
3400 if(!prs_uint32("architecture_ptr", ps, depth, &q_u->architecture_ptr))
3401 return False;
3402 if(!smb_io_unistr2("architecture", &q_u->architecture, q_u->architecture_ptr, ps, depth))
3403 return False;
3404
3405 if(!prs_align(ps))
3406 return False;
3407 if(!prs_uint32("level", ps, depth, &q_u->level))
3408 return False;
3409
3410 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
3411 return False;
3412
3413 if(!prs_align(ps))
3414 return False;
3415
3416 if(!prs_uint32("offered", ps, depth, &q_u->offered))
3417 return False;
3418
3419 if(!prs_uint32("clientmajorversion", ps, depth, &q_u->clientmajorversion))
3420 return False;
3421 if(!prs_uint32("clientminorversion", ps, depth, &q_u->clientminorversion))
3422 return False;
3423
3424 return True;
3425 }
3426
3427 /*******************************************************************
3428 * read a structure.
3429 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3430 ********************************************************************/
3431
3432 BOOL spoolss_io_r_getprinterdriver2(char *desc, SPOOL_R_GETPRINTERDRIVER2 *r_u, prs_struct *ps, int depth)
3433 {
3434 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriver2");
3435 depth++;
3436
3437 if (!prs_align(ps))
3438 return False;
3439
3440 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
3441 return False;
3442
3443 if (!prs_align(ps))
3444 return False;
3445 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3446 return False;
3447 if (!prs_uint32("servermajorversion", ps, depth, &r_u->servermajorversion))
3448 return False;
3449 if (!prs_uint32("serverminorversion", ps, depth, &r_u->serverminorversion))
3450 return False;
3451 if (!prs_werror("status", ps, depth, &r_u->status))
3452 return False;
3453
3454 return True;
3455 }
3456
3457 /*******************************************************************
3458 * init a structure.
3459 ********************************************************************/
3460
3461 BOOL make_spoolss_q_enumprinters(
3462 SPOOL_Q_ENUMPRINTERS *q_u,
3463 uint32 flags,
3464 fstring servername,
3465 uint32 level,
3466 NEW_BUFFER *buffer,
3467 uint32 offered
3468 )
3469 {
3470 q_u->flags=flags;
3471
3472 q_u->servername_ptr = (servername != NULL) ? 1 : 0;
3473 init_buf_unistr2(&q_u->servername, &q_u->servername_ptr, servername);
3474
3475 q_u->level=level;
3476 q_u->buffer=buffer;
3477 q_u->offered=offered;
3478
3479 return True;
3480 }
3481
3482 /*******************************************************************
3483 * init a structure.
3484 ********************************************************************/
3485
3486 BOOL make_spoolss_q_enumports(SPOOL_Q_ENUMPORTS *q_u,
3487 fstring servername, uint32 level,
3488 NEW_BUFFER *buffer, uint32 offered)
3489 {
3490 q_u->name_ptr = (servername != NULL) ? 1 : 0;
3491 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
3492
3493 q_u->level=level;
3494 q_u->buffer=buffer;
3495 q_u->offered=offered;
3496
3497 return True;
3498 }
3499
3500 /*******************************************************************
3501 * read a structure.
3502 * called from spoolss_enumprinters (srv_spoolss.c)
3503 ********************************************************************/
3504
3505 BOOL spoolss_io_q_enumprinters(char *desc, SPOOL_Q_ENUMPRINTERS *q_u, prs_struct *ps, int depth)
3506 {
3507 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinters");
3508 depth++;
3509
3510 if (!prs_align(ps))
3511 return False;
3512
3513 if (!prs_uint32("flags", ps, depth, &q_u->flags))
3514 return False;
3515 if (!prs_uint32("servername_ptr", ps, depth, &q_u->servername_ptr))
3516 return False;
3517
3518 if (!smb_io_unistr2("", &q_u->servername, q_u->servername_ptr, ps, depth))
3519 return False;
3520
3521 if (!prs_align(ps))
3522 return False;
3523 if (!prs_uint32("level", ps, depth, &q_u->level))
3524 return False;
3525
3526 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
3527 return False;
3528
3529 if (!prs_align(ps))
3530 return False;
3531 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3532 return False;
3533
3534 return True;
3535 }
3536
3537 /*******************************************************************
3538 Parse a SPOOL_R_ENUMPRINTERS structure.
3539 ********************************************************************/
3540
3541 BOOL spoolss_io_r_enumprinters(char *desc, SPOOL_R_ENUMPRINTERS *r_u, prs_struct *ps, int depth)
3542 {
3543 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinters");
3544 depth++;
3545
3546 if (!prs_align(ps))
3547 return False;
3548
3549 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
3550 return False;
3551
3552 if (!prs_align(ps))
3553 return False;
3554
3555 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3556 return False;
3557
3558 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3559 return False;
3560
3561 if (!prs_werror("status", ps, depth, &r_u->status))
3562 return False;
3563
3564 return True;
3565 }
3566
3567 /*******************************************************************
3568 * write a structure.
3569 * called from spoolss_r_enum_printers (srv_spoolss.c)
3570 *
3571 ********************************************************************/
3572
3573 BOOL spoolss_io_r_getprinter(char *desc, SPOOL_R_GETPRINTER *r_u, prs_struct *ps, int depth)
3574 {
3575 prs_debug(ps, depth, desc, "spoolss_io_r_getprinter");
3576 depth++;
3577
3578 if (!prs_align(ps))
3579 return False;
3580
3581 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
3582 return False;
3583
3584 if (!prs_align(ps))
3585 return False;
3586
3587 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3588 return False;
3589
3590 if (!prs_werror("status", ps, depth, &r_u->status))
3591 return False;
3592
3593 return True;
3594 }
3595
3596 /*******************************************************************
3597 * read a structure.
3598 * called from spoolss_getprinter (srv_spoolss.c)
3599 ********************************************************************/
3600
3601 BOOL spoolss_io_q_getprinter(char *desc, SPOOL_Q_GETPRINTER *q_u, prs_struct *ps, int depth)
3602 {
3603 prs_debug(ps, depth, desc, "spoolss_io_q_getprinter");
3604 depth++;
3605
3606 if (!prs_align(ps))
3607 return False;
3608
3609 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3610 return False;
3611 if (!prs_uint32("level", ps, depth, &q_u->level))
3612 return False;
3613
3614 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
3615 return False;
3616
3617 if (!prs_align(ps))
3618 return False;
3619 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3620 return False;
3621
3622 return True;
3623 }
3624
3625 /*******************************************************************
3626 * init a structure.
3627 ********************************************************************/
3628
3629 BOOL make_spoolss_q_getprinter(
3630 TALLOC_CTX *mem_ctx,
3631 SPOOL_Q_GETPRINTER *q_u,
3632 const POLICY_HND *hnd,
3633 uint32 level,
3634 NEW_BUFFER *buffer,
3635 uint32 offered
3636 )
3637 {
3638 if (q_u == NULL)
3639 {
3640 return False;
3641 }
3642 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3643
3644 q_u->level=level;
3645 q_u->buffer=buffer;
3646 q_u->offered=offered;
3647
3648 return True;
3649 }
3650
3651 /*******************************************************************
3652 * init a structure.
3653 ********************************************************************/
3654 BOOL make_spoolss_q_setprinter(TALLOC_CTX *mem_ctx, SPOOL_Q_SETPRINTER *q_u,
3655 const POLICY_HND *hnd, uint32 level, PRINTER_INFO_CTR *info,
3656 uint32 command)
3657 {
3658 SEC_DESC *secdesc;
3659 DEVICEMODE *devmode;
3660
3661 if (q_u == NULL)
3662 return False;
3663
3664 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3665
3666 q_u->level = level;
3667 q_u->info.level = level;
3668 q_u->info.info_ptr = (info != NULL) ? 1 : 0;
3669 switch (level) {
3670 case 2:
3671 secdesc = info->printers_2->secdesc;
3672 devmode = info->printers_2->devmode;
3673
3674 make_spoolss_printer_info_2 (mem_ctx, &q_u->info.info_2, info->printers_2);
3675 #if 1 /* JERRY TEST */
3676 q_u->secdesc_ctr = (SEC_DESC_BUF*)malloc(sizeof(SEC_DESC_BUF));
3677 if (!q_u->secdesc_ctr)
3678 return False;
3679 q_u->secdesc_ctr->ptr = (secdesc != NULL) ? 1: 0;
3680 q_u->secdesc_ctr->max_len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3681 q_u->secdesc_ctr->len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3682 q_u->secdesc_ctr->sec = secdesc;
3683
3684 q_u->devmode_ctr.devmode_ptr = (devmode != NULL) ? 1 : 0;
3685 q_u->devmode_ctr.size = (devmode != NULL) ? sizeof(DEVICEMODE) + (3*sizeof(uint32)) : 0;
3686 q_u->devmode_ctr.devmode = devmode;
3687 #else
3688 q_u->secdesc_ctr = NULL;
3689
3690 q_u->devmode_ctr.devmode_ptr = 0;
3691 q_u->devmode_ctr.size = 0;
3692 q_u->devmode_ctr.devmode = NULL;
3693 #endif
3694 break;
3695 default:
3696 DEBUG(0,("make_spoolss_q_setprinter: Unknown info level [%d]\n", level));
3697 break;
3698 }
3699
3700
3701 q_u->command = command;
3702
3703 return True;
3704 }
3705
3706
3707 /*******************************************************************
3708 ********************************************************************/
3709
3710 BOOL spoolss_io_r_setprinter(char *desc, SPOOL_R_SETPRINTER *r_u, prs_struct *ps, int depth)
3711 {
3712 prs_debug(ps, depth, desc, "spoolss_io_r_setprinter");
3713 depth++;
3714
3715 if(!prs_align(ps))
3716 return False;
3717
3718 if(!prs_werror("status", ps, depth, &r_u->status))
3719 return False;
3720
3721 return True;
3722 }
3723
3724 /*******************************************************************
3725 Marshall/unmarshall a SPOOL_Q_SETPRINTER struct.
3726 ********************************************************************/
3727
3728 BOOL spoolss_io_q_setprinter(char *desc, SPOOL_Q_SETPRINTER *q_u, prs_struct *ps, int depth)
3729 {
3730 uint32 ptr_sec_desc = 0;
3731
3732 prs_debug(ps, depth, desc, "spoolss_io_q_setprinter");
3733 depth++;
3734
3735 if(!prs_align(ps))
3736 return False;
3737
3738 if(!smb_io_pol_hnd("printer handle", &q_u->handle ,ps, depth))
3739 return False;
3740 if(!prs_uint32("level", ps, depth, &q_u->level))
3741 return False;
3742
3743 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
3744 return False;
3745
3746 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
3747 return False;
3748
3749 switch (q_u->level)
3750 {
3751 case 2:
3752 {
3753 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
3754 break;
3755 }
3756 case 3:
3757 {
3758 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
3759 break;
3760 }
3761 }
3762 if (ptr_sec_desc)
3763 {
3764 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
3765 return False;
3766 } else {
3767 uint32 dummy = 0;
3768
3769 /* Parse a NULL security descriptor. This should really
3770 happen inside the sec_io_desc_buf() function. */
3771
3772 prs_debug(ps, depth, "", "sec_io_desc_buf");
3773 if (!prs_uint32("size", ps, depth + 1, &dummy))
3774 return False;
3775 if (!prs_uint32("ptr", ps, depth + 1, &dummy)) return
3776 False;
3777 }
3778
3779 if(!prs_uint32("command", ps, depth, &q_u->command))
3780 return False;
3781
3782 return True;
3783 }
3784
3785 /*******************************************************************
3786 ********************************************************************/
3787
3788 BOOL spoolss_io_r_fcpn(char *desc, SPOOL_R_FCPN *r_u, prs_struct *ps, int depth)
3789 {
3790 prs_debug(ps, depth, desc, "spoolss_io_r_fcpn");
3791 depth++;
3792
3793 if(!prs_align(ps))
3794 return False;
3795
3796 if(!prs_werror("status", ps, depth, &r_u->status))
3797 return False;
3798
3799 return True;
3800 }
3801
3802 /*******************************************************************
3803 ********************************************************************/
3804
3805 BOOL spoolss_io_q_fcpn(char *desc, SPOOL_Q_FCPN *q_u, prs_struct *ps, int depth)
3806 {
3807
3808 prs_debug(ps, depth, desc, "spoolss_io_q_fcpn");
3809 depth++;
3810
3811 if(!prs_align(ps))
3812 return False;
3813
3814 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
3815 return False;
3816
3817 return True;
3818 }
3819
3820
3821 /*******************************************************************
3822 ********************************************************************/
3823
3824 BOOL spoolss_io_r_addjob(char *desc, SPOOL_R_ADDJOB *r_u, prs_struct *ps, int depth)
3825 {
3826 prs_debug(ps, depth, desc, "");
3827 depth++;
3828
3829 if(!prs_align(ps))
3830 return False;
3831
3832 if(!spoolss_io_buffer("", ps, depth, &r_u->buffer))
3833 return False;
3834
3835 if(!prs_align(ps))
3836 return False;
3837
3838 if(!prs_uint32("needed", ps, depth, &r_u->needed))
3839 return False;
3840
3841 if(!prs_werror("status", ps, depth, &r_u->status))
3842 return False;
3843
3844 return True;
3845 }
3846
3847 /*******************************************************************
3848 ********************************************************************/
3849
3850 BOOL spoolss_io_q_addjob(char *desc, SPOOL_Q_ADDJOB *q_u, prs_struct *ps, int depth)
3851 {
3852 prs_debug(ps, depth, desc, "");
3853 depth++;
3854
3855 if(!prs_align(ps))
3856 return False;
3857
3858 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3859 return False;
3860 if(!prs_uint32("level", ps, depth, &q_u->level))
3861 return False;
3862
3863 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
3864 return False;
3865
3866 if(!prs_align(ps))
3867 return False;
3868
3869 if(!prs_uint32("offered", ps, depth, &q_u->offered))
3870 return False;
3871
3872 return True;
3873 }
3874
3875 /*******************************************************************
3876 ********************************************************************/
3877
3878 BOOL spoolss_io_r_enumjobs(char *desc, SPOOL_R_ENUMJOBS *r_u, prs_struct *ps, int depth)
3879 {
3880 prs_debug(ps, depth, desc, "spoolss_io_r_enumjobs");
3881 depth++;
3882
3883 if (!prs_align(ps))
3884 return False;
3885
3886 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
3887 return False;
3888
3889 if (!prs_align(ps))
3890 return False;
3891
3892 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3893 return False;
3894
3895 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3896 return False;
3897
3898 if (!prs_werror("status", ps, depth, &r_u->status))
3899 return False;
3900
3901 return True;
3902 }
3903
3904 /*******************************************************************
3905 ********************************************************************/
3906
3907 BOOL make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS *q_u, const POLICY_HND *hnd,
3908 uint32 firstjob,
3909 uint32 numofjobs,
3910 uint32 level,
3911 NEW_BUFFER *buffer,
3912 uint32 offered)
3913 {
3914 if (q_u == NULL)
3915 {
3916 return False;
3917 }
3918 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3919 q_u->firstjob = firstjob;
3920 q_u->numofjobs = numofjobs;
3921 q_u->level = level;
3922 q_u->buffer= buffer;
3923 q_u->offered = offered;
3924 return True;
3925 }
3926
3927 /*******************************************************************
3928 ********************************************************************/
3929
3930 BOOL spoolss_io_q_enumjobs(char *desc, SPOOL_Q_ENUMJOBS *q_u, prs_struct *ps, int depth)
3931 {
3932 prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs");
3933 depth++;
3934
3935 if (!prs_align(ps))
3936 return False;
3937
3938 if (!smb_io_pol_hnd("printer handle",&q_u->handle, ps, depth))
3939 return False;
3940
3941 if (!prs_uint32("firstjob", ps, depth, &q_u->firstjob))
3942 return False;
3943 if (!prs_uint32("numofjobs", ps, depth, &q_u->numofjobs))
3944 return False;
3945 if (!prs_uint32("level", ps, depth, &q_u->level))
3946 return False;
3947
3948 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
3949 return False;
3950
3951 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3952 return False;
3953
3954 return True;
3955 }
3956
3957 /*******************************************************************
3958 ********************************************************************/
3959
3960 BOOL spoolss_io_r_schedulejob(char *desc, SPOOL_R_SCHEDULEJOB *r_u, prs_struct *ps, int depth)
3961 {
3962 prs_debug(ps, depth, desc, "spoolss_io_r_schedulejob");
3963 depth++;
3964
3965 if(!prs_align(ps))
3966 return False;
3967
3968 if(!prs_werror("status", ps, depth, &r_u->status))
3969 return False;
3970
3971 return True;
3972 }
3973
3974 /*******************************************************************
3975 ********************************************************************/
3976
3977 BOOL spoolss_io_q_schedulejob(char *desc, SPOOL_Q_SCHEDULEJOB *q_u, prs_struct *ps, int depth)
3978 {
3979 prs_debug(ps, depth, desc, "spoolss_io_q_schedulejob");
3980 depth++;
3981
3982 if(!prs_align(ps))
3983 return False;
3984
3985 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
3986 return False;
3987 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
3988 return False;
3989
3990 return True;
3991 }
3992
3993 /*******************************************************************
3994 ********************************************************************/
3995
3996 BOOL spoolss_io_r_setjob(char *desc, SPOOL_R_SETJOB *r_u, prs_struct *ps, int depth)
3997 {
3998 prs_debug(ps, depth, desc, "spoolss_io_r_setjob");
3999 depth++;
4000
4001 if(!prs_align(ps))
4002 return False;
4003
4004 if(!prs_werror("status", ps, depth, &r_u->status))
4005 return False;
4006
4007 return True;
4008 }
4009
4010 /*******************************************************************
4011 ********************************************************************/
4012
4013 BOOL spoolss_io_q_setjob(char *desc, SPOOL_Q_SETJOB *q_u, prs_struct *ps, int depth)
4014 {
4015 prs_debug(ps, depth, desc, "spoolss_io_q_setjob");
4016 depth++;
4017
4018 if(!prs_align(ps))
4019 return False;
4020
4021 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4022 return False;
4023 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
4024 return False;
4025 /*
4026 * level is usually 0. If (level!=0) then I'm in trouble !
4027 * I will try to generate setjob command with level!=0, one day.
4028 */
4029 if(!prs_uint32("level", ps, depth, &q_u->level))
4030 return False;
4031 if(!prs_uint32("command", ps, depth, &q_u->command))
4032 return False;
4033
4034 return True;
4035 }
4036
4037 /*******************************************************************
4038 Parse a SPOOL_R_ENUMPRINTERDRIVERS structure.
4039 ********************************************************************/
4040
4041 BOOL spoolss_io_r_enumprinterdrivers(char *desc, SPOOL_R_ENUMPRINTERDRIVERS *r_u, prs_struct *ps, int depth)
4042 {
4043 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdrivers");
4044 depth++;
4045
4046 if (!prs_align(ps))
4047 return False;
4048
4049 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
4050 return False;
4051
4052 if (!prs_align(ps))
4053 return False;
4054
4055 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4056 return False;
4057
4058 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4059 return False;
4060
4061 if (!prs_werror("status", ps, depth, &r_u->status))
4062 return False;
4063
4064 return True;
4065 }
4066
4067 /*******************************************************************
4068 * init a structure.
4069 ********************************************************************/
4070
4071 BOOL make_spoolss_q_enumprinterdrivers(SPOOL_Q_ENUMPRINTERDRIVERS *q_u,
4072 const char *name,
4073 const char *environment,
4074 uint32 level,
4075 NEW_BUFFER *buffer, uint32 offered)
4076 {
4077 init_buf_unistr2(&q_u->name, &q_u->name_ptr, name);
4078 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, environment);
4079
4080 q_u->level=level;
4081 q_u->buffer=buffer;
4082 q_u->offered=offered;
4083
4084 return True;
4085 }
4086
4087 /*******************************************************************
4088 Parse a SPOOL_Q_ENUMPRINTERDRIVERS structure.
4089 ********************************************************************/
4090
4091 BOOL spoolss_io_q_enumprinterdrivers(char *desc, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, prs_struct *ps, int depth)
4092 {
4093
4094 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdrivers");
4095 depth++;
4096
4097 if (!prs_align(ps))
4098 return False;
4099
4100 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
4101 return False;
4102 if (!smb_io_unistr2("", &q_u->name, q_u->name_ptr,ps, depth))
4103 return False;
4104
4105 if (!prs_align(ps))
4106 return False;
4107 if (!prs_uint32("environment_ptr", ps, depth, &q_u->environment_ptr))
4108 return False;
4109 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
4110 return False;
4111
4112 if (!prs_align(ps))
4113 return False;
4114 if (!prs_uint32("level", ps, depth, &q_u->level))
4115 return False;
4116
4117 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
4118 return False;
4119
4120 if (!prs_align(ps))
4121 return False;
4122
4123 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4124 return False;
4125
4126 return True;
4127 }
4128
4129 /*******************************************************************
4130 ********************************************************************/
4131
4132 BOOL spoolss_io_q_enumforms(char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth)
4133 {
4134
4135 prs_debug(ps, depth, desc, "spoolss_io_q_enumforms");
4136 depth++;
4137
4138 if (!prs_align(ps))
4139 return False;
4140 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4141 return False;
4142 if (!prs_uint32("level", ps, depth, &q_u->level))
4143 return False;
4144
4145 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
4146 return False;
4147
4148 if (!prs_align(ps))
4149 return False;
4150 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4151 return False;
4152
4153 return True;
4154 }
4155
4156 /*******************************************************************
4157 ********************************************************************/
4158
4159 BOOL spoolss_io_r_enumforms(char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth)
4160 {
4161 prs_debug(ps, depth, desc, "spoolss_io_r_enumforms");
4162 depth++;
4163
4164 if (!prs_align(ps))
4165 return False;
4166
4167 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
4168 return False;
4169
4170 if (!prs_align(ps))
4171 return False;
4172
4173 if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
4174 return False;
4175
4176 if (!prs_uint32("numofforms", ps, depth, &r_u->numofforms))
4177 return False;
4178
4179 if (!prs_werror("status", ps, depth, &r_u->status))
4180 return False;
4181
4182 return True;
4183 }
4184
4185 /*******************************************************************
4186 ********************************************************************/
4187
4188 BOOL spoolss_io_q_getform(char *desc, SPOOL_Q_GETFORM *q_u, prs_struct *ps, int depth)
4189 {
4190
4191 prs_debug(ps, depth, desc, "spoolss_io_q_getform");
4192 depth++;
4193
4194 if (!prs_align(ps))
4195 return False;
4196 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4197 return False;
4198 if (!smb_io_unistr2("", &q_u->formname,True,ps,depth))
4199 return False;
4200
4201 if (!prs_align(ps))
4202 return False;
4203
4204 if (!prs_uint32("level", ps, depth, &q_u->level))
4205 return False;
4206
4207 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
4208 return False;
4209
4210 if (!prs_align(ps))
4211 return False;
4212 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4213 return False;
4214
4215 return True;
4216 }
4217
4218 /*******************************************************************
4219 ********************************************************************/
4220
4221 BOOL spoolss_io_r_getform(char *desc, SPOOL_R_GETFORM *r_u, prs_struct *ps, int depth)
4222 {
4223 prs_debug(ps, depth, desc, "spoolss_io_r_getform");
4224 depth++;
4225
4226 if (!prs_align(ps))
4227 return False;
4228
4229 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
4230 return False;
4231
4232 if (!prs_align(ps))
4233 return False;
4234
4235 if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
4236 return False;
4237
4238 if (!prs_werror("status", ps, depth, &r_u->status))
4239 return False;
4240
4241 return True;
4242 }
4243
4244 /*******************************************************************
4245 Parse a SPOOL_R_ENUMPORTS structure.
4246 ********************************************************************/
4247
4248 BOOL spoolss_io_r_enumports(char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
4249 {
4250 prs_debug(ps, depth, desc, "spoolss_io_r_enumports");
4251 depth++;
4252
4253 if (!prs_align(ps))
4254 return False;
4255
4256 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
4257 return False;
4258
4259 if (!prs_align(ps))
4260 return False;
4261
4262 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4263 return False;
4264
4265 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4266 return False;
4267
4268 if (!prs_werror("status", ps, depth, &r_u->status))
4269 return False;
4270
4271 return True;
4272 }
4273
4274 /*******************************************************************
4275 ********************************************************************/
4276
4277 BOOL spoolss_io_q_enumports(char *desc, SPOOL_Q_ENUMPORTS *q_u, prs_struct *ps, int depth)
4278 {
4279 prs_debug(ps, depth, desc, "");
4280 depth++;
4281
4282 if (!prs_align(ps))
4283 return False;
4284
4285 if (!prs_uint32("", ps, depth, &q_u->name_ptr))
4286 return False;
4287 if (!smb_io_unistr2("", &q_u->name,True,ps,depth))
4288 return False;
4289
4290 if (!prs_align(ps))
4291 return False;
4292 if (!prs_uint32("level", ps, depth, &q_u->level))
4293 return False;
4294
4295 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
4296 return False;
4297
4298 if (!prs_align(ps))
4299 return False;
4300 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4301 return False;
4302
4303 return True;
4304 }
4305
4306 /*******************************************************************
4307 Parse a SPOOL_PRINTER_INFO_LEVEL_1 structure.
4308 ********************************************************************/
4309
4310 BOOL spool_io_printer_info_level_1(char *desc, SPOOL_PRINTER_INFO_LEVEL_1 *il, prs_struct *ps, int depth)
4311 {
4312 prs_debug(ps, depth, desc, "spool_io_printer_info_level_1");
4313 depth++;
4314
4315 if(!prs_align(ps))
4316 return False;
4317
4318 if(!prs_uint32("flags", ps, depth, &il->flags))
4319 return False;
4320 if(!prs_uint32("description_ptr", ps, depth, &il->description_ptr))
4321 return False;
4322 if(!prs_uint32("name_ptr", ps, depth, &il->name_ptr))
4323 return False;
4324 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4325 return False;
4326
4327 if(!smb_io_unistr2("description", &il->description, il->description_ptr, ps, depth))
4328 return False;
4329 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4330 return False;
4331 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4332 return False;
4333
4334 return True;
4335 }
4336
4337 /*******************************************************************
4338 Parse a SPOOL_PRINTER_INFO_LEVEL_3 structure.
4339 ********************************************************************/
4340
4341 BOOL spool_io_printer_info_level_3(char *desc, SPOOL_PRINTER_INFO_LEVEL_3 *il, prs_struct *ps, int depth)
4342 {
4343 prs_debug(ps, depth, desc, "spool_io_printer_info_level_3");
4344 depth++;
4345
4346 if(!prs_align(ps))
4347 return False;
4348
4349 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4350 return False;
4351
4352 return True;
4353 }
4354
4355 /*******************************************************************
4356 Parse a SPOOL_PRINTER_INFO_LEVEL_2 structure.
4357 ********************************************************************/
4358
4359 BOOL spool_io_printer_info_level_2(char *desc, SPOOL_PRINTER_INFO_LEVEL_2 *il, prs_struct *ps, int depth)
4360 {
4361 prs_debug(ps, depth, desc, "spool_io_printer_info_level_2");
4362 depth++;
4363
4364 if(!prs_align(ps))
4365 return False;
4366
4367 if(!prs_uint32("servername_ptr", ps, depth, &il->servername_ptr))
4368 return False;
4369 if(!prs_uint32("printername_ptr", ps, depth, &il->printername_ptr))
4370 return False;
4371 if(!prs_uint32("sharename_ptr", ps, depth, &il->sharename_ptr))
4372 return False;
4373 if(!prs_uint32("portname_ptr", ps, depth, &il->portname_ptr))
4374 return False;
4375
4376 if(!prs_uint32("drivername_ptr", ps, depth, &il->drivername_ptr))
4377 return False;
4378 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4379 return False;
4380 if(!prs_uint32("location_ptr", ps, depth, &il->location_ptr))
4381 return False;
4382 if(!prs_uint32("devmode_ptr", ps, depth, &il->devmode_ptr))
4383 return False;
4384 if(!prs_uint32("sepfile_ptr", ps, depth, &il->sepfile_ptr))
4385 return False;
4386 if(!prs_uint32("printprocessor_ptr", ps, depth, &il->printprocessor_ptr))
4387 return False;
4388 if(!prs_uint32("datatype_ptr", ps, depth, &il->datatype_ptr))
4389 return False;
4390 if(!prs_uint32("parameters_ptr", ps, depth, &il->parameters_ptr))
4391 return False;
4392 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4393 return False;
4394
4395 if(!prs_uint32("attributes", ps, depth, &il->attributes))
4396 return False;
4397 if(!prs_uint32("priority", ps, depth, &il->priority))
4398 return False;
4399 if(!prs_uint32("default_priority", ps, depth, &il->default_priority))
4400 return False;
4401 if(!prs_uint32("starttime", ps, depth, &il->starttime))
4402 return False;
4403 if(!prs_uint32("untiltime", ps, depth, &il->untiltime))
4404 return False;
4405 if(!prs_uint32("status", ps, depth, &il->status))
4406 return False;
4407 if(!prs_uint32("cjobs", ps, depth, &il->cjobs))
4408 return False;
4409 if(!prs_uint32("averageppm", ps, depth, &il->averageppm))
4410 return False;
4411
4412 if(!smb_io_unistr2("servername", &il->servername, il->servername_ptr, ps, depth))
4413 return False;
4414 if(!smb_io_unistr2("printername", &il->printername, il->printername_ptr, ps, depth))
4415 return False;
4416 if(!smb_io_unistr2("sharename", &il->sharename, il->sharename_ptr, ps, depth))
4417 return False;
4418 if(!smb_io_unistr2("portname", &il->portname, il->portname_ptr, ps, depth))
4419 return False;
4420 if(!smb_io_unistr2("drivername", &il->drivername, il->drivername_ptr, ps, depth))
4421 return False;
4422 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4423 return False;
4424 if(!smb_io_unistr2("location", &il->location, il->location_ptr, ps, depth))
4425 return False;
4426 if(!smb_io_unistr2("sepfile", &il->sepfile, il->sepfile_ptr, ps, depth))
4427 return False;
4428 if(!smb_io_unistr2("printprocessor", &il->printprocessor, il->printprocessor_ptr, ps, depth))
4429 return False;
4430 if(!smb_io_unistr2("datatype", &il->datatype, il->datatype_ptr, ps, depth))
4431 return False;
4432 if(!smb_io_unistr2("parameters", &il->parameters, il->parameters_ptr, ps, depth))
4433 return False;
4434
4435 return True;
4436 }
4437
4438 /*******************************************************************
4439 ********************************************************************/
4440
4441 BOOL spool_io_printer_info_level(char *desc, SPOOL_PRINTER_INFO_LEVEL *il, prs_struct *ps, int depth)
4442 {
4443 prs_debug(ps, depth, desc, "spool_io_printer_info_level");
4444 depth++;
4445
4446 if(!prs_align(ps))
4447 return False;
4448 if(!prs_uint32("level", ps, depth, &il->level))
4449 return False;
4450 if(!prs_uint32("info_ptr", ps, depth, &il->info_ptr))
4451 return False;
4452
4453 /* if no struct inside just return */
4454 if (il->info_ptr==0) {
4455 if (UNMARSHALLING(ps)) {
4456 il->info_1=NULL;
4457 il->info_2=NULL;
4458 }
4459 return True;
4460 }
4461
4462 switch (il->level) {
4463 /*
4464 * level 0 is used by setprinter when managing the queue
4465 * (hold, stop, start a queue)
4466 */
4467 case 0:
4468 break;
4469 /* DOCUMENT ME!!! What is level 1 used for? */
4470 case 1:
4471 {
4472 if (UNMARSHALLING(ps)) {
4473 if ((il->info_1=(SPOOL_PRINTER_INFO_LEVEL_1 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_INFO_LEVEL_1))) == NULL)
4474 return False;
4475 }
4476 if (!spool_io_printer_info_level_1("", il->info_1, ps, depth))
4477 return False;
4478 break;
4479 }
4480 /*
4481 * level 2 is used by addprinter
4482 * and by setprinter when updating printer's info
4483 */
4484 case 2:
4485 if (UNMARSHALLING(ps)) {
4486 if ((il->info_2=(SPOOL_PRINTER_INFO_LEVEL_2 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_INFO_LEVEL_2))) == NULL)
4487 return False;
4488 }
4489 if (!spool_io_printer_info_level_2("", il->info_2, ps, depth))
4490 return False;
4491 break;
4492 /* DOCUMENT ME!!! What is level 3 used for? */
4493 case 3:
4494 {
4495 if (UNMARSHALLING(ps)) {
4496 if ((il->info_3=(SPOOL_PRINTER_INFO_LEVEL_3 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_INFO_LEVEL_3))) == NULL)
4497 return False;
4498 }
4499 if (!spool_io_printer_info_level_3("", il->info_3, ps, depth))
4500 return False;
4501 break;
4502 }
4503 }
4504
4505 return True;
4506 }
4507
4508 /*******************************************************************
4509 ********************************************************************/
4510
4511 BOOL spoolss_io_q_addprinterex(char *desc, SPOOL_Q_ADDPRINTEREX *q_u, prs_struct *ps, int depth)
4512 {
4513 uint32 ptr_sec_desc = 0;
4514
4515 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterex");
4516 depth++;
4517
4518 if(!prs_align(ps))
4519 return False;
4520 if(!prs_uint32("", ps, depth, &q_u->server_name_ptr))
4521 return False;
4522 if(!smb_io_unistr2("", &q_u->server_name, q_u->server_name_ptr, ps, depth))
4523 return False;
4524
4525 if(!prs_align(ps))
4526 return False;
4527
4528 if(!prs_uint32("info_level", ps, depth, &q_u->level))
4529 return False;
4530
4531 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
4532 return False;
4533
4534 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
4535 return False;
4536
4537 switch (q_u->level) {
4538 case 2:
4539 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
4540 break;
4541 case 3:
4542 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
4543 break;
4544 }
4545 if (ptr_sec_desc) {
4546 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
4547 return False;
4548 } else {
4549 uint32 dummy;
4550
4551 /* Parse a NULL security descriptor. This should really
4552 happen inside the sec_io_desc_buf() function. */
4553
4554 prs_debug(ps, depth, "", "sec_io_desc_buf");
4555 if (!prs_uint32("size", ps, depth + 1, &dummy))
4556 return False;
4557 if (!prs_uint32("ptr", ps, depth + 1, &dummy))
4558 return False;
4559 }
4560
4561 if(!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
4562 return False;
4563 if(!spool_io_user_level("", &q_u->user_ctr, ps, depth))
4564 return False;
4565
4566 return True;
4567 }
4568
4569 /*******************************************************************
4570 ********************************************************************/
4571
4572 BOOL spoolss_io_r_addprinterex(char *desc, SPOOL_R_ADDPRINTEREX *r_u,
4573 prs_struct *ps, int depth)
4574 {
4575 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterex");
4576 depth++;
4577
4578 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
4579 return False;
4580
4581 if(!prs_werror("status", ps, depth, &r_u->status))
4582 return False;
4583
4584 return True;
4585 }
4586
4587 /*******************************************************************
4588 ********************************************************************/
4589
4590 BOOL spool_io_printer_driver_info_level_3(char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **q_u,
4591 prs_struct *ps, int depth)
4592 {
4593 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *il;
4594
4595 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_3");
4596 depth++;
4597
4598 /* reading */
4599 if (UNMARSHALLING(ps)) {
4600 il=(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3));
4601 if(il == NULL)
4602 return False;
4603 *q_u=il;
4604 }
4605 else {
4606 il=*q_u;
4607 }
4608
4609 if(!prs_align(ps))
4610 return False;
4611
4612 if(!prs_uint32("cversion", ps, depth, &il->cversion))
4613 return False;
4614 if(!prs_uint32("name", ps, depth, &il->name_ptr))
4615 return False;
4616 if(!prs_uint32("environment", ps, depth, &il->environment_ptr))
4617 return False;
4618 if(!prs_uint32("driverpath", ps, depth, &il->driverpath_ptr))
4619 return False;
4620 if(!prs_uint32("datafile", ps, depth, &il->datafile_ptr))
4621 return False;
4622 if(!prs_uint32("configfile", ps, depth, &il->configfile_ptr))
4623 return False;
4624 if(!prs_uint32("helpfile", ps, depth, &il->helpfile_ptr))
4625 return False;
4626 if(!prs_uint32("monitorname", ps, depth, &il->monitorname_ptr))
4627 return False;
4628 if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
4629 return False;
4630 if(!prs_uint32("dependentfilessize", ps, depth, &il->dependentfilessize))
4631 return False;
4632 if(!prs_uint32("dependentfiles", ps, depth, &il->dependentfiles_ptr))
4633 return False;
4634
4635 if(!prs_align(ps))
4636 return False;
4637
4638 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4639 return False;
4640 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
4641 return False;
4642 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
4643 return False;
4644 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
4645 return False;
4646 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
4647 return False;
4648 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
4649 return False;
4650 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
4651 return False;
4652 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
4653 return False;
4654
4655 if(!prs_align(ps))
4656 return False;
4657
4658 if (il->dependentfiles_ptr)
4659 smb_io_buffer5("", &il->dependentfiles, ps, depth);
4660
4661 return True;
4662 }
4663
4664 /*******************************************************************
4665 parse a SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 structure
4666 ********************************************************************/
4667
4668 BOOL spool_io_printer_driver_info_level_6(char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 **q_u,
4669 prs_struct *ps, int depth)
4670 {
4671 SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *il;
4672
4673 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_6");
4674 depth++;
4675
4676 /* reading */
4677 if (UNMARSHALLING(ps)) {
4678 il=(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6));
4679 if(il == NULL)
4680 return False;
4681 *q_u=il;
4682 }
4683 else {
4684 il=*q_u;
4685 }
4686
4687 if(!prs_align(ps))
4688 return False;
4689
4690
4691 /* parse the main elements the packet */
4692
4693 if(!prs_uint32("version", ps, depth, &il->version))
4694 return False;
4695
4696 if(!prs_uint32("name_ptr", ps, depth, &il->name_ptr))
4697 return False;
4698 /*
4699 * If name_ptr is NULL then the next 4 bytes are the name_ptr. A driver
4700 * with a NULL name just isn't a driver For example: "HP LaserJet 4si"
4701 * from W2K CDROM (which uses unidriver). JohnR 010205
4702 */
4703 if (!il->name_ptr) {
4704 DEBUG(5,("spool_io_printer_driver_info_level_6: name_ptr is NULL! Get next value\n"));
4705 if(!prs_uint32("name_ptr", ps, depth, &il->name_ptr))
4706 return False;
4707 }
4708
4709 if(!prs_uint32("environment_ptr", ps, depth, &il->environment_ptr))
4710 return False;
4711 if(!prs_uint32("driverpath_ptr", ps, depth, &il->driverpath_ptr))
4712 return False;
4713 if(!prs_uint32("datafile_ptr", ps, depth, &il->datafile_ptr))
4714 return False;
4715 if(!prs_uint32("configfile_ptr", ps, depth, &il->configfile_ptr))
4716 return False;
4717 if(!prs_uint32("helpfile_ptr", ps, depth, &il->helpfile_ptr))
4718 return False;
4719 if(!prs_uint32("monitorname_ptr", ps, depth, &il->monitorname_ptr))
4720 return False;
4721 if(!prs_uint32("defaultdatatype_ptr", ps, depth, &il->defaultdatatype_ptr))
4722 return False;
4723 if(!prs_uint32("dependentfiles_len", ps, depth, &il->dependentfiles_len))
4724 return False;
4725 if(!prs_uint32("dependentfiles_ptr", ps, depth, &il->dependentfiles_ptr))
4726 return False;
4727 if(!prs_uint32("previousnames_len", ps, depth, &il->previousnames_len))
4728 return False;
4729 if(!prs_uint32("previousnames_ptr", ps, depth, &il->previousnames_ptr))
4730 return False;
4731 if(!smb_io_time("driverdate", &il->driverdate, ps, depth))
4732 return False;
4733 if(!prs_uint32("dummy4", ps, depth, &il->dummy4))
4734 return False;
4735 if(!prs_uint64("driverversion", ps, depth, &il->driverversion))
4736 return False;
4737 if(!prs_uint32("mfgname_ptr", ps, depth, &il->mfgname_ptr))
4738 return False;
4739 if(!prs_uint32("oemurl_ptr", ps, depth, &il->oemurl_ptr))
4740 return False;
4741 if(!prs_uint32("hardwareid_ptr", ps, depth, &il->hardwareid_ptr))
4742 return False;
4743 if(!prs_uint32("provider_ptr", ps, depth, &il->provider_ptr))
4744 return False;
4745
4746 /* parse the structures in the packet */
4747
4748 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4749 return False;
4750 if(!prs_align(ps))
4751 return False;
4752
4753 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
4754 return False;
4755 if(!prs_align(ps))
4756 return False;
4757
4758 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
4759 return False;
4760 if(!prs_align(ps))
4761 return False;
4762
4763 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
4764 return False;
4765 if(!prs_align(ps))
4766 return False;
4767
4768 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
4769 return False;
4770 if(!prs_align(ps))
4771 return False;
4772
4773 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
4774 return False;
4775 if(!prs_align(ps))
4776 return False;
4777
4778 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
4779 return False;
4780 if(!prs_align(ps))
4781 return False;
4782
4783 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
4784 return False;
4785 if(!prs_align(ps))
4786 return False;
4787 if (il->dependentfiles_ptr) {
4788 if(!smb_io_buffer5("dependentfiles", &il->dependentfiles, ps, depth))
4789 return False;
4790 if(!prs_align(ps))
4791 return False;
4792 }
4793 if (il->previousnames_ptr) {
4794 if(!smb_io_buffer5("previousnames", &il->previousnames, ps, depth))
4795 return False;
4796 if(!prs_align(ps))
4797 return False;
4798 }
4799 if(!smb_io_unistr2("mfgname", &il->mfgname, il->mfgname_ptr, ps, depth))
4800 return False;
4801 if(!prs_align(ps))
4802 return False;
4803 if(!smb_io_unistr2("oemurl", &il->oemurl, il->oemurl_ptr, ps, depth))
4804 return False;
4805 if(!prs_align(ps))
4806 return False;
4807 if(!smb_io_unistr2("hardwareid", &il->hardwareid, il->hardwareid_ptr, ps, depth))
4808 return False;
4809 if(!prs_align(ps))
4810 return False;
4811 if(!smb_io_unistr2("provider", &il->provider, il->provider_ptr, ps, depth))
4812 return False;
4813
4814 return True;
4815 }
4816
4817 /*******************************************************************
4818 convert a buffer of UNICODE strings null terminated
4819 the buffer is terminated by a NULL
4820
4821 convert to an dos codepage array (null terminated)
4822
4823 dynamically allocate memory
4824
4825 ********************************************************************/
4826 static BOOL uniarray_2_dosarray(BUFFER5 *buf5, fstring **ar)
4827 {
4828 fstring f, *tar;
4829 int n = 0;
4830 char *src;
4831
4832 if (buf5==NULL)
4833 return False;
4834
4835 src = (char *)buf5->buffer;
4836 *ar = NULL;
4837
4838 while (src < ((char *)buf5->buffer) + buf5->buf_len*2) {
4839 unistr_to_dos(f, src, sizeof(f)-1);
4840 src = skip_unibuf(src, 2*buf5->buf_len - PTR_DIFF(src,buf5->buffer));
4841 tar = (fstring *)Realloc(*ar, sizeof(fstring)*(n+2));
4842 if (!tar)
4843 return False;
4844 else
4845 *ar = tar;
4846 fstrcpy((*ar)[n], f);
4847 n++;
4848 }
4849 fstrcpy((*ar)[n], "");
4850
4851 return True;
4852 }
4853
4854
4855
4856
4857 /*******************************************************************
4858 read a UNICODE array with null terminated strings
4859 and null terminated array
4860 and size of array at beginning
4861 ********************************************************************/
4862
4863 BOOL smb_io_unibuffer(char *desc, UNISTR2 *buffer, prs_struct *ps, int depth)
4864 {
4865 if (buffer==NULL) return False;
4866
4867 buffer->undoc=0;
4868 buffer->uni_str_len=buffer->uni_max_len;
4869
4870 if(!prs_uint32("buffer_size", ps, depth, &buffer->uni_max_len))
4871 return False;
4872
4873 if(!prs_unistr2(True, "buffer ", ps, depth, buffer))
4874 return False;
4875
4876 return True;
4877 }
4878
4879 /*******************************************************************
4880 ********************************************************************/
4881
4882 BOOL spool_io_printer_driver_info_level(char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL *il, prs_struct *ps, int depth)
4883 {
4884 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level");
4885 depth++;
4886
4887 if(!prs_align(ps))
4888 return False;
4889 if(!prs_uint32("level", ps, depth, &il->level))
4890 return False;
4891 if(!prs_uint32("ptr", ps, depth, &il->ptr))
4892 return False;
4893
4894 if (il->ptr==0)
4895 return True;
4896
4897 switch (il->level) {
4898 case 3:
4899 if(!spool_io_printer_driver_info_level_3("", &il->info_3, ps, depth))
4900 return False;
4901 break;
4902 case 6:
4903 if(!spool_io_printer_driver_info_level_6("", &il->info_6, ps, depth))
4904 return False;
4905 break;
4906 default:
4907 return False;
4908 }
4909
4910 return True;
4911 }
4912
4913 /*******************************************************************
4914 init a SPOOL_Q_ADDPRINTERDRIVER struct
4915 ******************************************************************/
4916
4917 BOOL make_spoolss_q_addprinterdriver(
4918 TALLOC_CTX *mem_ctx,
4919 SPOOL_Q_ADDPRINTERDRIVER *q_u,
4920 const char* srv_name,
4921 uint32 level,
4922 PRINTER_DRIVER_CTR *info)
4923 {
4924 DEBUG(5,("make_spoolss_q_addprinterdriver\n"));
4925
4926 q_u->server_name_ptr = (srv_name!=NULL)?1:0;
4927 init_unistr2(&q_u->server_name, srv_name, strlen(srv_name)+1);
4928
4929 q_u->level = level;
4930
4931 q_u->info.level = level;
4932 q_u->info.ptr = (info!=NULL)?1:0;
4933 switch (level)
4934 {
4935 /* info level 3 is supported by Windows 95/98, WinNT and Win2k */
4936 case 3 :
4937 make_spoolss_driver_info_3(mem_ctx, &q_u->info.info_3, info->info3);
4938 break;
4939
4940 /* info level 6 is supported by WinME and Win2k */
4941 case 6:
4942 /* WRITEME!! will add later --jerry */
4943 break;
4944
4945 default:
4946 DEBUG(0,("make_spoolss_q_addprinterdriver: Unknown info level [%d]\n", level));
4947 break;
4948 }
4949
4950 return True;
4951 }
4952
4953 BOOL make_spoolss_driver_info_3(
4954 TALLOC_CTX *mem_ctx,
4955 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **spool_drv_info,
4956 DRIVER_INFO_3 *info3
4957 )
4958 {
4959 uint32 len = 0;
4960 uint16 *ptr = info3->dependentfiles;
4961 BOOL done = False;
4962 BOOL null_char = False;
4963 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *inf;
4964
4965 if (!(inf=(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3*)talloc_zero(mem_ctx, sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3))))
4966 return False;
4967
4968 inf->cversion = info3->version;
4969 inf->name_ptr = (info3->name.buffer!=NULL)?1:0;
4970 inf->environment_ptr = (info3->architecture.buffer!=NULL)?1:0;
4971 inf->driverpath_ptr = (info3->driverpath.buffer!=NULL)?1:0;
4972 inf->datafile_ptr = (info3->datafile.buffer!=NULL)?1:0;
4973 inf->configfile_ptr = (info3->configfile.buffer!=NULL)?1:0;
4974 inf->helpfile_ptr = (info3->helpfile.buffer!=NULL)?1:0;
4975 inf->monitorname_ptr = (info3->monitorname.buffer!=NULL)?1:0;
4976 inf->defaultdatatype_ptr = (info3->defaultdatatype.buffer!=NULL)?1:0;
4977
4978 init_unistr2_from_unistr(&inf->name, &info3->name);
4979 init_unistr2_from_unistr(&inf->environment, &info3->architecture);
4980 init_unistr2_from_unistr(&inf->driverpath, &info3->driverpath);
4981 init_unistr2_from_unistr(&inf->datafile, &info3->datafile);
4982 init_unistr2_from_unistr(&inf->configfile, &info3->configfile);
4983 init_unistr2_from_unistr(&inf->helpfile, &info3->helpfile);
4984 init_unistr2_from_unistr(&inf->monitorname, &info3->monitorname);
4985 init_unistr2_from_unistr(&inf->defaultdatatype, &info3->defaultdatatype);
4986
4987 while (!done)
4988 {
4989 switch (*ptr)
4990 {
4991 case 0:
4992 /* the null_char BOOL is used to help locate
4993 two '\0's back to back */
4994 if (null_char)
4995 done = True;
4996 else
4997 null_char = True;
4998 break;
4999
5000 default:
5001 null_char = False;
5002 ;;
5003 break;
5004 }
5005 len++;
5006 ptr++;
5007 }
5008 inf->dependentfiles_ptr = (info3->dependentfiles != NULL) ? 1 : 0;
5009 inf->dependentfilessize = len;
5010 if(!make_spoolss_buffer5(mem_ctx, &inf->dependentfiles, len, info3->dependentfiles))
5011 {
5012 SAFE_FREE(inf);
5013 return False;
5014 }
5015
5016 *spool_drv_info = inf;
5017
5018 return True;
5019 }
5020
5021 /*******************************************************************
5022 make a BUFFER5 struct from a uint16*
5023 ******************************************************************/
5024 BOOL make_spoolss_buffer5(TALLOC_CTX *mem_ctx, BUFFER5 *buf5, uint32 len, uint16 *src)
5025 {
5026
5027 buf5->buf_len = len;
5028 if((buf5->buffer=(uint16*)talloc_memdup(mem_ctx, src, sizeof(uint16)*len)) == NULL)
5029 {
5030 DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
5031 return False;
5032 }
5033
5034 return True;
5035 }
5036
5037 /*******************************************************************
5038 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
5039 ********************************************************************/
5040
5041 BOOL spoolss_io_q_addprinterdriver(char *desc, SPOOL_Q_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
5042 {
5043 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriver");
5044 depth++;
5045
5046 if(!prs_align(ps))
5047 return False;
5048
5049 if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
5050 return False;
5051 if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
5052 return False;
5053
5054 if(!prs_align(ps))
5055 return False;
5056 if(!prs_uint32("info_level", ps, depth, &q_u->level))
5057 return False;
5058
5059 if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
5060 return False;
5061
5062 return True;
5063 }
5064
5065 /*******************************************************************
5066 ********************************************************************/
5067
5068 BOOL spoolss_io_r_addprinterdriver(char *desc, SPOOL_R_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
5069 {
5070 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriver");
5071 depth++;
5072
5073 if(!prs_werror("status", ps, depth, &q_u->status))
5074 return False;
5075
5076 return True;
5077 }
5078
5079 /*******************************************************************
5080 ********************************************************************/
5081
5082 BOOL uni_2_asc_printer_driver_3(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *uni,
5083 NT_PRINTER_DRIVER_INFO_LEVEL_3 **asc)
5084 {
5085 NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
5086
5087 DEBUG(7,("uni_2_asc_printer_driver_3: Converting from UNICODE to ASCII\n"));
5088
5089 if (*asc==NULL)
5090 {
5091 *asc=(NT_PRINTER_DRIVER_INFO_LEVEL_3 *)malloc(sizeof(NT_PRINTER_DRIVER_INFO_LEVEL_3));
5092 if(*asc == NULL)
5093 return False;
5094 ZERO_STRUCTP(*asc);
5095 }
5096
5097 d=*asc;
5098
5099 d->cversion=uni->cversion;
5100
5101 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name)-1);
5102 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment)-1);
5103 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath)-1);
5104 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile)-1);
5105 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile)-1);
5106 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile)-1);
5107 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname)-1);
5108 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype)-1);
5109
5110 DEBUGADD(8,( "version: %d\n", d->cversion));
5111 DEBUGADD(8,( "name: %s\n", d->name));
5112 DEBUGADD(8,( "environment: %s\n", d->environment));
5113 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
5114 DEBUGADD(8,( "datafile: %s\n", d->datafile));
5115 DEBUGADD(8,( "configfile: %s\n", d->configfile));
5116 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
5117 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
5118 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5119
5120 if (uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5121 return True;
5122
5123 SAFE_FREE(*asc);
5124 return False;
5125 }
5126
5127 /*******************************************************************
5128 ********************************************************************/
5129 BOOL uni_2_asc_printer_driver_6(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *uni,
5130 NT_PRINTER_DRIVER_INFO_LEVEL_6 **asc)
5131 {
5132 NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
5133
5134 DEBUG(7,("uni_2_asc_printer_driver_6: Converting from UNICODE to ASCII\n"));
5135
5136 if (*asc==NULL)
5137 {
5138 *asc=(NT_PRINTER_DRIVER_INFO_LEVEL_6 *)malloc(sizeof(NT_PRINTER_DRIVER_INFO_LEVEL_6));
5139 if(*asc == NULL)
5140 return False;
5141 ZERO_STRUCTP(*asc);
5142 }
5143
5144 d=*asc;
5145
5146 d->version=uni->version;
5147
5148 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name)-1);
5149 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment)-1);
5150 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath)-1);
5151 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile)-1);
5152 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile)-1);
5153 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile)-1);
5154 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname)-1);
5155 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype)-1);
5156
5157 DEBUGADD(8,( "version: %d\n", d->version));
5158 DEBUGADD(8,( "name: %s\n", d->name));
5159 DEBUGADD(8,( "environment: %s\n", d->environment));
5160 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
5161 DEBUGADD(8,( "datafile: %s\n", d->datafile));
5162 DEBUGADD(8,( "configfile: %s\n", d->configfile));
5163 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
5164 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
5165 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5166
5167 if (!uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5168 goto error;
5169 if (!uniarray_2_dosarray(&uni->previousnames, &d->previousnames ))
5170 goto error;
5171
5172 return True;
5173
5174 error:
5175 SAFE_FREE(*asc);
5176 return False;
5177 }
5178
5179 BOOL uni_2_asc_printer_info_2(const SPOOL_PRINTER_INFO_LEVEL_2 *uni,
5180 NT_PRINTER_INFO_LEVEL_2 **asc)
5181 {
5182 NT_PRINTER_INFO_LEVEL_2 *d;
5183 time_t time_unix;
5184
5185 DEBUG(7,("Converting from UNICODE to ASCII\n"));
5186 time_unix=time(NULL);
5187
5188 if (*asc==NULL) {
5189 DEBUGADD(8,("allocating memory\n"));
5190
5191 *asc=(NT_PRINTER_INFO_LEVEL_2 *)malloc(sizeof(NT_PRINTER_INFO_LEVEL_2));
5192 if(*asc == NULL)
5193 return False;
5194 ZERO_STRUCTP(*asc);
5195
5196 /* we allocate memory iff called from
5197 * addprinter(ex) so we can do one time stuff here.
5198 */
5199 (*asc)->setuptime=time_unix;
5200 }
5201 DEBUGADD(8,("start converting\n"));
5202
5203 d=*asc;
5204
5205 d->attributes=uni->attributes;
5206 d->priority=uni->priority;
5207 d->default_priority=uni->default_priority;
5208 d->starttime=uni->starttime;
5209 d->untiltime=uni->untiltime;
5210 d->status=uni->status;
5211 d->cjobs=uni->cjobs;
5212
5213 unistr2_to_ascii(d->servername, &uni->servername, sizeof(d->servername)-1);
5214 unistr2_to_ascii(d->printername, &uni->printername, sizeof(d->printername)-1);
5215 unistr2_to_ascii(d->sharename, &uni->sharename, sizeof(d->sharename)-1);
5216 unistr2_to_ascii(d->portname, &uni->portname, sizeof(d->portname)-1);
5217 unistr2_to_ascii(d->drivername, &uni->drivername, sizeof(d->drivername)-1);
5218 unistr2_to_ascii(d->comment, &uni->comment, sizeof(d->comment)-1);
5219 unistr2_to_ascii(d->location, &uni->location, sizeof(d->location)-1);
5220 unistr2_to_ascii(d->sepfile, &uni->sepfile, sizeof(d->sepfile)-1);
5221 unistr2_to_ascii(d->printprocessor, &uni->printprocessor, sizeof(d->printprocessor)-1);
5222 unistr2_to_ascii(d->datatype, &uni->datatype, sizeof(d->datatype)-1);
5223 unistr2_to_ascii(d->parameters, &uni->parameters, sizeof(d->parameters)-1);
5224
5225 return True;
5226 }
5227
5228 /*******************************************************************
5229 * init a structure.
5230 ********************************************************************/
5231
5232 BOOL make_spoolss_q_getprinterdriverdir(SPOOL_Q_GETPRINTERDRIVERDIR *q_u,
5233 fstring servername, fstring env_name, uint32 level,
5234 NEW_BUFFER *buffer, uint32 offered)
5235 {
5236 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
5237 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, env_name);
5238
5239 q_u->level=level;
5240 q_u->buffer=buffer;
5241 q_u->offered=offered;
5242
5243 return True;
5244 }
5245
5246 /*******************************************************************
5247 Parse a SPOOL_Q_GETPRINTERDRIVERDIR structure.
5248 ********************************************************************/
5249
5250 BOOL spoolss_io_q_getprinterdriverdir(char *desc, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, prs_struct *ps, int depth)
5251 {
5252 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriverdir");
5253 depth++;
5254
5255 if(!prs_align(ps))
5256 return False;
5257 if(!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5258 return False;
5259 if(!smb_io_unistr2("", &q_u->name, q_u->name_ptr, ps, depth))
5260 return False;
5261
5262 if(!prs_align(ps))
5263 return False;
5264
5265 if(!prs_uint32("", ps, depth, &q_u->environment_ptr))
5266 return False;
5267 if(!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5268 return False;
5269
5270 if(!prs_align(ps))
5271 return False;
5272
5273 if(!prs_uint32("level", ps, depth, &q_u->level))
5274 return False;
5275
5276 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
5277 return False;
5278
5279 if(!prs_align(ps))
5280 return False;
5281
5282 if(!prs_uint32("offered", ps, depth, &q_u->offered))
5283 return False;
5284
5285 return True;
5286 }
5287
5288 /*******************************************************************
5289 Parse a SPOOL_R_GETPRINTERDRIVERDIR structure.
5290 ********************************************************************/
5291
5292 BOOL spoolss_io_r_getprinterdriverdir(char *desc, SPOOL_R_GETPRINTERDRIVERDIR *r_u, prs_struct *ps, int depth)
5293 {
5294 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriverdir");
5295 depth++;
5296
5297 if (!prs_align(ps))
5298 return False;
5299
5300 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
5301 return False;
5302
5303 if (!prs_align(ps))
5304 return False;
5305
5306 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5307 return False;
5308
5309 if (!prs_werror("status", ps, depth, &r_u->status))
5310 return False;
5311
5312 return True;
5313 }
5314
5315 /*******************************************************************
5316 ********************************************************************/
5317
5318 BOOL spoolss_io_r_enumprintprocessors(char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
5319 {
5320 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
5321 depth++;
5322
5323 if (!prs_align(ps))
5324 return False;
5325
5326 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
5327 return False;
5328
5329 if (!prs_align(ps))
5330 return False;
5331
5332 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5333 return False;
5334
5335 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5336 return False;
5337
5338 if (!prs_werror("status", ps, depth, &r_u->status))
5339 return False;
5340
5341 return True;
5342 }
5343
5344 /*******************************************************************
5345 ********************************************************************/
5346
5347 BOOL spoolss_io_q_enumprintprocessors(char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
5348 {
5349 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
5350 depth++;
5351
5352 if (!prs_align(ps))
5353 return False;
5354
5355 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5356 return False;
5357 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5358 return False;
5359
5360 if (!prs_align(ps))
5361 return False;
5362
5363 if (!prs_uint32("", ps, depth, &q_u->environment_ptr))
5364 return False;
5365 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5366 return False;
5367
5368 if (!prs_align(ps))
5369 return False;
5370
5371 if (!prs_uint32("level", ps, depth, &q_u->level))
5372 return False;
5373
5374 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
5375 return False;
5376
5377 if (!prs_align(ps))
5378 return False;
5379
5380 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5381 return False;
5382
5383 return True;
5384 }
5385
5386 /*******************************************************************
5387 ********************************************************************/
5388
5389 BOOL spoolss_io_q_addprintprocessor(char *desc, SPOOL_Q_ADDPRINTPROCESSOR *q_u, prs_struct *ps, int depth)
5390 {
5391 prs_debug(ps, depth, desc, "spoolss_io_q_addprintprocessor");
5392 depth++;
5393
5394 if (!prs_align(ps))
5395 return False;
5396
5397 if (!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
5398 return False;
5399 if (!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
5400 return False;
5401
5402 if (!prs_align(ps))
5403 return False;
5404 if (!smb_io_unistr2("environment", &q_u->environment, True, ps, depth))
5405 return False;
5406
5407 if (!prs_align(ps))
5408 return False;
5409 if (!smb_io_unistr2("path", &q_u->path, True, ps, depth))
5410 return False;
5411
5412 if (!prs_align(ps))
5413 return False;
5414 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5415 return False;
5416
5417 return True;
5418 }
5419
5420 /*******************************************************************
5421 ********************************************************************/
5422
5423 BOOL spoolss_io_r_addprintprocessor(char *desc, SPOOL_R_ADDPRINTPROCESSOR *r_u, prs_struct *ps, int depth)
5424 {
5425 prs_debug(ps, depth, desc, "spoolss_io_r_addprintproicessor");
5426 depth++;
5427
5428 if (!prs_align(ps))
5429 return False;
5430
5431 if (!prs_werror("status", ps, depth, &r_u->status))
5432 return False;
5433
5434 return True;
5435 }
5436
5437 /*******************************************************************
5438 ********************************************************************/
5439
5440 BOOL spoolss_io_r_enumprintprocdatatypes(char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u, prs_struct *ps, int depth)
5441 {
5442 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes");
5443 depth++;
5444
5445 if (!prs_align(ps))
5446 return False;
5447
5448 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
5449 return False;
5450
5451 if (!prs_align(ps))
5452 return False;
5453
5454 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5455 return False;
5456
5457 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5458 return False;
5459
5460 if (!prs_werror("status", ps, depth, &r_u->status))
5461 return False;
5462
5463 return True;
5464 }
5465
5466 /*******************************************************************
5467 ********************************************************************/
5468
5469 BOOL spoolss_io_q_enumprintprocdatatypes(char *desc, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, prs_struct *ps, int depth)
5470 {
5471 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocdatatypes");
5472 depth++;
5473
5474 if (!prs_align(ps))
5475 return False;
5476
5477 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5478 return False;
5479 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5480 return False;
5481
5482 if (!prs_align(ps))
5483 return False;
5484
5485 if (!prs_uint32("processor_ptr", ps, depth, &q_u->processor_ptr))
5486 return False;
5487 if (!smb_io_unistr2("processor", &q_u->processor, q_u->processor_ptr, ps, depth))
5488 return False;
5489
5490 if (!prs_align(ps))
5491 return False;
5492
5493 if (!prs_uint32("level", ps, depth, &q_u->level))
5494 return False;
5495
5496 if(!spoolss_io_buffer("buffer", ps, depth, &q_u->buffer))
5497 return False;
5498
5499 if (!prs_align(ps))
5500 return False;
5501
5502 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5503 return False;
5504
5505 return True;
5506 }
5507
5508 /*******************************************************************
5509 Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
5510 ********************************************************************/
5511
5512 BOOL spoolss_io_q_enumprintmonitors(char *desc, SPOOL_Q_ENUMPRINTMONITORS *q_u, prs_struct *ps, int depth)
5513 {
5514 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintmonitors");
5515 depth++;
5516
5517 if (!prs_align(ps))
5518 return False;
5519
5520 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5521 return False;
5522 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5523 return False;
5524
5525 if (!prs_align(ps))
5526 return False;
5527
5528 if (!prs_uint32("level", ps, depth, &q_u->level))
5529 return False;
5530
5531 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
5532 return False;
5533
5534 if (!prs_align(ps))
5535 return False;
5536
5537 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5538 return False;
5539
5540 return True;
5541 }
5542
5543 /*******************************************************************
5544 ********************************************************************/
5545
5546 BOOL spoolss_io_r_enumprintmonitors(char *desc, SPOOL_R_ENUMPRINTMONITORS *r_u, prs_struct *ps, int depth)
5547 {
5548 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintmonitors");
5549 depth++;
5550
5551 if (!prs_align(ps))
5552 return False;
5553
5554 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
5555 return False;
5556
5557 if (!prs_align(ps))
5558 return False;
5559
5560 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5561 return False;
5562
5563 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5564 return False;
5565
5566 if (!prs_werror("status", ps, depth, &r_u->status))
5567 return False;
5568
5569 return True;
5570 }
5571
5572 /*******************************************************************
5573 ********************************************************************/
5574
5575 BOOL spoolss_io_r_enumprinterdata(char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth)
5576 {
5577 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata");
5578 depth++;
5579
5580 if(!prs_align(ps))
5581 return False;
5582 if(!prs_uint32("valuesize", ps, depth, &r_u->valuesize))
5583 return False;
5584
5585 if(!prs_uint16uni(False, "value", ps, depth, r_u->value, r_u->valuesize ))
5586 return False;
5587
5588 if(!prs_align(ps))
5589 return False;
5590
5591 if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
5592 return False;
5593
5594 if(!prs_uint32("type", ps, depth, &r_u->type))
5595 return False;
5596
5597 if(!prs_uint32("datasize", ps, depth, &r_u->datasize))
5598 return False;
5599 if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
5600 return False;
5601 if(!prs_align(ps))
5602 return False;
5603
5604 if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
5605 return False;
5606 if(!prs_werror("status", ps, depth, &r_u->status))
5607 return False;
5608
5609 return True;
5610 }
5611
5612 /*******************************************************************
5613 ********************************************************************/
5614
5615 BOOL spoolss_io_q_enumprinterdata(char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
5616 {
5617 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
5618 depth++;
5619
5620 if(!prs_align(ps))
5621 return False;
5622 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
5623 return False;
5624 if(!prs_uint32("index", ps, depth, &q_u->index))
5625 return False;
5626 if(!prs_uint32("valuesize", ps, depth, &q_u->valuesize))
5627 return False;
5628 if(!prs_uint32("datasize", ps, depth, &q_u->datasize))
5629 return False;
5630
5631 return True;
5632 }
5633
5634 /*******************************************************************
5635 ********************************************************************/
5636
5637 BOOL make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u,
5638 const POLICY_HND *hnd,
5639 uint32 idx, uint32 valuelen, uint32 datalen)
5640 {
5641 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5642 q_u->index=idx;
5643 q_u->valuesize=valuelen;
5644 q_u->datasize=datalen;
5645
5646 return True;
5647 }
5648
5649 /*******************************************************************
5650 ********************************************************************/
5651 BOOL make_spoolss_q_setprinterdata(SPOOL_Q_SETPRINTERDATA *q_u, TALLOC_CTX *ctx, const POLICY_HND *hnd,
5652 char* value, char* data)
5653 {
5654 UNISTR2 tmp;
5655
5656 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5657 q_u->type = REG_SZ;
5658 init_unistr2(&q_u->value, value, strlen(value)+1);
5659
5660 init_unistr2(&tmp, data, strlen(data)+1);
5661 q_u->max_len = q_u->real_len = tmp.uni_max_len*2;
5662 q_u->data = talloc(ctx, q_u->real_len);
5663 memcpy(q_u->data, tmp.buffer, q_u->real_len);
5664
5665 return True;
5666 }
5667 /*******************************************************************
5668 ********************************************************************/
5669
5670 BOOL spoolss_io_q_setprinterdata(char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
5671 {
5672 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
5673 depth++;
5674
5675 if(!prs_align(ps))
5676 return False;
5677 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5678 return False;
5679 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
5680 return False;
5681
5682 if(!prs_align(ps))
5683 return False;
5684
5685 if(!prs_uint32("type", ps, depth, &q_u->type))
5686 return False;
5687
5688 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
5689 return False;
5690
5691 switch (q_u->type)
5692 {
5693 case REG_SZ:
5694 case REG_BINARY:
5695 case REG_DWORD:
5696 case REG_MULTI_SZ:
5697 if (q_u->max_len) {
5698 if (UNMARSHALLING(ps))
5699 q_u->data=(uint8 *)prs_alloc_mem(ps, q_u->max_len * sizeof(uint8));
5700 if(q_u->data == NULL)
5701 return False;
5702 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
5703 return False;
5704 }
5705 if(!prs_align(ps))
5706 return False;
5707 break;
5708 }
5709
5710 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
5711 return False;
5712
5713 return True;
5714 }
5715
5716 /*******************************************************************
5717 ********************************************************************/
5718
5719 BOOL spoolss_io_r_setprinterdata(char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
5720 {
5721 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
5722 depth++;
5723
5724 if(!prs_align(ps))
5725 return False;
5726 if(!prs_werror("status", ps, depth, &r_u->status))
5727 return False;
5728
5729 return True;
5730 }
5731
5732 /*******************************************************************
5733 ********************************************************************/
5734 BOOL spoolss_io_q_resetprinter(char *desc, SPOOL_Q_RESETPRINTER *q_u, prs_struct *ps, int depth)
5735 {
5736 prs_debug(ps, depth, desc, "spoolss_io_q_resetprinter");
5737 depth++;
5738
5739 if (!prs_align(ps))
5740 return False;
5741 if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5742 return False;
5743
5744 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
5745 return False;
5746
5747 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
5748 return False;
5749
5750 return True;
5751 }
5752
5753
5754 /*******************************************************************
5755 ********************************************************************/
5756 BOOL spoolss_io_r_resetprinter(char *desc, SPOOL_R_RESETPRINTER *r_u, prs_struct *ps, int depth)
5757 {
5758 prs_debug(ps, depth, desc, "spoolss_io_r_resetprinter");
5759 depth++;
5760
5761 if(!prs_align(ps))
5762 return False;
5763 if(!prs_werror("status", ps, depth, &r_u->status))
5764 return False;
5765
5766 return True;
5767 }
5768
5769 /*******************************************************************
5770 ********************************************************************/
5771 BOOL convert_specific_param(NT_PRINTER_PARAM **param, const UNISTR2 *value,
5772 uint32 type, const uint8 *data, uint32 len)
5773 {
5774 DEBUG(5,("converting a specific param struct\n"));
5775
5776 if (*param == NULL)
5777 {
5778 *param=(NT_PRINTER_PARAM *)malloc(sizeof(NT_PRINTER_PARAM));
5779 if(*param == NULL)
5780 return False;
5781 memset((char *)*param, '\0', sizeof(NT_PRINTER_PARAM));
5782 DEBUGADD(6,("Allocated a new PARAM struct\n"));
5783 }
5784 unistr2_to_ascii((*param)->value, value, sizeof((*param)->value)-1);
5785 (*param)->type = type;
5786
5787 /* le champ data n'est pas NULL termine */
5788 /* on stocke donc la longueur */
5789
5790 (*param)->data_len=len;
5791
5792 if (len) {
5793 (*param)->data=(uint8 *)malloc(len * sizeof(uint8));
5794 if((*param)->data == NULL)
5795 return False;
5796 memcpy((*param)->data, data, len);
5797 }
5798
5799 DEBUGADD(6,("\tvalue:[%s], len:[%d]\n",(*param)->value, (*param)->data_len));
5800 dump_data(10, (char *)(*param)->data, (*param)->data_len);
5801
5802 return True;
5803 }
5804
5805 /*******************************************************************
5806 ********************************************************************/
5807
5808 static BOOL spoolss_io_addform(char *desc, FORM *f, uint32 ptr, prs_struct *ps, int depth)
5809 {
5810 prs_debug(ps, depth, desc, "spoolss_io_addform");
5811 depth++;
5812 if(!prs_align(ps))
5813 return False;
5814
5815 if (ptr!=0)
5816 {
5817 if(!prs_uint32("flags", ps, depth, &f->flags))
5818 return False;
5819 if(!prs_uint32("name_ptr", ps, depth, &f->name_ptr))
5820 return False;
5821 if(!prs_uint32("size_x", ps, depth, &f->size_x))
5822 return False;
5823 if(!prs_uint32("size_y", ps, depth, &f->size_y))
5824 return False;
5825 if(!prs_uint32("left", ps, depth, &f->left))
5826 return False;
5827 if(!prs_uint32("top", ps, depth, &f->top))
5828 return False;
5829 if(!prs_uint32("right", ps, depth, &f->right))
5830 return False;
5831 if(!prs_uint32("bottom", ps, depth, &f->bottom))
5832 return False;
5833
5834 if(!smb_io_unistr2("", &f->name, f->name_ptr, ps, depth))
5835 return False;
5836 }
5837
5838 return True;
5839 }
5840
5841 /*******************************************************************
5842 ********************************************************************/
5843
5844 BOOL spoolss_io_q_deleteform(char *desc, SPOOL_Q_DELETEFORM *q_u, prs_struct *ps, int depth)
5845 {
5846 prs_debug(ps, depth, desc, "spoolss_io_q_deleteform");
5847 depth++;
5848
5849 if(!prs_align(ps))
5850 return False;
5851 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5852 return False;
5853 if(!smb_io_unistr2("form name", &q_u->name, True, ps, depth))
5854 return False;
5855
5856 return True;
5857 }
5858
5859 /*******************************************************************
5860 ********************************************************************/
5861
5862 BOOL spoolss_io_r_deleteform(char *desc, SPOOL_R_DELETEFORM *r_u, prs_struct *ps, int depth)
5863 {
5864 prs_debug(ps, depth, desc, "spoolss_io_r_deleteform");
5865 depth++;
5866
5867 if(!prs_align(ps))
5868 return False;
5869 if(!prs_werror("status", ps, depth, &r_u->status))
5870 return False;
5871
5872 return True;
5873 }
5874
5875 /*******************************************************************
5876 ********************************************************************/
5877
5878 BOOL spoolss_io_q_addform(char *desc, SPOOL_Q_ADDFORM *q_u, prs_struct *ps, int depth)
5879 {
5880 uint32 useless_ptr=0;
5881 prs_debug(ps, depth, desc, "spoolss_io_q_addform");
5882 depth++;
5883
5884 if(!prs_align(ps))
5885 return False;
5886 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5887 return False;
5888 if(!prs_uint32("level", ps, depth, &q_u->level))
5889 return False;
5890 if(!prs_uint32("level2", ps, depth, &q_u->level2))
5891 return False;
5892
5893 if (q_u->level==1)
5894 {
5895 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
5896 return False;
5897 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
5898 return False;
5899 }
5900
5901 return True;
5902 }
5903
5904 /*******************************************************************
5905 ********************************************************************/
5906
5907 BOOL spoolss_io_r_addform(char *desc, SPOOL_R_ADDFORM *r_u, prs_struct *ps, int depth)
5908 {
5909 prs_debug(ps, depth, desc, "spoolss_io_r_addform");
5910 depth++;
5911
5912 if(!prs_align(ps))
5913 return False;
5914 if(!prs_werror("status", ps, depth, &r_u->status))
5915 return False;
5916
5917 return True;
5918 }
5919
5920 /*******************************************************************
5921 ********************************************************************/
5922
5923 BOOL spoolss_io_q_setform(char *desc, SPOOL_Q_SETFORM *q_u, prs_struct *ps, int depth)
5924 {
5925 uint32 useless_ptr=0;
5926 prs_debug(ps, depth, desc, "spoolss_io_q_setform");
5927 depth++;
5928
5929 if(!prs_align(ps))
5930 return False;
5931 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5932 return False;
5933 if(!smb_io_unistr2("", &q_u->name, True, ps, depth))
5934 return False;
5935
5936 if(!prs_align(ps))
5937 return False;
5938
5939 if(!prs_uint32("level", ps, depth, &q_u->level))
5940 return False;
5941 if(!prs_uint32("level2", ps, depth, &q_u->level2))
5942 return False;
5943
5944 if (q_u->level==1)
5945 {
5946 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
5947 return False;
5948 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
5949 return False;
5950 }
5951
5952 return True;
5953 }
5954
5955 /*******************************************************************
5956 ********************************************************************/
5957
5958 BOOL spoolss_io_r_setform(char *desc, SPOOL_R_SETFORM *r_u, prs_struct *ps, int depth)
5959 {
5960 prs_debug(ps, depth, desc, "spoolss_io_r_setform");
5961 depth++;
5962
5963 if(!prs_align(ps))
5964 return False;
5965 if(!prs_werror("status", ps, depth, &r_u->status))
5966 return False;
5967
5968 return True;
5969 }
5970
5971 /*******************************************************************
5972 Parse a SPOOL_R_GETJOB structure.
5973 ********************************************************************/
5974
5975 BOOL spoolss_io_r_getjob(char *desc, SPOOL_R_GETJOB *r_u, prs_struct *ps, int depth)
5976 {
5977 prs_debug(ps, depth, desc, "spoolss_io_r_getjob");
5978 depth++;
5979
5980 if (!prs_align(ps))
5981 return False;
5982
5983 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
5984 return False;
5985
5986 if (!prs_align(ps))
5987 return False;
5988
5989 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5990 return False;
5991
5992 if (!prs_werror("status", ps, depth, &r_u->status))
5993 return False;
5994
5995 return True;
5996 }
5997
5998 /*******************************************************************
5999 Parse a SPOOL_Q_GETJOB structure.
6000 ********************************************************************/
6001
6002 BOOL spoolss_io_q_getjob(char *desc, SPOOL_Q_GETJOB *q_u, prs_struct *ps, int depth)
6003 {
6004 prs_debug(ps, depth, desc, "");
6005 depth++;
6006
6007 if(!prs_align(ps))
6008 return False;
6009
6010 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6011 return False;
6012 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
6013 return False;
6014 if(!prs_uint32("level", ps, depth, &q_u->level))
6015 return False;
6016
6017 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
6018 return False;
6019
6020 if(!prs_align(ps))
6021 return False;
6022
6023 if(!prs_uint32("offered", ps, depth, &q_u->offered))
6024 return False;
6025
6026 return True;
6027 }
6028
6029 void free_devmode(DEVICEMODE *devmode)
6030 {
6031 if (devmode!=NULL) {
6032 SAFE_FREE(devmode->private);
6033 SAFE_FREE(devmode);
6034 }
6035 }
6036
6037 void free_printer_info_1(PRINTER_INFO_1 *printer)
6038 {
6039 SAFE_FREE(printer);
6040 }
6041
6042 void free_printer_info_2(PRINTER_INFO_2 *printer)
6043 {
6044 if (printer!=NULL) {
6045 free_devmode(printer->devmode);
6046 printer->devmode = NULL;
6047 SAFE_FREE(printer);
6048 }
6049 }
6050
6051 void free_printer_info_3(PRINTER_INFO_3 *printer)
6052 {
6053 SAFE_FREE(printer);
6054 }
6055
6056 void free_printer_info_4(PRINTER_INFO_4 *printer)
6057 {
6058 SAFE_FREE(printer);
6059 }
6060
6061 void free_printer_info_5(PRINTER_INFO_5 *printer)
6062 {
6063 SAFE_FREE(printer);
6064 }
6065
6066 void free_job_info_2(JOB_INFO_2 *job)
6067 {
6068 if (job!=NULL)
6069 free_devmode(job->devmode);
6070 }
6071
6072 /*******************************************************************
6073 * init a structure.
6074 ********************************************************************/
6075
6076 BOOL make_spoolss_q_replyopenprinter(SPOOL_Q_REPLYOPENPRINTER *q_u,
6077 const fstring string, uint32 printer, uint32 type)
6078 {
6079 if (q_u == NULL)
6080 return False;
6081
6082 init_unistr2(&q_u->string, string, strlen(string)+1);
6083
6084 q_u->printer=printer;
6085 q_u->type=type;
6086
6087 q_u->unknown0=0x0;
6088 q_u->unknown1=0x0;
6089
6090 return True;
6091 }
6092
6093 /*******************************************************************
6094 Parse a SPOOL_Q_REPLYOPENPRINTER structure.
6095 ********************************************************************/
6096
6097 BOOL spoolss_io_q_replyopenprinter(char *desc, SPOOL_Q_REPLYOPENPRINTER *q_u, prs_struct *ps, int depth)
6098 {
6099 prs_debug(ps, depth, desc, "spoolss_io_q_replyopenprinter");
6100 depth++;
6101
6102 if(!prs_align(ps))
6103 return False;
6104
6105 if(!smb_io_unistr2("", &q_u->string, True, ps, depth))
6106 return False;
6107
6108 if(!prs_align(ps))
6109 return False;
6110
6111 if(!prs_uint32("printer", ps, depth, &q_u->printer))
6112 return False;
6113 if(!prs_uint32("type", ps, depth, &q_u->type))
6114 return False;
6115
6116 if(!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6117 return False;
6118 if(!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6119 return False;
6120
6121 return True;
6122 }
6123
6124 /*******************************************************************
6125 Parse a SPOOL_R_REPLYOPENPRINTER structure.
6126 ********************************************************************/
6127
6128 BOOL spoolss_io_r_replyopenprinter(char *desc, SPOOL_R_REPLYOPENPRINTER *r_u, prs_struct *ps, int depth)
6129 {
6130 prs_debug(ps, depth, desc, "spoolss_io_r_replyopenprinter");
6131 depth++;
6132
6133 if (!prs_align(ps))
6134 return False;
6135
6136 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6137 return False;
6138
6139 if (!prs_werror("status", ps, depth, &r_u->status))
6140 return False;
6141
6142 return True;
6143 }
6144
6145 /*******************************************************************
6146 * init a structure.
6147 ********************************************************************/
6148 BOOL make_spoolss_q_routerreplyprinter(SPOOL_Q_ROUTERREPLYPRINTER *q_u, POLICY_HND *hnd,
6149 uint32 condition, uint32 change_id)
6150 {
6151
6152 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6153
6154 q_u->condition = condition;
6155 q_u->change_id = change_id;
6156
6157 /* magic values */
6158 q_u->unknown1 = 0x1;
6159 memset(q_u->unknown2, 0x0, 5);
6160 q_u->unknown2[0] = 0x1;
6161
6162 return True;
6163 }
6164
6165 /*******************************************************************
6166 Parse a SPOOL_Q_ROUTERREPLYPRINTER structure.
6167 ********************************************************************/
6168 BOOL spoolss_io_q_routerreplyprinter (char *desc, SPOOL_Q_ROUTERREPLYPRINTER *q_u, prs_struct *ps, int depth)
6169 {
6170
6171 prs_debug(ps, depth, desc, "spoolss_io_q_routerreplyprinter");
6172 depth++;
6173
6174 if (!prs_align(ps))
6175 return False;
6176
6177 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6178 return False;
6179
6180 if (!prs_uint32("condition", ps, depth, &q_u->condition))
6181 return False;
6182
6183 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6184 return False;
6185
6186 if (!prs_uint32("change_id", ps, depth, &q_u->change_id))
6187 return False;
6188
6189 if (!prs_uint8s(False, "private", ps, depth, q_u->unknown2, 5))
6190 return False;
6191
6192 return True;
6193 }
6194
6195 /*******************************************************************
6196 Parse a SPOOL_R_ROUTERREPLYPRINTER structure.
6197 ********************************************************************/
6198 BOOL spoolss_io_r_routerreplyprinter (char *desc, SPOOL_R_ROUTERREPLYPRINTER *r_u, prs_struct *ps, int depth)
6199 {
6200 prs_debug(ps, depth, desc, "spoolss_io_r_routerreplyprinter");
6201 depth++;
6202
6203 if (!prs_align(ps))
6204 return False;
6205
6206 if (!prs_werror("status", ps, depth, &r_u->status))
6207 return False;
6208
6209 return True;
6210 }
6211
6212 /*******************************************************************
6213 * init a structure.
6214 ********************************************************************/
6215
6216 BOOL make_spoolss_q_reply_closeprinter(SPOOL_Q_REPLYCLOSEPRINTER *q_u, POLICY_HND *hnd)
6217 {
6218 if (q_u == NULL)
6219 return False;
6220
6221 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6222
6223 return True;
6224 }
6225
6226 /*******************************************************************
6227 Parse a SPOOL_Q_REPLYCLOSEPRINTER structure.
6228 ********************************************************************/
6229
6230 BOOL spoolss_io_q_replycloseprinter(char *desc, SPOOL_Q_REPLYCLOSEPRINTER *q_u, prs_struct *ps, int depth)
6231 {
6232 prs_debug(ps, depth, desc, "spoolss_io_q_replycloseprinter");
6233 depth++;
6234
6235 if(!prs_align(ps))
6236 return False;
6237
6238 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6239 return False;
6240
6241 return True;
6242 }
6243
6244 /*******************************************************************
6245 Parse a SPOOL_R_REPLYCLOSEPRINTER structure.
6246 ********************************************************************/
6247
6248 BOOL spoolss_io_r_replycloseprinter(char *desc, SPOOL_R_REPLYCLOSEPRINTER *r_u, prs_struct *ps, int depth)
6249 {
6250 prs_debug(ps, depth, desc, "spoolss_io_r_replycloseprinter");
6251 depth++;
6252
6253 if (!prs_align(ps))
6254 return False;
6255
6256 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6257 return False;
6258
6259 if (!prs_werror("status", ps, depth, &r_u->status))
6260 return False;
6261
6262 return True;
6263 }
6264
6265 #if 0 /* JERRY - not currently used but could be :-) */
6266
6267 /*******************************************************************
6268 Deep copy a SPOOL_NOTIFY_INFO_DATA structure
6269 ******************************************************************/
6270 static BOOL copy_spool_notify_info_data(SPOOL_NOTIFY_INFO_DATA *dst,
6271 SPOOL_NOTIFY_INFO_DATA *src, int n)
6272 {
6273 int i;
6274
6275 memcpy(dst, src, sizeof(SPOOL_NOTIFY_INFO_DATA)*n);
6276
6277 for (i=0; i<n; i++) {
6278 int len;
6279 uint16 *s = NULL;
6280
6281 if (src->size != POINTER)
6282 continue;
6283 len = src->notify_data.data.length;
6284 s = malloc(sizeof(uint16)*len);
6285 if (s == NULL) {
6286 DEBUG(0,("copy_spool_notify_info_data: malloc() failed!\n"));
6287 return False;
6288 }
6289
6290 memcpy(s, src->notify_data.data.string, len*2);
6291 dst->notify_data.data.string = s;
6292 }
6293
6294 return True;
6295 }
6296
6297 /*******************************************************************
6298 Deep copy a SPOOL_NOTIFY_INFO structure
6299 ******************************************************************/
6300 static BOOL copy_spool_notify_info(SPOOL_NOTIFY_INFO *dst, SPOOL_NOTIFY_INFO *src)
6301 {
6302 if (!dst) {
6303 DEBUG(0,("copy_spool_notify_info: NULL destination pointer!\n"));
6304 return False;
6305 }
6306
6307 dst->version = src->version;
6308 dst->flags = src->flags;
6309 dst->count = src->count;
6310
6311 if (dst->count)
6312 {
6313 dst->data = malloc(dst->count * sizeof(SPOOL_NOTIFY_INFO_DATA));
6314
6315 DEBUG(10,("copy_spool_notify_info: allocating space for [%d] PRINTER_NOTIFY_INFO_DATA entries\n",
6316 dst->count));
6317
6318 if (dst->data == NULL) {
6319 DEBUG(0,("copy_spool_notify_info: malloc() failed for [%d] entries!\n",
6320 dst->count));
6321 return False;
6322 }
6323
6324 return (copy_spool_notify_info_data(dst->data, src->data, src->count));
6325 }
6326
6327 return True;
6328 }
6329 #endif /* JERRY */
6330
6331 /*******************************************************************
6332 * init a structure.
6333 ********************************************************************/
6334
6335 BOOL make_spoolss_q_reply_rrpcn(SPOOL_Q_REPLY_RRPCN *q_u, POLICY_HND *hnd,
6336 uint32 change_low, uint32 change_high,
6337 SPOOL_NOTIFY_INFO *info)
6338 {
6339 if (q_u == NULL)
6340 return False;
6341
6342 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6343
6344 q_u->change_low=change_low;
6345 q_u->change_high=change_high;
6346
6347 q_u->unknown0=0x0;
6348 q_u->unknown1=0x0;
6349
6350 q_u->info_ptr=0xaddee11e;
6351
6352 q_u->info.version=2;
6353
6354 if (info->count) {
6355 DEBUG(10,("make_spoolss_q_reply_rrpcn: [%d] PRINTER_NOTIFY_INFO_DATA\n",
6356 info->count));
6357 q_u->info.version = info->version;
6358 q_u->info.flags = info->flags;
6359 q_u->info.count = info->count;
6360 /* pointer field - be careful! */
6361 q_u->info.data = info->data;
6362 }
6363 else {
6364 q_u->info.flags=PRINTER_NOTIFY_INFO_DISCARDED;
6365 q_u->info.count=0;
6366 }
6367
6368 return True;
6369 }
6370
6371 /*******************************************************************
6372 Parse a SPOOL_Q_REPLY_RRPCN structure.
6373 ********************************************************************/
6374
6375 BOOL spoolss_io_q_reply_rrpcn(char *desc, SPOOL_Q_REPLY_RRPCN *q_u, prs_struct *ps, int depth)
6376 {
6377 prs_debug(ps, depth, desc, "spoolss_io_q_reply_rrpcn");
6378 depth++;
6379
6380 if(!prs_align(ps))
6381 return False;
6382
6383 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6384 return False;
6385
6386 if (!prs_uint32("change_low", ps, depth, &q_u->change_low))
6387 return False;
6388
6389 if (!prs_uint32("change_high", ps, depth, &q_u->change_high))
6390 return False;
6391
6392 if (!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6393 return False;
6394
6395 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6396 return False;
6397
6398 if (!prs_uint32("info_ptr", ps, depth, &q_u->info_ptr))
6399 return False;
6400
6401 if(q_u->info_ptr!=0)
6402 if(!smb_io_notify_info(desc, &q_u->info, ps, depth))
6403 return False;
6404
6405 return True;
6406 }
6407
6408 /*******************************************************************
6409 Parse a SPOOL_R_REPLY_RRPCN structure.
6410 ********************************************************************/
6411
6412 BOOL spoolss_io_r_reply_rrpcn(char *desc, SPOOL_R_REPLY_RRPCN *r_u, prs_struct *ps, int depth)
6413 {
6414 prs_debug(ps, depth, desc, "spoolss_io_r_reply_rrpcn");
6415 depth++;
6416
6417 if (!prs_align(ps))
6418 return False;
6419
6420 if (!prs_uint32("unknown0", ps, depth, &r_u->unknown0))
6421 return False;
6422
6423 if (!prs_werror("status", ps, depth, &r_u->status))
6424 return False;
6425
6426 return True;
6427 }
6428
6429 /*******************************************************************
6430 * read a structure.
6431 * called from spoolss_q_getprinterdataex (srv_spoolss.c)
6432 ********************************************************************/
6433
6434 BOOL spoolss_io_q_getprinterdataex(char *desc, SPOOL_Q_GETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6435 {
6436 if (q_u == NULL)
6437 return False;
6438
6439 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdataex");
6440 depth++;
6441
6442 if (!prs_align(ps))
6443 return False;
6444 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6445 return False;
6446 if (!prs_align(ps))
6447 return False;
6448 if (!smb_io_unistr2("keyname", &q_u->keyname,True,ps,depth))
6449 return False;
6450 if (!prs_align(ps))
6451 return False;
6452 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
6453 return False;
6454 if (!prs_align(ps))
6455 return False;
6456 if (!prs_uint32("size", ps, depth, &q_u->size))
6457 return False;
6458
6459 return True;
6460 }
6461
6462 /*******************************************************************
6463 * write a structure.
6464 * called from spoolss_r_getprinterdataex (srv_spoolss.c)
6465 ********************************************************************/
6466
6467 BOOL spoolss_io_r_getprinterdataex(char *desc, SPOOL_R_GETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6468 {
6469 if (r_u == NULL)
6470 return False;
6471
6472 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdataex");
6473 depth++;
6474
6475 if (!prs_align(ps))
6476 return False;
6477 if (!prs_uint32("type", ps, depth, &r_u->type))
6478 return False;
6479 if (!prs_uint32("size", ps, depth, &r_u->size))
6480 return False;
6481
6482 if (!prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size))
6483 return False;
6484
6485 if (!prs_align(ps))
6486 return False;
6487
6488 if (!prs_uint32("needed", ps, depth, &r_u->needed))
6489 return False;
6490 if (!prs_werror("status", ps, depth, &r_u->status))
6491 return False;
6492
6493 return True;
6494 }
6495
6496 /*******************************************************************
6497 * read a structure.
6498 ********************************************************************/
6499
6500 BOOL spoolss_io_q_setprinterdataex(char *desc, SPOOL_Q_SETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6501 {
6502 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdataex");
6503 depth++;
6504
6505 if(!prs_align(ps))
6506 return False;
6507 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6508 return False;
6509 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6510 return False;
6511
6512 if(!prs_align(ps))
6513 return False;
6514
6515 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
6516 return False;
6517
6518 if(!prs_align(ps))
6519 return False;
6520
6521 if(!prs_uint32("type", ps, depth, &q_u->type))
6522 return False;
6523
6524 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
6525 return False;
6526
6527 switch (q_u->type)
6528 {
6529 case 0x1:
6530 case 0x3:
6531 case 0x4:
6532 case 0x7:
6533 if (q_u->max_len) {
6534 if (UNMARSHALLING(ps))
6535 q_u->data=(uint8 *)prs_alloc_mem(ps, q_u->max_len * sizeof(uint8));
6536 if(q_u->data == NULL)
6537 return False;
6538 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
6539 return False;
6540 }
6541 if(!prs_align(ps))
6542 return False;
6543 break;
6544 }
6545
6546 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
6547 return False;
6548
6549 return True;
6550 }
6551
6552 /*******************************************************************
6553 * write a structure.
6554 ********************************************************************/
6555
6556 BOOL spoolss_io_r_setprinterdataex(char *desc, SPOOL_R_SETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6557 {
6558 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdataex");
6559 depth++;
6560
6561 if(!prs_align(ps))
6562 return False;
6563 if(!prs_werror("status", ps, depth, &r_u->status))
6564 return False;
6565
6566 return True;
6567 }
6568
6569
6570 /*******************************************************************
6571 * read a structure.
6572 ********************************************************************/
6573
6574 BOOL spoolss_io_q_enumprinterkey(char *desc, SPOOL_Q_ENUMPRINTERKEY *q_u, prs_struct *ps, int depth)
6575 {
6576 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterkey");
6577 depth++;
6578
6579 if(!prs_align(ps))
6580 return False;
6581 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6582 return False;
6583
6584 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6585 return False;
6586
6587 if(!prs_align(ps))
6588 return False;
6589
6590 if(!prs_uint32("size", ps, depth, &q_u->size))
6591 return False;
6592
6593 return True;
6594 }
6595
6596 /*******************************************************************
6597 * write a structure.
6598 ********************************************************************/
6599
6600 BOOL spoolss_io_r_enumprinterkey(char *desc, SPOOL_R_ENUMPRINTERKEY *r_u, prs_struct *ps, int depth)
6601 {
6602 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterkey");
6603 depth++;
6604
6605 if(!prs_align(ps))
6606 return False;
6607
6608 if (!smb_io_buffer5("", &r_u->keys, ps, depth))
6609 return False;
6610
6611 if(!prs_align(ps))
6612 return False;
6613
6614 if(!prs_uint32("needed", ps, depth, &r_u->needed))
6615 return False;
6616
6617 if(!prs_werror("status", ps, depth, &r_u->status))
6618 return False;
6619
6620 return True;
6621 }
6622
6623
6624 /*******************************************************************
6625 * read a structure.
6626 ********************************************************************/
6627
6628 BOOL spoolss_io_q_enumprinterdataex(char *desc, SPOOL_Q_ENUMPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6629 {
6630 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdataex");
6631 depth++;
6632
6633 if(!prs_align(ps))
6634 return False;
6635 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6636 return False;
6637
6638 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6639 return False;
6640
6641 if(!prs_align(ps))
6642 return False;
6643
6644 if(!prs_uint32("size", ps, depth, &q_u->size))
6645 return False;
6646
6647 return True;
6648 }
6649
6650 /*******************************************************************
6651 ********************************************************************/
6652 static BOOL spoolss_io_printer_enum_values_ctr(char *desc, prs_struct *ps,
6653 PRINTER_ENUM_VALUES_CTR *ctr, int depth)
6654 {
6655 int i;
6656 uint32 valuename_offset,
6657 data_offset,
6658 current_offset;
6659 const uint32 basic_unit = 20; /* size of static portion of enum_values */
6660
6661 prs_debug(ps, depth, desc, "spoolss_io_printer_enum_values_ctr");
6662 depth++;
6663
6664 if (!prs_uint32("size", ps, depth, &ctr->size))
6665 return False;
6666
6667 /* offset data begins at 20 bytes per structure * size_of_array.
6668 Don't forget the uint32 at the beginning */
6669
6670 current_offset = basic_unit * ctr->size_of_array;
6671
6672 /* first loop to write basic enum_value information */
6673
6674 for (i=0; i<ctr->size_of_array; i++)
6675 {
6676 valuename_offset = current_offset;
6677 if (!prs_uint32("valuename_offset", ps, depth, &valuename_offset))
6678 return False;
6679
6680 if (!prs_uint32("value_len", ps, depth, &ctr->values[i].value_len))
6681 return False;
6682
6683 if (!prs_uint32("type", ps, depth, &ctr->values[i].type))
6684 return False;
6685
6686 data_offset = ctr->values[i].value_len + valuename_offset;
6687 if (!prs_uint32("data_offset", ps, depth, &data_offset))
6688 return False;
6689
6690 if (!prs_uint32("data_len", ps, depth, &ctr->values[i].data_len))
6691 return False;
6692
6693 current_offset = data_offset + ctr->values[i].data_len - basic_unit;
6694 }
6695
6696 /* loop #2 for writing the dynamically size objects
6697 while viewing conversations between Win2k -> Win2k,
6698 4-byte alignment does not seem to matter here --jerry */
6699
6700 for (i=0; i<ctr->size_of_array; i++)
6701 {
6702
6703 if (!prs_unistr("valuename", ps, depth, &ctr->values[i].valuename))
6704 return False;
6705
6706 if (!prs_uint8s(False, "data", ps, depth, ctr->values[i].data, ctr->values[i].data_len))
6707 return False;
6708 }
6709
6710
6711
6712 return True;
6713 }
6714
6715
6716 /*******************************************************************
6717 * write a structure.
6718 ********************************************************************/
6719
6720 BOOL spoolss_io_r_enumprinterdataex(char *desc, SPOOL_R_ENUMPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6721 {
6722 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdataex");
6723 depth++;
6724
6725 if(!prs_align(ps))
6726 return False;
6727
6728 if (!spoolss_io_printer_enum_values_ctr("", ps, &r_u->ctr, depth ))
6729 return False;
6730
6731 if(!prs_align(ps))
6732 return False;
6733
6734 if(!prs_uint32("needed", ps, depth, &r_u->needed))
6735 return False;
6736
6737 if(!prs_uint32("returned", ps, depth, &r_u->returned))
6738 return False;
6739
6740 if(!prs_werror("status", ps, depth, &r_u->status))
6741 return False;
6742
6743 return True;
6744 }
6745
6746
6747 /*******************************************************************
6748 * write a structure.
6749 ********************************************************************/
6750
6751 /*
6752 uint32 GetPrintProcessorDirectory(
6753 [in] unistr2 *name,
6754 [in] unistr2 *environment,
6755 [in] uint32 level,
6756 [in,out] NEW_BUFFER buffer,
6757 [in] uint32 offered,
6758 [out] uint32 needed,
6759 [out] uint32 returned
6760 );
6761
6762 */
6763
6764 BOOL make_spoolss_q_getprintprocessordirectory(SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, const char *name, char *environment, int level, NEW_BUFFER *buffer, uint32 offered)
6765 {
6766 DEBUG(5,("make_spoolss_q_getprintprocessordirectory\n"));
6767
6768 init_unistr2(&q_u->name, name, strlen(name)+1);
6769 init_unistr2(&q_u->environment, environment, strlen(environment)+1);
6770
6771 q_u->level = level;
6772
6773 q_u->buffer = buffer;
6774 q_u->offered = offered;
6775
6776 return True;
6777 }
6778
6779 BOOL spoolss_io_q_getprintprocessordirectory(char *desc, SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, prs_struct *ps, int depth)
6780 {
6781 uint32 ptr;
6782
6783 prs_debug(ps, depth, desc, "spoolss_io_q_getprintprocessordirectory");
6784 depth++;
6785
6786 if(!prs_align(ps))
6787 return False;
6788
6789 if (!prs_uint32("ptr", ps, depth, &ptr))
6790 return False;
6791
6792 if (ptr) {
6793 if(!smb_io_unistr2("name", &q_u->name, True, ps, depth))
6794 return False;
6795 }
6796
6797 if (!prs_align(ps))
6798 return False;
6799
6800 if (!prs_uint32("ptr", ps, depth, &ptr))
6801 return False;
6802
6803 if (ptr) {
6804 if(!smb_io_unistr2("environment", &q_u->environment, True,
6805 ps, depth))
6806 return False;
6807 }
6808
6809 if (!prs_align(ps))
6810 return False;
6811
6812 if(!prs_uint32("level", ps, depth, &q_u->level))
6813 return False;
6814
6815 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
6816 return False;
6817
6818 if(!prs_align(ps))
6819 return False;
6820
6821 if(!prs_uint32("offered", ps, depth, &q_u->offered))
6822 return False;
6823
6824 return True;
6825 }
6826
6827 /*******************************************************************
6828 * write a structure.
6829 ********************************************************************/
6830
6831 BOOL spoolss_io_r_getprintprocessordirectory(char *desc, SPOOL_R_GETPRINTPROCESSORDIRECTORY *r_u, prs_struct *ps, int depth)
6832 {
6833 prs_debug(ps, depth, desc, "spoolss_io_r_getprintprocessordirectory");
6834 depth++;
6835
6836 if(!prs_align(ps))
6837 return False;
6838
6839 if(!spoolss_io_buffer("", ps, depth, &r_u->buffer))
6840 return False;
6841
6842 if(!prs_align(ps))
6843 return False;
6844
6845 if(!prs_uint32("needed", ps, depth, &r_u->needed))
6846 return False;
6847
6848 if(!prs_werror("status", ps, depth, &r_u->status))
6849 return False;
6850
6851 return True;
6852 }
6853
6854 BOOL smb_io_printprocessordirectory_1(char *desc, NEW_BUFFER *buffer, PRINTPROCESSOR_DIRECTORY_1 *info, int depth)
6855 {
6856 prs_struct *ps=&buffer->prs;
6857
6858 prs_debug(ps, depth, desc, "smb_io_printprocessordirectory_1");
6859 depth++;
6860
6861 buffer->struct_start=prs_offset(ps);
6862
6863 if (!smb_io_unistr(desc, &info->name, ps, depth))
6864 return False;
6865
6866 return True;
6867 }
Samba GIT mirror