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