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