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