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