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