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