?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-spoolss: use pidl for _spoolss_SetPrinter.
[Samba.git] / source3 / rpc_parse / parse_spoolss.c
blob3475203ac47b2500112269c9e8ce1527bdf8342b
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-2000,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
6 * Copyright (C) Jean François Micouleau 1998-2000,
7 * Copyright (C) Gerald Carter 2000-2002,
8 * Copyright (C) Tim Potter 2001-2002.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 3 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, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25
26 #undef DBGC_CLASS
27 #define DBGC_CLASS DBGC_RPC_PARSE
28
29
30 /*******************************************************************
31 This should be moved in a more generic lib.
32 ********************************************************************/
33
34 bool spoolss_io_system_time(const char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
35 {
36 if(!prs_uint16("year", ps, depth, &systime->year))
37 return False;
38 if(!prs_uint16("month", ps, depth, &systime->month))
39 return False;
40 if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
41 return False;
42 if(!prs_uint16("day", ps, depth, &systime->day))
43 return False;
44 if(!prs_uint16("hour", ps, depth, &systime->hour))
45 return False;
46 if(!prs_uint16("minute", ps, depth, &systime->minute))
47 return False;
48 if(!prs_uint16("second", ps, depth, &systime->second))
49 return False;
50 if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
51 return False;
52
53 return True;
54 }
55
56 /*******************************************************************
57 ********************************************************************/
58
59 bool make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
60 {
61 systime->year=unixtime->tm_year+1900;
62 systime->month=unixtime->tm_mon+1;
63 systime->dayofweek=unixtime->tm_wday;
64 systime->day=unixtime->tm_mday;
65 systime->hour=unixtime->tm_hour;
66 systime->minute=unixtime->tm_min;
67 systime->second=unixtime->tm_sec;
68 systime->milliseconds=0;
69
70 return True;
71 }
72
73 /*******************************************************************
74 reads or writes an NOTIFY OPTION TYPE structure.
75 ********************************************************************/
76
77 /* NOTIFY_OPTION_TYPE and NOTIFY_OPTION_TYPE_DATA are really one
78 structure. The _TYPE structure is really the deferred referrants (i.e
79 the notify fields array) of the _TYPE structure. -tpot */
80
81 static bool smb_io_notify_option_type(const char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
82 {
83 prs_debug(ps, depth, desc, "smb_io_notify_option_type");
84 depth++;
85
86 if (!prs_align(ps))
87 return False;
88
89 if(!prs_uint16("type", ps, depth, &type->type))
90 return False;
91 if(!prs_uint16("reserved0", ps, depth, &type->reserved0))
92 return False;
93 if(!prs_uint32("reserved1", ps, depth, &type->reserved1))
94 return False;
95 if(!prs_uint32("reserved2", ps, depth, &type->reserved2))
96 return False;
97 if(!prs_uint32("count", ps, depth, &type->count))
98 return False;
99 if(!prs_uint32("fields_ptr", ps, depth, &type->fields_ptr))
100 return False;
101
102 return True;
103 }
104
105 /*******************************************************************
106 reads or writes an NOTIFY OPTION TYPE DATA.
107 ********************************************************************/
108
109 static bool smb_io_notify_option_type_data(const char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
110 {
111 int i;
112
113 prs_debug(ps, depth, desc, "smb_io_notify_option_type_data");
114 depth++;
115
116 /* if there are no fields just return */
117 if (type->fields_ptr==0)
118 return True;
119
120 if(!prs_align(ps))
121 return False;
122
123 if(!prs_uint32("count2", ps, depth, &type->count2))
124 return False;
125
126 if (type->count2 != type->count)
127 DEBUG(4,("What a mess, count was %x now is %x !\n", type->count, type->count2));
128
129 if (type->count2 > MAX_NOTIFY_TYPE_FOR_NOW) {
130 return False;
131 }
132
133 /* parse the option type data */
134 for(i=0;i<type->count2;i++)
135 if(!prs_uint16("fields",ps,depth,&type->fields[i]))
136 return False;
137 return True;
138 }
139
140 /*******************************************************************
141 reads or writes an NOTIFY OPTION structure.
142 ********************************************************************/
143
144 static bool smb_io_notify_option_type_ctr(const char *desc, SPOOL_NOTIFY_OPTION_TYPE_CTR *ctr , prs_struct *ps, int depth)
145 {
146 int i;
147
148 prs_debug(ps, depth, desc, "smb_io_notify_option_type_ctr");
149 depth++;
150
151 if(!prs_uint32("count", ps, depth, &ctr->count))
152 return False;
153
154 /* reading */
155 if (UNMARSHALLING(ps) && ctr->count)
156 if((ctr->type=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION_TYPE,ctr->count)) == NULL)
157 return False;
158
159 /* the option type struct */
160 for(i=0;i<ctr->count;i++)
161 if(!smb_io_notify_option_type("", &ctr->type[i] , ps, depth))
162 return False;
163
164 /* the type associated with the option type struct */
165 for(i=0;i<ctr->count;i++)
166 if(!smb_io_notify_option_type_data("", &ctr->type[i] , ps, depth))
167 return False;
168
169 return True;
170 }
171
172 /*******************************************************************
173 reads or writes an NOTIFY OPTION structure.
174 ********************************************************************/
175
176 static bool smb_io_notify_option(const char *desc, SPOOL_NOTIFY_OPTION *option, prs_struct *ps, int depth)
177 {
178 prs_debug(ps, depth, desc, "smb_io_notify_option");
179 depth++;
180
181 if(!prs_uint32("version", ps, depth, &option->version))
182 return False;
183 if(!prs_uint32("flags", ps, depth, &option->flags))
184 return False;
185 if(!prs_uint32("count", ps, depth, &option->count))
186 return False;
187 if(!prs_uint32("option_type_ptr", ps, depth, &option->option_type_ptr))
188 return False;
189
190 /* marshalling or unmarshalling, that would work */
191 if (option->option_type_ptr!=0) {
192 if(!smb_io_notify_option_type_ctr("", &option->ctr ,ps, depth))
193 return False;
194 }
195 else {
196 option->ctr.type=NULL;
197 option->ctr.count=0;
198 }
199
200 return True;
201 }
202
203 /*******************************************************************
204 reads or writes an NOTIFY INFO DATA structure.
205 ********************************************************************/
206
207 static bool smb_io_notify_info_data(const char *desc,SPOOL_NOTIFY_INFO_DATA *data, prs_struct *ps, int depth)
208 {
209 uint32 useless_ptr=0x0FF0ADDE;
210
211 prs_debug(ps, depth, desc, "smb_io_notify_info_data");
212 depth++;
213
214 if(!prs_align(ps))
215 return False;
216 if(!prs_uint16("type", ps, depth, &data->type))
217 return False;
218 if(!prs_uint16("field", ps, depth, &data->field))
219 return False;
220
221 if(!prs_uint32("how many words", ps, depth, &data->size))
222 return False;
223 if(!prs_uint32("id", ps, depth, &data->id))
224 return False;
225 if(!prs_uint32("how many words", ps, depth, &data->size))
226 return False;
227
228 switch (data->enc_type) {
229
230 /* One and two value data has two uint32 values */
231
232 case NOTIFY_ONE_VALUE:
233 case NOTIFY_TWO_VALUE:
234
235 if(!prs_uint32("value[0]", ps, depth, &data->notify_data.value[0]))
236 return False;
237 if(!prs_uint32("value[1]", ps, depth, &data->notify_data.value[1]))
238 return False;
239 break;
240
241 /* Pointers and strings have a string length and a
242 pointer. For a string the length is expressed as
243 the number of uint16 characters plus a trailing
244 \0\0. */
245
246 case NOTIFY_POINTER:
247
248 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length ))
249 return False;
250 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
251 return False;
252
253 break;
254
255 case NOTIFY_STRING:
256
257 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
258 return False;
259
260 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
261 return False;
262
263 break;
264
265 case NOTIFY_SECDESC:
266 if( !prs_uint32( "sd size", ps, depth, &data->notify_data.sd.size ) )
267 return False;
268 if( !prs_uint32( "pointer", ps, depth, &useless_ptr ) )
269 return False;
270
271 break;
272
273 default:
274 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data\n",
275 data->enc_type));
276 break;
277 }
278
279 return True;
280 }
281
282 /*******************************************************************
283 reads or writes an NOTIFY INFO DATA structure.
284 ********************************************************************/
285
286 bool smb_io_notify_info_data_strings(const char *desc,SPOOL_NOTIFY_INFO_DATA *data,
287 prs_struct *ps, int depth)
288 {
289 prs_debug(ps, depth, desc, "smb_io_notify_info_data_strings");
290 depth++;
291
292 if(!prs_align(ps))
293 return False;
294
295 switch(data->enc_type) {
296
297 /* No data for values */
298
299 case NOTIFY_ONE_VALUE:
300 case NOTIFY_TWO_VALUE:
301
302 break;
303
304 /* Strings start with a length in uint16s */
305
306 case NOTIFY_STRING:
307
308 if (MARSHALLING(ps))
309 data->notify_data.data.length /= 2;
310
311 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
312 return False;
313
314 if (UNMARSHALLING(ps) && data->notify_data.data.length) {
315 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16,
316 data->notify_data.data.length);
317
318 if (!data->notify_data.data.string)
319 return False;
320 }
321
322 if (!prs_uint16uni(True, "string", ps, depth, data->notify_data.data.string,
323 data->notify_data.data.length))
324 return False;
325
326 if (MARSHALLING(ps))
327 data->notify_data.data.length *= 2;
328
329 break;
330
331 case NOTIFY_POINTER:
332
333 if (UNMARSHALLING(ps) && data->notify_data.data.length) {
334 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16,
335 data->notify_data.data.length);
336
337 if (!data->notify_data.data.string)
338 return False;
339 }
340
341 if(!prs_uint8s(True,"buffer",ps,depth,(uint8*)data->notify_data.data.string,data->notify_data.data.length))
342 return False;
343
344 break;
345
346 case NOTIFY_SECDESC:
347 if( !prs_uint32("secdesc size ", ps, depth, &data->notify_data.sd.size ) )
348 return False;
349 if ( !sec_io_desc( "sec_desc", &data->notify_data.sd.desc, ps, depth ) )
350 return False;
351 break;
352
353 default:
354 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data_strings\n",
355 data->enc_type));
356 break;
357 }
358
359 #if 0
360 if (isvalue==False) {
361
362 /* length of string in unicode include \0 */
363 x=data->notify_data.data.length+1;
364
365 if (data->field != 16)
366 if(!prs_uint32("string length", ps, depth, &x ))
367 return False;
368
369 if (MARSHALLING(ps)) {
370 /* These are already in little endian format. Don't byte swap. */
371 if (x == 1) {
372
373 /* No memory allocated for this string
374 therefore following the data.string
375 pointer is a bad idea. Use a pointer to
376 the uint32 length union member to
377 provide a source for a unicode NULL */
378
379 if(!prs_uint8s(True,"string",ps,depth, (uint8 *)&data->notify_data.data.length,x*2))
380 return False;
381 } else {
382
383 if (data->field == 16)
384 x /= 2;
385
386 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
387 return False;
388 }
389 } else {
390
391 /* Tallocate memory for string */
392
393 if (x) {
394 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16, x * 2);
395 if (!data->notify_data.data.string)
396 return False;
397 } else {
398 data->notify_data.data.string = NULL;
399 }
400
401 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
402 return False;
403 }
404 }
405
406 #endif
407
408 #if 0 /* JERRY */
409 /* Win2k does not seem to put this parse align here */
410 if(!prs_align(ps))
411 return False;
412 #endif
413
414 return True;
415 }
416
417 /*******************************************************************
418 reads or writes an NOTIFY INFO structure.
419 ********************************************************************/
420
421 static bool smb_io_notify_info(const char *desc, SPOOL_NOTIFY_INFO *info, prs_struct *ps, int depth)
422 {
423 int i;
424
425 prs_debug(ps, depth, desc, "smb_io_notify_info");
426 depth++;
427
428 if(!prs_align(ps))
429 return False;
430
431 if(!prs_uint32("count", ps, depth, &info->count))
432 return False;
433 if(!prs_uint32("version", ps, depth, &info->version))
434 return False;
435 if(!prs_uint32("flags", ps, depth, &info->flags))
436 return False;
437 if(!prs_uint32("count", ps, depth, &info->count))
438 return False;
439
440 for (i=0;i<info->count;i++) {
441 if(!smb_io_notify_info_data(desc, &info->data[i], ps, depth))
442 return False;
443 }
444
445 /* now do the strings at the end of the stream */
446 for (i=0;i<info->count;i++) {
447 if(!smb_io_notify_info_data_strings(desc, &info->data[i], ps, depth))
448 return False;
449 }
450
451 return True;
452 }
453
454 /*******************************************************************
455 ********************************************************************/
456
457 bool spool_io_user_level_1( const char *desc, prs_struct *ps, int depth, SPOOL_USER_1 *q_u )
458 {
459 prs_debug(ps, depth, desc, "");
460 depth++;
461
462 if (!prs_align(ps))
463 return False;
464
465 if (!prs_uint32("size", ps, depth, &q_u->size))
466 return False;
467
468 if (!prs_io_unistr2_p("", ps, depth, &q_u->client_name))
469 return False;
470 if (!prs_io_unistr2_p("", ps, depth, &q_u->user_name))
471 return False;
472
473 if (!prs_uint32("build", ps, depth, &q_u->build))
474 return False;
475 if (!prs_uint32("major", ps, depth, &q_u->major))
476 return False;
477 if (!prs_uint32("minor", ps, depth, &q_u->minor))
478 return False;
479 if (!prs_uint32("processor", ps, depth, &q_u->processor))
480 return False;
481
482 if (!prs_io_unistr2("", ps, depth, q_u->client_name))
483 return False;
484 if (!prs_align(ps))
485 return False;
486
487 if (!prs_io_unistr2("", ps, depth, q_u->user_name))
488 return False;
489
490 return True;
491 }
492
493 /*******************************************************************
494 ********************************************************************/
495
496 static bool spool_io_user_level(const char *desc, SPOOL_USER_CTR *q_u, prs_struct *ps, int depth)
497 {
498 if (q_u==NULL)
499 return False;
500
501 prs_debug(ps, depth, desc, "spool_io_user_level");
502 depth++;
503
504 if (!prs_align(ps))
505 return False;
506
507 if (!prs_uint32("level", ps, depth, &q_u->level))
508 return False;
509
510 switch ( q_u->level )
511 {
512 case 1:
513 if ( !prs_pointer( "" , ps, depth, (void*)&q_u->user.user1,
514 sizeof(SPOOL_USER_1), (PRS_POINTER_CAST)spool_io_user_level_1 ))
515 {
516 return False;
517 }
518 break;
519 default:
520 return False;
521 }
522
523 return True;
524 }
525
526 /*******************************************************************
527 * read or write a DEVICEMODE struct.
528 * on reading allocate memory for the private member
529 ********************************************************************/
530
531 #define DM_NUM_OPTIONAL_FIELDS 8
532
533 bool spoolss_io_devmode(const char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
534 {
535 int available_space; /* size of the device mode left to parse */
536 /* only important on unmarshalling */
537 int i = 0;
538 uint16 *unistr_buffer;
539 int j;
540
541 struct optional_fields {
542 fstring name;
543 uint32* field;
544 } opt_fields[DM_NUM_OPTIONAL_FIELDS] = {
545 { "icmmethod", NULL },
546 { "icmintent", NULL },
547 { "mediatype", NULL },
548 { "dithertype", NULL },
549 { "reserved1", NULL },
550 { "reserved2", NULL },
551 { "panningwidth", NULL },
552 { "panningheight", NULL }
553 };
554
555 /* assign at run time to keep non-gcc compilers happy */
556
557 opt_fields[0].field = &devmode->icmmethod;
558 opt_fields[1].field = &devmode->icmintent;
559 opt_fields[2].field = &devmode->mediatype;
560 opt_fields[3].field = &devmode->dithertype;
561 opt_fields[4].field = &devmode->reserved1;
562 opt_fields[5].field = &devmode->reserved2;
563 opt_fields[6].field = &devmode->panningwidth;
564 opt_fields[7].field = &devmode->panningheight;
565
566
567 prs_debug(ps, depth, desc, "spoolss_io_devmode");
568 depth++;
569
570 if (UNMARSHALLING(ps)) {
571 devmode->devicename.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
572 if (devmode->devicename.buffer == NULL)
573 return False;
574 unistr_buffer = devmode->devicename.buffer;
575 }
576 else {
577 /* devicename is a static sized string but the buffer we set is not */
578 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
579 memset( unistr_buffer, 0x0, MAXDEVICENAME );
580 for ( j=0; devmode->devicename.buffer[j]; j++ )
581 unistr_buffer[j] = devmode->devicename.buffer[j];
582 }
583
584 if (!prs_uint16uni(True,"devicename", ps, depth, unistr_buffer, MAXDEVICENAME))
585 return False;
586
587 if (!prs_uint16("specversion", ps, depth, &devmode->specversion))
588 return False;
589
590 if (!prs_uint16("driverversion", ps, depth, &devmode->driverversion))
591 return False;
592 if (!prs_uint16("size", ps, depth, &devmode->size))
593 return False;
594 if (!prs_uint16("driverextra", ps, depth, &devmode->driverextra))
595 return False;
596 if (!prs_uint32("fields", ps, depth, &devmode->fields))
597 return False;
598 if (!prs_uint16("orientation", ps, depth, &devmode->orientation))
599 return False;
600 if (!prs_uint16("papersize", ps, depth, &devmode->papersize))
601 return False;
602 if (!prs_uint16("paperlength", ps, depth, &devmode->paperlength))
603 return False;
604 if (!prs_uint16("paperwidth", ps, depth, &devmode->paperwidth))
605 return False;
606 if (!prs_uint16("scale", ps, depth, &devmode->scale))
607 return False;
608 if (!prs_uint16("copies", ps, depth, &devmode->copies))
609 return False;
610 if (!prs_uint16("defaultsource", ps, depth, &devmode->defaultsource))
611 return False;
612 if (!prs_uint16("printquality", ps, depth, &devmode->printquality))
613 return False;
614 if (!prs_uint16("color", ps, depth, &devmode->color))
615 return False;
616 if (!prs_uint16("duplex", ps, depth, &devmode->duplex))
617 return False;
618 if (!prs_uint16("yresolution", ps, depth, &devmode->yresolution))
619 return False;
620 if (!prs_uint16("ttoption", ps, depth, &devmode->ttoption))
621 return False;
622 if (!prs_uint16("collate", ps, depth, &devmode->collate))
623 return False;
624
625 if (UNMARSHALLING(ps)) {
626 devmode->formname.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
627 if (devmode->formname.buffer == NULL)
628 return False;
629 unistr_buffer = devmode->formname.buffer;
630 }
631 else {
632 /* devicename is a static sized string but the buffer we set is not */
633 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
634 memset( unistr_buffer, 0x0, MAXDEVICENAME );
635 for ( j=0; devmode->formname.buffer[j]; j++ )
636 unistr_buffer[j] = devmode->formname.buffer[j];
637 }
638
639 if (!prs_uint16uni(True, "formname", ps, depth, unistr_buffer, MAXDEVICENAME))
640 return False;
641 if (!prs_uint16("logpixels", ps, depth, &devmode->logpixels))
642 return False;
643 if (!prs_uint32("bitsperpel", ps, depth, &devmode->bitsperpel))
644 return False;
645 if (!prs_uint32("pelswidth", ps, depth, &devmode->pelswidth))
646 return False;
647 if (!prs_uint32("pelsheight", ps, depth, &devmode->pelsheight))
648 return False;
649 if (!prs_uint32("displayflags", ps, depth, &devmode->displayflags))
650 return False;
651 if (!prs_uint32("displayfrequency", ps, depth, &devmode->displayfrequency))
652 return False;
653 /*
654 * every device mode I've ever seen on the wire at least has up
655 * to the displayfrequency field. --jerry (05-09-2002)
656 */
657
658 /* add uint32's + uint16's + two UNICODE strings */
659
660 available_space = devmode->size - (sizeof(uint32)*6 + sizeof(uint16)*18 + sizeof(uint16)*64);
661
662 /* Sanity check - we only have uint32's left tp parse */
663
664 if ( available_space && ((available_space % sizeof(uint32)) != 0) ) {
665 DEBUG(0,("spoolss_io_devmode: available_space [%d] no in multiple of 4 bytes (size = %d)!\n",
666 available_space, devmode->size));
667 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
668 return False;
669 }
670
671 /*
672 * Conditional parsing. Assume that the DeviceMode has been
673 * zero'd by the caller.
674 */
675
676 while ((available_space > 0) && (i < DM_NUM_OPTIONAL_FIELDS))
677 {
678 DEBUG(11, ("spoolss_io_devmode: [%d] bytes left to parse in devmode\n", available_space));
679 if (!prs_uint32(opt_fields[i].name, ps, depth, opt_fields[i].field))
680 return False;
681 available_space -= sizeof(uint32);
682 i++;
683 }
684
685 /* Sanity Check - we should no available space at this point unless
686 MS changes the device mode structure */
687
688 if (available_space) {
689 DEBUG(0,("spoolss_io_devmode: I've parsed all I know and there is still stuff left|\n"));
690 DEBUG(0,("spoolss_io_devmode: available_space = [%d], devmode_size = [%d]!\n",
691 available_space, devmode->size));
692 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
693 return False;
694 }
695
696
697 if (devmode->driverextra!=0) {
698 if (UNMARSHALLING(ps)) {
699 devmode->dev_private=PRS_ALLOC_MEM(ps, uint8, devmode->driverextra);
700 if(devmode->dev_private == NULL)
701 return False;
702 DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for dev_private\n",devmode->driverextra));
703 }
704
705 DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of dev_private\n",devmode->driverextra));
706 if (!prs_uint8s(False, "dev_private", ps, depth,
707 devmode->dev_private, devmode->driverextra))
708 return False;
709 }
710
711 return True;
712 }
713
714 /*******************************************************************
715 Read or write a DEVICEMODE container
716 ********************************************************************/
717
718 static bool spoolss_io_devmode_cont(const char *desc, DEVMODE_CTR *dm_c, prs_struct *ps, int depth)
719 {
720 if (dm_c==NULL)
721 return False;
722
723 prs_debug(ps, depth, desc, "spoolss_io_devmode_cont");
724 depth++;
725
726 if(!prs_align(ps))
727 return False;
728
729 if (!prs_uint32("size", ps, depth, &dm_c->size))
730 return False;
731
732 if (!prs_uint32("devmode_ptr", ps, depth, &dm_c->devmode_ptr))
733 return False;
734
735 if (dm_c->size==0 || dm_c->devmode_ptr==0) {
736 if (UNMARSHALLING(ps))
737 /* if while reading there is no DEVMODE ... */
738 dm_c->devmode=NULL;
739 return True;
740 }
741
742 /* so we have a DEVICEMODE to follow */
743 if (UNMARSHALLING(ps)) {
744 DEBUG(9,("Allocating memory for spoolss_io_devmode\n"));
745 dm_c->devmode=PRS_ALLOC_MEM(ps,DEVICEMODE,1);
746 if(dm_c->devmode == NULL)
747 return False;
748 }
749
750 /* this is bad code, shouldn't be there */
751 if (!prs_uint32("size", ps, depth, &dm_c->size))
752 return False;
753
754 if (!spoolss_io_devmode(desc, ps, depth, dm_c->devmode))
755 return False;
756
757 return True;
758 }
759
760 /*******************************************************************
761 * init a structure.
762 ********************************************************************/
763
764 bool make_spoolss_q_addprinterex( TALLOC_CTX *mem_ctx, SPOOL_Q_ADDPRINTEREX *q_u,
765 const char *srv_name, const char* clientname, const char* user_name,
766 uint32 level, PRINTER_INFO_CTR *ctr)
767 {
768 DEBUG(5,("make_spoolss_q_addprinterex\n"));
769
770 if (!ctr || !ctr->printers_2)
771 return False;
772
773 ZERO_STRUCTP(q_u);
774
775 q_u->server_name = TALLOC_P( mem_ctx, UNISTR2 );
776 if (!q_u->server_name) {
777 return False;
778 }
779 init_unistr2(q_u->server_name, srv_name, UNI_FLAGS_NONE);
780
781 q_u->level = level;
782
783 q_u->info.level = level;
784 q_u->info.info_ptr = (ctr->printers_2!=NULL)?1:0;
785 switch (level) {
786 case 2:
787 /* init q_u->info.info2 from *info */
788 if (!make_spoolss_printer_info_2(mem_ctx, &q_u->info.info_2, ctr->printers_2)) {
789 DEBUG(0,("make_spoolss_q_addprinterex: Unable to fill SPOOL_Q_ADDPRINTEREX struct!\n"));
790 return False;
791 }
792 break;
793 default :
794 break;
795 }
796
797 q_u->user_switch=1;
798
799 q_u->user_ctr.level = 1;
800 q_u->user_ctr.user.user1 = TALLOC_P( talloc_tos(), SPOOL_USER_1 );
801 if (!q_u->user_ctr.user.user1) {
802 return False;
803 }
804 q_u->user_ctr.user.user1->build = 1381;
805 q_u->user_ctr.user.user1->major = 2;
806 q_u->user_ctr.user.user1->minor = 0;
807 q_u->user_ctr.user.user1->processor = 0;
808
809 q_u->user_ctr.user.user1->client_name = TALLOC_P( mem_ctx, UNISTR2 );
810 if (!q_u->user_ctr.user.user1->client_name) {
811 return False;
812 }
813 q_u->user_ctr.user.user1->user_name = TALLOC_P( mem_ctx, UNISTR2 );
814 if (!q_u->user_ctr.user.user1->user_name) {
815 return False;
816 }
817 init_unistr2(q_u->user_ctr.user.user1->client_name, clientname, UNI_STR_TERMINATE);
818 init_unistr2(q_u->user_ctr.user.user1->user_name, user_name, UNI_STR_TERMINATE);
819
820 q_u->user_ctr.user.user1->size = q_u->user_ctr.user.user1->user_name->uni_str_len +
821 q_u->user_ctr.user.user1->client_name->uni_str_len + 2;
822
823 return True;
824 }
825
826 /*******************************************************************
827 create a SPOOL_PRINTER_INFO_2 stuct from a PRINTER_INFO_2 struct
828 *******************************************************************/
829
830 bool make_spoolss_printer_info_2(TALLOC_CTX *ctx, SPOOL_PRINTER_INFO_LEVEL_2 **spool_info2,
831 PRINTER_INFO_2 *info)
832 {
833
834 SPOOL_PRINTER_INFO_LEVEL_2 *inf;
835
836 /* allocate the necessary memory */
837 if (!(inf=TALLOC_P(ctx, SPOOL_PRINTER_INFO_LEVEL_2))) {
838 DEBUG(0,("make_spoolss_printer_info_2: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_2 sruct!\n"));
839 return False;
840 }
841
842 inf->servername_ptr = (info->servername.buffer!=NULL)?1:0;
843 inf->printername_ptr = (info->printername.buffer!=NULL)?1:0;
844 inf->sharename_ptr = (info->sharename.buffer!=NULL)?1:0;
845 inf->portname_ptr = (info->portname.buffer!=NULL)?1:0;
846 inf->drivername_ptr = (info->drivername.buffer!=NULL)?1:0;
847 inf->comment_ptr = (info->comment.buffer!=NULL)?1:0;
848 inf->location_ptr = (info->location.buffer!=NULL)?1:0;
849 inf->devmode_ptr = (info->devmode!=NULL)?1:0;
850 inf->sepfile_ptr = (info->sepfile.buffer!=NULL)?1:0;
851 inf->printprocessor_ptr = (info->printprocessor.buffer!=NULL)?1:0;
852 inf->datatype_ptr = (info->datatype.buffer!=NULL)?1:0;
853 inf->parameters_ptr = (info->parameters.buffer!=NULL)?1:0;
854 inf->secdesc_ptr = (info->secdesc!=NULL)?1:0;
855 inf->attributes = info->attributes;
856 inf->priority = info->priority;
857 inf->default_priority = info->defaultpriority;
858 inf->starttime = info->starttime;
859 inf->untiltime = info->untiltime;
860 inf->cjobs = info->cjobs;
861 inf->averageppm = info->averageppm;
862 init_unistr2_from_unistr(inf, &inf->servername, &info->servername);
863 init_unistr2_from_unistr(inf, &inf->printername, &info->printername);
864 init_unistr2_from_unistr(inf, &inf->sharename, &info->sharename);
865 init_unistr2_from_unistr(inf, &inf->portname, &info->portname);
866 init_unistr2_from_unistr(inf, &inf->drivername, &info->drivername);
867 init_unistr2_from_unistr(inf, &inf->comment, &info->comment);
868 init_unistr2_from_unistr(inf, &inf->location, &info->location);
869 init_unistr2_from_unistr(inf, &inf->sepfile, &info->sepfile);
870 init_unistr2_from_unistr(inf, &inf->printprocessor, &info->printprocessor);
871 init_unistr2_from_unistr(inf, &inf->datatype, &info->datatype);
872 init_unistr2_from_unistr(inf, &inf->parameters, &info->parameters);
873 init_unistr2_from_unistr(inf, &inf->datatype, &info->datatype);
874
875 *spool_info2 = inf;
876
877 return True;
878 }
879
880 /*******************************************************************
881 create a SPOOL_PRINTER_INFO_3 struct from a PRINTER_INFO_3 struct
882 *******************************************************************/
883
884 bool make_spoolss_printer_info_3(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_3 **spool_info3,
885 PRINTER_INFO_3 *info)
886 {
887
888 SPOOL_PRINTER_INFO_LEVEL_3 *inf;
889
890 /* allocate the necessary memory */
891 if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_3))) {
892 DEBUG(0,("make_spoolss_printer_info_3: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_3 sruct!\n"));
893 return False;
894 }
895
896 inf->secdesc_ptr = (info->secdesc!=NULL)?1:0;
897
898 *spool_info3 = inf;
899
900 return True;
901 }
902
903 /*******************************************************************
904 create a SPOOL_PRINTER_INFO_7 struct from a PRINTER_INFO_7 struct
905 *******************************************************************/
906
907 bool make_spoolss_printer_info_7(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_7 **spool_info7,
908 PRINTER_INFO_7 *info)
909 {
910
911 SPOOL_PRINTER_INFO_LEVEL_7 *inf;
912
913 /* allocate the necessary memory */
914 if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_7))) {
915 DEBUG(0,("make_spoolss_printer_info_7: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_7 struct!\n"));
916 return False;
917 }
918
919 inf->guid_ptr = (info->guid.buffer!=NULL)?1:0;
920 inf->action = info->action;
921 init_unistr2_from_unistr(inf, &inf->guid, &info->guid);
922
923 *spool_info7 = inf;
924
925 return True;
926 }
927
928 /*******************************************************************
929 * make a structure.
930 ********************************************************************/
931
932 bool make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u,
933 const POLICY_HND *handle,
934 const char *valuename, uint32 size)
935 {
936 if (q_u == NULL) return False;
937
938 DEBUG(5,("make_spoolss_q_getprinterdata\n"));
939
940 q_u->handle = *handle;
941 init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
942 q_u->size = size;
943
944 return True;
945 }
946
947 /*******************************************************************
948 * read a structure.
949 * called from spoolss_q_getprinterdata (srv_spoolss.c)
950 ********************************************************************/
951
952 bool spoolss_io_q_getprinterdata(const char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_struct *ps, int depth)
953 {
954 if (q_u == NULL)
955 return False;
956
957 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdata");
958 depth++;
959
960 if (!prs_align(ps))
961 return False;
962 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
963 return False;
964 if (!prs_align(ps))
965 return False;
966 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
967 return False;
968 if (!prs_align(ps))
969 return False;
970 if (!prs_uint32("size", ps, depth, &q_u->size))
971 return False;
972
973 return True;
974 }
975
976 /*******************************************************************
977 * write a structure.
978 * called from spoolss_r_getprinterdata (srv_spoolss.c)
979 ********************************************************************/
980
981 bool spoolss_io_r_getprinterdata(const char *desc, SPOOL_R_GETPRINTERDATA *r_u, prs_struct *ps, int depth)
982 {
983 if (r_u == NULL)
984 return False;
985
986 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdata");
987 depth++;
988
989 if (!prs_align(ps))
990 return False;
991 if (!prs_uint32("type", ps, depth, &r_u->type))
992 return False;
993 if (!prs_uint32("size", ps, depth, &r_u->size))
994 return False;
995
996 if (UNMARSHALLING(ps) && r_u->size) {
997 r_u->data = PRS_ALLOC_MEM(ps, unsigned char, r_u->size);
998 if(!r_u->data)
999 return False;
1000 }
1001
1002 if (!prs_uint8s( False, "data", ps, depth, r_u->data, r_u->size ))
1003 return False;
1004
1005 if (!prs_align(ps))
1006 return False;
1007
1008 if (!prs_uint32("needed", ps, depth, &r_u->needed))
1009 return False;
1010 if (!prs_werror("status", ps, depth, &r_u->status))
1011 return False;
1012
1013 return True;
1014 }
1015
1016 /*******************************************************************
1017 * read a structure.
1018 * called from spoolss_q_rffpcnex (srv_spoolss.c)
1019 ********************************************************************/
1020
1021 bool spoolss_io_q_rffpcnex(const char *desc, SPOOL_Q_RFFPCNEX *q_u, prs_struct *ps, int depth)
1022 {
1023 prs_debug(ps, depth, desc, "spoolss_io_q_rffpcnex");
1024 depth++;
1025
1026 if(!prs_align(ps))
1027 return False;
1028
1029 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1030 return False;
1031 if(!prs_uint32("flags", ps, depth, &q_u->flags))
1032 return False;
1033 if(!prs_uint32("options", ps, depth, &q_u->options))
1034 return False;
1035 if(!prs_uint32("localmachine_ptr", ps, depth, &q_u->localmachine_ptr))
1036 return False;
1037 if(!smb_io_unistr2("localmachine", &q_u->localmachine, q_u->localmachine_ptr, ps, depth))
1038 return False;
1039
1040 if(!prs_align(ps))
1041 return False;
1042
1043 if(!prs_uint32("printerlocal", ps, depth, &q_u->printerlocal))
1044 return False;
1045
1046 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1047 return False;
1048
1049 if (q_u->option_ptr!=0) {
1050
1051 if (UNMARSHALLING(ps))
1052 if((q_u->option=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION,1)) == NULL)
1053 return False;
1054
1055 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1056 return False;
1057 }
1058
1059 return True;
1060 }
1061
1062 /*******************************************************************
1063 * write a structure.
1064 * called from spoolss_r_rffpcnex (srv_spoolss.c)
1065 ********************************************************************/
1066
1067 bool spoolss_io_r_rffpcnex(const char *desc, SPOOL_R_RFFPCNEX *r_u, prs_struct *ps, int depth)
1068 {
1069 prs_debug(ps, depth, desc, "spoolss_io_r_rffpcnex");
1070 depth++;
1071
1072 if(!prs_werror("status", ps, depth, &r_u->status))
1073 return False;
1074
1075 return True;
1076 }
1077
1078 /*******************************************************************
1079 * read a structure.
1080 * called from spoolss_q_rfnpcnex (srv_spoolss.c)
1081 ********************************************************************/
1082
1083 bool spoolss_io_q_rfnpcnex(const char *desc, SPOOL_Q_RFNPCNEX *q_u, prs_struct *ps, int depth)
1084 {
1085 prs_debug(ps, depth, desc, "spoolss_io_q_rfnpcnex");
1086 depth++;
1087
1088 if(!prs_align(ps))
1089 return False;
1090
1091 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1092 return False;
1093
1094 if(!prs_uint32("change", ps, depth, &q_u->change))
1095 return False;
1096
1097 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1098 return False;
1099
1100 if (q_u->option_ptr!=0) {
1101
1102 if (UNMARSHALLING(ps))
1103 if((q_u->option=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION,1)) == NULL)
1104 return False;
1105
1106 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1107 return False;
1108 }
1109
1110 return True;
1111 }
1112
1113 /*******************************************************************
1114 * write a structure.
1115 * called from spoolss_r_rfnpcnex (srv_spoolss.c)
1116 ********************************************************************/
1117
1118 bool spoolss_io_r_rfnpcnex(const char *desc, SPOOL_R_RFNPCNEX *r_u, prs_struct *ps, int depth)
1119 {
1120 prs_debug(ps, depth, desc, "spoolss_io_r_rfnpcnex");
1121 depth++;
1122
1123 if(!prs_align(ps))
1124 return False;
1125
1126 if (!prs_uint32("info_ptr", ps, depth, &r_u->info_ptr))
1127 return False;
1128
1129 if(!smb_io_notify_info("notify info", &r_u->info ,ps,depth))
1130 return False;
1131
1132 if(!prs_align(ps))
1133 return False;
1134 if(!prs_werror("status", ps, depth, &r_u->status))
1135 return False;
1136
1137 return True;
1138 }
1139
1140 /*******************************************************************
1141 * return the length of a uint16 (obvious, but the code is clean)
1142 ********************************************************************/
1143
1144 static uint32 size_of_uint16(uint16 *value)
1145 {
1146 return (sizeof(*value));
1147 }
1148
1149 /*******************************************************************
1150 * return the length of a uint32 (obvious, but the code is clean)
1151 ********************************************************************/
1152
1153 static uint32 size_of_uint32(uint32 *value)
1154 {
1155 return (sizeof(*value));
1156 }
1157
1158 /*******************************************************************
1159 * return the length of a NTTIME (obvious, but the code is clean)
1160 ********************************************************************/
1161
1162 static uint32 size_of_nttime(NTTIME *value)
1163 {
1164 return (sizeof(*value));
1165 }
1166
1167 /*******************************************************************
1168 * return the length of a uint32 (obvious, but the code is clean)
1169 ********************************************************************/
1170
1171 static uint32 size_of_device_mode(DEVICEMODE *devmode)
1172 {
1173 if (devmode==NULL)
1174 return (4);
1175 else
1176 return (4+devmode->size+devmode->driverextra);
1177 }
1178
1179 /*******************************************************************
1180 * return the length of a uint32 (obvious, but the code is clean)
1181 ********************************************************************/
1182
1183 static uint32 size_of_systemtime(SYSTEMTIME *systime)
1184 {
1185 if (systime==NULL)
1186 return (4);
1187 else
1188 return (sizeof(SYSTEMTIME) +4);
1189 }
1190
1191 /*******************************************************************
1192 Parse a DEVMODE structure and its relative pointer.
1193 ********************************************************************/
1194
1195 static bool smb_io_reldevmode(const char *desc, RPC_BUFFER *buffer, int depth, DEVICEMODE **devmode)
1196 {
1197 prs_struct *ps=&buffer->prs;
1198
1199 prs_debug(ps, depth, desc, "smb_io_reldevmode");
1200 depth++;
1201
1202 if (MARSHALLING(ps)) {
1203 uint32 struct_offset = prs_offset(ps);
1204 uint32 relative_offset;
1205
1206 if (*devmode == NULL) {
1207 relative_offset=0;
1208 if (!prs_uint32("offset", ps, depth, &relative_offset))
1209 return False;
1210 DEBUG(8, ("boing, the devmode was NULL\n"));
1211
1212 return True;
1213 }
1214
1215 buffer->string_at_end -= ((*devmode)->size + (*devmode)->driverextra);
1216
1217 /* mz: we have to align the device mode for VISTA */
1218 if (buffer->string_at_end % 4) {
1219 buffer->string_at_end += 4 - (buffer->string_at_end % 4);
1220 }
1221
1222 if(!prs_set_offset(ps, buffer->string_at_end))
1223 return False;
1224
1225 /* write the DEVMODE */
1226 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
1227 return False;
1228
1229 if(!prs_set_offset(ps, struct_offset))
1230 return False;
1231
1232 relative_offset=buffer->string_at_end - buffer->struct_start;
1233 /* write its offset */
1234 if (!prs_uint32("offset", ps, depth, &relative_offset))
1235 return False;
1236 }
1237 else {
1238 uint32 old_offset;
1239
1240 /* read the offset */
1241 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
1242 return False;
1243 if (buffer->string_at_end == 0) {
1244 *devmode = NULL;
1245 return True;
1246 }
1247
1248 old_offset = prs_offset(ps);
1249 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
1250 return False;
1251
1252 /* read the string */
1253 if((*devmode=PRS_ALLOC_MEM(ps,DEVICEMODE,1)) == NULL)
1254 return False;
1255 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
1256 return False;
1257
1258 if(!prs_set_offset(ps, old_offset))
1259 return False;
1260 }
1261 return True;
1262 }
1263
1264 /*******************************************************************
1265 Parse a PRINTER_INFO_0 structure.
1266 ********************************************************************/
1267
1268 bool smb_io_printer_info_0(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_0 *info, int depth)
1269 {
1270 prs_struct *ps=&buffer->prs;
1271
1272 prs_debug(ps, depth, desc, "smb_io_printer_info_0");
1273 depth++;
1274
1275 buffer->struct_start=prs_offset(ps);
1276
1277 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
1278 return False;
1279 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
1280 return False;
1281
1282 if(!prs_uint32("cjobs", ps, depth, &info->cjobs))
1283 return False;
1284 if(!prs_uint32("total_jobs", ps, depth, &info->total_jobs))
1285 return False;
1286 if(!prs_uint32("total_bytes", ps, depth, &info->total_bytes))
1287 return False;
1288
1289 if(!prs_uint16("year", ps, depth, &info->year))
1290 return False;
1291 if(!prs_uint16("month", ps, depth, &info->month))
1292 return False;
1293 if(!prs_uint16("dayofweek", ps, depth, &info->dayofweek))
1294 return False;
1295 if(!prs_uint16("day", ps, depth, &info->day))
1296 return False;
1297 if(!prs_uint16("hour", ps, depth, &info->hour))
1298 return False;
1299 if(!prs_uint16("minute", ps, depth, &info->minute))
1300 return False;
1301 if(!prs_uint16("second", ps, depth, &info->second))
1302 return False;
1303 if(!prs_uint16("milliseconds", ps, depth, &info->milliseconds))
1304 return False;
1305
1306 if(!prs_uint32("global_counter", ps, depth, &info->global_counter))
1307 return False;
1308 if(!prs_uint32("total_pages", ps, depth, &info->total_pages))
1309 return False;
1310
1311 if(!prs_uint16("major_version", ps, depth, &info->major_version))
1312 return False;
1313 if(!prs_uint16("build_version", ps, depth, &info->build_version))
1314 return False;
1315 if(!prs_uint32("unknown7", ps, depth, &info->unknown7))
1316 return False;
1317 if(!prs_uint32("unknown8", ps, depth, &info->unknown8))
1318 return False;
1319 if(!prs_uint32("unknown9", ps, depth, &info->unknown9))
1320 return False;
1321 if(!prs_uint32("session_counter", ps, depth, &info->session_counter))
1322 return False;
1323 if(!prs_uint32("unknown11", ps, depth, &info->unknown11))
1324 return False;
1325 if(!prs_uint32("printer_errors", ps, depth, &info->printer_errors))
1326 return False;
1327 if(!prs_uint32("unknown13", ps, depth, &info->unknown13))
1328 return False;
1329 if(!prs_uint32("unknown14", ps, depth, &info->unknown14))
1330 return False;
1331 if(!prs_uint32("unknown15", ps, depth, &info->unknown15))
1332 return False;
1333 if(!prs_uint32("unknown16", ps, depth, &info->unknown16))
1334 return False;
1335 if(!prs_uint32("change_id", ps, depth, &info->change_id))
1336 return False;
1337 if(!prs_uint32("unknown18", ps, depth, &info->unknown18))
1338 return False;
1339 if(!prs_uint32("status" , ps, depth, &info->status))
1340 return False;
1341 if(!prs_uint32("unknown20", ps, depth, &info->unknown20))
1342 return False;
1343 if(!prs_uint32("c_setprinter", ps, depth, &info->c_setprinter))
1344 return False;
1345 if(!prs_uint16("unknown22", ps, depth, &info->unknown22))
1346 return False;
1347 if(!prs_uint16("unknown23", ps, depth, &info->unknown23))
1348 return False;
1349 if(!prs_uint16("unknown24", ps, depth, &info->unknown24))
1350 return False;
1351 if(!prs_uint16("unknown25", ps, depth, &info->unknown25))
1352 return False;
1353 if(!prs_uint16("unknown26", ps, depth, &info->unknown26))
1354 return False;
1355 if(!prs_uint16("unknown27", ps, depth, &info->unknown27))
1356 return False;
1357 if(!prs_uint16("unknown28", ps, depth, &info->unknown28))
1358 return False;
1359 if(!prs_uint16("unknown29", ps, depth, &info->unknown29))
1360 return False;
1361
1362 return True;
1363 }
1364
1365 /*******************************************************************
1366 Parse a PRINTER_INFO_1 structure.
1367 ********************************************************************/
1368
1369 bool smb_io_printer_info_1(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_1 *info, int depth)
1370 {
1371 prs_struct *ps=&buffer->prs;
1372
1373 prs_debug(ps, depth, desc, "smb_io_printer_info_1");
1374 depth++;
1375
1376 buffer->struct_start=prs_offset(ps);
1377
1378 if (!prs_uint32("flags", ps, depth, &info->flags))
1379 return False;
1380 if (!smb_io_relstr("description", buffer, depth, &info->description))
1381 return False;
1382 if (!smb_io_relstr("name", buffer, depth, &info->name))
1383 return False;
1384 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
1385 return False;
1386
1387 return True;
1388 }
1389
1390 /*******************************************************************
1391 Parse a PRINTER_INFO_2 structure.
1392 ********************************************************************/
1393
1394 bool smb_io_printer_info_2(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_2 *info, int depth)
1395 {
1396 prs_struct *ps=&buffer->prs;
1397 uint32 dm_offset, sd_offset, current_offset;
1398 uint32 dummy_value = 0, has_secdesc = 0;
1399
1400 prs_debug(ps, depth, desc, "smb_io_printer_info_2");
1401 depth++;
1402
1403 buffer->struct_start=prs_offset(ps);
1404
1405 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
1406 return False;
1407 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
1408 return False;
1409 if (!smb_io_relstr("sharename", buffer, depth, &info->sharename))
1410 return False;
1411 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
1412 return False;
1413 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
1414 return False;
1415 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
1416 return False;
1417 if (!smb_io_relstr("location", buffer, depth, &info->location))
1418 return False;
1419
1420 /* save current offset and wind forwared by a uint32 */
1421 dm_offset = prs_offset(ps);
1422 if (!prs_uint32("devmode", ps, depth, &dummy_value))
1423 return False;
1424
1425 if (!smb_io_relstr("sepfile", buffer, depth, &info->sepfile))
1426 return False;
1427 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
1428 return False;
1429 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
1430 return False;
1431 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
1432 return False;
1433
1434 /* save current offset for the sec_desc */
1435 sd_offset = prs_offset(ps);
1436 if (!prs_uint32("sec_desc", ps, depth, &has_secdesc))
1437 return False;
1438
1439
1440 /* save current location so we can pick back up here */
1441 current_offset = prs_offset(ps);
1442
1443 /* parse the devmode */
1444 if (!prs_set_offset(ps, dm_offset))
1445 return False;
1446 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
1447 return False;
1448
1449 /* parse the sec_desc */
1450 if (info->secdesc) {
1451 if (!prs_set_offset(ps, sd_offset))
1452 return False;
1453 if (!smb_io_relsecdesc("secdesc", buffer, depth, &info->secdesc))
1454 return False;
1455 }
1456
1457 /* pick up where we left off */
1458 if (!prs_set_offset(ps, current_offset))
1459 return False;
1460
1461 if (!prs_uint32("attributes", ps, depth, &info->attributes))
1462 return False;
1463 if (!prs_uint32("priority", ps, depth, &info->priority))
1464 return False;
1465 if (!prs_uint32("defpriority", ps, depth, &info->defaultpriority))
1466 return False;
1467 if (!prs_uint32("starttime", ps, depth, &info->starttime))
1468 return False;
1469 if (!prs_uint32("untiltime", ps, depth, &info->untiltime))
1470 return False;
1471 if (!prs_uint32("status", ps, depth, &info->status))
1472 return False;
1473 if (!prs_uint32("jobs", ps, depth, &info->cjobs))
1474 return False;
1475 if (!prs_uint32("averageppm", ps, depth, &info->averageppm))
1476 return False;
1477
1478 return True;
1479 }
1480
1481 /*******************************************************************
1482 Parse a PRINTER_INFO_3 structure.
1483 ********************************************************************/
1484
1485 bool smb_io_printer_info_3(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_3 *info, int depth)
1486 {
1487 uint32 offset = 0;
1488 prs_struct *ps=&buffer->prs;
1489
1490 prs_debug(ps, depth, desc, "smb_io_printer_info_3");
1491 depth++;
1492
1493 buffer->struct_start=prs_offset(ps);
1494
1495 if (MARSHALLING(ps)) {
1496 /* Ensure the SD is 8 byte aligned in the buffer. */
1497 uint32 start = prs_offset(ps); /* Remember the start position. */
1498 uint32 off_val = 0;
1499
1500 /* Write a dummy value. */
1501 if (!prs_uint32("offset", ps, depth, &off_val))
1502 return False;
1503
1504 /* 8 byte align. */
1505 if (!prs_align_uint64(ps))
1506 return False;
1507
1508 /* Remember where we must seek back to write the SD. */
1509 offset = prs_offset(ps);
1510
1511 /* Calculate the real offset for the SD. */
1512
1513 off_val = offset - start;
1514
1515 /* Seek back to where we store the SD offset & store. */
1516 prs_set_offset(ps, start);
1517 if (!prs_uint32("offset", ps, depth, &off_val))
1518 return False;
1519
1520 /* Return to after the 8 byte align. */
1521 prs_set_offset(ps, offset);
1522
1523 } else {
1524 if (!prs_uint32("offset", ps, depth, &offset))
1525 return False;
1526 /* Seek within the buffer. */
1527 if (!prs_set_offset(ps, offset))
1528 return False;
1529 }
1530 if (!sec_io_desc("sec_desc", &info->secdesc, ps, depth))
1531 return False;
1532
1533 return True;
1534 }
1535
1536 /*******************************************************************
1537 Parse a PRINTER_INFO_4 structure.
1538 ********************************************************************/
1539
1540 bool smb_io_printer_info_4(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_4 *info, int depth)
1541 {
1542 prs_struct *ps=&buffer->prs;
1543
1544 prs_debug(ps, depth, desc, "smb_io_printer_info_4");
1545 depth++;
1546
1547 buffer->struct_start=prs_offset(ps);
1548
1549 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
1550 return False;
1551 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
1552 return False;
1553 if (!prs_uint32("attributes", ps, depth, &info->attributes))
1554 return False;
1555 return True;
1556 }
1557
1558 /*******************************************************************
1559 Parse a PRINTER_INFO_5 structure.
1560 ********************************************************************/
1561
1562 bool smb_io_printer_info_5(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_5 *info, int depth)
1563 {
1564 prs_struct *ps=&buffer->prs;
1565
1566 prs_debug(ps, depth, desc, "smb_io_printer_info_5");
1567 depth++;
1568
1569 buffer->struct_start=prs_offset(ps);
1570
1571 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
1572 return False;
1573 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
1574 return False;
1575 if (!prs_uint32("attributes", ps, depth, &info->attributes))
1576 return False;
1577 if (!prs_uint32("device_not_selected_timeout", ps, depth, &info->device_not_selected_timeout))
1578 return False;
1579 if (!prs_uint32("transmission_retry_timeout", ps, depth, &info->transmission_retry_timeout))
1580 return False;
1581 return True;
1582 }
1583
1584 /*******************************************************************
1585 Parse a PRINTER_INFO_6 structure.
1586 ********************************************************************/
1587
1588 bool smb_io_printer_info_6(const char *desc, RPC_BUFFER *buffer,
1589 PRINTER_INFO_6 *info, int depth)
1590 {
1591 prs_struct *ps=&buffer->prs;
1592
1593 prs_debug(ps, depth, desc, "smb_io_printer_info_6");
1594 depth++;
1595
1596 if (!prs_uint32("status", ps, depth, &info->status))
1597 return False;
1598
1599 return True;
1600 }
1601
1602 /*******************************************************************
1603 Parse a PRINTER_INFO_7 structure.
1604 ********************************************************************/
1605
1606 bool smb_io_printer_info_7(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_7 *info, int depth)
1607 {
1608 prs_struct *ps=&buffer->prs;
1609
1610 prs_debug(ps, depth, desc, "smb_io_printer_info_7");
1611 depth++;
1612
1613 buffer->struct_start=prs_offset(ps);
1614
1615 if (!smb_io_relstr("guid", buffer, depth, &info->guid))
1616 return False;
1617 if (!prs_uint32("action", ps, depth, &info->action))
1618 return False;
1619 return True;
1620 }
1621
1622 /*******************************************************************
1623 Parse a PORT_INFO_1 structure.
1624 ********************************************************************/
1625
1626 bool smb_io_port_info_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
1627 {
1628 prs_struct *ps=&buffer->prs;
1629
1630 prs_debug(ps, depth, desc, "smb_io_port_info_1");
1631 depth++;
1632
1633 buffer->struct_start=prs_offset(ps);
1634
1635 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
1636 return False;
1637
1638 return True;
1639 }
1640
1641 /*******************************************************************
1642 Parse a PORT_INFO_2 structure.
1643 ********************************************************************/
1644
1645 bool smb_io_port_info_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
1646 {
1647 prs_struct *ps=&buffer->prs;
1648
1649 prs_debug(ps, depth, desc, "smb_io_port_info_2");
1650 depth++;
1651
1652 buffer->struct_start=prs_offset(ps);
1653
1654 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
1655 return False;
1656 if (!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
1657 return False;
1658 if (!smb_io_relstr("description", buffer, depth, &info->description))
1659 return False;
1660 if (!prs_uint32("port_type", ps, depth, &info->port_type))
1661 return False;
1662 if (!prs_uint32("reserved", ps, depth, &info->reserved))
1663 return False;
1664
1665 return True;
1666 }
1667
1668 /*******************************************************************
1669 Parse a DRIVER_INFO_1 structure.
1670 ********************************************************************/
1671
1672 bool smb_io_printer_driver_info_1(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_1 *info, int depth)
1673 {
1674 prs_struct *ps=&buffer->prs;
1675
1676 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_1");
1677 depth++;
1678
1679 buffer->struct_start=prs_offset(ps);
1680
1681 if (!smb_io_relstr("name", buffer, depth, &info->name))
1682 return False;
1683
1684 return True;
1685 }
1686
1687 /*******************************************************************
1688 Parse a DRIVER_INFO_2 structure.
1689 ********************************************************************/
1690
1691 bool smb_io_printer_driver_info_2(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_2 *info, int depth)
1692 {
1693 prs_struct *ps=&buffer->prs;
1694
1695 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_2");
1696 depth++;
1697
1698 buffer->struct_start=prs_offset(ps);
1699
1700 if (!prs_uint32("version", ps, depth, &info->version))
1701 return False;
1702 if (!smb_io_relstr("name", buffer, depth, &info->name))
1703 return False;
1704 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
1705 return False;
1706 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
1707 return False;
1708 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
1709 return False;
1710 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
1711 return False;
1712
1713 return True;
1714 }
1715
1716 /*******************************************************************
1717 Parse a DRIVER_INFO_3 structure.
1718 ********************************************************************/
1719
1720 bool smb_io_printer_driver_info_3(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_3 *info, int depth)
1721 {
1722 prs_struct *ps=&buffer->prs;
1723
1724 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_3");
1725 depth++;
1726
1727 buffer->struct_start=prs_offset(ps);
1728
1729 if (!prs_uint32("version", ps, depth, &info->version))
1730 return False;
1731 if (!smb_io_relstr("name", buffer, depth, &info->name))
1732 return False;
1733 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
1734 return False;
1735 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
1736 return False;
1737 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
1738 return False;
1739 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
1740 return False;
1741 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
1742 return False;
1743
1744 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
1745 return False;
1746
1747 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
1748 return False;
1749 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
1750 return False;
1751
1752 return True;
1753 }
1754
1755 /*******************************************************************
1756 Parse a DRIVER_INFO_6 structure.
1757 ********************************************************************/
1758
1759 bool smb_io_printer_driver_info_6(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_6 *info, int depth)
1760 {
1761 prs_struct *ps=&buffer->prs;
1762
1763 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_6");
1764 depth++;
1765
1766 buffer->struct_start=prs_offset(ps);
1767
1768 if (!prs_uint32("version", ps, depth, &info->version))
1769 return False;
1770 if (!smb_io_relstr("name", buffer, depth, &info->name))
1771 return False;
1772 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
1773 return False;
1774 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
1775 return False;
1776 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
1777 return False;
1778 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
1779 return False;
1780 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
1781 return False;
1782
1783 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
1784 return False;
1785
1786 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
1787 return False;
1788 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
1789 return False;
1790
1791 if (!smb_io_relarraystr("previousdrivernames", buffer, depth, &info->previousdrivernames))
1792 return False;
1793
1794 if (!prs_uint64("date", ps, depth, &info->driver_date))
1795 return False;
1796
1797 if (!prs_uint32("padding", ps, depth, &info->padding))
1798 return False;
1799
1800 if (!prs_uint32("driver_version_low", ps, depth, &info->driver_version_low))
1801 return False;
1802
1803 if (!prs_uint32("driver_version_high", ps, depth, &info->driver_version_high))
1804 return False;
1805
1806 if (!smb_io_relstr("mfgname", buffer, depth, &info->mfgname))
1807 return False;
1808 if (!smb_io_relstr("oem_url", buffer, depth, &info->oem_url))
1809 return False;
1810 if (!smb_io_relstr("hardware_id", buffer, depth, &info->hardware_id))
1811 return False;
1812 if (!smb_io_relstr("provider", buffer, depth, &info->provider))
1813 return False;
1814
1815 return True;
1816 }
1817
1818 /*******************************************************************
1819 Parse a JOB_INFO_1 structure.
1820 ********************************************************************/
1821
1822 bool smb_io_job_info_1(const char *desc, RPC_BUFFER *buffer, JOB_INFO_1 *info, int depth)
1823 {
1824 prs_struct *ps=&buffer->prs;
1825
1826 prs_debug(ps, depth, desc, "smb_io_job_info_1");
1827 depth++;
1828
1829 buffer->struct_start=prs_offset(ps);
1830
1831 if (!prs_uint32("jobid", ps, depth, &info->jobid))
1832 return False;
1833 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
1834 return False;
1835 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
1836 return False;
1837 if (!smb_io_relstr("username", buffer, depth, &info->username))
1838 return False;
1839 if (!smb_io_relstr("document", buffer, depth, &info->document))
1840 return False;
1841 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
1842 return False;
1843 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
1844 return False;
1845 if (!prs_uint32("status", ps, depth, &info->status))
1846 return False;
1847 if (!prs_uint32("priority", ps, depth, &info->priority))
1848 return False;
1849 if (!prs_uint32("position", ps, depth, &info->position))
1850 return False;
1851 if (!prs_uint32("totalpages", ps, depth, &info->totalpages))
1852 return False;
1853 if (!prs_uint32("pagesprinted", ps, depth, &info->pagesprinted))
1854 return False;
1855 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted))
1856 return False;
1857
1858 return True;
1859 }
1860
1861 /*******************************************************************
1862 Parse a JOB_INFO_2 structure.
1863 ********************************************************************/
1864
1865 bool smb_io_job_info_2(const char *desc, RPC_BUFFER *buffer, JOB_INFO_2 *info, int depth)
1866 {
1867 uint32 pipo=0;
1868 prs_struct *ps=&buffer->prs;
1869
1870 prs_debug(ps, depth, desc, "smb_io_job_info_2");
1871 depth++;
1872
1873 buffer->struct_start=prs_offset(ps);
1874
1875 if (!prs_uint32("jobid",ps, depth, &info->jobid))
1876 return False;
1877 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
1878 return False;
1879 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
1880 return False;
1881 if (!smb_io_relstr("username", buffer, depth, &info->username))
1882 return False;
1883 if (!smb_io_relstr("document", buffer, depth, &info->document))
1884 return False;
1885 if (!smb_io_relstr("notifyname", buffer, depth, &info->notifyname))
1886 return False;
1887 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
1888 return False;
1889
1890 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
1891 return False;
1892 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
1893 return False;
1894 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
1895 return False;
1896 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
1897 return False;
1898 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
1899 return False;
1900
1901 /* SEC_DESC sec_desc;*/
1902 if (!prs_uint32("Hack! sec desc", ps, depth, &pipo))
1903 return False;
1904
1905 if (!prs_uint32("status",ps, depth, &info->status))
1906 return False;
1907 if (!prs_uint32("priority",ps, depth, &info->priority))
1908 return False;
1909 if (!prs_uint32("position",ps, depth, &info->position))
1910 return False;
1911 if (!prs_uint32("starttime",ps, depth, &info->starttime))
1912 return False;
1913 if (!prs_uint32("untiltime",ps, depth, &info->untiltime))
1914 return False;
1915 if (!prs_uint32("totalpages",ps, depth, &info->totalpages))
1916 return False;
1917 if (!prs_uint32("size",ps, depth, &info->size))
1918 return False;
1919 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted) )
1920 return False;
1921 if (!prs_uint32("timeelapsed",ps, depth, &info->timeelapsed))
1922 return False;
1923 if (!prs_uint32("pagesprinted",ps, depth, &info->pagesprinted))
1924 return False;
1925
1926 return True;
1927 }
1928
1929 /*******************************************************************
1930 ********************************************************************/
1931
1932 bool smb_io_form_1(const char *desc, RPC_BUFFER *buffer, FORM_1 *info, int depth)
1933 {
1934 prs_struct *ps=&buffer->prs;
1935
1936 prs_debug(ps, depth, desc, "smb_io_form_1");
1937 depth++;
1938
1939 buffer->struct_start=prs_offset(ps);
1940
1941 if (!prs_uint32("flag", ps, depth, &info->flag))
1942 return False;
1943
1944 if (!smb_io_relstr("name", buffer, depth, &info->name))
1945 return False;
1946
1947 if (!prs_uint32("width", ps, depth, &info->width))
1948 return False;
1949 if (!prs_uint32("length", ps, depth, &info->length))
1950 return False;
1951 if (!prs_uint32("left", ps, depth, &info->left))
1952 return False;
1953 if (!prs_uint32("top", ps, depth, &info->top))
1954 return False;
1955 if (!prs_uint32("right", ps, depth, &info->right))
1956 return False;
1957 if (!prs_uint32("bottom", ps, depth, &info->bottom))
1958 return False;
1959
1960 return True;
1961 }
1962
1963
1964
1965 /*******************************************************************
1966 Parse a DRIVER_DIRECTORY_1 structure.
1967 ********************************************************************/
1968
1969 bool smb_io_driverdir_1(const char *desc, RPC_BUFFER *buffer, DRIVER_DIRECTORY_1 *info, int depth)
1970 {
1971 prs_struct *ps=&buffer->prs;
1972
1973 prs_debug(ps, depth, desc, "smb_io_driverdir_1");
1974 depth++;
1975
1976 buffer->struct_start=prs_offset(ps);
1977
1978 if (!smb_io_unistr(desc, &info->name, ps, depth))
1979 return False;
1980
1981 return True;
1982 }
1983
1984 /*******************************************************************
1985 Parse a PORT_INFO_1 structure.
1986 ********************************************************************/
1987
1988 bool smb_io_port_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
1989 {
1990 prs_struct *ps=&buffer->prs;
1991
1992 prs_debug(ps, depth, desc, "smb_io_port_1");
1993 depth++;
1994
1995 buffer->struct_start=prs_offset(ps);
1996
1997 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
1998 return False;
1999
2000 return True;
2001 }
2002
2003 /*******************************************************************
2004 Parse a PORT_INFO_2 structure.
2005 ********************************************************************/
2006
2007 bool smb_io_port_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2008 {
2009 prs_struct *ps=&buffer->prs;
2010
2011 prs_debug(ps, depth, desc, "smb_io_port_2");
2012 depth++;
2013
2014 buffer->struct_start=prs_offset(ps);
2015
2016 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2017 return False;
2018 if(!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2019 return False;
2020 if(!smb_io_relstr("description", buffer, depth, &info->description))
2021 return False;
2022 if(!prs_uint32("port_type", ps, depth, &info->port_type))
2023 return False;
2024 if(!prs_uint32("reserved", ps, depth, &info->reserved))
2025 return False;
2026
2027 return True;
2028 }
2029
2030 /*******************************************************************
2031 ********************************************************************/
2032
2033 bool smb_io_printprocessor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_1 *info, int depth)
2034 {
2035 prs_struct *ps=&buffer->prs;
2036
2037 prs_debug(ps, depth, desc, "smb_io_printprocessor_info_1");
2038 depth++;
2039
2040 buffer->struct_start=prs_offset(ps);
2041
2042 if (smb_io_relstr("name", buffer, depth, &info->name))
2043 return False;
2044
2045 return True;
2046 }
2047
2048 /*******************************************************************
2049 ********************************************************************/
2050
2051 bool smb_io_printprocdatatype_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCDATATYPE_1 *info, int depth)
2052 {
2053 prs_struct *ps=&buffer->prs;
2054
2055 prs_debug(ps, depth, desc, "smb_io_printprocdatatype_info_1");
2056 depth++;
2057
2058 buffer->struct_start=prs_offset(ps);
2059
2060 if (smb_io_relstr("name", buffer, depth, &info->name))
2061 return False;
2062
2063 return True;
2064 }
2065
2066 /*******************************************************************
2067 ********************************************************************/
2068
2069 bool smb_io_printmonitor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_1 *info, int depth)
2070 {
2071 prs_struct *ps=&buffer->prs;
2072
2073 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_1");
2074 depth++;
2075
2076 buffer->struct_start=prs_offset(ps);
2077
2078 if (!smb_io_relstr("name", buffer, depth, &info->name))
2079 return False;
2080
2081 return True;
2082 }
2083
2084 /*******************************************************************
2085 ********************************************************************/
2086
2087 bool smb_io_printmonitor_info_2(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_2 *info, int depth)
2088 {
2089 prs_struct *ps=&buffer->prs;
2090
2091 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_2");
2092 depth++;
2093
2094 buffer->struct_start=prs_offset(ps);
2095
2096 if (!smb_io_relstr("name", buffer, depth, &info->name))
2097 return False;
2098 if (!smb_io_relstr("environment", buffer, depth, &info->environment))
2099 return False;
2100 if (!smb_io_relstr("dll_name", buffer, depth, &info->dll_name))
2101 return False;
2102
2103 return True;
2104 }
2105
2106 /*******************************************************************
2107 return the size required by a struct in the stream
2108 ********************************************************************/
2109
2110 uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
2111 {
2112 int size=0;
2113
2114 size+=size_of_relative_string( &info->printername );
2115 size+=size_of_relative_string( &info->servername );
2116
2117 size+=size_of_uint32( &info->cjobs);
2118 size+=size_of_uint32( &info->total_jobs);
2119 size+=size_of_uint32( &info->total_bytes);
2120
2121 size+=size_of_uint16( &info->year);
2122 size+=size_of_uint16( &info->month);
2123 size+=size_of_uint16( &info->dayofweek);
2124 size+=size_of_uint16( &info->day);
2125 size+=size_of_uint16( &info->hour);
2126 size+=size_of_uint16( &info->minute);
2127 size+=size_of_uint16( &info->second);
2128 size+=size_of_uint16( &info->milliseconds);
2129
2130 size+=size_of_uint32( &info->global_counter);
2131 size+=size_of_uint32( &info->total_pages);
2132
2133 size+=size_of_uint16( &info->major_version);
2134 size+=size_of_uint16( &info->build_version);
2135
2136 size+=size_of_uint32( &info->unknown7);
2137 size+=size_of_uint32( &info->unknown8);
2138 size+=size_of_uint32( &info->unknown9);
2139 size+=size_of_uint32( &info->session_counter);
2140 size+=size_of_uint32( &info->unknown11);
2141 size+=size_of_uint32( &info->printer_errors);
2142 size+=size_of_uint32( &info->unknown13);
2143 size+=size_of_uint32( &info->unknown14);
2144 size+=size_of_uint32( &info->unknown15);
2145 size+=size_of_uint32( &info->unknown16);
2146 size+=size_of_uint32( &info->change_id);
2147 size+=size_of_uint32( &info->unknown18);
2148 size+=size_of_uint32( &info->status);
2149 size+=size_of_uint32( &info->unknown20);
2150 size+=size_of_uint32( &info->c_setprinter);
2151
2152 size+=size_of_uint16( &info->unknown22);
2153 size+=size_of_uint16( &info->unknown23);
2154 size+=size_of_uint16( &info->unknown24);
2155 size+=size_of_uint16( &info->unknown25);
2156 size+=size_of_uint16( &info->unknown26);
2157 size+=size_of_uint16( &info->unknown27);
2158 size+=size_of_uint16( &info->unknown28);
2159 size+=size_of_uint16( &info->unknown29);
2160
2161 return size;
2162 }
2163
2164 /*******************************************************************
2165 return the size required by a struct in the stream
2166 ********************************************************************/
2167
2168 uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
2169 {
2170 int size=0;
2171
2172 size+=size_of_uint32( &info->flags );
2173 size+=size_of_relative_string( &info->description );
2174 size+=size_of_relative_string( &info->name );
2175 size+=size_of_relative_string( &info->comment );
2176
2177 return size;
2178 }
2179
2180 /*******************************************************************
2181 return the size required by a struct in the stream
2182 ********************************************************************/
2183
2184 uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
2185 {
2186 uint32 size=0;
2187
2188 size += 4;
2189
2190 size += ndr_size_security_descriptor( info->secdesc, NULL, 0 );
2191
2192 size+=size_of_device_mode( info->devmode );
2193
2194 size+=size_of_relative_string( &info->servername );
2195 size+=size_of_relative_string( &info->printername );
2196 size+=size_of_relative_string( &info->sharename );
2197 size+=size_of_relative_string( &info->portname );
2198 size+=size_of_relative_string( &info->drivername );
2199 size+=size_of_relative_string( &info->comment );
2200 size+=size_of_relative_string( &info->location );
2201
2202 size+=size_of_relative_string( &info->sepfile );
2203 size+=size_of_relative_string( &info->printprocessor );
2204 size+=size_of_relative_string( &info->datatype );
2205 size+=size_of_relative_string( &info->parameters );
2206
2207 size+=size_of_uint32( &info->attributes );
2208 size+=size_of_uint32( &info->priority );
2209 size+=size_of_uint32( &info->defaultpriority );
2210 size+=size_of_uint32( &info->starttime );
2211 size+=size_of_uint32( &info->untiltime );
2212 size+=size_of_uint32( &info->status );
2213 size+=size_of_uint32( &info->cjobs );
2214 size+=size_of_uint32( &info->averageppm );
2215
2216 /*
2217 * add any adjustments for alignment. This is
2218 * not optimal since we could be calling this
2219 * function from a loop (e.g. enumprinters), but
2220 * it is easier to maintain the calculation here and
2221 * not place the burden on the caller to remember. --jerry
2222 */
2223 if ((size % 4) != 0)
2224 size += 4 - (size % 4);
2225
2226 return size;
2227 }
2228
2229 /*******************************************************************
2230 return the size required by a struct in the stream
2231 ********************************************************************/
2232
2233 uint32 spoolss_size_printer_info_4(PRINTER_INFO_4 *info)
2234 {
2235 uint32 size=0;
2236
2237 size+=size_of_relative_string( &info->printername );
2238 size+=size_of_relative_string( &info->servername );
2239
2240 size+=size_of_uint32( &info->attributes );
2241 return size;
2242 }
2243
2244 /*******************************************************************
2245 return the size required by a struct in the stream
2246 ********************************************************************/
2247
2248 uint32 spoolss_size_printer_info_5(PRINTER_INFO_5 *info)
2249 {
2250 uint32 size=0;
2251
2252 size+=size_of_relative_string( &info->printername );
2253 size+=size_of_relative_string( &info->portname );
2254
2255 size+=size_of_uint32( &info->attributes );
2256 size+=size_of_uint32( &info->device_not_selected_timeout );
2257 size+=size_of_uint32( &info->transmission_retry_timeout );
2258 return size;
2259 }
2260
2261 /*******************************************************************
2262 return the size required by a struct in the stream
2263 ********************************************************************/
2264
2265 uint32 spoolss_size_printer_info_6(PRINTER_INFO_6 *info)
2266 {
2267 return sizeof(uint32);
2268 }
2269
2270 /*******************************************************************
2271 return the size required by a struct in the stream
2272 ********************************************************************/
2273
2274 uint32 spoolss_size_printer_info_3(PRINTER_INFO_3 *info)
2275 {
2276 /* The 8 is for the self relative pointer - 8 byte aligned.. */
2277 return 8 + (uint32)ndr_size_security_descriptor( info->secdesc, NULL, 0 );
2278 }
2279
2280 /*******************************************************************
2281 return the size required by a struct in the stream
2282 ********************************************************************/
2283
2284 uint32 spoolss_size_printer_info_7(PRINTER_INFO_7 *info)
2285 {
2286 uint32 size=0;
2287
2288 size+=size_of_relative_string( &info->guid );
2289 size+=size_of_uint32( &info->action );
2290 return size;
2291 }
2292
2293 /*******************************************************************
2294 return the size required by a struct in the stream
2295 ********************************************************************/
2296
2297 uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
2298 {
2299 int size=0;
2300 size+=size_of_relative_string( &info->name );
2301
2302 return size;
2303 }
2304
2305 /*******************************************************************
2306 return the size required by a struct in the stream
2307 ********************************************************************/
2308
2309 uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
2310 {
2311 int size=0;
2312 size+=size_of_uint32( &info->version );
2313 size+=size_of_relative_string( &info->name );
2314 size+=size_of_relative_string( &info->architecture );
2315 size+=size_of_relative_string( &info->driverpath );
2316 size+=size_of_relative_string( &info->datafile );
2317 size+=size_of_relative_string( &info->configfile );
2318
2319 return size;
2320 }
2321
2322 /*******************************************************************
2323 return the size required by a string array.
2324 ********************************************************************/
2325
2326 uint32 spoolss_size_string_array(uint16 *string)
2327 {
2328 uint32 i = 0;
2329
2330 if (string) {
2331 for (i=0; (string[i]!=0x0000) || (string[i+1]!=0x0000); i++);
2332 }
2333 i=i+2; /* to count all chars including the leading zero */
2334 i=2*i; /* because we need the value in bytes */
2335 i=i+4; /* the offset pointer size */
2336
2337 return i;
2338 }
2339
2340 /*******************************************************************
2341 return the size required by a struct in the stream
2342 ********************************************************************/
2343
2344 uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
2345 {
2346 int size=0;
2347
2348 size+=size_of_uint32( &info->version );
2349 size+=size_of_relative_string( &info->name );
2350 size+=size_of_relative_string( &info->architecture );
2351 size+=size_of_relative_string( &info->driverpath );
2352 size+=size_of_relative_string( &info->datafile );
2353 size+=size_of_relative_string( &info->configfile );
2354 size+=size_of_relative_string( &info->helpfile );
2355 size+=size_of_relative_string( &info->monitorname );
2356 size+=size_of_relative_string( &info->defaultdatatype );
2357
2358 size+=spoolss_size_string_array(info->dependentfiles);
2359
2360 return size;
2361 }
2362
2363 /*******************************************************************
2364 return the size required by a struct in the stream
2365 ********************************************************************/
2366
2367 uint32 spoolss_size_printer_driver_info_6(DRIVER_INFO_6 *info)
2368 {
2369 uint32 size=0;
2370
2371 size+=size_of_uint32( &info->version );
2372 size+=size_of_relative_string( &info->name );
2373 size+=size_of_relative_string( &info->architecture );
2374 size+=size_of_relative_string( &info->driverpath );
2375 size+=size_of_relative_string( &info->datafile );
2376 size+=size_of_relative_string( &info->configfile );
2377 size+=size_of_relative_string( &info->helpfile );
2378
2379 size+=spoolss_size_string_array(info->dependentfiles);
2380
2381 size+=size_of_relative_string( &info->monitorname );
2382 size+=size_of_relative_string( &info->defaultdatatype );
2383
2384 size+=spoolss_size_string_array(info->previousdrivernames);
2385
2386 size+=size_of_nttime(&info->driver_date);
2387 size+=size_of_uint32( &info->padding );
2388 size+=size_of_uint32( &info->driver_version_low );
2389 size+=size_of_uint32( &info->driver_version_high );
2390 size+=size_of_relative_string( &info->mfgname );
2391 size+=size_of_relative_string( &info->oem_url );
2392 size+=size_of_relative_string( &info->hardware_id );
2393 size+=size_of_relative_string( &info->provider );
2394
2395 return size;
2396 }
2397
2398 /*******************************************************************
2399 return the size required by a struct in the stream
2400 ********************************************************************/
2401
2402 uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
2403 {
2404 int size=0;
2405 size+=size_of_uint32( &info->jobid );
2406 size+=size_of_relative_string( &info->printername );
2407 size+=size_of_relative_string( &info->machinename );
2408 size+=size_of_relative_string( &info->username );
2409 size+=size_of_relative_string( &info->document );
2410 size+=size_of_relative_string( &info->datatype );
2411 size+=size_of_relative_string( &info->text_status );
2412 size+=size_of_uint32( &info->status );
2413 size+=size_of_uint32( &info->priority );
2414 size+=size_of_uint32( &info->position );
2415 size+=size_of_uint32( &info->totalpages );
2416 size+=size_of_uint32( &info->pagesprinted );
2417 size+=size_of_systemtime( &info->submitted );
2418
2419 return size;
2420 }
2421
2422 /*******************************************************************
2423 return the size required by a struct in the stream
2424 ********************************************************************/
2425
2426 uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
2427 {
2428 int size=0;
2429
2430 size+=4; /* size of sec desc ptr */
2431
2432 size+=size_of_uint32( &info->jobid );
2433 size+=size_of_relative_string( &info->printername );
2434 size+=size_of_relative_string( &info->machinename );
2435 size+=size_of_relative_string( &info->username );
2436 size+=size_of_relative_string( &info->document );
2437 size+=size_of_relative_string( &info->notifyname );
2438 size+=size_of_relative_string( &info->datatype );
2439 size+=size_of_relative_string( &info->printprocessor );
2440 size+=size_of_relative_string( &info->parameters );
2441 size+=size_of_relative_string( &info->drivername );
2442 size+=size_of_device_mode( info->devmode );
2443 size+=size_of_relative_string( &info->text_status );
2444 /* SEC_DESC sec_desc;*/
2445 size+=size_of_uint32( &info->status );
2446 size+=size_of_uint32( &info->priority );
2447 size+=size_of_uint32( &info->position );
2448 size+=size_of_uint32( &info->starttime );
2449 size+=size_of_uint32( &info->untiltime );
2450 size+=size_of_uint32( &info->totalpages );
2451 size+=size_of_uint32( &info->size );
2452 size+=size_of_systemtime( &info->submitted );
2453 size+=size_of_uint32( &info->timeelapsed );
2454 size+=size_of_uint32( &info->pagesprinted );
2455
2456 return size;
2457 }
2458
2459 /*******************************************************************
2460 return the size required by a struct in the stream
2461 ********************************************************************/
2462
2463 uint32 spoolss_size_form_1(FORM_1 *info)
2464 {
2465 int size=0;
2466
2467 size+=size_of_uint32( &info->flag );
2468 size+=size_of_relative_string( &info->name );
2469 size+=size_of_uint32( &info->width );
2470 size+=size_of_uint32( &info->length );
2471 size+=size_of_uint32( &info->left );
2472 size+=size_of_uint32( &info->top );
2473 size+=size_of_uint32( &info->right );
2474 size+=size_of_uint32( &info->bottom );
2475
2476 return size;
2477 }
2478
2479 /*******************************************************************
2480 return the size required by a struct in the stream
2481 ********************************************************************/
2482
2483 uint32 spoolss_size_port_info_1(PORT_INFO_1 *info)
2484 {
2485 int size=0;
2486
2487 size+=size_of_relative_string( &info->port_name );
2488
2489 return size;
2490 }
2491
2492 /*******************************************************************
2493 return the size required by a struct in the stream
2494 ********************************************************************/
2495
2496 uint32 spoolss_size_driverdir_info_1(DRIVER_DIRECTORY_1 *info)
2497 {
2498 int size=0;
2499
2500 size=str_len_uni(&info->name); /* the string length */
2501 size=size+1; /* add the leading zero */
2502 size=size*2; /* convert in char */
2503
2504 return size;
2505 }
2506
2507 /*******************************************************************
2508 return the size required by a struct in the stream
2509 ********************************************************************/
2510
2511 uint32 spoolss_size_printprocessordirectory_info_1(PRINTPROCESSOR_DIRECTORY_1 *info)
2512 {
2513 int size=0;
2514
2515 size=str_len_uni(&info->name); /* the string length */
2516 size=size+1; /* add the leading zero */
2517 size=size*2; /* convert in char */
2518
2519 return size;
2520 }
2521
2522 /*******************************************************************
2523 return the size required by a struct in the stream
2524 ********************************************************************/
2525
2526 uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
2527 {
2528 int size=0;
2529
2530 size+=size_of_relative_string( &info->port_name );
2531 size+=size_of_relative_string( &info->monitor_name );
2532 size+=size_of_relative_string( &info->description );
2533
2534 size+=size_of_uint32( &info->port_type );
2535 size+=size_of_uint32( &info->reserved );
2536
2537 return size;
2538 }
2539
2540 /*******************************************************************
2541 return the size required by a struct in the stream
2542 ********************************************************************/
2543
2544 uint32 spoolss_size_printprocessor_info_1(PRINTPROCESSOR_1 *info)
2545 {
2546 int size=0;
2547 size+=size_of_relative_string( &info->name );
2548
2549 return size;
2550 }
2551
2552 /*******************************************************************
2553 return the size required by a struct in the stream
2554 ********************************************************************/
2555
2556 uint32 spoolss_size_printprocdatatype_info_1(PRINTPROCDATATYPE_1 *info)
2557 {
2558 int size=0;
2559 size+=size_of_relative_string( &info->name );
2560
2561 return size;
2562 }
2563
2564 /*******************************************************************
2565 return the size required by a struct in the stream
2566 ********************************************************************/
2567 uint32 spoolss_size_printer_enum_values(PRINTER_ENUM_VALUES *p)
2568 {
2569 uint32 size = 0;
2570
2571 if (!p)
2572 return 0;
2573
2574 /* uint32(offset) + uint32(length) + length) */
2575 size += (size_of_uint32(&p->value_len)*2) + p->value_len;
2576 size += (size_of_uint32(&p->data_len)*2) + p->data_len + (p->data_len%2) ;
2577
2578 size += size_of_uint32(&p->type);
2579
2580 return size;
2581 }
2582
2583 /*******************************************************************
2584 return the size required by a struct in the stream
2585 ********************************************************************/
2586
2587 uint32 spoolss_size_printmonitor_info_1(PRINTMONITOR_1 *info)
2588 {
2589 int size=0;
2590 size+=size_of_relative_string( &info->name );
2591
2592 return size;
2593 }
2594
2595 /*******************************************************************
2596 return the size required by a struct in the stream
2597 ********************************************************************/
2598
2599 uint32 spoolss_size_printmonitor_info_2(PRINTMONITOR_2 *info)
2600 {
2601 int size=0;
2602 size+=size_of_relative_string( &info->name);
2603 size+=size_of_relative_string( &info->environment);
2604 size+=size_of_relative_string( &info->dll_name);
2605
2606 return size;
2607 }
2608
2609 /*******************************************************************
2610 * init a structure.
2611 ********************************************************************/
2612
2613 bool make_spoolss_q_getprinterdriver2(SPOOL_Q_GETPRINTERDRIVER2 *q_u,
2614 const POLICY_HND *hnd,
2615 const fstring architecture,
2616 uint32 level, uint32 clientmajor, uint32 clientminor,
2617 RPC_BUFFER *buffer, uint32 offered)
2618 {
2619 if (q_u == NULL)
2620 return False;
2621
2622 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
2623
2624 init_buf_unistr2(&q_u->architecture, &q_u->architecture_ptr, architecture);
2625
2626 q_u->level=level;
2627 q_u->clientmajorversion=clientmajor;
2628 q_u->clientminorversion=clientminor;
2629
2630 q_u->buffer=buffer;
2631 q_u->offered=offered;
2632
2633 return True;
2634 }
2635
2636 /*******************************************************************
2637 * read a structure.
2638 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
2639 ********************************************************************/
2640
2641 bool spoolss_io_q_getprinterdriver2(const char *desc, SPOOL_Q_GETPRINTERDRIVER2 *q_u, prs_struct *ps, int depth)
2642 {
2643 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriver2");
2644 depth++;
2645
2646 if(!prs_align(ps))
2647 return False;
2648
2649 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
2650 return False;
2651 if(!prs_uint32("architecture_ptr", ps, depth, &q_u->architecture_ptr))
2652 return False;
2653 if(!smb_io_unistr2("architecture", &q_u->architecture, q_u->architecture_ptr, ps, depth))
2654 return False;
2655
2656 if(!prs_align(ps))
2657 return False;
2658 if(!prs_uint32("level", ps, depth, &q_u->level))
2659 return False;
2660
2661 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
2662 return False;
2663
2664 if(!prs_align(ps))
2665 return False;
2666
2667 if(!prs_uint32("offered", ps, depth, &q_u->offered))
2668 return False;
2669
2670 if(!prs_uint32("clientmajorversion", ps, depth, &q_u->clientmajorversion))
2671 return False;
2672 if(!prs_uint32("clientminorversion", ps, depth, &q_u->clientminorversion))
2673 return False;
2674
2675 return True;
2676 }
2677
2678 /*******************************************************************
2679 * read a structure.
2680 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
2681 ********************************************************************/
2682
2683 bool spoolss_io_r_getprinterdriver2(const char *desc, SPOOL_R_GETPRINTERDRIVER2 *r_u, prs_struct *ps, int depth)
2684 {
2685 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriver2");
2686 depth++;
2687
2688 if (!prs_align(ps))
2689 return False;
2690
2691 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
2692 return False;
2693
2694 if (!prs_align(ps))
2695 return False;
2696 if (!prs_uint32("needed", ps, depth, &r_u->needed))
2697 return False;
2698 if (!prs_uint32("servermajorversion", ps, depth, &r_u->servermajorversion))
2699 return False;
2700 if (!prs_uint32("serverminorversion", ps, depth, &r_u->serverminorversion))
2701 return False;
2702 if (!prs_werror("status", ps, depth, &r_u->status))
2703 return False;
2704
2705 return True;
2706 }
2707
2708 /*******************************************************************
2709 * init a structure.
2710 ********************************************************************/
2711
2712 bool make_spoolss_q_enumprinters(
2713 SPOOL_Q_ENUMPRINTERS *q_u,
2714 uint32 flags,
2715 char *servername,
2716 uint32 level,
2717 RPC_BUFFER *buffer,
2718 uint32 offered
2719 )
2720 {
2721 q_u->flags=flags;
2722
2723 q_u->servername_ptr = (servername != NULL) ? 1 : 0;
2724 init_buf_unistr2(&q_u->servername, &q_u->servername_ptr, servername);
2725
2726 q_u->level=level;
2727 q_u->buffer=buffer;
2728 q_u->offered=offered;
2729
2730 return True;
2731 }
2732
2733 /*******************************************************************
2734 * init a structure.
2735 ********************************************************************/
2736
2737 bool make_spoolss_q_enumports(SPOOL_Q_ENUMPORTS *q_u,
2738 fstring servername, uint32 level,
2739 RPC_BUFFER *buffer, uint32 offered)
2740 {
2741 q_u->name_ptr = (servername != NULL) ? 1 : 0;
2742 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
2743
2744 q_u->level=level;
2745 q_u->buffer=buffer;
2746 q_u->offered=offered;
2747
2748 return True;
2749 }
2750
2751 /*******************************************************************
2752 * read a structure.
2753 * called from spoolss_enumprinters (srv_spoolss.c)
2754 ********************************************************************/
2755
2756 bool spoolss_io_q_enumprinters(const char *desc, SPOOL_Q_ENUMPRINTERS *q_u, prs_struct *ps, int depth)
2757 {
2758 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinters");
2759 depth++;
2760
2761 if (!prs_align(ps))
2762 return False;
2763
2764 if (!prs_uint32("flags", ps, depth, &q_u->flags))
2765 return False;
2766 if (!prs_uint32("servername_ptr", ps, depth, &q_u->servername_ptr))
2767 return False;
2768
2769 if (!smb_io_unistr2("", &q_u->servername, q_u->servername_ptr, ps, depth))
2770 return False;
2771
2772 if (!prs_align(ps))
2773 return False;
2774 if (!prs_uint32("level", ps, depth, &q_u->level))
2775 return False;
2776
2777 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
2778 return False;
2779
2780 if (!prs_align(ps))
2781 return False;
2782 if (!prs_uint32("offered", ps, depth, &q_u->offered))
2783 return False;
2784
2785 return True;
2786 }
2787
2788 /*******************************************************************
2789 Parse a SPOOL_R_ENUMPRINTERS structure.
2790 ********************************************************************/
2791
2792 bool spoolss_io_r_enumprinters(const char *desc, SPOOL_R_ENUMPRINTERS *r_u, prs_struct *ps, int depth)
2793 {
2794 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinters");
2795 depth++;
2796
2797 if (!prs_align(ps))
2798 return False;
2799
2800 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
2801 return False;
2802
2803 if (!prs_align(ps))
2804 return False;
2805
2806 if (!prs_uint32("needed", ps, depth, &r_u->needed))
2807 return False;
2808
2809 if (!prs_uint32("returned", ps, depth, &r_u->returned))
2810 return False;
2811
2812 if (!prs_werror("status", ps, depth, &r_u->status))
2813 return False;
2814
2815 return True;
2816 }
2817
2818 /*******************************************************************
2819 * write a structure.
2820 * called from spoolss_r_enum_printers (srv_spoolss.c)
2821 *
2822 ********************************************************************/
2823
2824 bool spoolss_io_r_getprinter(const char *desc, SPOOL_R_GETPRINTER *r_u, prs_struct *ps, int depth)
2825 {
2826 prs_debug(ps, depth, desc, "spoolss_io_r_getprinter");
2827 depth++;
2828
2829 if (!prs_align(ps))
2830 return False;
2831
2832 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
2833 return False;
2834
2835 if (!prs_align(ps))
2836 return False;
2837
2838 if (!prs_uint32("needed", ps, depth, &r_u->needed))
2839 return False;
2840
2841 if (!prs_werror("status", ps, depth, &r_u->status))
2842 return False;
2843
2844 return True;
2845 }
2846
2847 /*******************************************************************
2848 * read a structure.
2849 * called from spoolss_getprinter (srv_spoolss.c)
2850 ********************************************************************/
2851
2852 bool spoolss_io_q_getprinter(const char *desc, SPOOL_Q_GETPRINTER *q_u, prs_struct *ps, int depth)
2853 {
2854 prs_debug(ps, depth, desc, "spoolss_io_q_getprinter");
2855 depth++;
2856
2857 if (!prs_align(ps))
2858 return False;
2859
2860 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
2861 return False;
2862 if (!prs_uint32("level", ps, depth, &q_u->level))
2863 return False;
2864
2865 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
2866 return False;
2867
2868 if (!prs_align(ps))
2869 return False;
2870 if (!prs_uint32("offered", ps, depth, &q_u->offered))
2871 return False;
2872
2873 return True;
2874 }
2875
2876 /*******************************************************************
2877 * init a structure.
2878 ********************************************************************/
2879
2880 bool make_spoolss_q_getprinter(
2881 TALLOC_CTX *mem_ctx,
2882 SPOOL_Q_GETPRINTER *q_u,
2883 const POLICY_HND *hnd,
2884 uint32 level,
2885 RPC_BUFFER *buffer,
2886 uint32 offered
2887 )
2888 {
2889 if (q_u == NULL)
2890 {
2891 return False;
2892 }
2893 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
2894
2895 q_u->level=level;
2896 q_u->buffer=buffer;
2897 q_u->offered=offered;
2898
2899 return True;
2900 }
2901
2902 /*******************************************************************
2903 * init a structure.
2904 ********************************************************************/
2905 bool make_spoolss_q_setprinter(TALLOC_CTX *mem_ctx, SPOOL_Q_SETPRINTER *q_u,
2906 const POLICY_HND *hnd, uint32 level, PRINTER_INFO_CTR *info,
2907 uint32 command)
2908 {
2909 SEC_DESC *secdesc;
2910 DEVICEMODE *devmode;
2911
2912 if (!q_u || !info)
2913 return False;
2914
2915 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
2916
2917 q_u->level = level;
2918 q_u->info.level = level;
2919 q_u->info.info_ptr = 1; /* Info is != NULL, see above */
2920 switch (level) {
2921
2922 /* There's no such thing as a setprinter level 1 */
2923
2924 case 2:
2925 secdesc = info->printers_2->secdesc;
2926 devmode = info->printers_2->devmode;
2927
2928 make_spoolss_printer_info_2 (mem_ctx, &q_u->info.info_2, info->printers_2);
2929 #if 1 /* JERRY TEST */
2930 q_u->secdesc_ctr = SMB_MALLOC_P(SEC_DESC_BUF);
2931 if (!q_u->secdesc_ctr)
2932 return False;
2933 q_u->secdesc_ctr->sd = secdesc;
2934 q_u->secdesc_ctr->sd_size = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
2935
2936 q_u->devmode_ctr.devmode_ptr = (devmode != NULL) ? 1 : 0;
2937 q_u->devmode_ctr.size = (devmode != NULL) ? sizeof(DEVICEMODE) + (3*sizeof(uint32)) : 0;
2938 q_u->devmode_ctr.devmode = devmode;
2939 #else
2940 q_u->secdesc_ctr = NULL;
2941
2942 q_u->devmode_ctr.devmode_ptr = 0;
2943 q_u->devmode_ctr.size = 0;
2944 q_u->devmode_ctr.devmode = NULL;
2945 #endif
2946 break;
2947 case 3:
2948 secdesc = info->printers_3->secdesc;
2949
2950 make_spoolss_printer_info_3 (mem_ctx, &q_u->info.info_3, info->printers_3);
2951
2952 q_u->secdesc_ctr = SMB_MALLOC_P(SEC_DESC_BUF);
2953 if (!q_u->secdesc_ctr)
2954 return False;
2955 q_u->secdesc_ctr->sd_size = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
2956 q_u->secdesc_ctr->sd = secdesc;
2957
2958 break;
2959 case 7:
2960 make_spoolss_printer_info_7 (mem_ctx, &q_u->info.info_7, info->printers_7);
2961 break;
2962
2963 default:
2964 DEBUG(0,("make_spoolss_q_setprinter: Unknown info level [%d]\n", level));
2965 break;
2966 }
2967
2968
2969 q_u->command = command;
2970
2971 return True;
2972 }
2973
2974
2975 /*******************************************************************
2976 ********************************************************************/
2977
2978 bool spoolss_io_r_setprinter(const char *desc, SPOOL_R_SETPRINTER *r_u, prs_struct *ps, int depth)
2979 {
2980 prs_debug(ps, depth, desc, "spoolss_io_r_setprinter");
2981 depth++;
2982
2983 if(!prs_align(ps))
2984 return False;
2985
2986 if(!prs_werror("status", ps, depth, &r_u->status))
2987 return False;
2988
2989 return True;
2990 }
2991
2992 /*******************************************************************
2993 Marshall/unmarshall a SPOOL_Q_SETPRINTER struct.
2994 ********************************************************************/
2995
2996 bool spoolss_io_q_setprinter(const char *desc, SPOOL_Q_SETPRINTER *q_u, prs_struct *ps, int depth)
2997 {
2998 uint32 ptr_sec_desc = 0;
2999
3000 prs_debug(ps, depth, desc, "spoolss_io_q_setprinter");
3001 depth++;
3002
3003 if(!prs_align(ps))
3004 return False;
3005
3006 if(!smb_io_pol_hnd("printer handle", &q_u->handle ,ps, depth))
3007 return False;
3008 if(!prs_uint32("level", ps, depth, &q_u->level))
3009 return False;
3010
3011 /* check for supported levels and structures we know about */
3012
3013 switch ( q_u->level ) {
3014 case 0:
3015 case 2:
3016 case 3:
3017 case 7:
3018 /* supported levels */
3019 break;
3020 default:
3021 DEBUG(0,("spoolss_io_q_setprinter: unsupported printer info level [%d]\n",
3022 q_u->level));
3023 return True;
3024 }
3025
3026
3027 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
3028 return False;
3029
3030 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
3031 return False;
3032
3033 if(!prs_align(ps))
3034 return False;
3035
3036 switch (q_u->level)
3037 {
3038 case 2:
3039 {
3040 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
3041 break;
3042 }
3043 case 3:
3044 {
3045 /* FIXME ! Our parsing here is wrong I think,
3046 * but for a level3 it makes no sense for
3047 * ptr_sec_desc to be NULL. JRA. Based on
3048 * a Vista sniff from Martin Zielinski <mz@seh.de>.
3049 */
3050 if (UNMARSHALLING(ps)) {
3051 ptr_sec_desc = 1;
3052 } else {
3053 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
3054 }
3055 break;
3056 }
3057 }
3058 if (ptr_sec_desc)
3059 {
3060 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
3061 return False;
3062 } else {
3063 uint32 dummy = 0;
3064
3065 /* Parse a NULL security descriptor. This should really
3066 happen inside the sec_io_desc_buf() function. */
3067
3068 prs_debug(ps, depth, "", "sec_io_desc_buf");
3069 if (!prs_uint32("size", ps, depth + 1, &dummy))
3070 return False;
3071 if (!prs_uint32("ptr", ps, depth + 1, &dummy))
3072 return False;
3073 }
3074
3075 if(!prs_uint32("command", ps, depth, &q_u->command))
3076 return False;
3077
3078 return True;
3079 }
3080
3081 /*******************************************************************
3082 ********************************************************************/
3083
3084 bool spoolss_io_r_enumjobs(const char *desc, SPOOL_R_ENUMJOBS *r_u, prs_struct *ps, int depth)
3085 {
3086 prs_debug(ps, depth, desc, "spoolss_io_r_enumjobs");
3087 depth++;
3088
3089 if (!prs_align(ps))
3090 return False;
3091
3092 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3093 return False;
3094
3095 if (!prs_align(ps))
3096 return False;
3097
3098 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3099 return False;
3100
3101 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3102 return False;
3103
3104 if (!prs_werror("status", ps, depth, &r_u->status))
3105 return False;
3106
3107 return True;
3108 }
3109
3110 /*******************************************************************
3111 ********************************************************************/
3112
3113 bool make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS *q_u, const POLICY_HND *hnd,
3114 uint32 firstjob,
3115 uint32 numofjobs,
3116 uint32 level,
3117 RPC_BUFFER *buffer,
3118 uint32 offered)
3119 {
3120 if (q_u == NULL)
3121 {
3122 return False;
3123 }
3124 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3125 q_u->firstjob = firstjob;
3126 q_u->numofjobs = numofjobs;
3127 q_u->level = level;
3128 q_u->buffer= buffer;
3129 q_u->offered = offered;
3130 return True;
3131 }
3132
3133 /*******************************************************************
3134 ********************************************************************/
3135
3136 bool spoolss_io_q_enumjobs(const char *desc, SPOOL_Q_ENUMJOBS *q_u, prs_struct *ps, int depth)
3137 {
3138 prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs");
3139 depth++;
3140
3141 if (!prs_align(ps))
3142 return False;
3143
3144 if (!smb_io_pol_hnd("printer handle",&q_u->handle, ps, depth))
3145 return False;
3146
3147 if (!prs_uint32("firstjob", ps, depth, &q_u->firstjob))
3148 return False;
3149 if (!prs_uint32("numofjobs", ps, depth, &q_u->numofjobs))
3150 return False;
3151 if (!prs_uint32("level", ps, depth, &q_u->level))
3152 return False;
3153
3154 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3155 return False;
3156
3157 if(!prs_align(ps))
3158 return False;
3159
3160 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3161 return False;
3162
3163 return True;
3164 }
3165
3166 /*******************************************************************
3167 Parse a SPOOL_R_ENUMPRINTERDRIVERS structure.
3168 ********************************************************************/
3169
3170 bool spoolss_io_r_enumprinterdrivers(const char *desc, SPOOL_R_ENUMPRINTERDRIVERS *r_u, prs_struct *ps, int depth)
3171 {
3172 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdrivers");
3173 depth++;
3174
3175 if (!prs_align(ps))
3176 return False;
3177
3178 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3179 return False;
3180
3181 if (!prs_align(ps))
3182 return False;
3183
3184 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3185 return False;
3186
3187 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3188 return False;
3189
3190 if (!prs_werror("status", ps, depth, &r_u->status))
3191 return False;
3192
3193 return True;
3194 }
3195
3196 /*******************************************************************
3197 * init a structure.
3198 ********************************************************************/
3199
3200 bool make_spoolss_q_enumprinterdrivers(SPOOL_Q_ENUMPRINTERDRIVERS *q_u,
3201 const char *name,
3202 const char *environment,
3203 uint32 level,
3204 RPC_BUFFER *buffer, uint32 offered)
3205 {
3206 init_buf_unistr2(&q_u->name, &q_u->name_ptr, name);
3207 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, environment);
3208
3209 q_u->level=level;
3210 q_u->buffer=buffer;
3211 q_u->offered=offered;
3212
3213 return True;
3214 }
3215
3216 /*******************************************************************
3217 Parse a SPOOL_Q_ENUMPRINTERDRIVERS structure.
3218 ********************************************************************/
3219
3220 bool spoolss_io_q_enumprinterdrivers(const char *desc, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, prs_struct *ps, int depth)
3221 {
3222
3223 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdrivers");
3224 depth++;
3225
3226 if (!prs_align(ps))
3227 return False;
3228
3229 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
3230 return False;
3231 if (!smb_io_unistr2("", &q_u->name, q_u->name_ptr,ps, depth))
3232 return False;
3233
3234 if (!prs_align(ps))
3235 return False;
3236 if (!prs_uint32("environment_ptr", ps, depth, &q_u->environment_ptr))
3237 return False;
3238 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
3239 return False;
3240
3241 if (!prs_align(ps))
3242 return False;
3243 if (!prs_uint32("level", ps, depth, &q_u->level))
3244 return False;
3245
3246 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3247 return False;
3248
3249 if (!prs_align(ps))
3250 return False;
3251
3252 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3253 return False;
3254
3255 return True;
3256 }
3257
3258 /*******************************************************************
3259 ********************************************************************/
3260
3261 bool spoolss_io_q_enumforms(const char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth)
3262 {
3263
3264 prs_debug(ps, depth, desc, "spoolss_io_q_enumforms");
3265 depth++;
3266
3267 if (!prs_align(ps))
3268 return False;
3269 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
3270 return False;
3271 if (!prs_uint32("level", ps, depth, &q_u->level))
3272 return False;
3273
3274 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3275 return False;
3276
3277 if (!prs_align(ps))
3278 return False;
3279 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3280 return False;
3281
3282 return True;
3283 }
3284
3285 /*******************************************************************
3286 ********************************************************************/
3287
3288 bool spoolss_io_r_enumforms(const char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth)
3289 {
3290 prs_debug(ps, depth, desc, "spoolss_io_r_enumforms");
3291 depth++;
3292
3293 if (!prs_align(ps))
3294 return False;
3295
3296 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3297 return False;
3298
3299 if (!prs_align(ps))
3300 return False;
3301
3302 if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
3303 return False;
3304
3305 if (!prs_uint32("numofforms", ps, depth, &r_u->numofforms))
3306 return False;
3307
3308 if (!prs_werror("status", ps, depth, &r_u->status))
3309 return False;
3310
3311 return True;
3312 }
3313
3314 /*******************************************************************
3315 Parse a SPOOL_R_ENUMPORTS structure.
3316 ********************************************************************/
3317
3318 bool spoolss_io_r_enumports(const char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
3319 {
3320 prs_debug(ps, depth, desc, "spoolss_io_r_enumports");
3321 depth++;
3322
3323 if (!prs_align(ps))
3324 return False;
3325
3326 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3327 return False;
3328
3329 if (!prs_align(ps))
3330 return False;
3331
3332 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3333 return False;
3334
3335 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3336 return False;
3337
3338 if (!prs_werror("status", ps, depth, &r_u->status))
3339 return False;
3340
3341 return True;
3342 }
3343
3344 /*******************************************************************
3345 ********************************************************************/
3346
3347 bool spoolss_io_q_enumports(const char *desc, SPOOL_Q_ENUMPORTS *q_u, prs_struct *ps, int depth)
3348 {
3349 prs_debug(ps, depth, desc, "");
3350 depth++;
3351
3352 if (!prs_align(ps))
3353 return False;
3354
3355 if (!prs_uint32("", ps, depth, &q_u->name_ptr))
3356 return False;
3357 if (!smb_io_unistr2("", &q_u->name,True,ps,depth))
3358 return False;
3359
3360 if (!prs_align(ps))
3361 return False;
3362 if (!prs_uint32("level", ps, depth, &q_u->level))
3363 return False;
3364
3365 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3366 return False;
3367
3368 if (!prs_align(ps))
3369 return False;
3370 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3371 return False;
3372
3373 return True;
3374 }
3375
3376 /*******************************************************************
3377 Parse a SPOOL_PRINTER_INFO_LEVEL_1 structure.
3378 ********************************************************************/
3379
3380 bool spool_io_printer_info_level_1(const char *desc, SPOOL_PRINTER_INFO_LEVEL_1 *il, prs_struct *ps, int depth)
3381 {
3382 prs_debug(ps, depth, desc, "spool_io_printer_info_level_1");
3383 depth++;
3384
3385 if(!prs_align(ps))
3386 return False;
3387
3388 if(!prs_uint32("flags", ps, depth, &il->flags))
3389 return False;
3390 if(!prs_uint32("description_ptr", ps, depth, &il->description_ptr))
3391 return False;
3392 if(!prs_uint32("name_ptr", ps, depth, &il->name_ptr))
3393 return False;
3394 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
3395 return False;
3396
3397 if(!smb_io_unistr2("description", &il->description, il->description_ptr, ps, depth))
3398 return False;
3399 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
3400 return False;
3401 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
3402 return False;
3403
3404 return True;
3405 }
3406
3407 /*******************************************************************
3408 Parse a SPOOL_PRINTER_INFO_LEVEL_3 structure.
3409 ********************************************************************/
3410
3411 bool spool_io_printer_info_level_3(const char *desc, SPOOL_PRINTER_INFO_LEVEL_3 *il, prs_struct *ps, int depth)
3412 {
3413 prs_debug(ps, depth, desc, "spool_io_printer_info_level_3");
3414 depth++;
3415
3416 if(!prs_align(ps))
3417 return False;
3418
3419 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
3420 return False;
3421
3422 return True;
3423 }
3424
3425 /*******************************************************************
3426 Parse a SPOOL_PRINTER_INFO_LEVEL_2 structure.
3427 ********************************************************************/
3428
3429 bool spool_io_printer_info_level_2(const char *desc, SPOOL_PRINTER_INFO_LEVEL_2 *il, prs_struct *ps, int depth)
3430 {
3431 prs_debug(ps, depth, desc, "spool_io_printer_info_level_2");
3432 depth++;
3433
3434 if(!prs_align(ps))
3435 return False;
3436
3437 if(!prs_uint32("servername_ptr", ps, depth, &il->servername_ptr))
3438 return False;
3439 if(!prs_uint32("printername_ptr", ps, depth, &il->printername_ptr))
3440 return False;
3441 if(!prs_uint32("sharename_ptr", ps, depth, &il->sharename_ptr))
3442 return False;
3443 if(!prs_uint32("portname_ptr", ps, depth, &il->portname_ptr))
3444 return False;
3445
3446 if(!prs_uint32("drivername_ptr", ps, depth, &il->drivername_ptr))
3447 return False;
3448 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
3449 return False;
3450 if(!prs_uint32("location_ptr", ps, depth, &il->location_ptr))
3451 return False;
3452 if(!prs_uint32("devmode_ptr", ps, depth, &il->devmode_ptr))
3453 return False;
3454 if(!prs_uint32("sepfile_ptr", ps, depth, &il->sepfile_ptr))
3455 return False;
3456 if(!prs_uint32("printprocessor_ptr", ps, depth, &il->printprocessor_ptr))
3457 return False;
3458 if(!prs_uint32("datatype_ptr", ps, depth, &il->datatype_ptr))
3459 return False;
3460 if(!prs_uint32("parameters_ptr", ps, depth, &il->parameters_ptr))
3461 return False;
3462 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
3463 return False;
3464
3465 if(!prs_uint32("attributes", ps, depth, &il->attributes))
3466 return False;
3467 if(!prs_uint32("priority", ps, depth, &il->priority))
3468 return False;
3469 if(!prs_uint32("default_priority", ps, depth, &il->default_priority))
3470 return False;
3471 if(!prs_uint32("starttime", ps, depth, &il->starttime))
3472 return False;
3473 if(!prs_uint32("untiltime", ps, depth, &il->untiltime))
3474 return False;
3475 if(!prs_uint32("status", ps, depth, &il->status))
3476 return False;
3477 if(!prs_uint32("cjobs", ps, depth, &il->cjobs))
3478 return False;
3479 if(!prs_uint32("averageppm", ps, depth, &il->averageppm))
3480 return False;
3481
3482 if(!smb_io_unistr2("servername", &il->servername, il->servername_ptr, ps, depth))
3483 return False;
3484 if(!smb_io_unistr2("printername", &il->printername, il->printername_ptr, ps, depth))
3485 return False;
3486 if(!smb_io_unistr2("sharename", &il->sharename, il->sharename_ptr, ps, depth))
3487 return False;
3488 if(!smb_io_unistr2("portname", &il->portname, il->portname_ptr, ps, depth))
3489 return False;
3490 if(!smb_io_unistr2("drivername", &il->drivername, il->drivername_ptr, ps, depth))
3491 return False;
3492 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
3493 return False;
3494 if(!smb_io_unistr2("location", &il->location, il->location_ptr, ps, depth))
3495 return False;
3496 if(!smb_io_unistr2("sepfile", &il->sepfile, il->sepfile_ptr, ps, depth))
3497 return False;
3498 if(!smb_io_unistr2("printprocessor", &il->printprocessor, il->printprocessor_ptr, ps, depth))
3499 return False;
3500 if(!smb_io_unistr2("datatype", &il->datatype, il->datatype_ptr, ps, depth))
3501 return False;
3502 if(!smb_io_unistr2("parameters", &il->parameters, il->parameters_ptr, ps, depth))
3503 return False;
3504
3505 return True;
3506 }
3507
3508 bool spool_io_printer_info_level_7(const char *desc, SPOOL_PRINTER_INFO_LEVEL_7 *il, prs_struct *ps, int depth)
3509 {
3510 prs_debug(ps, depth, desc, "spool_io_printer_info_level_7");
3511 depth++;
3512
3513 if(!prs_align(ps))
3514 return False;
3515
3516 if(!prs_uint32("guid_ptr", ps, depth, &il->guid_ptr))
3517 return False;
3518 if(!prs_uint32("action", ps, depth, &il->action))
3519 return False;
3520
3521 if(!smb_io_unistr2("servername", &il->guid, il->guid_ptr, ps, depth))
3522 return False;
3523 return True;
3524 }
3525
3526 /*******************************************************************
3527 ********************************************************************/
3528
3529 bool spool_io_printer_info_level(const char *desc, SPOOL_PRINTER_INFO_LEVEL *il, prs_struct *ps, int depth)
3530 {
3531 prs_debug(ps, depth, desc, "spool_io_printer_info_level");
3532 depth++;
3533
3534 if(!prs_align(ps))
3535 return False;
3536 if(!prs_uint32("level", ps, depth, &il->level))
3537 return False;
3538 if(!prs_uint32("info_ptr", ps, depth, &il->info_ptr))
3539 return False;
3540
3541 /* if no struct inside just return */
3542 if (il->info_ptr==0) {
3543 if (UNMARSHALLING(ps)) {
3544 il->info_1=NULL;
3545 il->info_2=NULL;
3546 }
3547 return True;
3548 }
3549
3550 switch (il->level) {
3551 /*
3552 * level 0 is used by setprinter when managing the queue
3553 * (hold, stop, start a queue)
3554 */
3555 case 0:
3556 break;
3557 /* DOCUMENT ME!!! What is level 1 used for? */
3558 case 1:
3559 {
3560 if (UNMARSHALLING(ps)) {
3561 if ((il->info_1=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_1,1)) == NULL)
3562 return False;
3563 }
3564 if (!spool_io_printer_info_level_1("", il->info_1, ps, depth))
3565 return False;
3566 break;
3567 }
3568 /*
3569 * level 2 is used by addprinter
3570 * and by setprinter when updating printer's info
3571 */
3572 case 2:
3573 if (UNMARSHALLING(ps)) {
3574 if ((il->info_2=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_2,1)) == NULL)
3575 return False;
3576 }
3577 if (!spool_io_printer_info_level_2("", il->info_2, ps, depth))
3578 return False;
3579 break;
3580 /* DOCUMENT ME!!! What is level 3 used for? */
3581 case 3:
3582 {
3583 if (UNMARSHALLING(ps)) {
3584 if ((il->info_3=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_3,1)) == NULL)
3585 return False;
3586 }
3587 if (!spool_io_printer_info_level_3("", il->info_3, ps, depth))
3588 return False;
3589 break;
3590 }
3591 case 7:
3592 if (UNMARSHALLING(ps))
3593 if ((il->info_7=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_7,1)) == NULL)
3594 return False;
3595 if (!spool_io_printer_info_level_7("", il->info_7, ps, depth))
3596 return False;
3597 break;
3598 }
3599
3600 return True;
3601 }
3602
3603 /*******************************************************************
3604 ********************************************************************/
3605
3606 bool spoolss_io_q_addprinterex(const char *desc, SPOOL_Q_ADDPRINTEREX *q_u, prs_struct *ps, int depth)
3607 {
3608 uint32 ptr_sec_desc = 0;
3609
3610 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterex");
3611 depth++;
3612
3613 if(!prs_align(ps))
3614 return False;
3615
3616 if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->server_name))
3617 return False;
3618 if (!prs_io_unistr2("servername", ps, depth, q_u->server_name))
3619 return False;
3620
3621 if(!prs_align(ps))
3622 return False;
3623
3624 if(!prs_uint32("info_level", ps, depth, &q_u->level))
3625 return False;
3626
3627 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
3628 return False;
3629
3630 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
3631 return False;
3632
3633 if(!prs_align(ps))
3634 return False;
3635
3636 switch (q_u->level) {
3637 case 2:
3638 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
3639 break;
3640 case 3:
3641 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
3642 break;
3643 }
3644 if (ptr_sec_desc) {
3645 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
3646 return False;
3647 } else {
3648 uint32 dummy = 0;
3649
3650 /* Parse a NULL security descriptor. This should really
3651 happen inside the sec_io_desc_buf() function. */
3652
3653 prs_debug(ps, depth, "", "sec_io_desc_buf");
3654 if (!prs_uint32("size", ps, depth + 1, &dummy))
3655 return False;
3656 if (!prs_uint32("ptr", ps, depth + 1, &dummy))
3657 return False;
3658 }
3659
3660 if(!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
3661 return False;
3662 if(!spool_io_user_level("", &q_u->user_ctr, ps, depth))
3663 return False;
3664
3665 return True;
3666 }
3667
3668 /*******************************************************************
3669 ********************************************************************/
3670
3671 bool spoolss_io_r_addprinterex(const char *desc, SPOOL_R_ADDPRINTEREX *r_u,
3672 prs_struct *ps, int depth)
3673 {
3674 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterex");
3675 depth++;
3676
3677 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
3678 return False;
3679
3680 if(!prs_werror("status", ps, depth, &r_u->status))
3681 return False;
3682
3683 return True;
3684 }
3685
3686 /*******************************************************************
3687 ********************************************************************/
3688
3689 bool spool_io_printer_driver_info_level_3(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **q_u,
3690 prs_struct *ps, int depth)
3691 {
3692 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *il;
3693
3694 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_3");
3695 depth++;
3696
3697 /* reading */
3698 if (UNMARSHALLING(ps)) {
3699 il=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_DRIVER_INFO_LEVEL_3,1);
3700 if(il == NULL)
3701 return False;
3702 *q_u=il;
3703 }
3704 else {
3705 il=*q_u;
3706 }
3707
3708 if(!prs_align(ps))
3709 return False;
3710
3711 if(!prs_uint32("cversion", ps, depth, &il->cversion))
3712 return False;
3713 if(!prs_uint32("name", ps, depth, &il->name_ptr))
3714 return False;
3715 if(!prs_uint32("environment", ps, depth, &il->environment_ptr))
3716 return False;
3717 if(!prs_uint32("driverpath", ps, depth, &il->driverpath_ptr))
3718 return False;
3719 if(!prs_uint32("datafile", ps, depth, &il->datafile_ptr))
3720 return False;
3721 if(!prs_uint32("configfile", ps, depth, &il->configfile_ptr))
3722 return False;
3723 if(!prs_uint32("helpfile", ps, depth, &il->helpfile_ptr))
3724 return False;
3725 if(!prs_uint32("monitorname", ps, depth, &il->monitorname_ptr))
3726 return False;
3727 if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
3728 return False;
3729 if(!prs_uint32("dependentfilessize", ps, depth, &il->dependentfilessize))
3730 return False;
3731 if(!prs_uint32("dependentfiles", ps, depth, &il->dependentfiles_ptr))
3732 return False;
3733
3734 if(!prs_align(ps))
3735 return False;
3736
3737 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
3738 return False;
3739 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
3740 return False;
3741 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
3742 return False;
3743 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
3744 return False;
3745 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
3746 return False;
3747 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
3748 return False;
3749 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
3750 return False;
3751 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
3752 return False;
3753
3754 if(!prs_align(ps))
3755 return False;
3756
3757 if (il->dependentfiles_ptr)
3758 smb_io_buffer5("", &il->dependentfiles, ps, depth);
3759
3760 return True;
3761 }
3762
3763 /*******************************************************************
3764 parse a SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 structure
3765 ********************************************************************/
3766
3767 bool spool_io_printer_driver_info_level_6(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 **q_u,
3768 prs_struct *ps, int depth)
3769 {
3770 SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *il;
3771
3772 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_6");
3773 depth++;
3774
3775 /* reading */
3776 if (UNMARSHALLING(ps)) {
3777 il=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_DRIVER_INFO_LEVEL_6,1);
3778 if(il == NULL)
3779 return False;
3780 *q_u=il;
3781 }
3782 else {
3783 il=*q_u;
3784 }
3785
3786 if(!prs_align(ps))
3787 return False;
3788
3789 /*
3790 * I know this seems weird, but I have no other explanation.
3791 * This is observed behavior on both NT4 and 2K servers.
3792 * --jerry
3793 */
3794
3795 if (!prs_align_uint64(ps))
3796 return False;
3797
3798 /* parse the main elements the packet */
3799
3800 if(!prs_uint32("cversion ", ps, depth, &il->version))
3801 return False;
3802 if(!prs_uint32("name ", ps, depth, &il->name_ptr))
3803 return False;
3804 if(!prs_uint32("environment ", ps, depth, &il->environment_ptr))
3805 return False;
3806 if(!prs_uint32("driverpath ", ps, depth, &il->driverpath_ptr))
3807 return False;
3808 if(!prs_uint32("datafile ", ps, depth, &il->datafile_ptr))
3809 return False;
3810 if(!prs_uint32("configfile ", ps, depth, &il->configfile_ptr))
3811 return False;
3812 if(!prs_uint32("helpfile ", ps, depth, &il->helpfile_ptr))
3813 return False;
3814 if(!prs_uint32("monitorname ", ps, depth, &il->monitorname_ptr))
3815 return False;
3816 if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
3817 return False;
3818 if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_len))
3819 return False;
3820 if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_ptr))
3821 return False;
3822 if(!prs_uint32("previousnames ", ps, depth, &il->previousnames_len))
3823 return False;
3824 if(!prs_uint32("previousnames ", ps, depth, &il->previousnames_ptr))
3825 return False;
3826 if(!smb_io_time("driverdate ", &il->driverdate, ps, depth))
3827 return False;
3828 if(!prs_uint32("dummy4 ", ps, depth, &il->dummy4))
3829 return False;
3830 if(!prs_uint64("driverversion ", ps, depth, &il->driverversion))
3831 return False;
3832 if(!prs_uint32("mfgname ", ps, depth, &il->mfgname_ptr))
3833 return False;
3834 if(!prs_uint32("oemurl ", ps, depth, &il->oemurl_ptr))
3835 return False;
3836 if(!prs_uint32("hardwareid ", ps, depth, &il->hardwareid_ptr))
3837 return False;
3838 if(!prs_uint32("provider ", ps, depth, &il->provider_ptr))
3839 return False;
3840
3841 /* parse the structures in the packet */
3842
3843 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
3844 return False;
3845 if(!prs_align(ps))
3846 return False;
3847
3848 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
3849 return False;
3850 if(!prs_align(ps))
3851 return False;
3852
3853 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
3854 return False;
3855 if(!prs_align(ps))
3856 return False;
3857
3858 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
3859 return False;
3860 if(!prs_align(ps))
3861 return False;
3862
3863 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
3864 return False;
3865 if(!prs_align(ps))
3866 return False;
3867
3868 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
3869 return False;
3870 if(!prs_align(ps))
3871 return False;
3872
3873 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
3874 return False;
3875 if(!prs_align(ps))
3876 return False;
3877
3878 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
3879 return False;
3880 if(!prs_align(ps))
3881 return False;
3882 if (il->dependentfiles_ptr) {
3883 if(!smb_io_buffer5("dependentfiles", &il->dependentfiles, ps, depth))
3884 return False;
3885 if(!prs_align(ps))
3886 return False;
3887 }
3888 if (il->previousnames_ptr) {
3889 if(!smb_io_buffer5("previousnames", &il->previousnames, ps, depth))
3890 return False;
3891 if(!prs_align(ps))
3892 return False;
3893 }
3894 if(!smb_io_unistr2("mfgname", &il->mfgname, il->mfgname_ptr, ps, depth))
3895 return False;
3896 if(!prs_align(ps))
3897 return False;
3898 if(!smb_io_unistr2("oemurl", &il->oemurl, il->oemurl_ptr, ps, depth))
3899 return False;
3900 if(!prs_align(ps))
3901 return False;
3902 if(!smb_io_unistr2("hardwareid", &il->hardwareid, il->hardwareid_ptr, ps, depth))
3903 return False;
3904 if(!prs_align(ps))
3905 return False;
3906 if(!smb_io_unistr2("provider", &il->provider, il->provider_ptr, ps, depth))
3907 return False;
3908
3909 return True;
3910 }
3911
3912 /*******************************************************************
3913 convert a buffer of UNICODE strings null terminated
3914 the buffer is terminated by a NULL
3915
3916 convert to an dos codepage array (null terminated)
3917
3918 dynamically allocate memory
3919
3920 ********************************************************************/
3921
3922 static bool uniarray_2_dosarray(BUFFER5 *buf5, fstring **ar)
3923 {
3924 fstring f;
3925 int n = 0;
3926 char *src;
3927
3928 if (buf5==NULL)
3929 return False;
3930
3931 src = (char *)buf5->buffer;
3932 *ar = SMB_MALLOC_ARRAY(fstring, 1);
3933 if (!*ar) {
3934 return False;
3935 }
3936
3937 while (src < ((char *)buf5->buffer) + buf5->buf_len*2) {
3938 rpcstr_pull(f, src, sizeof(f)-1, -1, STR_TERMINATE);
3939 src = skip_unibuf(src, 2*buf5->buf_len - PTR_DIFF(src,buf5->buffer));
3940 *ar = SMB_REALLOC_ARRAY(*ar, fstring, n+2);
3941 if (!*ar) {
3942 return False;
3943 }
3944 fstrcpy((*ar)[n], f);
3945 n++;
3946 }
3947
3948 fstrcpy((*ar)[n], "");
3949
3950 return True;
3951 }
3952
3953 /*******************************************************************
3954 read a UNICODE array with null terminated strings
3955 and null terminated array
3956 and size of array at beginning
3957 ********************************************************************/
3958
3959 bool smb_io_unibuffer(const char *desc, UNISTR2 *buffer, prs_struct *ps, int depth)
3960 {
3961 if (buffer==NULL) return False;
3962
3963 buffer->offset=0;
3964 buffer->uni_str_len=buffer->uni_max_len;
3965
3966 if(!prs_uint32("buffer_size", ps, depth, &buffer->uni_max_len))
3967 return False;
3968
3969 if(!prs_unistr2(True, "buffer ", ps, depth, buffer))
3970 return False;
3971
3972 return True;
3973 }
3974
3975 /*******************************************************************
3976 ********************************************************************/
3977
3978 bool spool_io_printer_driver_info_level(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL *il, prs_struct *ps, int depth)
3979 {
3980 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level");
3981 depth++;
3982
3983 if(!prs_align(ps))
3984 return False;
3985 if(!prs_uint32("level", ps, depth, &il->level))
3986 return False;
3987 if(!prs_uint32("ptr", ps, depth, &il->ptr))
3988 return False;
3989
3990 if (il->ptr==0)
3991 return True;
3992
3993 switch (il->level) {
3994 case 3:
3995 if(!spool_io_printer_driver_info_level_3("", &il->info_3, ps, depth))
3996 return False;
3997 break;
3998 case 6:
3999 if(!spool_io_printer_driver_info_level_6("", &il->info_6, ps, depth))
4000 return False;
4001 break;
4002 default:
4003 return False;
4004 }
4005
4006 return True;
4007 }
4008
4009 /*******************************************************************
4010 init a SPOOL_Q_ADDPRINTERDRIVER struct
4011 ******************************************************************/
4012
4013 bool make_spoolss_q_addprinterdriver(TALLOC_CTX *mem_ctx,
4014 SPOOL_Q_ADDPRINTERDRIVER *q_u, const char* srv_name,
4015 uint32 level, PRINTER_DRIVER_CTR *info)
4016 {
4017 DEBUG(5,("make_spoolss_q_addprinterdriver\n"));
4018
4019 if (!srv_name || !info) {
4020 return False;
4021 }
4022
4023 q_u->server_name_ptr = 1; /* srv_name is != NULL, see above */
4024 init_unistr2(&q_u->server_name, srv_name, UNI_STR_TERMINATE);
4025
4026 q_u->level = level;
4027
4028 q_u->info.level = level;
4029 q_u->info.ptr = 1; /* Info is != NULL, see above */
4030 switch (level)
4031 {
4032 /* info level 3 is supported by Windows 95/98, WinNT and Win2k */
4033 case 3 :
4034 make_spoolss_driver_info_3(mem_ctx, &q_u->info.info_3, info->info3);
4035 break;
4036
4037 default:
4038 DEBUG(0,("make_spoolss_q_addprinterdriver: Unknown info level [%d]\n", level));
4039 break;
4040 }
4041
4042 return True;
4043 }
4044
4045 bool make_spoolss_driver_info_3(TALLOC_CTX *mem_ctx,
4046 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **spool_drv_info,
4047 DRIVER_INFO_3 *info3)
4048 {
4049 uint32 len = 0;
4050 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *inf;
4051
4052 if (!(inf=TALLOC_ZERO_P(mem_ctx, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3)))
4053 return False;
4054
4055 inf->cversion = info3->version;
4056 inf->name_ptr = (info3->name.buffer!=NULL)?1:0;
4057 inf->environment_ptr = (info3->architecture.buffer!=NULL)?1:0;
4058 inf->driverpath_ptr = (info3->driverpath.buffer!=NULL)?1:0;
4059 inf->datafile_ptr = (info3->datafile.buffer!=NULL)?1:0;
4060 inf->configfile_ptr = (info3->configfile.buffer!=NULL)?1:0;
4061 inf->helpfile_ptr = (info3->helpfile.buffer!=NULL)?1:0;
4062 inf->monitorname_ptr = (info3->monitorname.buffer!=NULL)?1:0;
4063 inf->defaultdatatype_ptr = (info3->defaultdatatype.buffer!=NULL)?1:0;
4064
4065 init_unistr2_from_unistr(inf, &inf->name, &info3->name);
4066 init_unistr2_from_unistr(inf, &inf->environment, &info3->architecture);
4067 init_unistr2_from_unistr(inf, &inf->driverpath, &info3->driverpath);
4068 init_unistr2_from_unistr(inf, &inf->datafile, &info3->datafile);
4069 init_unistr2_from_unistr(inf, &inf->configfile, &info3->configfile);
4070 init_unistr2_from_unistr(inf, &inf->helpfile, &info3->helpfile);
4071 init_unistr2_from_unistr(inf, &inf->monitorname, &info3->monitorname);
4072 init_unistr2_from_unistr(inf, &inf->defaultdatatype, &info3->defaultdatatype);
4073
4074 if (info3->dependentfiles) {
4075 bool done = False;
4076 bool null_char = False;
4077 uint16 *ptr = info3->dependentfiles;
4078
4079 while (!done) {
4080 switch (*ptr) {
4081 case 0:
4082 /* the null_char bool is used to help locate
4083 two '\0's back to back */
4084 if (null_char) {
4085 done = True;
4086 } else {
4087 null_char = True;
4088 }
4089 break;
4090
4091 default:
4092 null_char = False;
4093 break;
4094 }
4095 len++;
4096 ptr++;
4097 }
4098 }
4099
4100 inf->dependentfiles_ptr = (info3->dependentfiles != NULL) ? 1 : 0;
4101 inf->dependentfilessize = (info3->dependentfiles != NULL) ? len : 0;
4102 if(!make_spoolss_buffer5(mem_ctx, &inf->dependentfiles, len, info3->dependentfiles)) {
4103 SAFE_FREE(inf);
4104 return False;
4105 }
4106
4107 *spool_drv_info = inf;
4108
4109 return True;
4110 }
4111
4112 /*******************************************************************
4113 make a BUFFER5 struct from a uint16*
4114 ******************************************************************/
4115
4116 bool make_spoolss_buffer5(TALLOC_CTX *mem_ctx, BUFFER5 *buf5, uint32 len, uint16 *src)
4117 {
4118
4119 buf5->buf_len = len;
4120 if (src) {
4121 if (len) {
4122 if((buf5->buffer=(uint16*)TALLOC_MEMDUP(mem_ctx, src, sizeof(uint16)*len)) == NULL) {
4123 DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
4124 return False;
4125 }
4126 } else {
4127 buf5->buffer = NULL;
4128 }
4129 } else {
4130 buf5->buffer=NULL;
4131 }
4132
4133 return True;
4134 }
4135
4136 /*******************************************************************
4137 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
4138 ********************************************************************/
4139
4140 bool spoolss_io_q_addprinterdriver(const char *desc, SPOOL_Q_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
4141 {
4142 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriver");
4143 depth++;
4144
4145 if(!prs_align(ps))
4146 return False;
4147
4148 if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
4149 return False;
4150 if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
4151 return False;
4152
4153 if(!prs_align(ps))
4154 return False;
4155 if(!prs_uint32("info_level", ps, depth, &q_u->level))
4156 return False;
4157
4158 if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
4159 return False;
4160
4161 return True;
4162 }
4163
4164 /*******************************************************************
4165 ********************************************************************/
4166
4167 bool spoolss_io_r_addprinterdriver(const char *desc, SPOOL_R_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
4168 {
4169 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriver");
4170 depth++;
4171
4172 if(!prs_werror("status", ps, depth, &q_u->status))
4173 return False;
4174
4175 return True;
4176 }
4177
4178 /*******************************************************************
4179 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
4180 ********************************************************************/
4181
4182 bool spoolss_io_q_addprinterdriverex(const char *desc, SPOOL_Q_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
4183 {
4184 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriverex");
4185 depth++;
4186
4187 if(!prs_align(ps))
4188 return False;
4189
4190 if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
4191 return False;
4192 if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
4193 return False;
4194
4195 if(!prs_align(ps))
4196 return False;
4197 if(!prs_uint32("info_level", ps, depth, &q_u->level))
4198 return False;
4199
4200 if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
4201 return False;
4202
4203 if(!prs_align(ps))
4204 return False;
4205 if(!prs_uint32("copy flags", ps, depth, &q_u->copy_flags))
4206 return False;
4207
4208 return True;
4209 }
4210
4211 /*******************************************************************
4212 ********************************************************************/
4213
4214 bool spoolss_io_r_addprinterdriverex(const char *desc, SPOOL_R_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
4215 {
4216 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriverex");
4217 depth++;
4218
4219 if(!prs_werror("status", ps, depth, &q_u->status))
4220 return False;
4221
4222 return True;
4223 }
4224
4225 /*******************************************************************
4226 ********************************************************************/
4227
4228 bool uni_2_asc_printer_driver_3(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *uni,
4229 NT_PRINTER_DRIVER_INFO_LEVEL_3 **asc)
4230 {
4231 NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
4232
4233 DEBUG(7,("uni_2_asc_printer_driver_3: Converting from UNICODE to ASCII\n"));
4234
4235 if (*asc==NULL)
4236 {
4237 *asc=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
4238 if(*asc == NULL)
4239 return False;
4240 ZERO_STRUCTP(*asc);
4241 }
4242
4243 d=*asc;
4244
4245 d->cversion=uni->cversion;
4246
4247 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name));
4248 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment));
4249 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath));
4250 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile));
4251 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile));
4252 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile));
4253 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname));
4254 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype));
4255
4256 DEBUGADD(8,( "version: %d\n", d->cversion));
4257 DEBUGADD(8,( "name: %s\n", d->name));
4258 DEBUGADD(8,( "environment: %s\n", d->environment));
4259 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
4260 DEBUGADD(8,( "datafile: %s\n", d->datafile));
4261 DEBUGADD(8,( "configfile: %s\n", d->configfile));
4262 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
4263 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
4264 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
4265
4266 if (uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
4267 return True;
4268
4269 SAFE_FREE(*asc);
4270 return False;
4271 }
4272
4273 /*******************************************************************
4274 ********************************************************************/
4275 bool uni_2_asc_printer_driver_6(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *uni,
4276 NT_PRINTER_DRIVER_INFO_LEVEL_6 **asc)
4277 {
4278 NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
4279
4280 DEBUG(7,("uni_2_asc_printer_driver_6: Converting from UNICODE to ASCII\n"));
4281
4282 if (*asc==NULL)
4283 {
4284 *asc=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
4285 if(*asc == NULL)
4286 return False;
4287 ZERO_STRUCTP(*asc);
4288 }
4289
4290 d=*asc;
4291
4292 d->version=uni->version;
4293
4294 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name));
4295 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment));
4296 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath));
4297 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile));
4298 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile));
4299 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile));
4300 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname));
4301 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype));
4302
4303 DEBUGADD(8,( "version: %d\n", d->version));
4304 DEBUGADD(8,( "name: %s\n", d->name));
4305 DEBUGADD(8,( "environment: %s\n", d->environment));
4306 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
4307 DEBUGADD(8,( "datafile: %s\n", d->datafile));
4308 DEBUGADD(8,( "configfile: %s\n", d->configfile));
4309 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
4310 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
4311 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
4312
4313 if (!uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
4314 goto error;
4315 if (!uniarray_2_dosarray(&uni->previousnames, &d->previousnames ))
4316 goto error;
4317
4318 return True;
4319
4320 error:
4321 SAFE_FREE(*asc);
4322 return False;
4323 }
4324
4325 bool uni_2_asc_printer_info_2(const SPOOL_PRINTER_INFO_LEVEL_2 *uni,
4326 NT_PRINTER_INFO_LEVEL_2 *d)
4327 {
4328 DEBUG(7,("Converting from UNICODE to ASCII\n"));
4329
4330 d->attributes=uni->attributes;
4331 d->priority=uni->priority;
4332 d->default_priority=uni->default_priority;
4333 d->starttime=uni->starttime;
4334 d->untiltime=uni->untiltime;
4335 d->status=uni->status;
4336 d->cjobs=uni->cjobs;
4337
4338 unistr2_to_ascii(d->servername, &uni->servername, sizeof(d->servername));
4339 unistr2_to_ascii(d->printername, &uni->printername, sizeof(d->printername));
4340 unistr2_to_ascii(d->sharename, &uni->sharename, sizeof(d->sharename));
4341 unistr2_to_ascii(d->portname, &uni->portname, sizeof(d->portname));
4342 unistr2_to_ascii(d->drivername, &uni->drivername, sizeof(d->drivername));
4343 unistr2_to_ascii(d->comment, &uni->comment, sizeof(d->comment));
4344 unistr2_to_ascii(d->location, &uni->location, sizeof(d->location));
4345 unistr2_to_ascii(d->sepfile, &uni->sepfile, sizeof(d->sepfile));
4346 unistr2_to_ascii(d->printprocessor, &uni->printprocessor, sizeof(d->printprocessor));
4347 unistr2_to_ascii(d->datatype, &uni->datatype, sizeof(d->datatype));
4348 unistr2_to_ascii(d->parameters, &uni->parameters, sizeof(d->parameters));
4349
4350 return True;
4351 }
4352
4353 /*******************************************************************
4354 * init a structure.
4355 ********************************************************************/
4356
4357 bool make_spoolss_q_getprinterdriverdir(SPOOL_Q_GETPRINTERDRIVERDIR *q_u,
4358 fstring servername, fstring env_name, uint32 level,
4359 RPC_BUFFER *buffer, uint32 offered)
4360 {
4361 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
4362 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, env_name);
4363
4364 q_u->level=level;
4365 q_u->buffer=buffer;
4366 q_u->offered=offered;
4367
4368 return True;
4369 }
4370
4371 /*******************************************************************
4372 Parse a SPOOL_Q_GETPRINTERDRIVERDIR structure.
4373 ********************************************************************/
4374
4375 bool spoolss_io_q_getprinterdriverdir(const char *desc, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, prs_struct *ps, int depth)
4376 {
4377 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriverdir");
4378 depth++;
4379
4380 if(!prs_align(ps))
4381 return False;
4382 if(!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
4383 return False;
4384 if(!smb_io_unistr2("", &q_u->name, q_u->name_ptr, ps, depth))
4385 return False;
4386
4387 if(!prs_align(ps))
4388 return False;
4389
4390 if(!prs_uint32("", ps, depth, &q_u->environment_ptr))
4391 return False;
4392 if(!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
4393 return False;
4394
4395 if(!prs_align(ps))
4396 return False;
4397
4398 if(!prs_uint32("level", ps, depth, &q_u->level))
4399 return False;
4400
4401 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4402 return False;
4403
4404 if(!prs_align(ps))
4405 return False;
4406
4407 if(!prs_uint32("offered", ps, depth, &q_u->offered))
4408 return False;
4409
4410 return True;
4411 }
4412
4413 /*******************************************************************
4414 Parse a SPOOL_R_GETPRINTERDRIVERDIR structure.
4415 ********************************************************************/
4416
4417 bool spoolss_io_r_getprinterdriverdir(const char *desc, SPOOL_R_GETPRINTERDRIVERDIR *r_u, prs_struct *ps, int depth)
4418 {
4419 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriverdir");
4420 depth++;
4421
4422 if (!prs_align(ps))
4423 return False;
4424
4425 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4426 return False;
4427
4428 if (!prs_align(ps))
4429 return False;
4430
4431 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4432 return False;
4433
4434 if (!prs_werror("status", ps, depth, &r_u->status))
4435 return False;
4436
4437 return True;
4438 }
4439
4440 /*******************************************************************
4441 ********************************************************************/
4442
4443 bool spoolss_io_r_enumprintprocessors(const char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
4444 {
4445 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
4446 depth++;
4447
4448 if (!prs_align(ps))
4449 return False;
4450
4451 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4452 return False;
4453
4454 if (!prs_align(ps))
4455 return False;
4456
4457 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4458 return False;
4459
4460 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4461 return False;
4462
4463 if (!prs_werror("status", ps, depth, &r_u->status))
4464 return False;
4465
4466 return True;
4467 }
4468
4469 /*******************************************************************
4470 ********************************************************************/
4471
4472 bool spoolss_io_q_enumprintprocessors(const char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
4473 {
4474 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
4475 depth++;
4476
4477 if (!prs_align(ps))
4478 return False;
4479
4480 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
4481 return False;
4482 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
4483 return False;
4484
4485 if (!prs_align(ps))
4486 return False;
4487
4488 if (!prs_uint32("", ps, depth, &q_u->environment_ptr))
4489 return False;
4490 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
4491 return False;
4492
4493 if (!prs_align(ps))
4494 return False;
4495
4496 if (!prs_uint32("level", ps, depth, &q_u->level))
4497 return False;
4498
4499 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4500 return False;
4501
4502 if (!prs_align(ps))
4503 return False;
4504
4505 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4506 return False;
4507
4508 return True;
4509 }
4510
4511 /*******************************************************************
4512 ********************************************************************/
4513
4514 bool spoolss_io_r_enumprintprocdatatypes(const char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u, prs_struct *ps, int depth)
4515 {
4516 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes");
4517 depth++;
4518
4519 if (!prs_align(ps))
4520 return False;
4521
4522 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4523 return False;
4524
4525 if (!prs_align(ps))
4526 return False;
4527
4528 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4529 return False;
4530
4531 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4532 return False;
4533
4534 if (!prs_werror("status", ps, depth, &r_u->status))
4535 return False;
4536
4537 return True;
4538 }
4539
4540 /*******************************************************************
4541 ********************************************************************/
4542
4543 bool spoolss_io_q_enumprintprocdatatypes(const char *desc, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, prs_struct *ps, int depth)
4544 {
4545 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocdatatypes");
4546 depth++;
4547
4548 if (!prs_align(ps))
4549 return False;
4550
4551 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
4552 return False;
4553 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
4554 return False;
4555
4556 if (!prs_align(ps))
4557 return False;
4558
4559 if (!prs_uint32("processor_ptr", ps, depth, &q_u->processor_ptr))
4560 return False;
4561 if (!smb_io_unistr2("processor", &q_u->processor, q_u->processor_ptr, ps, depth))
4562 return False;
4563
4564 if (!prs_align(ps))
4565 return False;
4566
4567 if (!prs_uint32("level", ps, depth, &q_u->level))
4568 return False;
4569
4570 if(!prs_rpcbuffer_p("buffer", ps, depth, &q_u->buffer))
4571 return False;
4572
4573 if (!prs_align(ps))
4574 return False;
4575
4576 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4577 return False;
4578
4579 return True;
4580 }
4581
4582 /*******************************************************************
4583 Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
4584 ********************************************************************/
4585
4586 bool spoolss_io_q_enumprintmonitors(const char *desc, SPOOL_Q_ENUMPRINTMONITORS *q_u, prs_struct *ps, int depth)
4587 {
4588 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintmonitors");
4589 depth++;
4590
4591 if (!prs_align(ps))
4592 return False;
4593
4594 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
4595 return False;
4596 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
4597 return False;
4598
4599 if (!prs_align(ps))
4600 return False;
4601
4602 if (!prs_uint32("level", ps, depth, &q_u->level))
4603 return False;
4604
4605 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4606 return False;
4607
4608 if (!prs_align(ps))
4609 return False;
4610
4611 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4612 return False;
4613
4614 return True;
4615 }
4616
4617 /*******************************************************************
4618 ********************************************************************/
4619
4620 bool spoolss_io_r_enumprintmonitors(const char *desc, SPOOL_R_ENUMPRINTMONITORS *r_u, prs_struct *ps, int depth)
4621 {
4622 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintmonitors");
4623 depth++;
4624
4625 if (!prs_align(ps))
4626 return False;
4627
4628 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4629 return False;
4630
4631 if (!prs_align(ps))
4632 return False;
4633
4634 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4635 return False;
4636
4637 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4638 return False;
4639
4640 if (!prs_werror("status", ps, depth, &r_u->status))
4641 return False;
4642
4643 return True;
4644 }
4645
4646 /*******************************************************************
4647 ********************************************************************/
4648
4649 bool spoolss_io_r_enumprinterdata(const char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth)
4650 {
4651 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata");
4652 depth++;
4653
4654 if(!prs_align(ps))
4655 return False;
4656 if(!prs_uint32("valuesize", ps, depth, &r_u->valuesize))
4657 return False;
4658
4659 if (UNMARSHALLING(ps) && r_u->valuesize) {
4660 r_u->value = PRS_ALLOC_MEM(ps, uint16, r_u->valuesize);
4661 if (!r_u->value) {
4662 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata value\n"));
4663 return False;
4664 }
4665 }
4666
4667 if(!prs_uint16uni(False, "value", ps, depth, r_u->value, r_u->valuesize ))
4668 return False;
4669
4670 if(!prs_align(ps))
4671 return False;
4672
4673 if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
4674 return False;
4675
4676 if(!prs_uint32("type", ps, depth, &r_u->type))
4677 return False;
4678
4679 if(!prs_uint32("datasize", ps, depth, &r_u->datasize))
4680 return False;
4681
4682 if (UNMARSHALLING(ps) && r_u->datasize) {
4683 r_u->data = PRS_ALLOC_MEM(ps, uint8, r_u->datasize);
4684 if (!r_u->data) {
4685 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata data\n"));
4686 return False;
4687 }
4688 }
4689
4690 if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
4691 return False;
4692 if(!prs_align(ps))
4693 return False;
4694
4695 if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
4696 return False;
4697 if(!prs_werror("status", ps, depth, &r_u->status))
4698 return False;
4699
4700 return True;
4701 }
4702
4703 /*******************************************************************
4704 ********************************************************************/
4705
4706 bool spoolss_io_q_enumprinterdata(const char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
4707 {
4708 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
4709 depth++;
4710
4711 if(!prs_align(ps))
4712 return False;
4713 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4714 return False;
4715 if(!prs_uint32("index", ps, depth, &q_u->index))
4716 return False;
4717 if(!prs_uint32("valuesize", ps, depth, &q_u->valuesize))
4718 return False;
4719 if(!prs_uint32("datasize", ps, depth, &q_u->datasize))
4720 return False;
4721
4722 return True;
4723 }
4724
4725 /*******************************************************************
4726 ********************************************************************/
4727
4728 bool make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u,
4729 const POLICY_HND *hnd,
4730 uint32 idx, uint32 valuelen, uint32 datalen)
4731 {
4732 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
4733 q_u->index=idx;
4734 q_u->valuesize=valuelen;
4735 q_u->datasize=datalen;
4736
4737 return True;
4738 }
4739
4740 /*******************************************************************
4741 ********************************************************************/
4742
4743 bool make_spoolss_q_enumprinterdataex(SPOOL_Q_ENUMPRINTERDATAEX *q_u,
4744 const POLICY_HND *hnd, const char *key,
4745 uint32 size)
4746 {
4747 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
4748 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
4749 q_u->size = size;
4750
4751 return True;
4752 }
4753
4754 /*******************************************************************
4755 ********************************************************************/
4756 bool make_spoolss_q_setprinterdata(SPOOL_Q_SETPRINTERDATA *q_u, const POLICY_HND *hnd,
4757 char* value, uint32 data_type, char* data, uint32 data_size)
4758 {
4759 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
4760 q_u->type = data_type;
4761 init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
4762
4763 q_u->max_len = q_u->real_len = data_size;
4764 q_u->data = (unsigned char *)data;
4765
4766 return True;
4767 }
4768
4769 /*******************************************************************
4770 ********************************************************************/
4771
4772 bool spoolss_io_q_setprinterdata(const char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
4773 {
4774 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
4775 depth++;
4776
4777 if(!prs_align(ps))
4778 return False;
4779 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
4780 return False;
4781 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
4782 return False;
4783
4784 if(!prs_align(ps))
4785 return False;
4786
4787 if(!prs_uint32("type", ps, depth, &q_u->type))
4788 return False;
4789
4790 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
4791 return False;
4792
4793 switch (q_u->type)
4794 {
4795 case REG_SZ:
4796 case REG_BINARY:
4797 case REG_DWORD:
4798 case REG_MULTI_SZ:
4799 if (q_u->max_len) {
4800 if (UNMARSHALLING(ps))
4801 q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
4802 if(q_u->data == NULL)
4803 return False;
4804 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
4805 return False;
4806 }
4807 if(!prs_align(ps))
4808 return False;
4809 break;
4810 }
4811
4812 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
4813 return False;
4814
4815 return True;
4816 }
4817
4818 /*******************************************************************
4819 ********************************************************************/
4820
4821 bool spoolss_io_r_setprinterdata(const char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
4822 {
4823 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
4824 depth++;
4825
4826 if(!prs_align(ps))
4827 return False;
4828 if(!prs_werror("status", ps, depth, &r_u->status))
4829 return False;
4830
4831 return True;
4832 }
4833
4834 /*******************************************************************
4835 ********************************************************************/
4836 bool spoolss_io_q_resetprinter(const char *desc, SPOOL_Q_RESETPRINTER *q_u, prs_struct *ps, int depth)
4837 {
4838 prs_debug(ps, depth, desc, "spoolss_io_q_resetprinter");
4839 depth++;
4840
4841 if (!prs_align(ps))
4842 return False;
4843 if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
4844 return False;
4845
4846 if (!prs_uint32("datatype_ptr", ps, depth, &q_u->datatype_ptr))
4847 return False;
4848
4849 if (q_u->datatype_ptr) {
4850 if (!smb_io_unistr2("datatype", &q_u->datatype, q_u->datatype_ptr?True:False, ps, depth))
4851 return False;
4852 }
4853
4854 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
4855 return False;
4856
4857 return True;
4858 }
4859
4860
4861 /*******************************************************************
4862 ********************************************************************/
4863 bool spoolss_io_r_resetprinter(const char *desc, SPOOL_R_RESETPRINTER *r_u, prs_struct *ps, int depth)
4864 {
4865 prs_debug(ps, depth, desc, "spoolss_io_r_resetprinter");
4866 depth++;
4867
4868 if(!prs_align(ps))
4869 return False;
4870 if(!prs_werror("status", ps, depth, &r_u->status))
4871 return False;
4872
4873 return True;
4874 }
4875
4876 /*******************************************************************
4877 Parse a SPOOL_R_GETJOB structure.
4878 ********************************************************************/
4879
4880 bool spoolss_io_r_getjob(const char *desc, SPOOL_R_GETJOB *r_u, prs_struct *ps, int depth)
4881 {
4882 prs_debug(ps, depth, desc, "spoolss_io_r_getjob");
4883 depth++;
4884
4885 if (!prs_align(ps))
4886 return False;
4887
4888 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4889 return False;
4890
4891 if (!prs_align(ps))
4892 return False;
4893
4894 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4895 return False;
4896
4897 if (!prs_werror("status", ps, depth, &r_u->status))
4898 return False;
4899
4900 return True;
4901 }
4902
4903 /*******************************************************************
4904 Parse a SPOOL_Q_GETJOB structure.
4905 ********************************************************************/
4906
4907 bool spoolss_io_q_getjob(const char *desc, SPOOL_Q_GETJOB *q_u, prs_struct *ps, int depth)
4908 {
4909 prs_debug(ps, depth, desc, "");
4910 depth++;
4911
4912 if(!prs_align(ps))
4913 return False;
4914
4915 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4916 return False;
4917 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
4918 return False;
4919 if(!prs_uint32("level", ps, depth, &q_u->level))
4920 return False;
4921
4922 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4923 return False;
4924
4925 if(!prs_align(ps))
4926 return False;
4927
4928 if(!prs_uint32("offered", ps, depth, &q_u->offered))
4929 return False;
4930
4931 return True;
4932 }
4933
4934 void free_devmode(DEVICEMODE *devmode)
4935 {
4936 if (devmode!=NULL) {
4937 SAFE_FREE(devmode->dev_private);
4938 SAFE_FREE(devmode);
4939 }
4940 }
4941
4942 void free_printer_info_1(PRINTER_INFO_1 *printer)
4943 {
4944 SAFE_FREE(printer);
4945 }
4946
4947 void free_printer_info_2(PRINTER_INFO_2 *printer)
4948 {
4949 if (printer!=NULL) {
4950 free_devmode(printer->devmode);
4951 printer->devmode = NULL;
4952 SAFE_FREE(printer);
4953 }
4954 }
4955
4956 void free_printer_info_3(PRINTER_INFO_3 *printer)
4957 {
4958 SAFE_FREE(printer);
4959 }
4960
4961 void free_printer_info_4(PRINTER_INFO_4 *printer)
4962 {
4963 SAFE_FREE(printer);
4964 }
4965
4966 void free_printer_info_5(PRINTER_INFO_5 *printer)
4967 {
4968 SAFE_FREE(printer);
4969 }
4970
4971 void free_printer_info_6(PRINTER_INFO_6 *printer)
4972 {
4973 SAFE_FREE(printer);
4974 }
4975
4976 void free_printer_info_7(PRINTER_INFO_7 *printer)
4977 {
4978 SAFE_FREE(printer);
4979 }
4980
4981 void free_job_info_2(JOB_INFO_2 *job)
4982 {
4983 if (job!=NULL)
4984 free_devmode(job->devmode);
4985 }
4986
4987 #if 0 /* JERRY - not currently used but could be :-) */
4988
4989 /*******************************************************************
4990 Deep copy a SPOOL_NOTIFY_INFO_DATA structure
4991 ******************************************************************/
4992 static bool copy_spool_notify_info_data(SPOOL_NOTIFY_INFO_DATA *dst,
4993 SPOOL_NOTIFY_INFO_DATA *src, int n)
4994 {
4995 int i;
4996
4997 memcpy(dst, src, sizeof(SPOOL_NOTIFY_INFO_DATA)*n);
4998
4999 for (i=0; i<n; i++) {
5000 int len;
5001 uint16 *s = NULL;
5002
5003 if (src->size != POINTER)
5004 continue;
5005 len = src->notify_data.data.length;
5006 s = SMB_MALLOC_ARRAY(uint16, len);
5007 if (s == NULL) {
5008 DEBUG(0,("copy_spool_notify_info_data: malloc() failed!\n"));
5009 return False;
5010 }
5011
5012 memcpy(s, src->notify_data.data.string, len*2);
5013 dst->notify_data.data.string = s;
5014 }
5015
5016 return True;
5017 }
5018
5019 /*******************************************************************
5020 Deep copy a SPOOL_NOTIFY_INFO structure
5021 ******************************************************************/
5022 static bool copy_spool_notify_info(SPOOL_NOTIFY_INFO *dst, SPOOL_NOTIFY_INFO *src)
5023 {
5024 if (!dst) {
5025 DEBUG(0,("copy_spool_notify_info: NULL destination pointer!\n"));
5026 return False;
5027 }
5028
5029 dst->version = src->version;
5030 dst->flags = src->flags;
5031 dst->count = src->count;
5032
5033 if (dst->count)
5034 {
5035 dst->data = SMB_MALLOC_ARRAY(SPOOL_NOTIFY_INFO_DATA, dst->count);
5036
5037 DEBUG(10,("copy_spool_notify_info: allocating space for [%d] PRINTER_NOTIFY_INFO_DATA entries\n",
5038 dst->count));
5039
5040 if (dst->data == NULL) {
5041 DEBUG(0,("copy_spool_notify_info: malloc() failed for [%d] entries!\n",
5042 dst->count));
5043 return False;
5044 }
5045
5046 return (copy_spool_notify_info_data(dst->data, src->data, src->count));
5047 }
5048
5049 return True;
5050 }
5051 #endif /* JERRY */
5052
5053 /*******************************************************************
5054 * init a structure.
5055 ********************************************************************/
5056
5057 bool make_spoolss_q_reply_rrpcn(SPOOL_Q_REPLY_RRPCN *q_u, POLICY_HND *hnd,
5058 uint32 change_low, uint32 change_high,
5059 SPOOL_NOTIFY_INFO *info)
5060 {
5061 if (q_u == NULL)
5062 return False;
5063
5064 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5065
5066 q_u->change_low=change_low;
5067 q_u->change_high=change_high;
5068
5069 q_u->unknown0=0x0;
5070 q_u->unknown1=0x0;
5071
5072 q_u->info_ptr=0x0FF0ADDE;
5073
5074 q_u->info.version=2;
5075
5076 if (info->count) {
5077 DEBUG(10,("make_spoolss_q_reply_rrpcn: [%d] PRINTER_NOTIFY_INFO_DATA\n",
5078 info->count));
5079 q_u->info.version = info->version;
5080 q_u->info.flags = info->flags;
5081 q_u->info.count = info->count;
5082 /* pointer field - be careful! */
5083 q_u->info.data = info->data;
5084 }
5085 else {
5086 q_u->info.flags=PRINTER_NOTIFY_INFO_DISCARDED;
5087 q_u->info.count=0;
5088 }
5089
5090 return True;
5091 }
5092
5093 /*******************************************************************
5094 Parse a SPOOL_Q_REPLY_RRPCN structure.
5095 ********************************************************************/
5096
5097 bool spoolss_io_q_reply_rrpcn(const char *desc, SPOOL_Q_REPLY_RRPCN *q_u, prs_struct *ps, int depth)
5098 {
5099 prs_debug(ps, depth, desc, "spoolss_io_q_reply_rrpcn");
5100 depth++;
5101
5102 if(!prs_align(ps))
5103 return False;
5104
5105 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
5106 return False;
5107
5108 if (!prs_uint32("change_low", ps, depth, &q_u->change_low))
5109 return False;
5110
5111 if (!prs_uint32("change_high", ps, depth, &q_u->change_high))
5112 return False;
5113
5114 if (!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
5115 return False;
5116
5117 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
5118 return False;
5119
5120 if (!prs_uint32("info_ptr", ps, depth, &q_u->info_ptr))
5121 return False;
5122
5123 if(q_u->info_ptr!=0)
5124 if(!smb_io_notify_info(desc, &q_u->info, ps, depth))
5125 return False;
5126
5127 return True;
5128 }
5129
5130 /*******************************************************************
5131 Parse a SPOOL_R_REPLY_RRPCN structure.
5132 ********************************************************************/
5133
5134 bool spoolss_io_r_reply_rrpcn(const char *desc, SPOOL_R_REPLY_RRPCN *r_u, prs_struct *ps, int depth)
5135 {
5136 prs_debug(ps, depth, desc, "spoolss_io_r_reply_rrpcn");
5137 depth++;
5138
5139 if (!prs_align(ps))
5140 return False;
5141
5142 if (!prs_uint32("unknown0", ps, depth, &r_u->unknown0))
5143 return False;
5144
5145 if (!prs_werror("status", ps, depth, &r_u->status))
5146 return False;
5147
5148 return True;
5149 }
5150
5151 /*******************************************************************
5152 * read a structure.
5153 ********************************************************************/
5154 bool make_spoolss_q_enumprinterkey(SPOOL_Q_ENUMPRINTERKEY *q_u,
5155 POLICY_HND *hnd, const char *key,
5156 uint32 size)
5157 {
5158 DEBUG(5,("make_spoolss_q_enumprinterkey\n"));
5159
5160 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5161 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
5162 q_u->size = size;
5163
5164 return True;
5165 }
5166
5167 /*******************************************************************
5168 * read a structure.
5169 ********************************************************************/
5170
5171 bool spoolss_io_q_enumprinterkey(const char *desc, SPOOL_Q_ENUMPRINTERKEY *q_u, prs_struct *ps, int depth)
5172 {
5173 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterkey");
5174 depth++;
5175
5176 if(!prs_align(ps))
5177 return False;
5178 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5179 return False;
5180
5181 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
5182 return False;
5183
5184 if(!prs_align(ps))
5185 return False;
5186
5187 if(!prs_uint32("size", ps, depth, &q_u->size))
5188 return False;
5189
5190 return True;
5191 }
5192
5193 /*******************************************************************
5194 * write a structure.
5195 ********************************************************************/
5196
5197 bool spoolss_io_r_enumprinterkey(const char *desc, SPOOL_R_ENUMPRINTERKEY *r_u, prs_struct *ps, int depth)
5198 {
5199 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterkey");
5200 depth++;
5201
5202 if(!prs_align(ps))
5203 return False;
5204
5205 if (!smb_io_buffer5("", &r_u->keys, ps, depth))
5206 return False;
5207
5208 if(!prs_align(ps))
5209 return False;
5210
5211 if(!prs_uint32("needed", ps, depth, &r_u->needed))
5212 return False;
5213
5214 if(!prs_werror("status", ps, depth, &r_u->status))
5215 return False;
5216
5217 return True;
5218 }
5219
5220 /*******************************************************************
5221 * read a structure.
5222 ********************************************************************/
5223
5224 bool spoolss_io_q_enumprinterdataex(const char *desc, SPOOL_Q_ENUMPRINTERDATAEX *q_u, prs_struct *ps, int depth)
5225 {
5226 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdataex");
5227 depth++;
5228
5229 if(!prs_align(ps))
5230 return False;
5231 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5232 return False;
5233
5234 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
5235 return False;
5236
5237 if(!prs_align(ps))
5238 return False;
5239
5240 if(!prs_uint32("size", ps, depth, &q_u->size))
5241 return False;
5242
5243 return True;
5244 }
5245
5246 /*******************************************************************
5247 ********************************************************************/
5248
5249 static bool spoolss_io_printer_enum_values_ctr(const char *desc, prs_struct *ps,
5250 PRINTER_ENUM_VALUES_CTR *ctr, int depth)
5251 {
5252 int i;
5253 uint32 valuename_offset,
5254 data_offset,
5255 current_offset;
5256 const uint32 basic_unit = 20; /* size of static portion of enum_values */
5257
5258 prs_debug(ps, depth, desc, "spoolss_io_printer_enum_values_ctr");
5259 depth++;
5260
5261 /*
5262 * offset data begins at 20 bytes per structure * size_of_array.
5263 * Don't forget the uint32 at the beginning
5264 * */
5265
5266 current_offset = basic_unit * ctr->size_of_array;
5267
5268 /* first loop to write basic enum_value information */
5269
5270 if (UNMARSHALLING(ps) && ctr->size_of_array) {
5271 ctr->values = PRS_ALLOC_MEM(ps, PRINTER_ENUM_VALUES, ctr->size_of_array);
5272 if (!ctr->values)
5273 return False;
5274 }
5275
5276 for (i=0; i<ctr->size_of_array; i++) {
5277 uint32 base_offset, return_offset;
5278
5279 base_offset = prs_offset(ps);
5280
5281 valuename_offset = current_offset;
5282 if (!prs_uint32("valuename_offset", ps, depth, &valuename_offset))
5283 return False;
5284
5285 /* Read or write the value. */
5286
5287 return_offset = prs_offset(ps);
5288
5289 if (!prs_set_offset(ps, base_offset + valuename_offset)) {
5290 return False;
5291 }
5292
5293 if (!prs_unistr("valuename", ps, depth, &ctr->values[i].valuename))
5294 return False;
5295
5296 /* And go back. */
5297 if (!prs_set_offset(ps, return_offset))
5298 return False;
5299
5300 if (!prs_uint32("value_len", ps, depth, &ctr->values[i].value_len))
5301 return False;
5302
5303 if (!prs_uint32("type", ps, depth, &ctr->values[i].type))
5304 return False;
5305
5306 data_offset = ctr->values[i].value_len + valuename_offset;
5307
5308 if (!prs_uint32("data_offset", ps, depth, &data_offset))
5309 return False;
5310
5311 if (!prs_uint32("data_len", ps, depth, &ctr->values[i].data_len))
5312 return False;
5313
5314 /* Read or write the data. */
5315
5316 return_offset = prs_offset(ps);
5317
5318 if (!prs_set_offset(ps, base_offset + data_offset)) {
5319 return False;
5320 }
5321
5322 if ( ctr->values[i].data_len ) {
5323 if ( UNMARSHALLING(ps) ) {
5324 ctr->values[i].data = PRS_ALLOC_MEM(ps, uint8, ctr->values[i].data_len);
5325 if (!ctr->values[i].data)
5326 return False;
5327 }
5328 if (!prs_uint8s(False, "data", ps, depth, ctr->values[i].data, ctr->values[i].data_len))
5329 return False;
5330 }
5331
5332 current_offset = data_offset + ctr->values[i].data_len - basic_unit;
5333 /* account for 2 byte alignment */
5334 current_offset += (current_offset % 2);
5335
5336 /* Remember how far we got. */
5337 data_offset = prs_offset(ps);
5338
5339 /* And go back. */
5340 if (!prs_set_offset(ps, return_offset))
5341 return False;
5342
5343 }
5344
5345 /* Go to the last data offset we got to. */
5346
5347 if (!prs_set_offset(ps, data_offset))
5348 return False;
5349
5350 /* And ensure we're 2 byte aligned. */
5351
5352 if ( !prs_align_uint16(ps) )
5353 return False;
5354
5355 return True;
5356 }
5357
5358 /*******************************************************************
5359 * write a structure.
5360 ********************************************************************/
5361
5362 bool spoolss_io_r_enumprinterdataex(const char *desc, SPOOL_R_ENUMPRINTERDATAEX *r_u, prs_struct *ps, int depth)
5363 {
5364 uint32 data_offset, end_offset;
5365 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdataex");
5366 depth++;
5367
5368 if(!prs_align(ps))
5369 return False;
5370
5371 if (!prs_uint32("size", ps, depth, &r_u->ctr.size))
5372 return False;
5373
5374 data_offset = prs_offset(ps);
5375
5376 if (!prs_set_offset(ps, data_offset + r_u->ctr.size))
5377 return False;
5378
5379 if(!prs_align(ps))
5380 return False;
5381
5382 if(!prs_uint32("needed", ps, depth, &r_u->needed))
5383 return False;
5384
5385 if(!prs_uint32("returned", ps, depth, &r_u->returned))
5386 return False;
5387
5388 if(!prs_werror("status", ps, depth, &r_u->status))
5389 return False;
5390
5391 r_u->ctr.size_of_array = r_u->returned;
5392
5393 end_offset = prs_offset(ps);
5394
5395 if (!prs_set_offset(ps, data_offset))
5396 return False;
5397
5398 if (r_u->ctr.size)
5399 if (!spoolss_io_printer_enum_values_ctr("", ps, &r_u->ctr, depth ))
5400 return False;
5401
5402 if (!prs_set_offset(ps, end_offset))
5403 return False;
5404 return True;
5405 }
5406
5407 /*******************************************************************
5408 * write a structure.
5409 ********************************************************************/
5410
5411 /*
5412 uint32 GetPrintProcessorDirectory(
5413 [in] unistr2 *name,
5414 [in] unistr2 *environment,
5415 [in] uint32 level,
5416 [in,out] RPC_BUFFER buffer,
5417 [in] uint32 offered,
5418 [out] uint32 needed,
5419 [out] uint32 returned
5420 );
5421
5422 */
5423
5424 bool make_spoolss_q_getprintprocessordirectory(SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, const char *name, char *environment, int level, RPC_BUFFER *buffer, uint32 offered)
5425 {
5426 DEBUG(5,("make_spoolss_q_getprintprocessordirectory\n"));
5427
5428 init_unistr2(&q_u->name, name, UNI_STR_TERMINATE);
5429 init_unistr2(&q_u->environment, environment, UNI_STR_TERMINATE);
5430
5431 q_u->level = level;
5432
5433 q_u->buffer = buffer;
5434 q_u->offered = offered;
5435
5436 return True;
5437 }
5438
5439 bool spoolss_io_q_getprintprocessordirectory(const char *desc, SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, prs_struct *ps, int depth)
5440 {
5441 uint32 ptr = 0;
5442
5443 prs_debug(ps, depth, desc, "spoolss_io_q_getprintprocessordirectory");
5444 depth++;
5445
5446 if(!prs_align(ps))
5447 return False;
5448
5449 if (!prs_uint32("ptr", ps, depth, &ptr))
5450 return False;
5451
5452 if (ptr) {
5453 if(!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5454 return False;
5455 }
5456
5457 if (!prs_align(ps))
5458 return False;
5459
5460 if (!prs_uint32("ptr", ps, depth, &ptr))
5461 return False;
5462
5463 if (ptr) {
5464 if(!smb_io_unistr2("environment", &q_u->environment, True,
5465 ps, depth))
5466 return False;
5467 }
5468
5469 if (!prs_align(ps))
5470 return False;
5471
5472 if(!prs_uint32("level", ps, depth, &q_u->level))
5473 return False;
5474
5475 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5476 return False;
5477
5478 if(!prs_align(ps))
5479 return False;
5480
5481 if(!prs_uint32("offered", ps, depth, &q_u->offered))
5482 return False;
5483
5484 return True;
5485 }
5486
5487 /*******************************************************************
5488 * write a structure.
5489 ********************************************************************/
5490
5491 bool spoolss_io_r_getprintprocessordirectory(const char *desc, SPOOL_R_GETPRINTPROCESSORDIRECTORY *r_u, prs_struct *ps, int depth)
5492 {
5493 prs_debug(ps, depth, desc, "spoolss_io_r_getprintprocessordirectory");
5494 depth++;
5495
5496 if(!prs_align(ps))
5497 return False;
5498
5499 if(!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5500 return False;
5501
5502 if(!prs_align(ps))
5503 return False;
5504
5505 if(!prs_uint32("needed", ps, depth, &r_u->needed))
5506 return False;
5507
5508 if(!prs_werror("status", ps, depth, &r_u->status))
5509 return False;
5510
5511 return True;
5512 }
5513
5514 bool smb_io_printprocessordirectory_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_DIRECTORY_1 *info, int depth)
5515 {
5516 prs_struct *ps=&buffer->prs;
5517
5518 prs_debug(ps, depth, desc, "smb_io_printprocessordirectory_1");
5519 depth++;
5520
5521 buffer->struct_start=prs_offset(ps);
5522
5523 if (!smb_io_unistr(desc, &info->name, ps, depth))
5524 return False;
5525
5526 return True;
5527 }
5528
5529 /*******************************************************************
5530 * init a structure.
5531 ********************************************************************/
5532
5533 bool make_spoolss_q_enumforms(SPOOL_Q_ENUMFORMS *q_u, POLICY_HND *handle,
5534 uint32 level, RPC_BUFFER *buffer,
5535 uint32 offered)
5536 {
5537 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
5538 q_u->level = level;
5539 q_u->buffer=buffer;
5540 q_u->offered=offered;
5541
5542 return True;
5543 }
5544
5545 /*******************************************************************
5546 * init a structure.
5547 ********************************************************************/
5548
5549 bool make_spoolss_q_getjob(SPOOL_Q_GETJOB *q_u, POLICY_HND *handle,
5550 uint32 jobid, uint32 level, RPC_BUFFER *buffer,
5551 uint32 offered)
5552 {
5553 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
5554 q_u->jobid = jobid;
5555 q_u->level = level;
5556 q_u->buffer = buffer;
5557 q_u->offered = offered;
5558
5559 return True;
5560 }
5561
5562 /*******************************************************************
5563 * init a structure.
5564 ********************************************************************/
5565
5566 bool make_spoolss_q_rffpcnex(SPOOL_Q_RFFPCNEX *q_u, POLICY_HND *handle,
5567 uint32 flags, uint32 options, const char *localmachine,
5568 uint32 printerlocal, SPOOL_NOTIFY_OPTION *option)
5569 {
5570 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
5571
5572 q_u->flags = flags;
5573 q_u->options = options;
5574
5575 q_u->localmachine_ptr = 1;
5576
5577 init_unistr2(&q_u->localmachine, localmachine, UNI_STR_TERMINATE);
5578
5579 q_u->printerlocal = printerlocal;
5580
5581 if (option)
5582 q_u->option_ptr = 1;
5583
5584 q_u->option = option;
5585
5586 return True;
5587 }
5588
5589
5590 /*******************************************************************
5591 ********************************************************************/
5592
5593 bool spoolss_io_q_xcvdataport(const char *desc, SPOOL_Q_XCVDATAPORT *q_u, prs_struct *ps, int depth)
5594 {
5595 prs_debug(ps, depth, desc, "spoolss_io_q_xcvdataport");
5596 depth++;
5597
5598 if(!prs_align(ps))
5599 return False;
5600
5601 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5602 return False;
5603
5604 if(!smb_io_unistr2("", &q_u->dataname, True, ps, depth))
5605 return False;
5606
5607 if (!prs_align(ps))
5608 return False;
5609
5610 if(!prs_rpcbuffer("", ps, depth, &q_u->indata))
5611 return False;
5612
5613 if (!prs_align(ps))
5614 return False;
5615
5616 if (!prs_uint32("indata_len", ps, depth, &q_u->indata_len))
5617 return False;
5618 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5619 return False;
5620 if (!prs_uint32("unknown", ps, depth, &q_u->unknown))
5621 return False;
5622
5623 return True;
5624 }
5625
5626 /*******************************************************************
5627 ********************************************************************/
5628
5629 bool spoolss_io_r_xcvdataport(const char *desc, SPOOL_R_XCVDATAPORT *r_u, prs_struct *ps, int depth)
5630 {
5631 prs_debug(ps, depth, desc, "spoolss_io_r_xcvdataport");
5632 depth++;
5633
5634 if(!prs_align(ps))
5635 return False;
5636 if(!prs_rpcbuffer("", ps, depth, &r_u->outdata))
5637 return False;
5638
5639 if (!prs_align(ps))
5640 return False;
5641
5642 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5643 return False;
5644 if (!prs_uint32("unknown", ps, depth, &r_u->unknown))
5645 return False;
5646
5647 if(!prs_werror("status", ps, depth, &r_u->status))
5648 return False;
5649
5650 return True;
5651 }
5652
5653 /*******************************************************************
5654 ********************************************************************/
5655
5656 bool make_monitorui_buf( RPC_BUFFER *buf, const char *dllname )
5657 {
5658 UNISTR string;
5659
5660 if ( !buf )
5661 return False;
5662
5663 init_unistr( &string, dllname );
5664
5665 if ( !prs_unistr( "ui_dll", &buf->prs, 0, &string ) )
5666 return False;
5667
5668 return True;
5669 }
5670
5671 /*******************************************************************
5672 ********************************************************************/
5673
5674 #define PORT_DATA_1_PAD 540
5675
5676 static bool smb_io_port_data_1( const char *desc, RPC_BUFFER *buf, int depth, SPOOL_PORT_DATA_1 *p1 )
5677 {
5678 prs_struct *ps = &buf->prs;
5679 uint8 padding[PORT_DATA_1_PAD];
5680
5681 prs_debug(ps, depth, desc, "smb_io_port_data_1");
5682 depth++;
5683
5684 if(!prs_align(ps))
5685 return False;
5686
5687 if( !prs_uint16s(True, "portname", ps, depth, p1->portname, MAX_PORTNAME))
5688 return False;
5689
5690 if (!prs_uint32("version", ps, depth, &p1->version))
5691 return False;
5692 if (!prs_uint32("protocol", ps, depth, &p1->protocol))
5693 return False;
5694 if (!prs_uint32("size", ps, depth, &p1->size))
5695 return False;
5696 if (!prs_uint32("reserved", ps, depth, &p1->reserved))
5697 return False;
5698
5699 if( !prs_uint16s(True, "hostaddress", ps, depth, p1->hostaddress, MAX_NETWORK_NAME))
5700 return False;
5701 if( !prs_uint16s(True, "snmpcommunity", ps, depth, p1->snmpcommunity, MAX_SNMP_COMM_NAME))
5702 return False;
5703
5704 if (!prs_uint32("dblspool", ps, depth, &p1->dblspool))
5705 return False;
5706
5707 if( !prs_uint16s(True, "queue", ps, depth, p1->queue, MAX_QUEUE_NAME))
5708 return False;
5709 if( !prs_uint16s(True, "ipaddress", ps, depth, p1->ipaddress, MAX_IPADDR_STRING))
5710 return False;
5711
5712 if( !prs_uint8s(False, "", ps, depth, padding, PORT_DATA_1_PAD))
5713 return False;
5714
5715 if (!prs_uint32("port", ps, depth, &p1->port))
5716 return False;
5717 if (!prs_uint32("snmpenabled", ps, depth, &p1->snmpenabled))
5718 return False;
5719 if (!prs_uint32("snmpdevindex", ps, depth, &p1->snmpdevindex))
5720 return False;
5721
5722 return True;
5723 }
5724
5725 /*******************************************************************
5726 ********************************************************************/
5727
5728 bool convert_port_data_1( NT_PORT_DATA_1 *port1, RPC_BUFFER *buf )
5729 {
5730 SPOOL_PORT_DATA_1 spdata_1;
5731
5732 ZERO_STRUCT( spdata_1 );
5733
5734 if ( !smb_io_port_data_1( "port_data_1", buf, 0, &spdata_1 ) )
5735 return False;
5736
5737 rpcstr_pull(port1->name, spdata_1.portname, sizeof(port1->name), -1, 0);
5738 rpcstr_pull(port1->queue, spdata_1.queue, sizeof(port1->queue), -1, 0);
5739 rpcstr_pull(port1->hostaddr, spdata_1.hostaddress, sizeof(port1->hostaddr), -1, 0);
5740
5741 port1->port = spdata_1.port;
5742
5743 switch ( spdata_1.protocol ) {
5744 case 1:
5745 port1->protocol = PORT_PROTOCOL_DIRECT;
5746 break;
5747 case 2:
5748 port1->protocol = PORT_PROTOCOL_LPR;
5749 break;
5750 default:
5751 DEBUG(3,("convert_port_data_1: unknown protocol [%d]!\n",
5752 spdata_1.protocol));
5753 return False;
5754 }
5755
5756 return True;
5757 }
Samba GIT mirror