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