?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r9742: merging reg_objects and NT_PRINTER_DATA changes from SAMBA_3_0
[Samba.git] / source / rpc_parse / parse_spoolss.c
blob45b683e9c607b33db38c3e2308adc98a5f2aec5d
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 *d)
5360 {
5361 DEBUG(7,("Converting from UNICODE to ASCII\n"));
5362
5363 d->attributes=uni->attributes;
5364 d->priority=uni->priority;
5365 d->default_priority=uni->default_priority;
5366 d->starttime=uni->starttime;
5367 d->untiltime=uni->untiltime;
5368 d->status=uni->status;
5369 d->cjobs=uni->cjobs;
5370
5371 unistr2_to_ascii(d->servername, &uni->servername, sizeof(d->servername)-1);
5372 unistr2_to_ascii(d->printername, &uni->printername, sizeof(d->printername)-1);
5373 unistr2_to_ascii(d->sharename, &uni->sharename, sizeof(d->sharename)-1);
5374 unistr2_to_ascii(d->portname, &uni->portname, sizeof(d->portname)-1);
5375 unistr2_to_ascii(d->drivername, &uni->drivername, sizeof(d->drivername)-1);
5376 unistr2_to_ascii(d->comment, &uni->comment, sizeof(d->comment)-1);
5377 unistr2_to_ascii(d->location, &uni->location, sizeof(d->location)-1);
5378 unistr2_to_ascii(d->sepfile, &uni->sepfile, sizeof(d->sepfile)-1);
5379 unistr2_to_ascii(d->printprocessor, &uni->printprocessor, sizeof(d->printprocessor)-1);
5380 unistr2_to_ascii(d->datatype, &uni->datatype, sizeof(d->datatype)-1);
5381 unistr2_to_ascii(d->parameters, &uni->parameters, sizeof(d->parameters)-1);
5382
5383 return True;
5384 }
5385
5386 /*******************************************************************
5387 * init a structure.
5388 ********************************************************************/
5389
5390 BOOL make_spoolss_q_getprinterdriverdir(SPOOL_Q_GETPRINTERDRIVERDIR *q_u,
5391 fstring servername, fstring env_name, uint32 level,
5392 RPC_BUFFER *buffer, uint32 offered)
5393 {
5394 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
5395 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, env_name);
5396
5397 q_u->level=level;
5398 q_u->buffer=buffer;
5399 q_u->offered=offered;
5400
5401 return True;
5402 }
5403
5404 /*******************************************************************
5405 Parse a SPOOL_Q_GETPRINTERDRIVERDIR structure.
5406 ********************************************************************/
5407
5408 BOOL spoolss_io_q_getprinterdriverdir(const char *desc, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, prs_struct *ps, int depth)
5409 {
5410 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriverdir");
5411 depth++;
5412
5413 if(!prs_align(ps))
5414 return False;
5415 if(!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5416 return False;
5417 if(!smb_io_unistr2("", &q_u->name, q_u->name_ptr, ps, depth))
5418 return False;
5419
5420 if(!prs_align(ps))
5421 return False;
5422
5423 if(!prs_uint32("", ps, depth, &q_u->environment_ptr))
5424 return False;
5425 if(!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5426 return False;
5427
5428 if(!prs_align(ps))
5429 return False;
5430
5431 if(!prs_uint32("level", ps, depth, &q_u->level))
5432 return False;
5433
5434 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5435 return False;
5436
5437 if(!prs_align(ps))
5438 return False;
5439
5440 if(!prs_uint32("offered", ps, depth, &q_u->offered))
5441 return False;
5442
5443 return True;
5444 }
5445
5446 /*******************************************************************
5447 Parse a SPOOL_R_GETPRINTERDRIVERDIR structure.
5448 ********************************************************************/
5449
5450 BOOL spoolss_io_r_getprinterdriverdir(const char *desc, SPOOL_R_GETPRINTERDRIVERDIR *r_u, prs_struct *ps, int depth)
5451 {
5452 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriverdir");
5453 depth++;
5454
5455 if (!prs_align(ps))
5456 return False;
5457
5458 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5459 return False;
5460
5461 if (!prs_align(ps))
5462 return False;
5463
5464 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5465 return False;
5466
5467 if (!prs_werror("status", ps, depth, &r_u->status))
5468 return False;
5469
5470 return True;
5471 }
5472
5473 /*******************************************************************
5474 ********************************************************************/
5475
5476 BOOL spoolss_io_r_enumprintprocessors(const char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
5477 {
5478 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
5479 depth++;
5480
5481 if (!prs_align(ps))
5482 return False;
5483
5484 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5485 return False;
5486
5487 if (!prs_align(ps))
5488 return False;
5489
5490 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5491 return False;
5492
5493 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5494 return False;
5495
5496 if (!prs_werror("status", ps, depth, &r_u->status))
5497 return False;
5498
5499 return True;
5500 }
5501
5502 /*******************************************************************
5503 ********************************************************************/
5504
5505 BOOL spoolss_io_q_enumprintprocessors(const char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
5506 {
5507 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
5508 depth++;
5509
5510 if (!prs_align(ps))
5511 return False;
5512
5513 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5514 return False;
5515 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5516 return False;
5517
5518 if (!prs_align(ps))
5519 return False;
5520
5521 if (!prs_uint32("", ps, depth, &q_u->environment_ptr))
5522 return False;
5523 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5524 return False;
5525
5526 if (!prs_align(ps))
5527 return False;
5528
5529 if (!prs_uint32("level", ps, depth, &q_u->level))
5530 return False;
5531
5532 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5533 return False;
5534
5535 if (!prs_align(ps))
5536 return False;
5537
5538 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5539 return False;
5540
5541 return True;
5542 }
5543
5544 /*******************************************************************
5545 ********************************************************************/
5546
5547 BOOL spoolss_io_q_addprintprocessor(const char *desc, SPOOL_Q_ADDPRINTPROCESSOR *q_u, prs_struct *ps, int depth)
5548 {
5549 prs_debug(ps, depth, desc, "spoolss_io_q_addprintprocessor");
5550 depth++;
5551
5552 if (!prs_align(ps))
5553 return False;
5554
5555 if (!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
5556 return False;
5557 if (!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
5558 return False;
5559
5560 if (!prs_align(ps))
5561 return False;
5562 if (!smb_io_unistr2("environment", &q_u->environment, True, ps, depth))
5563 return False;
5564
5565 if (!prs_align(ps))
5566 return False;
5567 if (!smb_io_unistr2("path", &q_u->path, True, ps, depth))
5568 return False;
5569
5570 if (!prs_align(ps))
5571 return False;
5572 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5573 return False;
5574
5575 return True;
5576 }
5577
5578 /*******************************************************************
5579 ********************************************************************/
5580
5581 BOOL spoolss_io_r_addprintprocessor(const char *desc, SPOOL_R_ADDPRINTPROCESSOR *r_u, prs_struct *ps, int depth)
5582 {
5583 prs_debug(ps, depth, desc, "spoolss_io_r_addprintproicessor");
5584 depth++;
5585
5586 if (!prs_align(ps))
5587 return False;
5588
5589 if (!prs_werror("status", ps, depth, &r_u->status))
5590 return False;
5591
5592 return True;
5593 }
5594
5595 /*******************************************************************
5596 ********************************************************************/
5597
5598 BOOL spoolss_io_r_enumprintprocdatatypes(const char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u, prs_struct *ps, int depth)
5599 {
5600 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes");
5601 depth++;
5602
5603 if (!prs_align(ps))
5604 return False;
5605
5606 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5607 return False;
5608
5609 if (!prs_align(ps))
5610 return False;
5611
5612 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5613 return False;
5614
5615 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5616 return False;
5617
5618 if (!prs_werror("status", ps, depth, &r_u->status))
5619 return False;
5620
5621 return True;
5622 }
5623
5624 /*******************************************************************
5625 ********************************************************************/
5626
5627 BOOL spoolss_io_q_enumprintprocdatatypes(const char *desc, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, prs_struct *ps, int depth)
5628 {
5629 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocdatatypes");
5630 depth++;
5631
5632 if (!prs_align(ps))
5633 return False;
5634
5635 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5636 return False;
5637 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5638 return False;
5639
5640 if (!prs_align(ps))
5641 return False;
5642
5643 if (!prs_uint32("processor_ptr", ps, depth, &q_u->processor_ptr))
5644 return False;
5645 if (!smb_io_unistr2("processor", &q_u->processor, q_u->processor_ptr, ps, depth))
5646 return False;
5647
5648 if (!prs_align(ps))
5649 return False;
5650
5651 if (!prs_uint32("level", ps, depth, &q_u->level))
5652 return False;
5653
5654 if(!prs_rpcbuffer_p("buffer", ps, depth, &q_u->buffer))
5655 return False;
5656
5657 if (!prs_align(ps))
5658 return False;
5659
5660 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5661 return False;
5662
5663 return True;
5664 }
5665
5666 /*******************************************************************
5667 Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
5668 ********************************************************************/
5669
5670 BOOL spoolss_io_q_enumprintmonitors(const char *desc, SPOOL_Q_ENUMPRINTMONITORS *q_u, prs_struct *ps, int depth)
5671 {
5672 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintmonitors");
5673 depth++;
5674
5675 if (!prs_align(ps))
5676 return False;
5677
5678 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5679 return False;
5680 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5681 return False;
5682
5683 if (!prs_align(ps))
5684 return False;
5685
5686 if (!prs_uint32("level", ps, depth, &q_u->level))
5687 return False;
5688
5689 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5690 return False;
5691
5692 if (!prs_align(ps))
5693 return False;
5694
5695 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5696 return False;
5697
5698 return True;
5699 }
5700
5701 /*******************************************************************
5702 ********************************************************************/
5703
5704 BOOL spoolss_io_r_enumprintmonitors(const char *desc, SPOOL_R_ENUMPRINTMONITORS *r_u, prs_struct *ps, int depth)
5705 {
5706 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintmonitors");
5707 depth++;
5708
5709 if (!prs_align(ps))
5710 return False;
5711
5712 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5713 return False;
5714
5715 if (!prs_align(ps))
5716 return False;
5717
5718 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5719 return False;
5720
5721 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5722 return False;
5723
5724 if (!prs_werror("status", ps, depth, &r_u->status))
5725 return False;
5726
5727 return True;
5728 }
5729
5730 /*******************************************************************
5731 ********************************************************************/
5732
5733 BOOL spoolss_io_r_enumprinterdata(const char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth)
5734 {
5735 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata");
5736 depth++;
5737
5738 if(!prs_align(ps))
5739 return False;
5740 if(!prs_uint32("valuesize", ps, depth, &r_u->valuesize))
5741 return False;
5742
5743 if (UNMARSHALLING(ps) && r_u->valuesize) {
5744 r_u->value = PRS_ALLOC_MEM(ps, uint16, r_u->valuesize);
5745 if (!r_u->value) {
5746 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata value\n"));
5747 return False;
5748 }
5749 }
5750
5751 if(!prs_uint16uni(False, "value", ps, depth, r_u->value, r_u->valuesize ))
5752 return False;
5753
5754 if(!prs_align(ps))
5755 return False;
5756
5757 if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
5758 return False;
5759
5760 if(!prs_uint32("type", ps, depth, &r_u->type))
5761 return False;
5762
5763 if(!prs_uint32("datasize", ps, depth, &r_u->datasize))
5764 return False;
5765
5766 if (UNMARSHALLING(ps) && r_u->datasize) {
5767 r_u->data = PRS_ALLOC_MEM(ps, uint8, r_u->datasize);
5768 if (!r_u->data) {
5769 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata data\n"));
5770 return False;
5771 }
5772 }
5773
5774 if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
5775 return False;
5776 if(!prs_align(ps))
5777 return False;
5778
5779 if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
5780 return False;
5781 if(!prs_werror("status", ps, depth, &r_u->status))
5782 return False;
5783
5784 return True;
5785 }
5786
5787 /*******************************************************************
5788 ********************************************************************/
5789
5790 BOOL spoolss_io_q_enumprinterdata(const char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
5791 {
5792 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
5793 depth++;
5794
5795 if(!prs_align(ps))
5796 return False;
5797 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
5798 return False;
5799 if(!prs_uint32("index", ps, depth, &q_u->index))
5800 return False;
5801 if(!prs_uint32("valuesize", ps, depth, &q_u->valuesize))
5802 return False;
5803 if(!prs_uint32("datasize", ps, depth, &q_u->datasize))
5804 return False;
5805
5806 return True;
5807 }
5808
5809 /*******************************************************************
5810 ********************************************************************/
5811
5812 BOOL make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u,
5813 const POLICY_HND *hnd,
5814 uint32 idx, uint32 valuelen, uint32 datalen)
5815 {
5816 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5817 q_u->index=idx;
5818 q_u->valuesize=valuelen;
5819 q_u->datasize=datalen;
5820
5821 return True;
5822 }
5823
5824 /*******************************************************************
5825 ********************************************************************/
5826
5827 BOOL make_spoolss_q_enumprinterdataex(SPOOL_Q_ENUMPRINTERDATAEX *q_u,
5828 const POLICY_HND *hnd, const char *key,
5829 uint32 size)
5830 {
5831 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5832 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
5833 q_u->size = size;
5834
5835 return True;
5836 }
5837
5838 /*******************************************************************
5839 ********************************************************************/
5840 BOOL make_spoolss_q_setprinterdata(SPOOL_Q_SETPRINTERDATA *q_u, const POLICY_HND *hnd,
5841 char* value, uint32 data_type, char* data, uint32 data_size)
5842 {
5843 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5844 q_u->type = data_type;
5845 init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
5846
5847 q_u->max_len = q_u->real_len = data_size;
5848 q_u->data = (unsigned char *)data;
5849
5850 return True;
5851 }
5852
5853 /*******************************************************************
5854 ********************************************************************/
5855 BOOL make_spoolss_q_setprinterdataex(SPOOL_Q_SETPRINTERDATAEX *q_u, const POLICY_HND *hnd,
5856 char *key, char* value, uint32 data_type, char* data,
5857 uint32 data_size)
5858 {
5859 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5860 q_u->type = data_type;
5861 init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
5862 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
5863
5864 q_u->max_len = q_u->real_len = data_size;
5865 q_u->data = (unsigned char *)data;
5866
5867 return True;
5868 }
5869
5870 /*******************************************************************
5871 ********************************************************************/
5872
5873 BOOL spoolss_io_q_setprinterdata(const char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
5874 {
5875 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
5876 depth++;
5877
5878 if(!prs_align(ps))
5879 return False;
5880 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5881 return False;
5882 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
5883 return False;
5884
5885 if(!prs_align(ps))
5886 return False;
5887
5888 if(!prs_uint32("type", ps, depth, &q_u->type))
5889 return False;
5890
5891 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
5892 return False;
5893
5894 switch (q_u->type)
5895 {
5896 case REG_SZ:
5897 case REG_BINARY:
5898 case REG_DWORD:
5899 case REG_MULTI_SZ:
5900 if (q_u->max_len) {
5901 if (UNMARSHALLING(ps))
5902 q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
5903 if(q_u->data == NULL)
5904 return False;
5905 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
5906 return False;
5907 }
5908 if(!prs_align(ps))
5909 return False;
5910 break;
5911 }
5912
5913 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
5914 return False;
5915
5916 return True;
5917 }
5918
5919 /*******************************************************************
5920 ********************************************************************/
5921
5922 BOOL spoolss_io_r_setprinterdata(const char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
5923 {
5924 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
5925 depth++;
5926
5927 if(!prs_align(ps))
5928 return False;
5929 if(!prs_werror("status", ps, depth, &r_u->status))
5930 return False;
5931
5932 return True;
5933 }
5934
5935 /*******************************************************************
5936 ********************************************************************/
5937 BOOL spoolss_io_q_resetprinter(const char *desc, SPOOL_Q_RESETPRINTER *q_u, prs_struct *ps, int depth)
5938 {
5939 prs_debug(ps, depth, desc, "spoolss_io_q_resetprinter");
5940 depth++;
5941
5942 if (!prs_align(ps))
5943 return False;
5944 if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5945 return False;
5946
5947 if (!prs_uint32("datatype_ptr", ps, depth, &q_u->datatype_ptr))
5948 return False;
5949
5950 if (q_u->datatype_ptr) {
5951 if (!smb_io_unistr2("datatype", &q_u->datatype, q_u->datatype_ptr?True:False, ps, depth))
5952 return False;
5953 }
5954
5955 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
5956 return False;
5957
5958 return True;
5959 }
5960
5961
5962 /*******************************************************************
5963 ********************************************************************/
5964 BOOL spoolss_io_r_resetprinter(const char *desc, SPOOL_R_RESETPRINTER *r_u, prs_struct *ps, int depth)
5965 {
5966 prs_debug(ps, depth, desc, "spoolss_io_r_resetprinter");
5967 depth++;
5968
5969 if(!prs_align(ps))
5970 return False;
5971 if(!prs_werror("status", ps, depth, &r_u->status))
5972 return False;
5973
5974 return True;
5975 }
5976
5977 /*******************************************************************
5978 ********************************************************************/
5979
5980 static BOOL spoolss_io_addform(const char *desc, FORM *f, uint32 ptr, prs_struct *ps, int depth)
5981 {
5982 prs_debug(ps, depth, desc, "spoolss_io_addform");
5983 depth++;
5984 if(!prs_align(ps))
5985 return False;
5986
5987 if (ptr!=0)
5988 {
5989 if(!prs_uint32("flags", ps, depth, &f->flags))
5990 return False;
5991 if(!prs_uint32("name_ptr", ps, depth, &f->name_ptr))
5992 return False;
5993 if(!prs_uint32("size_x", ps, depth, &f->size_x))
5994 return False;
5995 if(!prs_uint32("size_y", ps, depth, &f->size_y))
5996 return False;
5997 if(!prs_uint32("left", ps, depth, &f->left))
5998 return False;
5999 if(!prs_uint32("top", ps, depth, &f->top))
6000 return False;
6001 if(!prs_uint32("right", ps, depth, &f->right))
6002 return False;
6003 if(!prs_uint32("bottom", ps, depth, &f->bottom))
6004 return False;
6005
6006 if(!smb_io_unistr2("", &f->name, f->name_ptr, ps, depth))
6007 return False;
6008 }
6009
6010 return True;
6011 }
6012
6013 /*******************************************************************
6014 ********************************************************************/
6015
6016 BOOL spoolss_io_q_deleteform(const char *desc, SPOOL_Q_DELETEFORM *q_u, prs_struct *ps, int depth)
6017 {
6018 prs_debug(ps, depth, desc, "spoolss_io_q_deleteform");
6019 depth++;
6020
6021 if(!prs_align(ps))
6022 return False;
6023 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6024 return False;
6025 if(!smb_io_unistr2("form name", &q_u->name, True, ps, depth))
6026 return False;
6027
6028 return True;
6029 }
6030
6031 /*******************************************************************
6032 ********************************************************************/
6033
6034 BOOL spoolss_io_r_deleteform(const char *desc, SPOOL_R_DELETEFORM *r_u, prs_struct *ps, int depth)
6035 {
6036 prs_debug(ps, depth, desc, "spoolss_io_r_deleteform");
6037 depth++;
6038
6039 if(!prs_align(ps))
6040 return False;
6041 if(!prs_werror("status", ps, depth, &r_u->status))
6042 return False;
6043
6044 return True;
6045 }
6046
6047 /*******************************************************************
6048 ********************************************************************/
6049
6050 BOOL spoolss_io_q_addform(const char *desc, SPOOL_Q_ADDFORM *q_u, prs_struct *ps, int depth)
6051 {
6052 uint32 useless_ptr=1;
6053 prs_debug(ps, depth, desc, "spoolss_io_q_addform");
6054 depth++;
6055
6056 if(!prs_align(ps))
6057 return False;
6058 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6059 return False;
6060 if(!prs_uint32("level", ps, depth, &q_u->level))
6061 return False;
6062 if(!prs_uint32("level2", ps, depth, &q_u->level2))
6063 return False;
6064
6065 if (q_u->level==1)
6066 {
6067 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
6068 return False;
6069 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
6070 return False;
6071 }
6072
6073 return True;
6074 }
6075
6076 /*******************************************************************
6077 ********************************************************************/
6078
6079 BOOL spoolss_io_r_addform(const char *desc, SPOOL_R_ADDFORM *r_u, prs_struct *ps, int depth)
6080 {
6081 prs_debug(ps, depth, desc, "spoolss_io_r_addform");
6082 depth++;
6083
6084 if(!prs_align(ps))
6085 return False;
6086 if(!prs_werror("status", ps, depth, &r_u->status))
6087 return False;
6088
6089 return True;
6090 }
6091
6092 /*******************************************************************
6093 ********************************************************************/
6094
6095 BOOL spoolss_io_q_setform(const char *desc, SPOOL_Q_SETFORM *q_u, prs_struct *ps, int depth)
6096 {
6097 uint32 useless_ptr=1;
6098 prs_debug(ps, depth, desc, "spoolss_io_q_setform");
6099 depth++;
6100
6101 if(!prs_align(ps))
6102 return False;
6103 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6104 return False;
6105 if(!smb_io_unistr2("", &q_u->name, True, ps, depth))
6106 return False;
6107
6108 if(!prs_align(ps))
6109 return False;
6110
6111 if(!prs_uint32("level", ps, depth, &q_u->level))
6112 return False;
6113 if(!prs_uint32("level2", ps, depth, &q_u->level2))
6114 return False;
6115
6116 if (q_u->level==1)
6117 {
6118 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
6119 return False;
6120 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
6121 return False;
6122 }
6123
6124 return True;
6125 }
6126
6127 /*******************************************************************
6128 ********************************************************************/
6129
6130 BOOL spoolss_io_r_setform(const char *desc, SPOOL_R_SETFORM *r_u, prs_struct *ps, int depth)
6131 {
6132 prs_debug(ps, depth, desc, "spoolss_io_r_setform");
6133 depth++;
6134
6135 if(!prs_align(ps))
6136 return False;
6137 if(!prs_werror("status", ps, depth, &r_u->status))
6138 return False;
6139
6140 return True;
6141 }
6142
6143 /*******************************************************************
6144 Parse a SPOOL_R_GETJOB structure.
6145 ********************************************************************/
6146
6147 BOOL spoolss_io_r_getjob(const char *desc, SPOOL_R_GETJOB *r_u, prs_struct *ps, int depth)
6148 {
6149 prs_debug(ps, depth, desc, "spoolss_io_r_getjob");
6150 depth++;
6151
6152 if (!prs_align(ps))
6153 return False;
6154
6155 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
6156 return False;
6157
6158 if (!prs_align(ps))
6159 return False;
6160
6161 if (!prs_uint32("needed", ps, depth, &r_u->needed))
6162 return False;
6163
6164 if (!prs_werror("status", ps, depth, &r_u->status))
6165 return False;
6166
6167 return True;
6168 }
6169
6170 /*******************************************************************
6171 Parse a SPOOL_Q_GETJOB structure.
6172 ********************************************************************/
6173
6174 BOOL spoolss_io_q_getjob(const char *desc, SPOOL_Q_GETJOB *q_u, prs_struct *ps, int depth)
6175 {
6176 prs_debug(ps, depth, desc, "");
6177 depth++;
6178
6179 if(!prs_align(ps))
6180 return False;
6181
6182 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6183 return False;
6184 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
6185 return False;
6186 if(!prs_uint32("level", ps, depth, &q_u->level))
6187 return False;
6188
6189 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
6190 return False;
6191
6192 if(!prs_align(ps))
6193 return False;
6194
6195 if(!prs_uint32("offered", ps, depth, &q_u->offered))
6196 return False;
6197
6198 return True;
6199 }
6200
6201 void free_devmode(DEVICEMODE *devmode)
6202 {
6203 if (devmode!=NULL) {
6204 SAFE_FREE(devmode->dev_private);
6205 SAFE_FREE(devmode);
6206 }
6207 }
6208
6209 void free_printer_info_1(PRINTER_INFO_1 *printer)
6210 {
6211 SAFE_FREE(printer);
6212 }
6213
6214 void free_printer_info_2(PRINTER_INFO_2 *printer)
6215 {
6216 if (printer!=NULL) {
6217 free_devmode(printer->devmode);
6218 printer->devmode = NULL;
6219 SAFE_FREE(printer);
6220 }
6221 }
6222
6223 void free_printer_info_3(PRINTER_INFO_3 *printer)
6224 {
6225 SAFE_FREE(printer);
6226 }
6227
6228 void free_printer_info_4(PRINTER_INFO_4 *printer)
6229 {
6230 SAFE_FREE(printer);
6231 }
6232
6233 void free_printer_info_5(PRINTER_INFO_5 *printer)
6234 {
6235 SAFE_FREE(printer);
6236 }
6237
6238 void free_printer_info_7(PRINTER_INFO_7 *printer)
6239 {
6240 SAFE_FREE(printer);
6241 }
6242
6243 void free_job_info_2(JOB_INFO_2 *job)
6244 {
6245 if (job!=NULL)
6246 free_devmode(job->devmode);
6247 }
6248
6249 /*******************************************************************
6250 * init a structure.
6251 ********************************************************************/
6252
6253 BOOL make_spoolss_q_replyopenprinter(SPOOL_Q_REPLYOPENPRINTER *q_u,
6254 const fstring string, uint32 printer, uint32 type)
6255 {
6256 if (q_u == NULL)
6257 return False;
6258
6259 init_unistr2(&q_u->string, string, UNI_STR_TERMINATE);
6260
6261 q_u->printer=printer;
6262 q_u->type=type;
6263
6264 q_u->unknown0=0x0;
6265 q_u->unknown1=0x0;
6266
6267 return True;
6268 }
6269
6270 /*******************************************************************
6271 Parse a SPOOL_Q_REPLYOPENPRINTER structure.
6272 ********************************************************************/
6273
6274 BOOL spoolss_io_q_replyopenprinter(const char *desc, SPOOL_Q_REPLYOPENPRINTER *q_u, prs_struct *ps, int depth)
6275 {
6276 prs_debug(ps, depth, desc, "spoolss_io_q_replyopenprinter");
6277 depth++;
6278
6279 if(!prs_align(ps))
6280 return False;
6281
6282 if(!smb_io_unistr2("", &q_u->string, True, ps, depth))
6283 return False;
6284
6285 if(!prs_align(ps))
6286 return False;
6287
6288 if(!prs_uint32("printer", ps, depth, &q_u->printer))
6289 return False;
6290 if(!prs_uint32("type", ps, depth, &q_u->type))
6291 return False;
6292
6293 if(!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6294 return False;
6295 if(!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6296 return False;
6297
6298 return True;
6299 }
6300
6301 /*******************************************************************
6302 Parse a SPOOL_R_REPLYOPENPRINTER structure.
6303 ********************************************************************/
6304
6305 BOOL spoolss_io_r_replyopenprinter(const char *desc, SPOOL_R_REPLYOPENPRINTER *r_u, prs_struct *ps, int depth)
6306 {
6307 prs_debug(ps, depth, desc, "spoolss_io_r_replyopenprinter");
6308 depth++;
6309
6310 if (!prs_align(ps))
6311 return False;
6312
6313 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6314 return False;
6315
6316 if (!prs_werror("status", ps, depth, &r_u->status))
6317 return False;
6318
6319 return True;
6320 }
6321
6322 /*******************************************************************
6323 * init a structure.
6324 ********************************************************************/
6325 BOOL make_spoolss_q_routerreplyprinter(SPOOL_Q_ROUTERREPLYPRINTER *q_u, POLICY_HND *hnd,
6326 uint32 condition, uint32 change_id)
6327 {
6328
6329 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6330
6331 q_u->condition = condition;
6332 q_u->change_id = change_id;
6333
6334 /* magic values */
6335 q_u->unknown1 = 0x1;
6336 memset(q_u->unknown2, 0x0, 5);
6337 q_u->unknown2[0] = 0x1;
6338
6339 return True;
6340 }
6341
6342 /*******************************************************************
6343 Parse a SPOOL_Q_ROUTERREPLYPRINTER structure.
6344 ********************************************************************/
6345 BOOL spoolss_io_q_routerreplyprinter (const char *desc, SPOOL_Q_ROUTERREPLYPRINTER *q_u, prs_struct *ps, int depth)
6346 {
6347
6348 prs_debug(ps, depth, desc, "spoolss_io_q_routerreplyprinter");
6349 depth++;
6350
6351 if (!prs_align(ps))
6352 return False;
6353
6354 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6355 return False;
6356
6357 if (!prs_uint32("condition", ps, depth, &q_u->condition))
6358 return False;
6359
6360 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6361 return False;
6362
6363 if (!prs_uint32("change_id", ps, depth, &q_u->change_id))
6364 return False;
6365
6366 if (!prs_uint8s(False, "dev_private", ps, depth, q_u->unknown2, 5))
6367 return False;
6368
6369 return True;
6370 }
6371
6372 /*******************************************************************
6373 Parse a SPOOL_R_ROUTERREPLYPRINTER structure.
6374 ********************************************************************/
6375 BOOL spoolss_io_r_routerreplyprinter (const char *desc, SPOOL_R_ROUTERREPLYPRINTER *r_u, prs_struct *ps, int depth)
6376 {
6377 prs_debug(ps, depth, desc, "spoolss_io_r_routerreplyprinter");
6378 depth++;
6379
6380 if (!prs_align(ps))
6381 return False;
6382
6383 if (!prs_werror("status", ps, depth, &r_u->status))
6384 return False;
6385
6386 return True;
6387 }
6388
6389 /*******************************************************************
6390 * init a structure.
6391 ********************************************************************/
6392
6393 BOOL make_spoolss_q_reply_closeprinter(SPOOL_Q_REPLYCLOSEPRINTER *q_u, POLICY_HND *hnd)
6394 {
6395 if (q_u == NULL)
6396 return False;
6397
6398 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6399
6400 return True;
6401 }
6402
6403 /*******************************************************************
6404 Parse a SPOOL_Q_REPLYCLOSEPRINTER structure.
6405 ********************************************************************/
6406
6407 BOOL spoolss_io_q_replycloseprinter(const char *desc, SPOOL_Q_REPLYCLOSEPRINTER *q_u, prs_struct *ps, int depth)
6408 {
6409 prs_debug(ps, depth, desc, "spoolss_io_q_replycloseprinter");
6410 depth++;
6411
6412 if(!prs_align(ps))
6413 return False;
6414
6415 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6416 return False;
6417
6418 return True;
6419 }
6420
6421 /*******************************************************************
6422 Parse a SPOOL_R_REPLYCLOSEPRINTER structure.
6423 ********************************************************************/
6424
6425 BOOL spoolss_io_r_replycloseprinter(const char *desc, SPOOL_R_REPLYCLOSEPRINTER *r_u, prs_struct *ps, int depth)
6426 {
6427 prs_debug(ps, depth, desc, "spoolss_io_r_replycloseprinter");
6428 depth++;
6429
6430 if (!prs_align(ps))
6431 return False;
6432
6433 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6434 return False;
6435
6436 if (!prs_werror("status", ps, depth, &r_u->status))
6437 return False;
6438
6439 return True;
6440 }
6441
6442 #if 0 /* JERRY - not currently used but could be :-) */
6443
6444 /*******************************************************************
6445 Deep copy a SPOOL_NOTIFY_INFO_DATA structure
6446 ******************************************************************/
6447 static BOOL copy_spool_notify_info_data(SPOOL_NOTIFY_INFO_DATA *dst,
6448 SPOOL_NOTIFY_INFO_DATA *src, int n)
6449 {
6450 int i;
6451
6452 memcpy(dst, src, sizeof(SPOOL_NOTIFY_INFO_DATA)*n);
6453
6454 for (i=0; i<n; i++) {
6455 int len;
6456 uint16 *s = NULL;
6457
6458 if (src->size != POINTER)
6459 continue;
6460 len = src->notify_data.data.length;
6461 s = SMB_MALLOC_ARRAY(uint16, len);
6462 if (s == NULL) {
6463 DEBUG(0,("copy_spool_notify_info_data: malloc() failed!\n"));
6464 return False;
6465 }
6466
6467 memcpy(s, src->notify_data.data.string, len*2);
6468 dst->notify_data.data.string = s;
6469 }
6470
6471 return True;
6472 }
6473
6474 /*******************************************************************
6475 Deep copy a SPOOL_NOTIFY_INFO structure
6476 ******************************************************************/
6477 static BOOL copy_spool_notify_info(SPOOL_NOTIFY_INFO *dst, SPOOL_NOTIFY_INFO *src)
6478 {
6479 if (!dst) {
6480 DEBUG(0,("copy_spool_notify_info: NULL destination pointer!\n"));
6481 return False;
6482 }
6483
6484 dst->version = src->version;
6485 dst->flags = src->flags;
6486 dst->count = src->count;
6487
6488 if (dst->count)
6489 {
6490 dst->data = SMB_MALLOC_ARRAY(SPOOL_NOTIFY_INFO_DATA, dst->count);
6491
6492 DEBUG(10,("copy_spool_notify_info: allocating space for [%d] PRINTER_NOTIFY_INFO_DATA entries\n",
6493 dst->count));
6494
6495 if (dst->data == NULL) {
6496 DEBUG(0,("copy_spool_notify_info: malloc() failed for [%d] entries!\n",
6497 dst->count));
6498 return False;
6499 }
6500
6501 return (copy_spool_notify_info_data(dst->data, src->data, src->count));
6502 }
6503
6504 return True;
6505 }
6506 #endif /* JERRY */
6507
6508 /*******************************************************************
6509 * init a structure.
6510 ********************************************************************/
6511
6512 BOOL make_spoolss_q_reply_rrpcn(SPOOL_Q_REPLY_RRPCN *q_u, POLICY_HND *hnd,
6513 uint32 change_low, uint32 change_high,
6514 SPOOL_NOTIFY_INFO *info)
6515 {
6516 if (q_u == NULL)
6517 return False;
6518
6519 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6520
6521 q_u->change_low=change_low;
6522 q_u->change_high=change_high;
6523
6524 q_u->unknown0=0x0;
6525 q_u->unknown1=0x0;
6526
6527 q_u->info_ptr=0x0FF0ADDE;
6528
6529 q_u->info.version=2;
6530
6531 if (info->count) {
6532 DEBUG(10,("make_spoolss_q_reply_rrpcn: [%d] PRINTER_NOTIFY_INFO_DATA\n",
6533 info->count));
6534 q_u->info.version = info->version;
6535 q_u->info.flags = info->flags;
6536 q_u->info.count = info->count;
6537 /* pointer field - be careful! */
6538 q_u->info.data = info->data;
6539 }
6540 else {
6541 q_u->info.flags=PRINTER_NOTIFY_INFO_DISCARDED;
6542 q_u->info.count=0;
6543 }
6544
6545 return True;
6546 }
6547
6548 /*******************************************************************
6549 Parse a SPOOL_Q_REPLY_RRPCN structure.
6550 ********************************************************************/
6551
6552 BOOL spoolss_io_q_reply_rrpcn(const char *desc, SPOOL_Q_REPLY_RRPCN *q_u, prs_struct *ps, int depth)
6553 {
6554 prs_debug(ps, depth, desc, "spoolss_io_q_reply_rrpcn");
6555 depth++;
6556
6557 if(!prs_align(ps))
6558 return False;
6559
6560 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6561 return False;
6562
6563 if (!prs_uint32("change_low", ps, depth, &q_u->change_low))
6564 return False;
6565
6566 if (!prs_uint32("change_high", ps, depth, &q_u->change_high))
6567 return False;
6568
6569 if (!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6570 return False;
6571
6572 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6573 return False;
6574
6575 if (!prs_uint32("info_ptr", ps, depth, &q_u->info_ptr))
6576 return False;
6577
6578 if(q_u->info_ptr!=0)
6579 if(!smb_io_notify_info(desc, &q_u->info, ps, depth))
6580 return False;
6581
6582 return True;
6583 }
6584
6585 /*******************************************************************
6586 Parse a SPOOL_R_REPLY_RRPCN structure.
6587 ********************************************************************/
6588
6589 BOOL spoolss_io_r_reply_rrpcn(const char *desc, SPOOL_R_REPLY_RRPCN *r_u, prs_struct *ps, int depth)
6590 {
6591 prs_debug(ps, depth, desc, "spoolss_io_r_reply_rrpcn");
6592 depth++;
6593
6594 if (!prs_align(ps))
6595 return False;
6596
6597 if (!prs_uint32("unknown0", ps, depth, &r_u->unknown0))
6598 return False;
6599
6600 if (!prs_werror("status", ps, depth, &r_u->status))
6601 return False;
6602
6603 return True;
6604 }
6605
6606 /*******************************************************************
6607 * read a structure.
6608 * called from spoolss_q_getprinterdataex (srv_spoolss.c)
6609 ********************************************************************/
6610
6611 BOOL spoolss_io_q_getprinterdataex(const char *desc, SPOOL_Q_GETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6612 {
6613 if (q_u == NULL)
6614 return False;
6615
6616 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdataex");
6617 depth++;
6618
6619 if (!prs_align(ps))
6620 return False;
6621 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6622 return False;
6623 if (!prs_align(ps))
6624 return False;
6625 if (!smb_io_unistr2("keyname", &q_u->keyname,True,ps,depth))
6626 return False;
6627 if (!prs_align(ps))
6628 return False;
6629 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
6630 return False;
6631 if (!prs_align(ps))
6632 return False;
6633 if (!prs_uint32("size", ps, depth, &q_u->size))
6634 return False;
6635
6636 return True;
6637 }
6638
6639 /*******************************************************************
6640 * write a structure.
6641 * called from spoolss_r_getprinterdataex (srv_spoolss.c)
6642 ********************************************************************/
6643
6644 BOOL spoolss_io_r_getprinterdataex(const char *desc, SPOOL_R_GETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6645 {
6646 if (r_u == NULL)
6647 return False;
6648
6649 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdataex");
6650 depth++;
6651
6652 if (!prs_align(ps))
6653 return False;
6654 if (!prs_uint32("type", ps, depth, &r_u->type))
6655 return False;
6656 if (!prs_uint32("size", ps, depth, &r_u->size))
6657 return False;
6658
6659 if (UNMARSHALLING(ps) && r_u->size) {
6660 r_u->data = PRS_ALLOC_MEM(ps, unsigned char, r_u->size);
6661 if(!r_u->data)
6662 return False;
6663 }
6664
6665 if (!prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size))
6666 return False;
6667
6668 if (!prs_align(ps))
6669 return False;
6670
6671 if (!prs_uint32("needed", ps, depth, &r_u->needed))
6672 return False;
6673 if (!prs_werror("status", ps, depth, &r_u->status))
6674 return False;
6675
6676 return True;
6677 }
6678
6679 /*******************************************************************
6680 * read a structure.
6681 ********************************************************************/
6682
6683 BOOL spoolss_io_q_setprinterdataex(const char *desc, SPOOL_Q_SETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6684 {
6685 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdataex");
6686 depth++;
6687
6688 if(!prs_align(ps))
6689 return False;
6690 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6691 return False;
6692 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6693 return False;
6694
6695 if(!prs_align(ps))
6696 return False;
6697
6698 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
6699 return False;
6700
6701 if(!prs_align(ps))
6702 return False;
6703
6704 if(!prs_uint32("type", ps, depth, &q_u->type))
6705 return False;
6706
6707 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
6708 return False;
6709
6710 switch (q_u->type)
6711 {
6712 case 0x1:
6713 case 0x3:
6714 case 0x4:
6715 case 0x7:
6716 if (q_u->max_len) {
6717 if (UNMARSHALLING(ps))
6718 q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
6719 if(q_u->data == NULL)
6720 return False;
6721 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
6722 return False;
6723 }
6724 if(!prs_align(ps))
6725 return False;
6726 break;
6727 }
6728
6729 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
6730 return False;
6731
6732 return True;
6733 }
6734
6735 /*******************************************************************
6736 * write a structure.
6737 ********************************************************************/
6738
6739 BOOL spoolss_io_r_setprinterdataex(const char *desc, SPOOL_R_SETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6740 {
6741 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdataex");
6742 depth++;
6743
6744 if(!prs_align(ps))
6745 return False;
6746 if(!prs_werror("status", ps, depth, &r_u->status))
6747 return False;
6748
6749 return True;
6750 }
6751
6752 /*******************************************************************
6753 * read a structure.
6754 ********************************************************************/
6755 BOOL make_spoolss_q_enumprinterkey(SPOOL_Q_ENUMPRINTERKEY *q_u,
6756 POLICY_HND *hnd, const char *key,
6757 uint32 size)
6758 {
6759 DEBUG(5,("make_spoolss_q_enumprinterkey\n"));
6760
6761 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6762 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
6763 q_u->size = size;
6764
6765 return True;
6766 }
6767
6768 /*******************************************************************
6769 * read a structure.
6770 ********************************************************************/
6771
6772 BOOL spoolss_io_q_enumprinterkey(const char *desc, SPOOL_Q_ENUMPRINTERKEY *q_u, prs_struct *ps, int depth)
6773 {
6774 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterkey");
6775 depth++;
6776
6777 if(!prs_align(ps))
6778 return False;
6779 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6780 return False;
6781
6782 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6783 return False;
6784
6785 if(!prs_align(ps))
6786 return False;
6787
6788 if(!prs_uint32("size", ps, depth, &q_u->size))
6789 return False;
6790
6791 return True;
6792 }
6793
6794 /*******************************************************************
6795 * write a structure.
6796 ********************************************************************/
6797
6798 BOOL spoolss_io_r_enumprinterkey(const char *desc, SPOOL_R_ENUMPRINTERKEY *r_u, prs_struct *ps, int depth)
6799 {
6800 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterkey");
6801 depth++;
6802
6803 if(!prs_align(ps))
6804 return False;
6805
6806 if (!smb_io_buffer5("", &r_u->keys, ps, depth))
6807 return False;
6808
6809 if(!prs_align(ps))
6810 return False;
6811
6812 if(!prs_uint32("needed", ps, depth, &r_u->needed))
6813 return False;
6814
6815 if(!prs_werror("status", ps, depth, &r_u->status))
6816 return False;
6817
6818 return True;
6819 }
6820
6821 /*******************************************************************
6822 * read a structure.
6823 ********************************************************************/
6824
6825 BOOL make_spoolss_q_deleteprinterkey(SPOOL_Q_DELETEPRINTERKEY *q_u,
6826 POLICY_HND *hnd, char *keyname)
6827 {
6828 DEBUG(5,("make_spoolss_q_deleteprinterkey\n"));
6829
6830 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6831 init_unistr2(&q_u->keyname, keyname, UNI_STR_TERMINATE);
6832
6833 return True;
6834 }
6835
6836 /*******************************************************************
6837 * read a structure.
6838 ********************************************************************/
6839
6840 BOOL spoolss_io_q_deleteprinterkey(const char *desc, SPOOL_Q_DELETEPRINTERKEY *q_u, prs_struct *ps, int depth)
6841 {
6842 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterkey");
6843 depth++;
6844
6845 if(!prs_align(ps))
6846 return False;
6847 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6848 return False;
6849
6850 if(!smb_io_unistr2("", &q_u->keyname, True, ps, depth))
6851 return False;
6852
6853 return True;
6854 }
6855
6856 /*******************************************************************
6857 * write a structure.
6858 ********************************************************************/
6859
6860 BOOL spoolss_io_r_deleteprinterkey(const char *desc, SPOOL_R_DELETEPRINTERKEY *r_u, prs_struct *ps, int depth)
6861 {
6862 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterkey");
6863 depth++;
6864
6865 if(!prs_align(ps))
6866 return False;
6867
6868 if(!prs_werror("status", ps, depth, &r_u->status))
6869 return False;
6870
6871 return True;
6872 }
6873
6874
6875 /*******************************************************************
6876 * read a structure.
6877 ********************************************************************/
6878
6879 BOOL spoolss_io_q_enumprinterdataex(const char *desc, SPOOL_Q_ENUMPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6880 {
6881 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdataex");
6882 depth++;
6883
6884 if(!prs_align(ps))
6885 return False;
6886 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6887 return False;
6888
6889 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6890 return False;
6891
6892 if(!prs_align(ps))
6893 return False;
6894
6895 if(!prs_uint32("size", ps, depth, &q_u->size))
6896 return False;
6897
6898 return True;
6899 }
6900
6901 /*******************************************************************
6902 ********************************************************************/
6903
6904 static BOOL spoolss_io_printer_enum_values_ctr(const char *desc, prs_struct *ps,
6905 PRINTER_ENUM_VALUES_CTR *ctr, int depth)
6906 {
6907 int i;
6908 uint32 valuename_offset,
6909 data_offset,
6910 current_offset;
6911 const uint32 basic_unit = 20; /* size of static portion of enum_values */
6912
6913 prs_debug(ps, depth, desc, "spoolss_io_printer_enum_values_ctr");
6914 depth++;
6915
6916 /*
6917 * offset data begins at 20 bytes per structure * size_of_array.
6918 * Don't forget the uint32 at the beginning
6919 * */
6920
6921 current_offset = basic_unit * ctr->size_of_array;
6922
6923 /* first loop to write basic enum_value information */
6924
6925 if (UNMARSHALLING(ps)) {
6926 ctr->values = PRS_ALLOC_MEM(ps, PRINTER_ENUM_VALUES, ctr->size_of_array);
6927 if (!ctr->values)
6928 return False;
6929 }
6930
6931 for (i=0; i<ctr->size_of_array; i++) {
6932 valuename_offset = current_offset;
6933 if (!prs_uint32("valuename_offset", ps, depth, &valuename_offset))
6934 return False;
6935
6936 if (!prs_uint32("value_len", ps, depth, &ctr->values[i].value_len))
6937 return False;
6938
6939 if (!prs_uint32("type", ps, depth, &ctr->values[i].type))
6940 return False;
6941
6942 data_offset = ctr->values[i].value_len + valuename_offset;
6943
6944 if (!prs_uint32("data_offset", ps, depth, &data_offset))
6945 return False;
6946
6947 if (!prs_uint32("data_len", ps, depth, &ctr->values[i].data_len))
6948 return False;
6949
6950 current_offset = data_offset + ctr->values[i].data_len - basic_unit;
6951 /* account for 2 byte alignment */
6952 current_offset += (current_offset % 2);
6953 }
6954
6955 /*
6956 * loop #2 for writing the dynamically size objects; pay
6957 * attention to 2-byte alignment here....
6958 */
6959
6960 for (i=0; i<ctr->size_of_array; i++) {
6961
6962 if (!prs_unistr("valuename", ps, depth, &ctr->values[i].valuename))
6963 return False;
6964
6965 if ( ctr->values[i].data_len ) {
6966 if ( UNMARSHALLING(ps) ) {
6967 ctr->values[i].data = PRS_ALLOC_MEM(ps, uint8, ctr->values[i].data_len);
6968 if (!ctr->values[i].data)
6969 return False;
6970 }
6971 if (!prs_uint8s(False, "data", ps, depth, ctr->values[i].data, ctr->values[i].data_len))
6972 return False;
6973 }
6974
6975 if ( !prs_align_uint16(ps) )
6976 return False;
6977 }
6978
6979 return True;
6980 }
6981
6982 /*******************************************************************
6983 * write a structure.
6984 ********************************************************************/
6985
6986 BOOL spoolss_io_r_enumprinterdataex(const char *desc, SPOOL_R_ENUMPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6987 {
6988 uint32 data_offset, end_offset;
6989 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdataex");
6990 depth++;
6991
6992 if(!prs_align(ps))
6993 return False;
6994
6995 if (!prs_uint32("size", ps, depth, &r_u->ctr.size))
6996 return False;
6997
6998 data_offset = prs_offset(ps);
6999
7000 if (!prs_set_offset(ps, data_offset + r_u->ctr.size))
7001 return False;
7002
7003 if(!prs_align(ps))
7004 return False;
7005
7006 if(!prs_uint32("needed", ps, depth, &r_u->needed))
7007 return False;
7008
7009 if(!prs_uint32("returned", ps, depth, &r_u->returned))
7010 return False;
7011
7012 if(!prs_werror("status", ps, depth, &r_u->status))
7013 return False;
7014
7015 r_u->ctr.size_of_array = r_u->returned;
7016
7017 end_offset = prs_offset(ps);
7018
7019 if (!prs_set_offset(ps, data_offset))
7020 return False;
7021
7022 if (r_u->ctr.size)
7023 if (!spoolss_io_printer_enum_values_ctr("", ps, &r_u->ctr, depth ))
7024 return False;
7025
7026 if (!prs_set_offset(ps, end_offset))
7027 return False;
7028 return True;
7029 }
7030
7031 /*******************************************************************
7032 * write a structure.
7033 ********************************************************************/
7034
7035 /*
7036 uint32 GetPrintProcessorDirectory(
7037 [in] unistr2 *name,
7038 [in] unistr2 *environment,
7039 [in] uint32 level,
7040 [in,out] RPC_BUFFER buffer,
7041 [in] uint32 offered,
7042 [out] uint32 needed,
7043 [out] uint32 returned
7044 );
7045
7046 */
7047
7048 BOOL make_spoolss_q_getprintprocessordirectory(SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, const char *name, char *environment, int level, RPC_BUFFER *buffer, uint32 offered)
7049 {
7050 DEBUG(5,("make_spoolss_q_getprintprocessordirectory\n"));
7051
7052 init_unistr2(&q_u->name, name, UNI_STR_TERMINATE);
7053 init_unistr2(&q_u->environment, environment, UNI_STR_TERMINATE);
7054
7055 q_u->level = level;
7056
7057 q_u->buffer = buffer;
7058 q_u->offered = offered;
7059
7060 return True;
7061 }
7062
7063 BOOL spoolss_io_q_getprintprocessordirectory(const char *desc, SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, prs_struct *ps, int depth)
7064 {
7065 uint32 ptr;
7066
7067 prs_debug(ps, depth, desc, "spoolss_io_q_getprintprocessordirectory");
7068 depth++;
7069
7070 if(!prs_align(ps))
7071 return False;
7072
7073 if (!prs_uint32("ptr", ps, depth, &ptr))
7074 return False;
7075
7076 if (ptr) {
7077 if(!smb_io_unistr2("name", &q_u->name, True, ps, depth))
7078 return False;
7079 }
7080
7081 if (!prs_align(ps))
7082 return False;
7083
7084 if (!prs_uint32("ptr", ps, depth, &ptr))
7085 return False;
7086
7087 if (ptr) {
7088 if(!smb_io_unistr2("environment", &q_u->environment, True,
7089 ps, depth))
7090 return False;
7091 }
7092
7093 if (!prs_align(ps))
7094 return False;
7095
7096 if(!prs_uint32("level", ps, depth, &q_u->level))
7097 return False;
7098
7099 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
7100 return False;
7101
7102 if(!prs_align(ps))
7103 return False;
7104
7105 if(!prs_uint32("offered", ps, depth, &q_u->offered))
7106 return False;
7107
7108 return True;
7109 }
7110
7111 /*******************************************************************
7112 * write a structure.
7113 ********************************************************************/
7114
7115 BOOL spoolss_io_r_getprintprocessordirectory(const char *desc, SPOOL_R_GETPRINTPROCESSORDIRECTORY *r_u, prs_struct *ps, int depth)
7116 {
7117 prs_debug(ps, depth, desc, "spoolss_io_r_getprintprocessordirectory");
7118 depth++;
7119
7120 if(!prs_align(ps))
7121 return False;
7122
7123 if(!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
7124 return False;
7125
7126 if(!prs_align(ps))
7127 return False;
7128
7129 if(!prs_uint32("needed", ps, depth, &r_u->needed))
7130 return False;
7131
7132 if(!prs_werror("status", ps, depth, &r_u->status))
7133 return False;
7134
7135 return True;
7136 }
7137
7138 BOOL smb_io_printprocessordirectory_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_DIRECTORY_1 *info, int depth)
7139 {
7140 prs_struct *ps=&buffer->prs;
7141
7142 prs_debug(ps, depth, desc, "smb_io_printprocessordirectory_1");
7143 depth++;
7144
7145 buffer->struct_start=prs_offset(ps);
7146
7147 if (!smb_io_unistr(desc, &info->name, ps, depth))
7148 return False;
7149
7150 return True;
7151 }
7152
7153 /*******************************************************************
7154 * init a structure.
7155 ********************************************************************/
7156
7157 BOOL make_spoolss_q_addform(SPOOL_Q_ADDFORM *q_u, POLICY_HND *handle,
7158 int level, FORM *form)
7159 {
7160 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7161 q_u->level = level;
7162 q_u->level2 = level;
7163 memcpy(&q_u->form, form, sizeof(FORM));
7164
7165 return True;
7166 }
7167
7168 /*******************************************************************
7169 * init a structure.
7170 ********************************************************************/
7171
7172 BOOL make_spoolss_q_setform(SPOOL_Q_SETFORM *q_u, POLICY_HND *handle,
7173 int level, const char *form_name, FORM *form)
7174 {
7175 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7176 q_u->level = level;
7177 q_u->level2 = level;
7178 memcpy(&q_u->form, form, sizeof(FORM));
7179 init_unistr2(&q_u->name, form_name, UNI_STR_TERMINATE);
7180
7181 return True;
7182 }
7183
7184 /*******************************************************************
7185 * init a structure.
7186 ********************************************************************/
7187
7188 BOOL make_spoolss_q_deleteform(SPOOL_Q_DELETEFORM *q_u, POLICY_HND *handle,
7189 const char *form)
7190 {
7191 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7192 init_unistr2(&q_u->name, form, UNI_STR_TERMINATE);
7193 return True;
7194 }
7195
7196 /*******************************************************************
7197 * init a structure.
7198 ********************************************************************/
7199
7200 BOOL make_spoolss_q_getform(SPOOL_Q_GETFORM *q_u, POLICY_HND *handle,
7201 const char *formname, uint32 level,
7202 RPC_BUFFER *buffer, uint32 offered)
7203 {
7204 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7205 q_u->level = level;
7206 init_unistr2(&q_u->formname, formname, UNI_STR_TERMINATE);
7207 q_u->buffer=buffer;
7208 q_u->offered=offered;
7209
7210 return True;
7211 }
7212
7213 /*******************************************************************
7214 * init a structure.
7215 ********************************************************************/
7216
7217 BOOL make_spoolss_q_enumforms(SPOOL_Q_ENUMFORMS *q_u, POLICY_HND *handle,
7218 uint32 level, RPC_BUFFER *buffer,
7219 uint32 offered)
7220 {
7221 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7222 q_u->level = level;
7223 q_u->buffer=buffer;
7224 q_u->offered=offered;
7225
7226 return True;
7227 }
7228
7229 /*******************************************************************
7230 * init a structure.
7231 ********************************************************************/
7232
7233 BOOL make_spoolss_q_setjob(SPOOL_Q_SETJOB *q_u, POLICY_HND *handle,
7234 uint32 jobid, uint32 level, uint32 command)
7235 {
7236 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7237 q_u->jobid = jobid;
7238 q_u->level = level;
7239
7240 /* Hmm - the SPOOL_Q_SETJOB structure has a JOB_INFO ctr in it but
7241 the server side code has it marked as unused. */
7242
7243 q_u->command = command;
7244
7245 return True;
7246 }
7247
7248 /*******************************************************************
7249 * init a structure.
7250 ********************************************************************/
7251
7252 BOOL make_spoolss_q_getjob(SPOOL_Q_GETJOB *q_u, POLICY_HND *handle,
7253 uint32 jobid, uint32 level, RPC_BUFFER *buffer,
7254 uint32 offered)
7255 {
7256 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7257 q_u->jobid = jobid;
7258 q_u->level = level;
7259 q_u->buffer = buffer;
7260 q_u->offered = offered;
7261
7262 return True;
7263 }
7264
7265 /*******************************************************************
7266 * init a structure.
7267 ********************************************************************/
7268
7269 BOOL make_spoolss_q_startpageprinter(SPOOL_Q_STARTPAGEPRINTER *q_u,
7270 POLICY_HND *handle)
7271 {
7272 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7273
7274 return True;
7275 }
7276
7277 /*******************************************************************
7278 * init a structure.
7279 ********************************************************************/
7280
7281 BOOL make_spoolss_q_endpageprinter(SPOOL_Q_ENDPAGEPRINTER *q_u,
7282 POLICY_HND *handle)
7283 {
7284 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7285
7286 return True;
7287 }
7288
7289 /*******************************************************************
7290 * init a structure.
7291 ********************************************************************/
7292
7293 BOOL make_spoolss_q_startdocprinter(SPOOL_Q_STARTDOCPRINTER *q_u,
7294 POLICY_HND *handle, uint32 level,
7295 char *docname, char *outputfile,
7296 char *datatype)
7297 {
7298 DOC_INFO_CONTAINER *ctr = &q_u->doc_info_container;
7299
7300 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7301
7302 ctr->level = level;
7303
7304 switch (level) {
7305 case 1:
7306 ctr->docinfo.switch_value = level;
7307
7308 ctr->docinfo.doc_info_1.p_docname = docname ? 1 : 0;
7309 ctr->docinfo.doc_info_1.p_outputfile = outputfile ? 1 : 0;
7310 ctr->docinfo.doc_info_1.p_datatype = datatype ? 1 : 0;
7311
7312 init_unistr2(&ctr->docinfo.doc_info_1.docname, docname, UNI_STR_TERMINATE);
7313 init_unistr2(&ctr->docinfo.doc_info_1.outputfile, outputfile, UNI_STR_TERMINATE);
7314 init_unistr2(&ctr->docinfo.doc_info_1.datatype, datatype, UNI_STR_TERMINATE);
7315
7316 break;
7317 case 2:
7318 /* DOC_INFO_2 is only used by Windows 9x and since it
7319 doesn't do printing over RPC we don't have to worry
7320 about it. */
7321 default:
7322 DEBUG(3, ("unsupported info level %d\n", level));
7323 return False;
7324 }
7325
7326 return True;
7327 }
7328
7329 /*******************************************************************
7330 * init a structure.
7331 ********************************************************************/
7332
7333 BOOL make_spoolss_q_enddocprinter(SPOOL_Q_ENDDOCPRINTER *q_u,
7334 POLICY_HND *handle)
7335 {
7336 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7337
7338 return True;
7339 }
7340
7341 /*******************************************************************
7342 * init a structure.
7343 ********************************************************************/
7344
7345 BOOL make_spoolss_q_writeprinter(SPOOL_Q_WRITEPRINTER *q_u,
7346 POLICY_HND *handle, uint32 data_size,
7347 char *data)
7348 {
7349 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7350 q_u->buffer_size = q_u->buffer_size2 = data_size;
7351 q_u->buffer = (unsigned char *)data;
7352 return True;
7353 }
7354
7355 /*******************************************************************
7356 * init a structure.
7357 ********************************************************************/
7358
7359 BOOL make_spoolss_q_deleteprinterdata(SPOOL_Q_DELETEPRINTERDATA *q_u,
7360 POLICY_HND *handle, char *valuename)
7361 {
7362 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7363 init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
7364
7365 return True;
7366 }
7367
7368 /*******************************************************************
7369 * init a structure.
7370 ********************************************************************/
7371
7372 BOOL make_spoolss_q_deleteprinterdataex(SPOOL_Q_DELETEPRINTERDATAEX *q_u,
7373 POLICY_HND *handle, char *key,
7374 char *value)
7375 {
7376 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7377 init_unistr2(&q_u->valuename, value, UNI_STR_TERMINATE);
7378 init_unistr2(&q_u->keyname, key, UNI_STR_TERMINATE);
7379
7380 return True;
7381 }
7382
7383 /*******************************************************************
7384 * init a structure.
7385 ********************************************************************/
7386
7387 BOOL make_spoolss_q_rffpcnex(SPOOL_Q_RFFPCNEX *q_u, POLICY_HND *handle,
7388 uint32 flags, uint32 options, const char *localmachine,
7389 uint32 printerlocal, SPOOL_NOTIFY_OPTION *option)
7390 {
7391 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7392
7393 q_u->flags = flags;
7394 q_u->options = options;
7395
7396 q_u->localmachine_ptr = 1;
7397
7398 init_unistr2(&q_u->localmachine, localmachine, UNI_STR_TERMINATE);
7399
7400 q_u->printerlocal = printerlocal;
7401
7402 if (option)
7403 q_u->option_ptr = 1;
7404
7405 q_u->option = option;
7406
7407 return True;
7408 }
Samba GIT mirror