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.
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.
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.
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/>.
27 #define DBGC_CLASS DBGC_RPC_PARSE
30 /*******************************************************************
31 This should be moved in a more generic lib.
32 ********************************************************************/
34 BOOL
spoolss_io_system_time(const char *desc
, prs_struct
*ps
, int depth
, SYSTEMTIME
*systime
)
36 if(!prs_uint16("year", ps
, depth
, &systime
->year
))
38 if(!prs_uint16("month", ps
, depth
, &systime
->month
))
40 if(!prs_uint16("dayofweek", ps
, depth
, &systime
->dayofweek
))
42 if(!prs_uint16("day", ps
, depth
, &systime
->day
))
44 if(!prs_uint16("hour", ps
, depth
, &systime
->hour
))
46 if(!prs_uint16("minute", ps
, depth
, &systime
->minute
))
48 if(!prs_uint16("second", ps
, depth
, &systime
->second
))
50 if(!prs_uint16("milliseconds", ps
, depth
, &systime
->milliseconds
))
56 /*******************************************************************
57 ********************************************************************/
59 BOOL
make_systemtime(SYSTEMTIME
*systime
, struct tm
*unixtime
)
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;
73 /*******************************************************************
74 reads or writes an DOC_INFO structure.
75 ********************************************************************/
77 static BOOL
smb_io_doc_info_1(const char *desc
, DOC_INFO_1
*info_1
, prs_struct
*ps
, int depth
)
79 if (info_1
== NULL
) return False
;
81 prs_debug(ps
, depth
, desc
, "smb_io_doc_info_1");
87 if(!prs_uint32("p_docname", ps
, depth
, &info_1
->p_docname
))
89 if(!prs_uint32("p_outputfile", ps
, depth
, &info_1
->p_outputfile
))
91 if(!prs_uint32("p_datatype", ps
, depth
, &info_1
->p_datatype
))
94 if(!smb_io_unistr2("", &info_1
->docname
, info_1
->p_docname
, ps
, depth
))
96 if(!smb_io_unistr2("", &info_1
->outputfile
, info_1
->p_outputfile
, ps
, depth
))
98 if(!smb_io_unistr2("", &info_1
->datatype
, info_1
->p_datatype
, ps
, depth
))
104 /*******************************************************************
105 reads or writes an DOC_INFO structure.
106 ********************************************************************/
108 static BOOL
smb_io_doc_info(const char *desc
, DOC_INFO
*info
, prs_struct
*ps
, int depth
)
110 uint32 useless_ptr
=0;
112 if (info
== NULL
) return False
;
114 prs_debug(ps
, depth
, desc
, "smb_io_doc_info");
120 if(!prs_uint32("switch_value", ps
, depth
, &info
->switch_value
))
123 if(!prs_uint32("doc_info_X ptr", ps
, depth
, &useless_ptr
))
126 switch (info
->switch_value
)
129 if(!smb_io_doc_info_1("",&info
->doc_info_1
, ps
, depth
))
134 this is just a placeholder
136 MSDN July 1998 says doc_info_2 is only on
137 Windows 95, and as Win95 doesn't do RPC to print
138 this case is nearly impossible
140 Maybe one day with Windows for dishwasher 2037 ...
143 /* smb_io_doc_info_2("",&info->doc_info_2, ps, depth); */
146 DEBUG(0,("Something is obviously wrong somewhere !\n"));
153 /*******************************************************************
154 reads or writes an DOC_INFO_CONTAINER structure.
155 ********************************************************************/
157 static BOOL
smb_io_doc_info_container(const char *desc
, DOC_INFO_CONTAINER
*cont
, prs_struct
*ps
, int depth
)
159 if (cont
== NULL
) return False
;
161 prs_debug(ps
, depth
, desc
, "smb_io_doc_info_container");
167 if(!prs_uint32("level", ps
, depth
, &cont
->level
))
170 if(!smb_io_doc_info("",&cont
->docinfo
, ps
, depth
))
176 /*******************************************************************
177 reads or writes an NOTIFY OPTION TYPE structure.
178 ********************************************************************/
180 /* NOTIFY_OPTION_TYPE and NOTIFY_OPTION_TYPE_DATA are really one
181 structure. The _TYPE structure is really the deferred referrants (i.e
182 the notify fields array) of the _TYPE structure. -tpot */
184 static BOOL
smb_io_notify_option_type(const char *desc
, SPOOL_NOTIFY_OPTION_TYPE
*type
, prs_struct
*ps
, int depth
)
186 prs_debug(ps
, depth
, desc
, "smb_io_notify_option_type");
192 if(!prs_uint16("type", ps
, depth
, &type
->type
))
194 if(!prs_uint16("reserved0", ps
, depth
, &type
->reserved0
))
196 if(!prs_uint32("reserved1", ps
, depth
, &type
->reserved1
))
198 if(!prs_uint32("reserved2", ps
, depth
, &type
->reserved2
))
200 if(!prs_uint32("count", ps
, depth
, &type
->count
))
202 if(!prs_uint32("fields_ptr", ps
, depth
, &type
->fields_ptr
))
208 /*******************************************************************
209 reads or writes an NOTIFY OPTION TYPE DATA.
210 ********************************************************************/
212 static BOOL
smb_io_notify_option_type_data(const char *desc
, SPOOL_NOTIFY_OPTION_TYPE
*type
, prs_struct
*ps
, int depth
)
216 prs_debug(ps
, depth
, desc
, "smb_io_notify_option_type_data");
219 /* if there are no fields just return */
220 if (type
->fields_ptr
==0)
226 if(!prs_uint32("count2", ps
, depth
, &type
->count2
))
229 if (type
->count2
!= type
->count
)
230 DEBUG(4,("What a mess, count was %x now is %x !\n", type
->count
, type
->count2
));
232 if (type
->count2
> MAX_NOTIFY_TYPE_FOR_NOW
) {
236 /* parse the option type data */
237 for(i
=0;i
<type
->count2
;i
++)
238 if(!prs_uint16("fields",ps
,depth
,&type
->fields
[i
]))
243 /*******************************************************************
244 reads or writes an NOTIFY OPTION structure.
245 ********************************************************************/
247 static BOOL
smb_io_notify_option_type_ctr(const char *desc
, SPOOL_NOTIFY_OPTION_TYPE_CTR
*ctr
, prs_struct
*ps
, int depth
)
251 prs_debug(ps
, depth
, desc
, "smb_io_notify_option_type_ctr");
254 if(!prs_uint32("count", ps
, depth
, &ctr
->count
))
258 if (UNMARSHALLING(ps
) && ctr
->count
)
259 if((ctr
->type
=PRS_ALLOC_MEM(ps
,SPOOL_NOTIFY_OPTION_TYPE
,ctr
->count
)) == NULL
)
262 /* the option type struct */
263 for(i
=0;i
<ctr
->count
;i
++)
264 if(!smb_io_notify_option_type("", &ctr
->type
[i
] , ps
, depth
))
267 /* the type associated with the option type struct */
268 for(i
=0;i
<ctr
->count
;i
++)
269 if(!smb_io_notify_option_type_data("", &ctr
->type
[i
] , ps
, depth
))
275 /*******************************************************************
276 reads or writes an NOTIFY OPTION structure.
277 ********************************************************************/
279 static BOOL
smb_io_notify_option(const char *desc
, SPOOL_NOTIFY_OPTION
*option
, prs_struct
*ps
, int depth
)
281 prs_debug(ps
, depth
, desc
, "smb_io_notify_option");
284 if(!prs_uint32("version", ps
, depth
, &option
->version
))
286 if(!prs_uint32("flags", ps
, depth
, &option
->flags
))
288 if(!prs_uint32("count", ps
, depth
, &option
->count
))
290 if(!prs_uint32("option_type_ptr", ps
, depth
, &option
->option_type_ptr
))
293 /* marshalling or unmarshalling, that would work */
294 if (option
->option_type_ptr
!=0) {
295 if(!smb_io_notify_option_type_ctr("", &option
->ctr
,ps
, depth
))
299 option
->ctr
.type
=NULL
;
306 /*******************************************************************
307 reads or writes an NOTIFY INFO DATA structure.
308 ********************************************************************/
310 static BOOL
smb_io_notify_info_data(const char *desc
,SPOOL_NOTIFY_INFO_DATA
*data
, prs_struct
*ps
, int depth
)
312 uint32 useless_ptr
=0x0FF0ADDE;
314 prs_debug(ps
, depth
, desc
, "smb_io_notify_info_data");
319 if(!prs_uint16("type", ps
, depth
, &data
->type
))
321 if(!prs_uint16("field", ps
, depth
, &data
->field
))
324 if(!prs_uint32("how many words", ps
, depth
, &data
->size
))
326 if(!prs_uint32("id", ps
, depth
, &data
->id
))
328 if(!prs_uint32("how many words", ps
, depth
, &data
->size
))
331 switch (data
->enc_type
) {
333 /* One and two value data has two uint32 values */
335 case NOTIFY_ONE_VALUE
:
336 case NOTIFY_TWO_VALUE
:
338 if(!prs_uint32("value[0]", ps
, depth
, &data
->notify_data
.value
[0]))
340 if(!prs_uint32("value[1]", ps
, depth
, &data
->notify_data
.value
[1]))
344 /* Pointers and strings have a string length and a
345 pointer. For a string the length is expressed as
346 the number of uint16 characters plus a trailing
351 if(!prs_uint32("string length", ps
, depth
, &data
->notify_data
.data
.length
))
353 if(!prs_uint32("pointer", ps
, depth
, &useless_ptr
))
360 if(!prs_uint32("string length", ps
, depth
, &data
->notify_data
.data
.length
))
363 if(!prs_uint32("pointer", ps
, depth
, &useless_ptr
))
369 if( !prs_uint32( "sd size", ps
, depth
, &data
->notify_data
.sd
.size
) )
371 if( !prs_uint32( "pointer", ps
, depth
, &useless_ptr
) )
377 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data\n",
385 /*******************************************************************
386 reads or writes an NOTIFY INFO DATA structure.
387 ********************************************************************/
389 BOOL
smb_io_notify_info_data_strings(const char *desc
,SPOOL_NOTIFY_INFO_DATA
*data
,
390 prs_struct
*ps
, int depth
)
392 prs_debug(ps
, depth
, desc
, "smb_io_notify_info_data_strings");
398 switch(data
->enc_type
) {
400 /* No data for values */
402 case NOTIFY_ONE_VALUE
:
403 case NOTIFY_TWO_VALUE
:
407 /* Strings start with a length in uint16s */
412 data
->notify_data
.data
.length
/= 2;
414 if(!prs_uint32("string length", ps
, depth
, &data
->notify_data
.data
.length
))
417 if (UNMARSHALLING(ps
) && data
->notify_data
.data
.length
) {
418 data
->notify_data
.data
.string
= PRS_ALLOC_MEM(ps
, uint16
,
419 data
->notify_data
.data
.length
);
421 if (!data
->notify_data
.data
.string
)
425 if (!prs_uint16uni(True
, "string", ps
, depth
, data
->notify_data
.data
.string
,
426 data
->notify_data
.data
.length
))
430 data
->notify_data
.data
.length
*= 2;
436 if (UNMARSHALLING(ps
) && data
->notify_data
.data
.length
) {
437 data
->notify_data
.data
.string
= PRS_ALLOC_MEM(ps
, uint16
,
438 data
->notify_data
.data
.length
);
440 if (!data
->notify_data
.data
.string
)
444 if(!prs_uint8s(True
,"buffer",ps
,depth
,(uint8
*)data
->notify_data
.data
.string
,data
->notify_data
.data
.length
))
450 if( !prs_uint32("secdesc size ", ps
, depth
, &data
->notify_data
.sd
.size
) )
452 if ( !sec_io_desc( "sec_desc", &data
->notify_data
.sd
.desc
, ps
, depth
) )
457 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data_strings\n",
463 if (isvalue
==False
) {
465 /* length of string in unicode include \0 */
466 x
=data
->notify_data
.data
.length
+1;
468 if (data
->field
!= 16)
469 if(!prs_uint32("string length", ps
, depth
, &x
))
472 if (MARSHALLING(ps
)) {
473 /* These are already in little endian format. Don't byte swap. */
476 /* No memory allocated for this string
477 therefore following the data.string
478 pointer is a bad idea. Use a pointer to
479 the uint32 length union member to
480 provide a source for a unicode NULL */
482 if(!prs_uint8s(True
,"string",ps
,depth
, (uint8
*)&data
->notify_data
.data
.length
,x
*2))
486 if (data
->field
== 16)
489 if(!prs_uint16uni(True
,"string",ps
,depth
,data
->notify_data
.data
.string
,x
))
494 /* Tallocate memory for string */
497 data
->notify_data
.data
.string
= PRS_ALLOC_MEM(ps
, uint16
, x
* 2);
498 if (!data
->notify_data
.data
.string
)
501 data
->notify_data
.data
.string
= NULL
;
504 if(!prs_uint16uni(True
,"string",ps
,depth
,data
->notify_data
.data
.string
,x
))
512 /* Win2k does not seem to put this parse align here */
520 /*******************************************************************
521 reads or writes an NOTIFY INFO structure.
522 ********************************************************************/
524 static BOOL
smb_io_notify_info(const char *desc
, SPOOL_NOTIFY_INFO
*info
, prs_struct
*ps
, int depth
)
528 prs_debug(ps
, depth
, desc
, "smb_io_notify_info");
534 if(!prs_uint32("count", ps
, depth
, &info
->count
))
536 if(!prs_uint32("version", ps
, depth
, &info
->version
))
538 if(!prs_uint32("flags", ps
, depth
, &info
->flags
))
540 if(!prs_uint32("count", ps
, depth
, &info
->count
))
543 for (i
=0;i
<info
->count
;i
++) {
544 if(!smb_io_notify_info_data(desc
, &info
->data
[i
], ps
, depth
))
548 /* now do the strings at the end of the stream */
549 for (i
=0;i
<info
->count
;i
++) {
550 if(!smb_io_notify_info_data_strings(desc
, &info
->data
[i
], ps
, depth
))
557 /*******************************************************************
558 ********************************************************************/
560 BOOL
spool_io_user_level_1( const char *desc
, prs_struct
*ps
, int depth
, SPOOL_USER_1
*q_u
)
562 prs_debug(ps
, depth
, desc
, "");
568 if (!prs_uint32("size", ps
, depth
, &q_u
->size
))
571 if (!prs_io_unistr2_p("", ps
, depth
, &q_u
->client_name
))
573 if (!prs_io_unistr2_p("", ps
, depth
, &q_u
->user_name
))
576 if (!prs_uint32("build", ps
, depth
, &q_u
->build
))
578 if (!prs_uint32("major", ps
, depth
, &q_u
->major
))
580 if (!prs_uint32("minor", ps
, depth
, &q_u
->minor
))
582 if (!prs_uint32("processor", ps
, depth
, &q_u
->processor
))
585 if (!prs_io_unistr2("", ps
, depth
, q_u
->client_name
))
590 if (!prs_io_unistr2("", ps
, depth
, q_u
->user_name
))
596 /*******************************************************************
597 ********************************************************************/
599 static BOOL
spool_io_user_level(const char *desc
, SPOOL_USER_CTR
*q_u
, prs_struct
*ps
, int depth
)
604 prs_debug(ps
, depth
, desc
, "spool_io_user_level");
610 if (!prs_uint32("level", ps
, depth
, &q_u
->level
))
613 switch ( q_u
->level
)
616 if ( !prs_pointer( "" , ps
, depth
, (void*)&q_u
->user
.user1
,
617 sizeof(SPOOL_USER_1
), (PRS_POINTER_CAST
)spool_io_user_level_1
))
629 /*******************************************************************
630 * read or write a DEVICEMODE struct.
631 * on reading allocate memory for the private member
632 ********************************************************************/
634 #define DM_NUM_OPTIONAL_FIELDS 8
636 BOOL
spoolss_io_devmode(const char *desc
, prs_struct
*ps
, int depth
, DEVICEMODE
*devmode
)
638 int available_space
; /* size of the device mode left to parse */
639 /* only important on unmarshalling */
641 uint16
*unistr_buffer
;
644 struct optional_fields
{
647 } opt_fields
[DM_NUM_OPTIONAL_FIELDS
] = {
648 { "icmmethod", NULL
},
649 { "icmintent", NULL
},
650 { "mediatype", NULL
},
651 { "dithertype", NULL
},
652 { "reserved1", NULL
},
653 { "reserved2", NULL
},
654 { "panningwidth", NULL
},
655 { "panningheight", NULL
}
658 /* assign at run time to keep non-gcc compilers happy */
660 opt_fields
[0].field
= &devmode
->icmmethod
;
661 opt_fields
[1].field
= &devmode
->icmintent
;
662 opt_fields
[2].field
= &devmode
->mediatype
;
663 opt_fields
[3].field
= &devmode
->dithertype
;
664 opt_fields
[4].field
= &devmode
->reserved1
;
665 opt_fields
[5].field
= &devmode
->reserved2
;
666 opt_fields
[6].field
= &devmode
->panningwidth
;
667 opt_fields
[7].field
= &devmode
->panningheight
;
670 prs_debug(ps
, depth
, desc
, "spoolss_io_devmode");
673 if (UNMARSHALLING(ps
)) {
674 devmode
->devicename
.buffer
= PRS_ALLOC_MEM(ps
, uint16
, MAXDEVICENAME
);
675 if (devmode
->devicename
.buffer
== NULL
)
677 unistr_buffer
= devmode
->devicename
.buffer
;
680 /* devicename is a static sized string but the buffer we set is not */
681 unistr_buffer
= PRS_ALLOC_MEM(ps
, uint16
, MAXDEVICENAME
);
682 memset( unistr_buffer
, 0x0, MAXDEVICENAME
);
683 for ( j
=0; devmode
->devicename
.buffer
[j
]; j
++ )
684 unistr_buffer
[j
] = devmode
->devicename
.buffer
[j
];
687 if (!prs_uint16uni(True
,"devicename", ps
, depth
, unistr_buffer
, MAXDEVICENAME
))
690 if (!prs_uint16("specversion", ps
, depth
, &devmode
->specversion
))
693 if (!prs_uint16("driverversion", ps
, depth
, &devmode
->driverversion
))
695 if (!prs_uint16("size", ps
, depth
, &devmode
->size
))
697 if (!prs_uint16("driverextra", ps
, depth
, &devmode
->driverextra
))
699 if (!prs_uint32("fields", ps
, depth
, &devmode
->fields
))
701 if (!prs_uint16("orientation", ps
, depth
, &devmode
->orientation
))
703 if (!prs_uint16("papersize", ps
, depth
, &devmode
->papersize
))
705 if (!prs_uint16("paperlength", ps
, depth
, &devmode
->paperlength
))
707 if (!prs_uint16("paperwidth", ps
, depth
, &devmode
->paperwidth
))
709 if (!prs_uint16("scale", ps
, depth
, &devmode
->scale
))
711 if (!prs_uint16("copies", ps
, depth
, &devmode
->copies
))
713 if (!prs_uint16("defaultsource", ps
, depth
, &devmode
->defaultsource
))
715 if (!prs_uint16("printquality", ps
, depth
, &devmode
->printquality
))
717 if (!prs_uint16("color", ps
, depth
, &devmode
->color
))
719 if (!prs_uint16("duplex", ps
, depth
, &devmode
->duplex
))
721 if (!prs_uint16("yresolution", ps
, depth
, &devmode
->yresolution
))
723 if (!prs_uint16("ttoption", ps
, depth
, &devmode
->ttoption
))
725 if (!prs_uint16("collate", ps
, depth
, &devmode
->collate
))
728 if (UNMARSHALLING(ps
)) {
729 devmode
->formname
.buffer
= PRS_ALLOC_MEM(ps
, uint16
, MAXDEVICENAME
);
730 if (devmode
->formname
.buffer
== NULL
)
732 unistr_buffer
= devmode
->formname
.buffer
;
735 /* devicename is a static sized string but the buffer we set is not */
736 unistr_buffer
= PRS_ALLOC_MEM(ps
, uint16
, MAXDEVICENAME
);
737 memset( unistr_buffer
, 0x0, MAXDEVICENAME
);
738 for ( j
=0; devmode
->formname
.buffer
[j
]; j
++ )
739 unistr_buffer
[j
] = devmode
->formname
.buffer
[j
];
742 if (!prs_uint16uni(True
, "formname", ps
, depth
, unistr_buffer
, MAXDEVICENAME
))
744 if (!prs_uint16("logpixels", ps
, depth
, &devmode
->logpixels
))
746 if (!prs_uint32("bitsperpel", ps
, depth
, &devmode
->bitsperpel
))
748 if (!prs_uint32("pelswidth", ps
, depth
, &devmode
->pelswidth
))
750 if (!prs_uint32("pelsheight", ps
, depth
, &devmode
->pelsheight
))
752 if (!prs_uint32("displayflags", ps
, depth
, &devmode
->displayflags
))
754 if (!prs_uint32("displayfrequency", ps
, depth
, &devmode
->displayfrequency
))
757 * every device mode I've ever seen on the wire at least has up
758 * to the displayfrequency field. --jerry (05-09-2002)
761 /* add uint32's + uint16's + two UNICODE strings */
763 available_space
= devmode
->size
- (sizeof(uint32
)*6 + sizeof(uint16
)*18 + sizeof(uint16
)*64);
765 /* Sanity check - we only have uint32's left tp parse */
767 if ( available_space
&& ((available_space
% sizeof(uint32
)) != 0) ) {
768 DEBUG(0,("spoolss_io_devmode: available_space [%d] no in multiple of 4 bytes (size = %d)!\n",
769 available_space
, devmode
->size
));
770 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
775 * Conditional parsing. Assume that the DeviceMode has been
776 * zero'd by the caller.
779 while ((available_space
> 0) && (i
< DM_NUM_OPTIONAL_FIELDS
))
781 DEBUG(11, ("spoolss_io_devmode: [%d] bytes left to parse in devmode\n", available_space
));
782 if (!prs_uint32(opt_fields
[i
].name
, ps
, depth
, opt_fields
[i
].field
))
784 available_space
-= sizeof(uint32
);
788 /* Sanity Check - we should no available space at this point unless
789 MS changes the device mode structure */
791 if (available_space
) {
792 DEBUG(0,("spoolss_io_devmode: I've parsed all I know and there is still stuff left|\n"));
793 DEBUG(0,("spoolss_io_devmode: available_space = [%d], devmode_size = [%d]!\n",
794 available_space
, devmode
->size
));
795 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
800 if (devmode
->driverextra
!=0) {
801 if (UNMARSHALLING(ps
)) {
802 devmode
->dev_private
=PRS_ALLOC_MEM(ps
, uint8
, devmode
->driverextra
);
803 if(devmode
->dev_private
== NULL
)
805 DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for dev_private\n",devmode
->driverextra
));
808 DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of dev_private\n",devmode
->driverextra
));
809 if (!prs_uint8s(False
, "dev_private", ps
, depth
,
810 devmode
->dev_private
, devmode
->driverextra
))
817 /*******************************************************************
818 Read or write a DEVICEMODE container
819 ********************************************************************/
821 static BOOL
spoolss_io_devmode_cont(const char *desc
, DEVMODE_CTR
*dm_c
, prs_struct
*ps
, int depth
)
826 prs_debug(ps
, depth
, desc
, "spoolss_io_devmode_cont");
832 if (!prs_uint32("size", ps
, depth
, &dm_c
->size
))
835 if (!prs_uint32("devmode_ptr", ps
, depth
, &dm_c
->devmode_ptr
))
838 if (dm_c
->size
==0 || dm_c
->devmode_ptr
==0) {
839 if (UNMARSHALLING(ps
))
840 /* if while reading there is no DEVMODE ... */
845 /* so we have a DEVICEMODE to follow */
846 if (UNMARSHALLING(ps
)) {
847 DEBUG(9,("Allocating memory for spoolss_io_devmode\n"));
848 dm_c
->devmode
=PRS_ALLOC_MEM(ps
,DEVICEMODE
,1);
849 if(dm_c
->devmode
== NULL
)
853 /* this is bad code, shouldn't be there */
854 if (!prs_uint32("size", ps
, depth
, &dm_c
->size
))
857 if (!spoolss_io_devmode(desc
, ps
, depth
, dm_c
->devmode
))
863 /*******************************************************************
864 ********************************************************************/
866 static BOOL
spoolss_io_printer_default(const char *desc
, PRINTER_DEFAULT
*pd
, prs_struct
*ps
, int depth
)
871 prs_debug(ps
, depth
, desc
, "spoolss_io_printer_default");
874 if (!prs_uint32("datatype_ptr", ps
, depth
, &pd
->datatype_ptr
))
877 if (!smb_io_unistr2("datatype", &pd
->datatype
, pd
->datatype_ptr
, ps
,depth
))
883 if (!spoolss_io_devmode_cont("", &pd
->devmode_cont
, ps
, depth
))
889 if (!prs_uint32("access_required", ps
, depth
, &pd
->access_required
))
895 /*******************************************************************
897 ********************************************************************/
899 BOOL
make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX
*q_u
,
900 const fstring printername
,
901 const fstring datatype
,
902 uint32 access_required
,
903 const fstring clientname
,
904 const fstring user_name
)
906 DEBUG(5,("make_spoolss_q_open_printer_ex\n"));
908 q_u
->printername
= TALLOC_P( talloc_tos(), UNISTR2
);
909 if (!q_u
->printername
) {
912 init_unistr2(q_u
->printername
, printername
, UNI_STR_TERMINATE
);
914 q_u
->printer_default
.datatype_ptr
= 0;
916 q_u
->printer_default
.devmode_cont
.size
=0;
917 q_u
->printer_default
.devmode_cont
.devmode_ptr
=0;
918 q_u
->printer_default
.devmode_cont
.devmode
=NULL
;
919 q_u
->printer_default
.access_required
=access_required
;
921 q_u
->user_switch
= 1;
923 q_u
->user_ctr
.level
= 1;
924 q_u
->user_ctr
.user
.user1
= TALLOC_P( talloc_tos(), SPOOL_USER_1
);
925 if (!q_u
->user_ctr
.user
.user1
) {
928 q_u
->user_ctr
.user
.user1
->size
= strlen(clientname
) + strlen(user_name
) + 10;
929 q_u
->user_ctr
.user
.user1
->build
= 1381;
930 q_u
->user_ctr
.user
.user1
->major
= 2;
931 q_u
->user_ctr
.user
.user1
->minor
= 0;
932 q_u
->user_ctr
.user
.user1
->processor
= 0;
934 q_u
->user_ctr
.user
.user1
->client_name
= TALLOC_P( talloc_tos(), UNISTR2
);
935 if (!q_u
->user_ctr
.user
.user1
->client_name
) {
938 q_u
->user_ctr
.user
.user1
->user_name
= TALLOC_P( talloc_tos(), UNISTR2
);
939 if (!q_u
->user_ctr
.user
.user1
->user_name
) {
943 init_unistr2(q_u
->user_ctr
.user
.user1
->client_name
, clientname
, UNI_STR_TERMINATE
);
944 init_unistr2(q_u
->user_ctr
.user
.user1
->user_name
, user_name
, UNI_STR_TERMINATE
);
949 /*******************************************************************
951 ********************************************************************/
953 BOOL
make_spoolss_q_addprinterex( TALLOC_CTX
*mem_ctx
, SPOOL_Q_ADDPRINTEREX
*q_u
,
954 const char *srv_name
, const char* clientname
, const char* user_name
,
955 uint32 level
, PRINTER_INFO_CTR
*ctr
)
957 DEBUG(5,("make_spoolss_q_addprinterex\n"));
959 if (!ctr
|| !ctr
->printers_2
)
964 q_u
->server_name
= TALLOC_P( mem_ctx
, UNISTR2
);
965 if (!q_u
->server_name
) {
968 init_unistr2(q_u
->server_name
, srv_name
, UNI_FLAGS_NONE
);
972 q_u
->info
.level
= level
;
973 q_u
->info
.info_ptr
= (ctr
->printers_2
!=NULL
)?1:0;
976 /* init q_u->info.info2 from *info */
977 if (!make_spoolss_printer_info_2(mem_ctx
, &q_u
->info
.info_2
, ctr
->printers_2
)) {
978 DEBUG(0,("make_spoolss_q_addprinterex: Unable to fill SPOOL_Q_ADDPRINTEREX struct!\n"));
988 q_u
->user_ctr
.level
= 1;
989 q_u
->user_ctr
.user
.user1
= TALLOC_P( talloc_tos(), SPOOL_USER_1
);
990 if (!q_u
->user_ctr
.user
.user1
) {
993 q_u
->user_ctr
.user
.user1
->build
= 1381;
994 q_u
->user_ctr
.user
.user1
->major
= 2;
995 q_u
->user_ctr
.user
.user1
->minor
= 0;
996 q_u
->user_ctr
.user
.user1
->processor
= 0;
998 q_u
->user_ctr
.user
.user1
->client_name
= TALLOC_P( mem_ctx
, UNISTR2
);
999 if (!q_u
->user_ctr
.user
.user1
->client_name
) {
1002 q_u
->user_ctr
.user
.user1
->user_name
= TALLOC_P( mem_ctx
, UNISTR2
);
1003 if (!q_u
->user_ctr
.user
.user1
->user_name
) {
1006 init_unistr2(q_u
->user_ctr
.user
.user1
->client_name
, clientname
, UNI_STR_TERMINATE
);
1007 init_unistr2(q_u
->user_ctr
.user
.user1
->user_name
, user_name
, UNI_STR_TERMINATE
);
1009 q_u
->user_ctr
.user
.user1
->size
= q_u
->user_ctr
.user
.user1
->user_name
->uni_str_len
+
1010 q_u
->user_ctr
.user
.user1
->client_name
->uni_str_len
+ 2;
1015 /*******************************************************************
1016 create a SPOOL_PRINTER_INFO_2 stuct from a PRINTER_INFO_2 struct
1017 *******************************************************************/
1019 BOOL
make_spoolss_printer_info_2(TALLOC_CTX
*mem_ctx
, SPOOL_PRINTER_INFO_LEVEL_2
**spool_info2
,
1020 PRINTER_INFO_2
*info
)
1023 SPOOL_PRINTER_INFO_LEVEL_2
*inf
;
1025 /* allocate the necessary memory */
1026 if (!(inf
=TALLOC_P(mem_ctx
, SPOOL_PRINTER_INFO_LEVEL_2
))) {
1027 DEBUG(0,("make_spoolss_printer_info_2: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_2 sruct!\n"));
1031 inf
->servername_ptr
= (info
->servername
.buffer
!=NULL
)?1:0;
1032 inf
->printername_ptr
= (info
->printername
.buffer
!=NULL
)?1:0;
1033 inf
->sharename_ptr
= (info
->sharename
.buffer
!=NULL
)?1:0;
1034 inf
->portname_ptr
= (info
->portname
.buffer
!=NULL
)?1:0;
1035 inf
->drivername_ptr
= (info
->drivername
.buffer
!=NULL
)?1:0;
1036 inf
->comment_ptr
= (info
->comment
.buffer
!=NULL
)?1:0;
1037 inf
->location_ptr
= (info
->location
.buffer
!=NULL
)?1:0;
1038 inf
->devmode_ptr
= (info
->devmode
!=NULL
)?1:0;
1039 inf
->sepfile_ptr
= (info
->sepfile
.buffer
!=NULL
)?1:0;
1040 inf
->printprocessor_ptr
= (info
->printprocessor
.buffer
!=NULL
)?1:0;
1041 inf
->datatype_ptr
= (info
->datatype
.buffer
!=NULL
)?1:0;
1042 inf
->parameters_ptr
= (info
->parameters
.buffer
!=NULL
)?1:0;
1043 inf
->secdesc_ptr
= (info
->secdesc
!=NULL
)?1:0;
1044 inf
->attributes
= info
->attributes
;
1045 inf
->priority
= info
->priority
;
1046 inf
->default_priority
= info
->defaultpriority
;
1047 inf
->starttime
= info
->starttime
;
1048 inf
->untiltime
= info
->untiltime
;
1049 inf
->cjobs
= info
->cjobs
;
1050 inf
->averageppm
= info
->averageppm
;
1051 init_unistr2_from_unistr(&inf
->servername
, &info
->servername
);
1052 init_unistr2_from_unistr(&inf
->printername
, &info
->printername
);
1053 init_unistr2_from_unistr(&inf
->sharename
, &info
->sharename
);
1054 init_unistr2_from_unistr(&inf
->portname
, &info
->portname
);
1055 init_unistr2_from_unistr(&inf
->drivername
, &info
->drivername
);
1056 init_unistr2_from_unistr(&inf
->comment
, &info
->comment
);
1057 init_unistr2_from_unistr(&inf
->location
, &info
->location
);
1058 init_unistr2_from_unistr(&inf
->sepfile
, &info
->sepfile
);
1059 init_unistr2_from_unistr(&inf
->printprocessor
, &info
->printprocessor
);
1060 init_unistr2_from_unistr(&inf
->datatype
, &info
->datatype
);
1061 init_unistr2_from_unistr(&inf
->parameters
, &info
->parameters
);
1062 init_unistr2_from_unistr(&inf
->datatype
, &info
->datatype
);
1069 /*******************************************************************
1070 create a SPOOL_PRINTER_INFO_3 struct from a PRINTER_INFO_3 struct
1071 *******************************************************************/
1073 BOOL
make_spoolss_printer_info_3(TALLOC_CTX
*mem_ctx
, SPOOL_PRINTER_INFO_LEVEL_3
**spool_info3
,
1074 PRINTER_INFO_3
*info
)
1077 SPOOL_PRINTER_INFO_LEVEL_3
*inf
;
1079 /* allocate the necessary memory */
1080 if (!(inf
=TALLOC_P(mem_ctx
, SPOOL_PRINTER_INFO_LEVEL_3
))) {
1081 DEBUG(0,("make_spoolss_printer_info_3: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_3 sruct!\n"));
1085 inf
->secdesc_ptr
= (info
->secdesc
!=NULL
)?1:0;
1092 /*******************************************************************
1093 create a SPOOL_PRINTER_INFO_7 struct from a PRINTER_INFO_7 struct
1094 *******************************************************************/
1096 BOOL
make_spoolss_printer_info_7(TALLOC_CTX
*mem_ctx
, SPOOL_PRINTER_INFO_LEVEL_7
**spool_info7
,
1097 PRINTER_INFO_7
*info
)
1100 SPOOL_PRINTER_INFO_LEVEL_7
*inf
;
1102 /* allocate the necessary memory */
1103 if (!(inf
=TALLOC_P(mem_ctx
, SPOOL_PRINTER_INFO_LEVEL_7
))) {
1104 DEBUG(0,("make_spoolss_printer_info_7: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_7 struct!\n"));
1108 inf
->guid_ptr
= (info
->guid
.buffer
!=NULL
)?1:0;
1109 inf
->action
= info
->action
;
1110 init_unistr2_from_unistr(&inf
->guid
, &info
->guid
);
1118 /*******************************************************************
1120 * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1121 ********************************************************************/
1123 BOOL
spoolss_io_q_open_printer(const char *desc
, SPOOL_Q_OPEN_PRINTER
*q_u
, prs_struct
*ps
, int depth
)
1128 prs_debug(ps
, depth
, desc
, "spoolss_io_q_open_printer");
1134 if (!prs_io_unistr2_p("ptr", ps
, depth
, &q_u
->printername
))
1136 if (!prs_io_unistr2("printername", ps
, depth
, q_u
->printername
))
1142 if (!spoolss_io_printer_default("", &q_u
->printer_default
, ps
, depth
))
1148 /*******************************************************************
1149 * write a structure.
1150 * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1151 * called from spoolss_open_printer_ex (cli_spoolss.c)
1152 ********************************************************************/
1154 BOOL
spoolss_io_r_open_printer(const char *desc
, SPOOL_R_OPEN_PRINTER
*r_u
, prs_struct
*ps
, int depth
)
1156 if (r_u
== NULL
) return False
;
1158 prs_debug(ps
, depth
, desc
, "spoolss_io_r_open_printer");
1164 if (!smb_io_pol_hnd("printer handle",&(r_u
->handle
),ps
,depth
))
1167 if (!prs_werror("status code", ps
, depth
, &(r_u
->status
)))
1174 /*******************************************************************
1176 * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1177 ********************************************************************/
1179 BOOL
spoolss_io_q_open_printer_ex(const char *desc
, SPOOL_Q_OPEN_PRINTER_EX
*q_u
, prs_struct
*ps
, int depth
)
1184 prs_debug(ps
, depth
, desc
, "spoolss_io_q_open_printer_ex");
1190 if (!prs_io_unistr2_p("ptr", ps
, depth
, &q_u
->printername
))
1192 if (!prs_io_unistr2("printername", ps
, depth
, q_u
->printername
))
1198 if (!spoolss_io_printer_default("", &q_u
->printer_default
, ps
, depth
))
1201 if (!prs_uint32("user_switch", ps
, depth
, &q_u
->user_switch
))
1203 if (!spool_io_user_level("", &q_u
->user_ctr
, ps
, depth
))
1209 /*******************************************************************
1210 * write a structure.
1211 * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1212 * called from spoolss_open_printer_ex (cli_spoolss.c)
1213 ********************************************************************/
1215 BOOL
spoolss_io_r_open_printer_ex(const char *desc
, SPOOL_R_OPEN_PRINTER_EX
*r_u
, prs_struct
*ps
, int depth
)
1217 if (r_u
== NULL
) return False
;
1219 prs_debug(ps
, depth
, desc
, "spoolss_io_r_open_printer_ex");
1225 if (!smb_io_pol_hnd("printer handle",&(r_u
->handle
),ps
,depth
))
1228 if (!prs_werror("status code", ps
, depth
, &(r_u
->status
)))
1234 /*******************************************************************
1236 ********************************************************************/
1237 BOOL
make_spoolss_q_deleteprinterdriverex( TALLOC_CTX
*mem_ctx
,
1238 SPOOL_Q_DELETEPRINTERDRIVEREX
*q_u
,
1244 DEBUG(5,("make_spoolss_q_deleteprinterdriverex\n"));
1246 q_u
->server_ptr
= (server
!=NULL
)?1:0;
1247 q_u
->delete_flags
= DPD_DELETE_UNUSED_FILES
;
1249 /* these must be NULL terminated or else NT4 will
1250 complain about invalid parameters --jerry */
1251 init_unistr2(&q_u
->server
, server
, UNI_STR_TERMINATE
);
1252 init_unistr2(&q_u
->arch
, arch
, UNI_STR_TERMINATE
);
1253 init_unistr2(&q_u
->driver
, driver
, UNI_STR_TERMINATE
);
1256 q_u
->delete_flags
|= DPD_DELETE_SPECIFIC_VERSION
;
1257 q_u
->version
= version
;
1264 /*******************************************************************
1266 ********************************************************************/
1267 BOOL
make_spoolss_q_deleteprinterdriver(
1268 TALLOC_CTX
*mem_ctx
,
1269 SPOOL_Q_DELETEPRINTERDRIVER
*q_u
,
1275 DEBUG(5,("make_spoolss_q_deleteprinterdriver\n"));
1277 q_u
->server_ptr
= (server
!=NULL
)?1:0;
1279 /* these must be NULL terminated or else NT4 will
1280 complain about invalid parameters --jerry */
1281 init_unistr2(&q_u
->server
, server
, UNI_STR_TERMINATE
);
1282 init_unistr2(&q_u
->arch
, arch
, UNI_STR_TERMINATE
);
1283 init_unistr2(&q_u
->driver
, driver
, UNI_STR_TERMINATE
);
1288 /*******************************************************************
1290 ********************************************************************/
1292 BOOL
make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA
*q_u
,
1293 const POLICY_HND
*handle
,
1294 const char *valuename
, uint32 size
)
1296 if (q_u
== NULL
) return False
;
1298 DEBUG(5,("make_spoolss_q_getprinterdata\n"));
1300 q_u
->handle
= *handle
;
1301 init_unistr2(&q_u
->valuename
, valuename
, UNI_STR_TERMINATE
);
1307 /*******************************************************************
1309 ********************************************************************/
1311 BOOL
make_spoolss_q_getprinterdataex(SPOOL_Q_GETPRINTERDATAEX
*q_u
,
1312 const POLICY_HND
*handle
,
1313 const char *keyname
,
1314 const char *valuename
, uint32 size
)
1316 if (q_u
== NULL
) return False
;
1318 DEBUG(5,("make_spoolss_q_getprinterdataex\n"));
1320 q_u
->handle
= *handle
;
1321 init_unistr2(&q_u
->valuename
, valuename
, UNI_STR_TERMINATE
);
1322 init_unistr2(&q_u
->keyname
, keyname
, UNI_STR_TERMINATE
);
1328 /*******************************************************************
1330 * called from spoolss_q_getprinterdata (srv_spoolss.c)
1331 ********************************************************************/
1333 BOOL
spoolss_io_q_getprinterdata(const char *desc
, SPOOL_Q_GETPRINTERDATA
*q_u
, prs_struct
*ps
, int depth
)
1338 prs_debug(ps
, depth
, desc
, "spoolss_io_q_getprinterdata");
1343 if (!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
1347 if (!smb_io_unistr2("valuename", &q_u
->valuename
,True
,ps
,depth
))
1351 if (!prs_uint32("size", ps
, depth
, &q_u
->size
))
1357 /*******************************************************************
1359 * called from spoolss_q_deleteprinterdata (srv_spoolss.c)
1360 ********************************************************************/
1362 BOOL
spoolss_io_q_deleteprinterdata(const char *desc
, SPOOL_Q_DELETEPRINTERDATA
*q_u
, prs_struct
*ps
, int depth
)
1367 prs_debug(ps
, depth
, desc
, "spoolss_io_q_deleteprinterdata");
1372 if (!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
1376 if (!smb_io_unistr2("valuename", &q_u
->valuename
,True
,ps
,depth
))
1382 /*******************************************************************
1383 * write a structure.
1384 * called from spoolss_r_deleteprinterdata (srv_spoolss.c)
1385 ********************************************************************/
1387 BOOL
spoolss_io_r_deleteprinterdata(const char *desc
, SPOOL_R_DELETEPRINTERDATA
*r_u
, prs_struct
*ps
, int depth
)
1389 prs_debug(ps
, depth
, desc
, "spoolss_io_r_deleteprinterdata");
1391 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
1397 /*******************************************************************
1399 * called from spoolss_q_deleteprinterdataex (srv_spoolss.c)
1400 ********************************************************************/
1402 BOOL
spoolss_io_q_deleteprinterdataex(const char *desc
, SPOOL_Q_DELETEPRINTERDATAEX
*q_u
, prs_struct
*ps
, int depth
)
1407 prs_debug(ps
, depth
, desc
, "spoolss_io_q_deleteprinterdataex");
1412 if (!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
1415 if (!smb_io_unistr2("keyname ", &q_u
->keyname
, True
, ps
, depth
))
1417 if (!smb_io_unistr2("valuename", &q_u
->valuename
, True
, ps
, depth
))
1423 /*******************************************************************
1424 * write a structure.
1425 * called from spoolss_r_deleteprinterdataex (srv_spoolss.c)
1426 ********************************************************************/
1428 BOOL
spoolss_io_r_deleteprinterdataex(const char *desc
, SPOOL_R_DELETEPRINTERDATAEX
*r_u
, prs_struct
*ps
, int depth
)
1430 prs_debug(ps
, depth
, desc
, "spoolss_io_r_deleteprinterdataex");
1433 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
1439 /*******************************************************************
1440 * write a structure.
1441 * called from spoolss_r_getprinterdata (srv_spoolss.c)
1442 ********************************************************************/
1444 BOOL
spoolss_io_r_getprinterdata(const char *desc
, SPOOL_R_GETPRINTERDATA
*r_u
, prs_struct
*ps
, int depth
)
1449 prs_debug(ps
, depth
, desc
, "spoolss_io_r_getprinterdata");
1454 if (!prs_uint32("type", ps
, depth
, &r_u
->type
))
1456 if (!prs_uint32("size", ps
, depth
, &r_u
->size
))
1459 if (UNMARSHALLING(ps
) && r_u
->size
) {
1460 r_u
->data
= PRS_ALLOC_MEM(ps
, unsigned char, r_u
->size
);
1465 if (!prs_uint8s( False
, "data", ps
, depth
, r_u
->data
, r_u
->size
))
1471 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
1473 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
1479 /*******************************************************************
1481 ********************************************************************/
1483 BOOL
make_spoolss_q_closeprinter(SPOOL_Q_CLOSEPRINTER
*q_u
, POLICY_HND
*hnd
)
1485 if (q_u
== NULL
) return False
;
1487 DEBUG(5,("make_spoolss_q_closeprinter\n"));
1489 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
1494 /*******************************************************************
1496 * called from static spoolss_q_abortprinter (srv_spoolss.c)
1497 * called from spoolss_abortprinter (cli_spoolss.c)
1498 ********************************************************************/
1500 BOOL
spoolss_io_q_abortprinter(const char *desc
, SPOOL_Q_ABORTPRINTER
*q_u
, prs_struct
*ps
, int depth
)
1502 if (q_u
== NULL
) return False
;
1504 prs_debug(ps
, depth
, desc
, "spoolss_io_q_abortprinter");
1510 if (!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
1516 /*******************************************************************
1517 * write a structure.
1518 * called from spoolss_r_abortprinter (srv_spoolss.c)
1519 ********************************************************************/
1521 BOOL
spoolss_io_r_abortprinter(const char *desc
, SPOOL_R_ABORTPRINTER
*r_u
, prs_struct
*ps
, int depth
)
1523 prs_debug(ps
, depth
, desc
, "spoolss_io_r_abortprinter");
1525 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
1531 /*******************************************************************
1533 * called from static spoolss_q_deleteprinter (srv_spoolss.c)
1534 * called from spoolss_deleteprinter (cli_spoolss.c)
1535 ********************************************************************/
1537 BOOL
spoolss_io_q_deleteprinter(const char *desc
, SPOOL_Q_DELETEPRINTER
*q_u
, prs_struct
*ps
, int depth
)
1539 if (q_u
== NULL
) return False
;
1541 prs_debug(ps
, depth
, desc
, "spoolss_io_q_deleteprinter");
1547 if (!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
1553 /*******************************************************************
1554 * write a structure.
1555 * called from static spoolss_r_deleteprinter (srv_spoolss.c)
1556 * called from spoolss_deleteprinter (cli_spoolss.c)
1557 ********************************************************************/
1559 BOOL
spoolss_io_r_deleteprinter(const char *desc
, SPOOL_R_DELETEPRINTER
*r_u
, prs_struct
*ps
, int depth
)
1561 prs_debug(ps
, depth
, desc
, "spoolss_io_r_deleteprinter");
1567 if (!smb_io_pol_hnd("printer handle",&r_u
->handle
,ps
,depth
))
1569 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
1576 /*******************************************************************
1578 * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1579 * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1580 ********************************************************************/
1582 BOOL
spoolss_io_q_deleteprinterdriver(const char *desc
, SPOOL_Q_DELETEPRINTERDRIVER
*q_u
, prs_struct
*ps
, int depth
)
1584 if (q_u
== NULL
) return False
;
1586 prs_debug(ps
, depth
, desc
, "spoolss_io_q_deleteprinterdriver");
1592 if(!prs_uint32("server_ptr", ps
, depth
, &q_u
->server_ptr
))
1594 if(!smb_io_unistr2("server", &q_u
->server
, q_u
->server_ptr
, ps
, depth
))
1596 if(!smb_io_unistr2("arch", &q_u
->arch
, True
, ps
, depth
))
1598 if(!smb_io_unistr2("driver", &q_u
->driver
, True
, ps
, depth
))
1606 /*******************************************************************
1607 * write a structure.
1608 ********************************************************************/
1609 BOOL
spoolss_io_r_deleteprinterdriver(const char *desc
, SPOOL_R_DELETEPRINTERDRIVER
*r_u
, prs_struct
*ps
, int depth
)
1611 if (r_u
== NULL
) return False
;
1613 prs_debug(ps
, depth
, desc
, "spoolss_io_r_deleteprinterdriver");
1619 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
1626 /*******************************************************************
1628 * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1629 * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1630 ********************************************************************/
1632 BOOL
spoolss_io_q_deleteprinterdriverex(const char *desc
, SPOOL_Q_DELETEPRINTERDRIVEREX
*q_u
, prs_struct
*ps
, int depth
)
1634 if (q_u
== NULL
) return False
;
1636 prs_debug(ps
, depth
, desc
, "spoolss_io_q_deleteprinterdriverex");
1642 if(!prs_uint32("server_ptr", ps
, depth
, &q_u
->server_ptr
))
1644 if(!smb_io_unistr2("server", &q_u
->server
, q_u
->server_ptr
, ps
, depth
))
1646 if(!smb_io_unistr2("arch", &q_u
->arch
, True
, ps
, depth
))
1648 if(!smb_io_unistr2("driver", &q_u
->driver
, True
, ps
, depth
))
1654 if(!prs_uint32("delete_flags ", ps
, depth
, &q_u
->delete_flags
))
1656 if(!prs_uint32("version ", ps
, depth
, &q_u
->version
))
1664 /*******************************************************************
1665 * write a structure.
1666 ********************************************************************/
1667 BOOL
spoolss_io_r_deleteprinterdriverex(const char *desc
, SPOOL_R_DELETEPRINTERDRIVEREX
*r_u
, prs_struct
*ps
, int depth
)
1669 if (r_u
== NULL
) return False
;
1671 prs_debug(ps
, depth
, desc
, "spoolss_io_r_deleteprinterdriverex");
1677 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
1685 /*******************************************************************
1687 * called from static spoolss_q_closeprinter (srv_spoolss.c)
1688 * called from spoolss_closeprinter (cli_spoolss.c)
1689 ********************************************************************/
1691 BOOL
spoolss_io_q_closeprinter(const char *desc
, SPOOL_Q_CLOSEPRINTER
*q_u
, prs_struct
*ps
, int depth
)
1693 if (q_u
== NULL
) return False
;
1695 prs_debug(ps
, depth
, desc
, "spoolss_io_q_closeprinter");
1701 if (!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
1707 /*******************************************************************
1708 * write a structure.
1709 * called from static spoolss_r_closeprinter (srv_spoolss.c)
1710 * called from spoolss_closeprinter (cli_spoolss.c)
1711 ********************************************************************/
1713 BOOL
spoolss_io_r_closeprinter(const char *desc
, SPOOL_R_CLOSEPRINTER
*r_u
, prs_struct
*ps
, int depth
)
1715 prs_debug(ps
, depth
, desc
, "spoolss_io_r_closeprinter");
1721 if (!smb_io_pol_hnd("printer handle",&r_u
->handle
,ps
,depth
))
1723 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
1729 /*******************************************************************
1731 * called from spoolss_q_startdocprinter (srv_spoolss.c)
1732 ********************************************************************/
1734 BOOL
spoolss_io_q_startdocprinter(const char *desc
, SPOOL_Q_STARTDOCPRINTER
*q_u
, prs_struct
*ps
, int depth
)
1736 if (q_u
== NULL
) return False
;
1738 prs_debug(ps
, depth
, desc
, "spoolss_io_q_startdocprinter");
1744 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
1747 if(!smb_io_doc_info_container("",&q_u
->doc_info_container
, ps
, depth
))
1753 /*******************************************************************
1754 * write a structure.
1755 * called from spoolss_r_startdocprinter (srv_spoolss.c)
1756 ********************************************************************/
1758 BOOL
spoolss_io_r_startdocprinter(const char *desc
, SPOOL_R_STARTDOCPRINTER
*r_u
, prs_struct
*ps
, int depth
)
1760 prs_debug(ps
, depth
, desc
, "spoolss_io_r_startdocprinter");
1762 if(!prs_uint32("jobid", ps
, depth
, &r_u
->jobid
))
1764 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
1770 /*******************************************************************
1772 * called from spoolss_q_enddocprinter (srv_spoolss.c)
1773 ********************************************************************/
1775 BOOL
spoolss_io_q_enddocprinter(const char *desc
, SPOOL_Q_ENDDOCPRINTER
*q_u
, prs_struct
*ps
, int depth
)
1777 if (q_u
== NULL
) return False
;
1779 prs_debug(ps
, depth
, desc
, "spoolss_io_q_enddocprinter");
1785 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
1791 /*******************************************************************
1792 * write a structure.
1793 * called from spoolss_r_enddocprinter (srv_spoolss.c)
1794 ********************************************************************/
1796 BOOL
spoolss_io_r_enddocprinter(const char *desc
, SPOOL_R_ENDDOCPRINTER
*r_u
, prs_struct
*ps
, int depth
)
1798 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enddocprinter");
1800 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
1806 /*******************************************************************
1808 * called from spoolss_q_startpageprinter (srv_spoolss.c)
1809 ********************************************************************/
1811 BOOL
spoolss_io_q_startpageprinter(const char *desc
, SPOOL_Q_STARTPAGEPRINTER
*q_u
, prs_struct
*ps
, int depth
)
1813 if (q_u
== NULL
) return False
;
1815 prs_debug(ps
, depth
, desc
, "spoolss_io_q_startpageprinter");
1821 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
1827 /*******************************************************************
1828 * write a structure.
1829 * called from spoolss_r_startpageprinter (srv_spoolss.c)
1830 ********************************************************************/
1832 BOOL
spoolss_io_r_startpageprinter(const char *desc
, SPOOL_R_STARTPAGEPRINTER
*r_u
, prs_struct
*ps
, int depth
)
1834 prs_debug(ps
, depth
, desc
, "spoolss_io_r_startpageprinter");
1836 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
1842 /*******************************************************************
1844 * called from spoolss_q_endpageprinter (srv_spoolss.c)
1845 ********************************************************************/
1847 BOOL
spoolss_io_q_endpageprinter(const char *desc
, SPOOL_Q_ENDPAGEPRINTER
*q_u
, prs_struct
*ps
, int depth
)
1849 if (q_u
== NULL
) return False
;
1851 prs_debug(ps
, depth
, desc
, "spoolss_io_q_endpageprinter");
1857 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
1863 /*******************************************************************
1864 * write a structure.
1865 * called from spoolss_r_endpageprinter (srv_spoolss.c)
1866 ********************************************************************/
1868 BOOL
spoolss_io_r_endpageprinter(const char *desc
, SPOOL_R_ENDPAGEPRINTER
*r_u
, prs_struct
*ps
, int depth
)
1870 prs_debug(ps
, depth
, desc
, "spoolss_io_r_endpageprinter");
1872 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
1878 /*******************************************************************
1880 * called from spoolss_q_writeprinter (srv_spoolss.c)
1881 ********************************************************************/
1883 BOOL
spoolss_io_q_writeprinter(const char *desc
, SPOOL_Q_WRITEPRINTER
*q_u
, prs_struct
*ps
, int depth
)
1885 if (q_u
== NULL
) return False
;
1887 prs_debug(ps
, depth
, desc
, "spoolss_io_q_writeprinter");
1893 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
1895 if(!prs_uint32("buffer_size", ps
, depth
, &q_u
->buffer_size
))
1898 if (q_u
->buffer_size
!=0)
1900 if (UNMARSHALLING(ps
))
1901 q_u
->buffer
=PRS_ALLOC_MEM(ps
, uint8
, q_u
->buffer_size
);
1902 if(q_u
->buffer
== NULL
)
1904 if(!prs_uint8s(True
, "buffer", ps
, depth
, q_u
->buffer
, q_u
->buffer_size
))
1909 if(!prs_uint32("buffer_size2", ps
, depth
, &q_u
->buffer_size2
))
1915 /*******************************************************************
1916 * write a structure.
1917 * called from spoolss_r_writeprinter (srv_spoolss.c)
1918 ********************************************************************/
1920 BOOL
spoolss_io_r_writeprinter(const char *desc
, SPOOL_R_WRITEPRINTER
*r_u
, prs_struct
*ps
, int depth
)
1922 prs_debug(ps
, depth
, desc
, "spoolss_io_r_writeprinter");
1924 if(!prs_uint32("buffer_written", ps
, depth
, &r_u
->buffer_written
))
1926 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
1932 /*******************************************************************
1934 * called from spoolss_q_rffpcnex (srv_spoolss.c)
1935 ********************************************************************/
1937 BOOL
spoolss_io_q_rffpcnex(const char *desc
, SPOOL_Q_RFFPCNEX
*q_u
, prs_struct
*ps
, int depth
)
1939 prs_debug(ps
, depth
, desc
, "spoolss_io_q_rffpcnex");
1945 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
1947 if(!prs_uint32("flags", ps
, depth
, &q_u
->flags
))
1949 if(!prs_uint32("options", ps
, depth
, &q_u
->options
))
1951 if(!prs_uint32("localmachine_ptr", ps
, depth
, &q_u
->localmachine_ptr
))
1953 if(!smb_io_unistr2("localmachine", &q_u
->localmachine
, q_u
->localmachine_ptr
, ps
, depth
))
1959 if(!prs_uint32("printerlocal", ps
, depth
, &q_u
->printerlocal
))
1962 if(!prs_uint32("option_ptr", ps
, depth
, &q_u
->option_ptr
))
1965 if (q_u
->option_ptr
!=0) {
1967 if (UNMARSHALLING(ps
))
1968 if((q_u
->option
=PRS_ALLOC_MEM(ps
,SPOOL_NOTIFY_OPTION
,1)) == NULL
)
1971 if(!smb_io_notify_option("notify option", q_u
->option
, ps
, depth
))
1978 /*******************************************************************
1979 * write a structure.
1980 * called from spoolss_r_rffpcnex (srv_spoolss.c)
1981 ********************************************************************/
1983 BOOL
spoolss_io_r_rffpcnex(const char *desc
, SPOOL_R_RFFPCNEX
*r_u
, prs_struct
*ps
, int depth
)
1985 prs_debug(ps
, depth
, desc
, "spoolss_io_r_rffpcnex");
1988 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
1994 /*******************************************************************
1996 * called from spoolss_q_rfnpcnex (srv_spoolss.c)
1997 ********************************************************************/
1999 BOOL
spoolss_io_q_rfnpcnex(const char *desc
, SPOOL_Q_RFNPCNEX
*q_u
, prs_struct
*ps
, int depth
)
2001 prs_debug(ps
, depth
, desc
, "spoolss_io_q_rfnpcnex");
2007 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
2010 if(!prs_uint32("change", ps
, depth
, &q_u
->change
))
2013 if(!prs_uint32("option_ptr", ps
, depth
, &q_u
->option_ptr
))
2016 if (q_u
->option_ptr
!=0) {
2018 if (UNMARSHALLING(ps
))
2019 if((q_u
->option
=PRS_ALLOC_MEM(ps
,SPOOL_NOTIFY_OPTION
,1)) == NULL
)
2022 if(!smb_io_notify_option("notify option", q_u
->option
, ps
, depth
))
2029 /*******************************************************************
2030 * write a structure.
2031 * called from spoolss_r_rfnpcnex (srv_spoolss.c)
2032 ********************************************************************/
2034 BOOL
spoolss_io_r_rfnpcnex(const char *desc
, SPOOL_R_RFNPCNEX
*r_u
, prs_struct
*ps
, int depth
)
2036 prs_debug(ps
, depth
, desc
, "spoolss_io_r_rfnpcnex");
2042 if (!prs_uint32("info_ptr", ps
, depth
, &r_u
->info_ptr
))
2045 if(!smb_io_notify_info("notify info", &r_u
->info
,ps
,depth
))
2050 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
2056 /*******************************************************************
2057 * return the length of a uint16 (obvious, but the code is clean)
2058 ********************************************************************/
2060 static uint32
size_of_uint16(uint16
*value
)
2062 return (sizeof(*value
));
2065 /*******************************************************************
2066 * return the length of a uint32 (obvious, but the code is clean)
2067 ********************************************************************/
2069 static uint32
size_of_uint32(uint32
*value
)
2071 return (sizeof(*value
));
2074 /*******************************************************************
2075 * return the length of a NTTIME (obvious, but the code is clean)
2076 ********************************************************************/
2078 static uint32
size_of_nttime(NTTIME
*value
)
2080 return (sizeof(*value
));
2083 /*******************************************************************
2084 * return the length of a uint32 (obvious, but the code is clean)
2085 ********************************************************************/
2087 static uint32
size_of_device_mode(DEVICEMODE
*devmode
)
2092 return (4+devmode
->size
+devmode
->driverextra
);
2095 /*******************************************************************
2096 * return the length of a uint32 (obvious, but the code is clean)
2097 ********************************************************************/
2099 static uint32
size_of_systemtime(SYSTEMTIME
*systime
)
2104 return (sizeof(SYSTEMTIME
) +4);
2107 /*******************************************************************
2108 Parse a DEVMODE structure and its relative pointer.
2109 ********************************************************************/
2111 static BOOL
smb_io_reldevmode(const char *desc
, RPC_BUFFER
*buffer
, int depth
, DEVICEMODE
**devmode
)
2113 prs_struct
*ps
=&buffer
->prs
;
2115 prs_debug(ps
, depth
, desc
, "smb_io_reldevmode");
2118 if (MARSHALLING(ps
)) {
2119 uint32 struct_offset
= prs_offset(ps
);
2120 uint32 relative_offset
;
2122 if (*devmode
== NULL
) {
2124 if (!prs_uint32("offset", ps
, depth
, &relative_offset
))
2126 DEBUG(8, ("boing, the devmode was NULL\n"));
2131 buffer
->string_at_end
-= ((*devmode
)->size
+ (*devmode
)->driverextra
);
2133 if(!prs_set_offset(ps
, buffer
->string_at_end
))
2136 /* write the DEVMODE */
2137 if (!spoolss_io_devmode(desc
, ps
, depth
, *devmode
))
2140 if(!prs_set_offset(ps
, struct_offset
))
2143 relative_offset
=buffer
->string_at_end
- buffer
->struct_start
;
2144 /* write its offset */
2145 if (!prs_uint32("offset", ps
, depth
, &relative_offset
))
2151 /* read the offset */
2152 if (!prs_uint32("offset", ps
, depth
, &buffer
->string_at_end
))
2154 if (buffer
->string_at_end
== 0) {
2159 old_offset
= prs_offset(ps
);
2160 if(!prs_set_offset(ps
, buffer
->string_at_end
+ buffer
->struct_start
))
2163 /* read the string */
2164 if((*devmode
=PRS_ALLOC_MEM(ps
,DEVICEMODE
,1)) == NULL
)
2166 if (!spoolss_io_devmode(desc
, ps
, depth
, *devmode
))
2169 if(!prs_set_offset(ps
, old_offset
))
2175 /*******************************************************************
2176 Parse a PRINTER_INFO_0 structure.
2177 ********************************************************************/
2179 BOOL
smb_io_printer_info_0(const char *desc
, RPC_BUFFER
*buffer
, PRINTER_INFO_0
*info
, int depth
)
2181 prs_struct
*ps
=&buffer
->prs
;
2183 prs_debug(ps
, depth
, desc
, "smb_io_printer_info_0");
2186 buffer
->struct_start
=prs_offset(ps
);
2188 if (!smb_io_relstr("printername", buffer
, depth
, &info
->printername
))
2190 if (!smb_io_relstr("servername", buffer
, depth
, &info
->servername
))
2193 if(!prs_uint32("cjobs", ps
, depth
, &info
->cjobs
))
2195 if(!prs_uint32("total_jobs", ps
, depth
, &info
->total_jobs
))
2197 if(!prs_uint32("total_bytes", ps
, depth
, &info
->total_bytes
))
2200 if(!prs_uint16("year", ps
, depth
, &info
->year
))
2202 if(!prs_uint16("month", ps
, depth
, &info
->month
))
2204 if(!prs_uint16("dayofweek", ps
, depth
, &info
->dayofweek
))
2206 if(!prs_uint16("day", ps
, depth
, &info
->day
))
2208 if(!prs_uint16("hour", ps
, depth
, &info
->hour
))
2210 if(!prs_uint16("minute", ps
, depth
, &info
->minute
))
2212 if(!prs_uint16("second", ps
, depth
, &info
->second
))
2214 if(!prs_uint16("milliseconds", ps
, depth
, &info
->milliseconds
))
2217 if(!prs_uint32("global_counter", ps
, depth
, &info
->global_counter
))
2219 if(!prs_uint32("total_pages", ps
, depth
, &info
->total_pages
))
2222 if(!prs_uint16("major_version", ps
, depth
, &info
->major_version
))
2224 if(!prs_uint16("build_version", ps
, depth
, &info
->build_version
))
2226 if(!prs_uint32("unknown7", ps
, depth
, &info
->unknown7
))
2228 if(!prs_uint32("unknown8", ps
, depth
, &info
->unknown8
))
2230 if(!prs_uint32("unknown9", ps
, depth
, &info
->unknown9
))
2232 if(!prs_uint32("session_counter", ps
, depth
, &info
->session_counter
))
2234 if(!prs_uint32("unknown11", ps
, depth
, &info
->unknown11
))
2236 if(!prs_uint32("printer_errors", ps
, depth
, &info
->printer_errors
))
2238 if(!prs_uint32("unknown13", ps
, depth
, &info
->unknown13
))
2240 if(!prs_uint32("unknown14", ps
, depth
, &info
->unknown14
))
2242 if(!prs_uint32("unknown15", ps
, depth
, &info
->unknown15
))
2244 if(!prs_uint32("unknown16", ps
, depth
, &info
->unknown16
))
2246 if(!prs_uint32("change_id", ps
, depth
, &info
->change_id
))
2248 if(!prs_uint32("unknown18", ps
, depth
, &info
->unknown18
))
2250 if(!prs_uint32("status" , ps
, depth
, &info
->status
))
2252 if(!prs_uint32("unknown20", ps
, depth
, &info
->unknown20
))
2254 if(!prs_uint32("c_setprinter", ps
, depth
, &info
->c_setprinter
))
2256 if(!prs_uint16("unknown22", ps
, depth
, &info
->unknown22
))
2258 if(!prs_uint16("unknown23", ps
, depth
, &info
->unknown23
))
2260 if(!prs_uint16("unknown24", ps
, depth
, &info
->unknown24
))
2262 if(!prs_uint16("unknown25", ps
, depth
, &info
->unknown25
))
2264 if(!prs_uint16("unknown26", ps
, depth
, &info
->unknown26
))
2266 if(!prs_uint16("unknown27", ps
, depth
, &info
->unknown27
))
2268 if(!prs_uint16("unknown28", ps
, depth
, &info
->unknown28
))
2270 if(!prs_uint16("unknown29", ps
, depth
, &info
->unknown29
))
2276 /*******************************************************************
2277 Parse a PRINTER_INFO_1 structure.
2278 ********************************************************************/
2280 BOOL
smb_io_printer_info_1(const char *desc
, RPC_BUFFER
*buffer
, PRINTER_INFO_1
*info
, int depth
)
2282 prs_struct
*ps
=&buffer
->prs
;
2284 prs_debug(ps
, depth
, desc
, "smb_io_printer_info_1");
2287 buffer
->struct_start
=prs_offset(ps
);
2289 if (!prs_uint32("flags", ps
, depth
, &info
->flags
))
2291 if (!smb_io_relstr("description", buffer
, depth
, &info
->description
))
2293 if (!smb_io_relstr("name", buffer
, depth
, &info
->name
))
2295 if (!smb_io_relstr("comment", buffer
, depth
, &info
->comment
))
2301 /*******************************************************************
2302 Parse a PRINTER_INFO_2 structure.
2303 ********************************************************************/
2305 BOOL
smb_io_printer_info_2(const char *desc
, RPC_BUFFER
*buffer
, PRINTER_INFO_2
*info
, int depth
)
2307 prs_struct
*ps
=&buffer
->prs
;
2308 uint32 dm_offset
, sd_offset
, current_offset
;
2309 uint32 dummy_value
= 0, has_secdesc
= 0;
2311 prs_debug(ps
, depth
, desc
, "smb_io_printer_info_2");
2314 buffer
->struct_start
=prs_offset(ps
);
2316 if (!smb_io_relstr("servername", buffer
, depth
, &info
->servername
))
2318 if (!smb_io_relstr("printername", buffer
, depth
, &info
->printername
))
2320 if (!smb_io_relstr("sharename", buffer
, depth
, &info
->sharename
))
2322 if (!smb_io_relstr("portname", buffer
, depth
, &info
->portname
))
2324 if (!smb_io_relstr("drivername", buffer
, depth
, &info
->drivername
))
2326 if (!smb_io_relstr("comment", buffer
, depth
, &info
->comment
))
2328 if (!smb_io_relstr("location", buffer
, depth
, &info
->location
))
2331 /* save current offset and wind forwared by a uint32 */
2332 dm_offset
= prs_offset(ps
);
2333 if (!prs_uint32("devmode", ps
, depth
, &dummy_value
))
2336 if (!smb_io_relstr("sepfile", buffer
, depth
, &info
->sepfile
))
2338 if (!smb_io_relstr("printprocessor", buffer
, depth
, &info
->printprocessor
))
2340 if (!smb_io_relstr("datatype", buffer
, depth
, &info
->datatype
))
2342 if (!smb_io_relstr("parameters", buffer
, depth
, &info
->parameters
))
2345 /* save current offset for the sec_desc */
2346 sd_offset
= prs_offset(ps
);
2347 if (!prs_uint32("sec_desc", ps
, depth
, &has_secdesc
))
2351 /* save current location so we can pick back up here */
2352 current_offset
= prs_offset(ps
);
2354 /* parse the devmode */
2355 if (!prs_set_offset(ps
, dm_offset
))
2357 if (!smb_io_reldevmode("devmode", buffer
, depth
, &info
->devmode
))
2360 /* parse the sec_desc */
2361 if (info
->secdesc
) {
2362 if (!prs_set_offset(ps
, sd_offset
))
2364 if (!smb_io_relsecdesc("secdesc", buffer
, depth
, &info
->secdesc
))
2368 /* pick up where we left off */
2369 if (!prs_set_offset(ps
, current_offset
))
2372 if (!prs_uint32("attributes", ps
, depth
, &info
->attributes
))
2374 if (!prs_uint32("priority", ps
, depth
, &info
->priority
))
2376 if (!prs_uint32("defpriority", ps
, depth
, &info
->defaultpriority
))
2378 if (!prs_uint32("starttime", ps
, depth
, &info
->starttime
))
2380 if (!prs_uint32("untiltime", ps
, depth
, &info
->untiltime
))
2382 if (!prs_uint32("status", ps
, depth
, &info
->status
))
2384 if (!prs_uint32("jobs", ps
, depth
, &info
->cjobs
))
2386 if (!prs_uint32("averageppm", ps
, depth
, &info
->averageppm
))
2392 /*******************************************************************
2393 Parse a PRINTER_INFO_3 structure.
2394 ********************************************************************/
2396 BOOL
smb_io_printer_info_3(const char *desc
, RPC_BUFFER
*buffer
, PRINTER_INFO_3
*info
, int depth
)
2399 prs_struct
*ps
=&buffer
->prs
;
2401 prs_debug(ps
, depth
, desc
, "smb_io_printer_info_3");
2404 buffer
->struct_start
=prs_offset(ps
);
2406 if (MARSHALLING(ps
)) {
2407 /* Ensure the SD is 8 byte aligned in the buffer. */
2408 uint32 start
= prs_offset(ps
); /* Remember the start position. */
2411 /* Write a dummy value. */
2412 if (!prs_uint32("offset", ps
, depth
, &off_val
))
2416 if (!prs_align_uint64(ps
))
2419 /* Remember where we must seek back to write the SD. */
2420 offset
= prs_offset(ps
);
2422 /* Calculate the real offset for the SD. */
2424 off_val
= offset
- start
;
2426 /* Seek back to where we store the SD offset & store. */
2427 prs_set_offset(ps
, start
);
2428 if (!prs_uint32("offset", ps
, depth
, &off_val
))
2431 /* Return to after the 8 byte align. */
2432 prs_set_offset(ps
, offset
);
2435 if (!prs_uint32("offset", ps
, depth
, &offset
))
2437 /* Seek within the buffer. */
2438 if (!prs_set_offset(ps
, offset
))
2441 if (!sec_io_desc("sec_desc", &info
->secdesc
, ps
, depth
))
2447 /*******************************************************************
2448 Parse a PRINTER_INFO_4 structure.
2449 ********************************************************************/
2451 BOOL
smb_io_printer_info_4(const char *desc
, RPC_BUFFER
*buffer
, PRINTER_INFO_4
*info
, int depth
)
2453 prs_struct
*ps
=&buffer
->prs
;
2455 prs_debug(ps
, depth
, desc
, "smb_io_printer_info_4");
2458 buffer
->struct_start
=prs_offset(ps
);
2460 if (!smb_io_relstr("printername", buffer
, depth
, &info
->printername
))
2462 if (!smb_io_relstr("servername", buffer
, depth
, &info
->servername
))
2464 if (!prs_uint32("attributes", ps
, depth
, &info
->attributes
))
2469 /*******************************************************************
2470 Parse a PRINTER_INFO_5 structure.
2471 ********************************************************************/
2473 BOOL
smb_io_printer_info_5(const char *desc
, RPC_BUFFER
*buffer
, PRINTER_INFO_5
*info
, int depth
)
2475 prs_struct
*ps
=&buffer
->prs
;
2477 prs_debug(ps
, depth
, desc
, "smb_io_printer_info_5");
2480 buffer
->struct_start
=prs_offset(ps
);
2482 if (!smb_io_relstr("printername", buffer
, depth
, &info
->printername
))
2484 if (!smb_io_relstr("portname", buffer
, depth
, &info
->portname
))
2486 if (!prs_uint32("attributes", ps
, depth
, &info
->attributes
))
2488 if (!prs_uint32("device_not_selected_timeout", ps
, depth
, &info
->device_not_selected_timeout
))
2490 if (!prs_uint32("transmission_retry_timeout", ps
, depth
, &info
->transmission_retry_timeout
))
2495 /*******************************************************************
2496 Parse a PRINTER_INFO_6 structure.
2497 ********************************************************************/
2499 BOOL
smb_io_printer_info_6(const char *desc
, RPC_BUFFER
*buffer
,
2500 PRINTER_INFO_6
*info
, int depth
)
2502 prs_struct
*ps
=&buffer
->prs
;
2504 prs_debug(ps
, depth
, desc
, "smb_io_printer_info_6");
2507 if (!prs_uint32("status", ps
, depth
, &info
->status
))
2513 /*******************************************************************
2514 Parse a PRINTER_INFO_7 structure.
2515 ********************************************************************/
2517 BOOL
smb_io_printer_info_7(const char *desc
, RPC_BUFFER
*buffer
, PRINTER_INFO_7
*info
, int depth
)
2519 prs_struct
*ps
=&buffer
->prs
;
2521 prs_debug(ps
, depth
, desc
, "smb_io_printer_info_7");
2524 buffer
->struct_start
=prs_offset(ps
);
2526 if (!smb_io_relstr("guid", buffer
, depth
, &info
->guid
))
2528 if (!prs_uint32("action", ps
, depth
, &info
->action
))
2533 /*******************************************************************
2534 Parse a PORT_INFO_1 structure.
2535 ********************************************************************/
2537 BOOL
smb_io_port_info_1(const char *desc
, RPC_BUFFER
*buffer
, PORT_INFO_1
*info
, int depth
)
2539 prs_struct
*ps
=&buffer
->prs
;
2541 prs_debug(ps
, depth
, desc
, "smb_io_port_info_1");
2544 buffer
->struct_start
=prs_offset(ps
);
2546 if (!smb_io_relstr("port_name", buffer
, depth
, &info
->port_name
))
2552 /*******************************************************************
2553 Parse a PORT_INFO_2 structure.
2554 ********************************************************************/
2556 BOOL
smb_io_port_info_2(const char *desc
, RPC_BUFFER
*buffer
, PORT_INFO_2
*info
, int depth
)
2558 prs_struct
*ps
=&buffer
->prs
;
2560 prs_debug(ps
, depth
, desc
, "smb_io_port_info_2");
2563 buffer
->struct_start
=prs_offset(ps
);
2565 if (!smb_io_relstr("port_name", buffer
, depth
, &info
->port_name
))
2567 if (!smb_io_relstr("monitor_name", buffer
, depth
, &info
->monitor_name
))
2569 if (!smb_io_relstr("description", buffer
, depth
, &info
->description
))
2571 if (!prs_uint32("port_type", ps
, depth
, &info
->port_type
))
2573 if (!prs_uint32("reserved", ps
, depth
, &info
->reserved
))
2579 /*******************************************************************
2580 Parse a DRIVER_INFO_1 structure.
2581 ********************************************************************/
2583 BOOL
smb_io_printer_driver_info_1(const char *desc
, RPC_BUFFER
*buffer
, DRIVER_INFO_1
*info
, int depth
)
2585 prs_struct
*ps
=&buffer
->prs
;
2587 prs_debug(ps
, depth
, desc
, "smb_io_printer_driver_info_1");
2590 buffer
->struct_start
=prs_offset(ps
);
2592 if (!smb_io_relstr("name", buffer
, depth
, &info
->name
))
2598 /*******************************************************************
2599 Parse a DRIVER_INFO_2 structure.
2600 ********************************************************************/
2602 BOOL
smb_io_printer_driver_info_2(const char *desc
, RPC_BUFFER
*buffer
, DRIVER_INFO_2
*info
, int depth
)
2604 prs_struct
*ps
=&buffer
->prs
;
2606 prs_debug(ps
, depth
, desc
, "smb_io_printer_driver_info_2");
2609 buffer
->struct_start
=prs_offset(ps
);
2611 if (!prs_uint32("version", ps
, depth
, &info
->version
))
2613 if (!smb_io_relstr("name", buffer
, depth
, &info
->name
))
2615 if (!smb_io_relstr("architecture", buffer
, depth
, &info
->architecture
))
2617 if (!smb_io_relstr("driverpath", buffer
, depth
, &info
->driverpath
))
2619 if (!smb_io_relstr("datafile", buffer
, depth
, &info
->datafile
))
2621 if (!smb_io_relstr("configfile", buffer
, depth
, &info
->configfile
))
2627 /*******************************************************************
2628 Parse a DRIVER_INFO_3 structure.
2629 ********************************************************************/
2631 BOOL
smb_io_printer_driver_info_3(const char *desc
, RPC_BUFFER
*buffer
, DRIVER_INFO_3
*info
, int depth
)
2633 prs_struct
*ps
=&buffer
->prs
;
2635 prs_debug(ps
, depth
, desc
, "smb_io_printer_driver_info_3");
2638 buffer
->struct_start
=prs_offset(ps
);
2640 if (!prs_uint32("version", ps
, depth
, &info
->version
))
2642 if (!smb_io_relstr("name", buffer
, depth
, &info
->name
))
2644 if (!smb_io_relstr("architecture", buffer
, depth
, &info
->architecture
))
2646 if (!smb_io_relstr("driverpath", buffer
, depth
, &info
->driverpath
))
2648 if (!smb_io_relstr("datafile", buffer
, depth
, &info
->datafile
))
2650 if (!smb_io_relstr("configfile", buffer
, depth
, &info
->configfile
))
2652 if (!smb_io_relstr("helpfile", buffer
, depth
, &info
->helpfile
))
2655 if (!smb_io_relarraystr("dependentfiles", buffer
, depth
, &info
->dependentfiles
))
2658 if (!smb_io_relstr("monitorname", buffer
, depth
, &info
->monitorname
))
2660 if (!smb_io_relstr("defaultdatatype", buffer
, depth
, &info
->defaultdatatype
))
2666 /*******************************************************************
2667 Parse a DRIVER_INFO_6 structure.
2668 ********************************************************************/
2670 BOOL
smb_io_printer_driver_info_6(const char *desc
, RPC_BUFFER
*buffer
, DRIVER_INFO_6
*info
, int depth
)
2672 prs_struct
*ps
=&buffer
->prs
;
2674 prs_debug(ps
, depth
, desc
, "smb_io_printer_driver_info_6");
2677 buffer
->struct_start
=prs_offset(ps
);
2679 if (!prs_uint32("version", ps
, depth
, &info
->version
))
2681 if (!smb_io_relstr("name", buffer
, depth
, &info
->name
))
2683 if (!smb_io_relstr("architecture", buffer
, depth
, &info
->architecture
))
2685 if (!smb_io_relstr("driverpath", buffer
, depth
, &info
->driverpath
))
2687 if (!smb_io_relstr("datafile", buffer
, depth
, &info
->datafile
))
2689 if (!smb_io_relstr("configfile", buffer
, depth
, &info
->configfile
))
2691 if (!smb_io_relstr("helpfile", buffer
, depth
, &info
->helpfile
))
2694 if (!smb_io_relarraystr("dependentfiles", buffer
, depth
, &info
->dependentfiles
))
2697 if (!smb_io_relstr("monitorname", buffer
, depth
, &info
->monitorname
))
2699 if (!smb_io_relstr("defaultdatatype", buffer
, depth
, &info
->defaultdatatype
))
2702 if (!smb_io_relarraystr("previousdrivernames", buffer
, depth
, &info
->previousdrivernames
))
2705 if (!prs_uint64("date", ps
, depth
, &info
->driver_date
))
2708 if (!prs_uint32("padding", ps
, depth
, &info
->padding
))
2711 if (!prs_uint32("driver_version_low", ps
, depth
, &info
->driver_version_low
))
2714 if (!prs_uint32("driver_version_high", ps
, depth
, &info
->driver_version_high
))
2717 if (!smb_io_relstr("mfgname", buffer
, depth
, &info
->mfgname
))
2719 if (!smb_io_relstr("oem_url", buffer
, depth
, &info
->oem_url
))
2721 if (!smb_io_relstr("hardware_id", buffer
, depth
, &info
->hardware_id
))
2723 if (!smb_io_relstr("provider", buffer
, depth
, &info
->provider
))
2729 /*******************************************************************
2730 Parse a JOB_INFO_1 structure.
2731 ********************************************************************/
2733 BOOL
smb_io_job_info_1(const char *desc
, RPC_BUFFER
*buffer
, JOB_INFO_1
*info
, int depth
)
2735 prs_struct
*ps
=&buffer
->prs
;
2737 prs_debug(ps
, depth
, desc
, "smb_io_job_info_1");
2740 buffer
->struct_start
=prs_offset(ps
);
2742 if (!prs_uint32("jobid", ps
, depth
, &info
->jobid
))
2744 if (!smb_io_relstr("printername", buffer
, depth
, &info
->printername
))
2746 if (!smb_io_relstr("machinename", buffer
, depth
, &info
->machinename
))
2748 if (!smb_io_relstr("username", buffer
, depth
, &info
->username
))
2750 if (!smb_io_relstr("document", buffer
, depth
, &info
->document
))
2752 if (!smb_io_relstr("datatype", buffer
, depth
, &info
->datatype
))
2754 if (!smb_io_relstr("text_status", buffer
, depth
, &info
->text_status
))
2756 if (!prs_uint32("status", ps
, depth
, &info
->status
))
2758 if (!prs_uint32("priority", ps
, depth
, &info
->priority
))
2760 if (!prs_uint32("position", ps
, depth
, &info
->position
))
2762 if (!prs_uint32("totalpages", ps
, depth
, &info
->totalpages
))
2764 if (!prs_uint32("pagesprinted", ps
, depth
, &info
->pagesprinted
))
2766 if (!spoolss_io_system_time("submitted", ps
, depth
, &info
->submitted
))
2772 /*******************************************************************
2773 Parse a JOB_INFO_2 structure.
2774 ********************************************************************/
2776 BOOL
smb_io_job_info_2(const char *desc
, RPC_BUFFER
*buffer
, JOB_INFO_2
*info
, int depth
)
2779 prs_struct
*ps
=&buffer
->prs
;
2781 prs_debug(ps
, depth
, desc
, "smb_io_job_info_2");
2784 buffer
->struct_start
=prs_offset(ps
);
2786 if (!prs_uint32("jobid",ps
, depth
, &info
->jobid
))
2788 if (!smb_io_relstr("printername", buffer
, depth
, &info
->printername
))
2790 if (!smb_io_relstr("machinename", buffer
, depth
, &info
->machinename
))
2792 if (!smb_io_relstr("username", buffer
, depth
, &info
->username
))
2794 if (!smb_io_relstr("document", buffer
, depth
, &info
->document
))
2796 if (!smb_io_relstr("notifyname", buffer
, depth
, &info
->notifyname
))
2798 if (!smb_io_relstr("datatype", buffer
, depth
, &info
->datatype
))
2801 if (!smb_io_relstr("printprocessor", buffer
, depth
, &info
->printprocessor
))
2803 if (!smb_io_relstr("parameters", buffer
, depth
, &info
->parameters
))
2805 if (!smb_io_relstr("drivername", buffer
, depth
, &info
->drivername
))
2807 if (!smb_io_reldevmode("devmode", buffer
, depth
, &info
->devmode
))
2809 if (!smb_io_relstr("text_status", buffer
, depth
, &info
->text_status
))
2812 /* SEC_DESC sec_desc;*/
2813 if (!prs_uint32("Hack! sec desc", ps
, depth
, &pipo
))
2816 if (!prs_uint32("status",ps
, depth
, &info
->status
))
2818 if (!prs_uint32("priority",ps
, depth
, &info
->priority
))
2820 if (!prs_uint32("position",ps
, depth
, &info
->position
))
2822 if (!prs_uint32("starttime",ps
, depth
, &info
->starttime
))
2824 if (!prs_uint32("untiltime",ps
, depth
, &info
->untiltime
))
2826 if (!prs_uint32("totalpages",ps
, depth
, &info
->totalpages
))
2828 if (!prs_uint32("size",ps
, depth
, &info
->size
))
2830 if (!spoolss_io_system_time("submitted", ps
, depth
, &info
->submitted
) )
2832 if (!prs_uint32("timeelapsed",ps
, depth
, &info
->timeelapsed
))
2834 if (!prs_uint32("pagesprinted",ps
, depth
, &info
->pagesprinted
))
2840 /*******************************************************************
2841 ********************************************************************/
2843 BOOL
smb_io_form_1(const char *desc
, RPC_BUFFER
*buffer
, FORM_1
*info
, int depth
)
2845 prs_struct
*ps
=&buffer
->prs
;
2847 prs_debug(ps
, depth
, desc
, "smb_io_form_1");
2850 buffer
->struct_start
=prs_offset(ps
);
2852 if (!prs_uint32("flag", ps
, depth
, &info
->flag
))
2855 if (!smb_io_relstr("name", buffer
, depth
, &info
->name
))
2858 if (!prs_uint32("width", ps
, depth
, &info
->width
))
2860 if (!prs_uint32("length", ps
, depth
, &info
->length
))
2862 if (!prs_uint32("left", ps
, depth
, &info
->left
))
2864 if (!prs_uint32("top", ps
, depth
, &info
->top
))
2866 if (!prs_uint32("right", ps
, depth
, &info
->right
))
2868 if (!prs_uint32("bottom", ps
, depth
, &info
->bottom
))
2876 /*******************************************************************
2877 Parse a DRIVER_DIRECTORY_1 structure.
2878 ********************************************************************/
2880 BOOL
smb_io_driverdir_1(const char *desc
, RPC_BUFFER
*buffer
, DRIVER_DIRECTORY_1
*info
, int depth
)
2882 prs_struct
*ps
=&buffer
->prs
;
2884 prs_debug(ps
, depth
, desc
, "smb_io_driverdir_1");
2887 buffer
->struct_start
=prs_offset(ps
);
2889 if (!smb_io_unistr(desc
, &info
->name
, ps
, depth
))
2895 /*******************************************************************
2896 Parse a PORT_INFO_1 structure.
2897 ********************************************************************/
2899 BOOL
smb_io_port_1(const char *desc
, RPC_BUFFER
*buffer
, PORT_INFO_1
*info
, int depth
)
2901 prs_struct
*ps
=&buffer
->prs
;
2903 prs_debug(ps
, depth
, desc
, "smb_io_port_1");
2906 buffer
->struct_start
=prs_offset(ps
);
2908 if(!smb_io_relstr("port_name", buffer
, depth
, &info
->port_name
))
2914 /*******************************************************************
2915 Parse a PORT_INFO_2 structure.
2916 ********************************************************************/
2918 BOOL
smb_io_port_2(const char *desc
, RPC_BUFFER
*buffer
, PORT_INFO_2
*info
, int depth
)
2920 prs_struct
*ps
=&buffer
->prs
;
2922 prs_debug(ps
, depth
, desc
, "smb_io_port_2");
2925 buffer
->struct_start
=prs_offset(ps
);
2927 if(!smb_io_relstr("port_name", buffer
, depth
, &info
->port_name
))
2929 if(!smb_io_relstr("monitor_name", buffer
, depth
, &info
->monitor_name
))
2931 if(!smb_io_relstr("description", buffer
, depth
, &info
->description
))
2933 if(!prs_uint32("port_type", ps
, depth
, &info
->port_type
))
2935 if(!prs_uint32("reserved", ps
, depth
, &info
->reserved
))
2941 /*******************************************************************
2942 ********************************************************************/
2944 BOOL
smb_io_printprocessor_info_1(const char *desc
, RPC_BUFFER
*buffer
, PRINTPROCESSOR_1
*info
, int depth
)
2946 prs_struct
*ps
=&buffer
->prs
;
2948 prs_debug(ps
, depth
, desc
, "smb_io_printprocessor_info_1");
2951 buffer
->struct_start
=prs_offset(ps
);
2953 if (smb_io_relstr("name", buffer
, depth
, &info
->name
))
2959 /*******************************************************************
2960 ********************************************************************/
2962 BOOL
smb_io_printprocdatatype_info_1(const char *desc
, RPC_BUFFER
*buffer
, PRINTPROCDATATYPE_1
*info
, int depth
)
2964 prs_struct
*ps
=&buffer
->prs
;
2966 prs_debug(ps
, depth
, desc
, "smb_io_printprocdatatype_info_1");
2969 buffer
->struct_start
=prs_offset(ps
);
2971 if (smb_io_relstr("name", buffer
, depth
, &info
->name
))
2977 /*******************************************************************
2978 ********************************************************************/
2980 BOOL
smb_io_printmonitor_info_1(const char *desc
, RPC_BUFFER
*buffer
, PRINTMONITOR_1
*info
, int depth
)
2982 prs_struct
*ps
=&buffer
->prs
;
2984 prs_debug(ps
, depth
, desc
, "smb_io_printmonitor_info_1");
2987 buffer
->struct_start
=prs_offset(ps
);
2989 if (!smb_io_relstr("name", buffer
, depth
, &info
->name
))
2995 /*******************************************************************
2996 ********************************************************************/
2998 BOOL
smb_io_printmonitor_info_2(const char *desc
, RPC_BUFFER
*buffer
, PRINTMONITOR_2
*info
, int depth
)
3000 prs_struct
*ps
=&buffer
->prs
;
3002 prs_debug(ps
, depth
, desc
, "smb_io_printmonitor_info_2");
3005 buffer
->struct_start
=prs_offset(ps
);
3007 if (!smb_io_relstr("name", buffer
, depth
, &info
->name
))
3009 if (!smb_io_relstr("environment", buffer
, depth
, &info
->environment
))
3011 if (!smb_io_relstr("dll_name", buffer
, depth
, &info
->dll_name
))
3017 /*******************************************************************
3018 return the size required by a struct in the stream
3019 ********************************************************************/
3021 uint32
spoolss_size_printer_info_0(PRINTER_INFO_0
*info
)
3025 size
+=size_of_relative_string( &info
->printername
);
3026 size
+=size_of_relative_string( &info
->servername
);
3028 size
+=size_of_uint32( &info
->cjobs
);
3029 size
+=size_of_uint32( &info
->total_jobs
);
3030 size
+=size_of_uint32( &info
->total_bytes
);
3032 size
+=size_of_uint16( &info
->year
);
3033 size
+=size_of_uint16( &info
->month
);
3034 size
+=size_of_uint16( &info
->dayofweek
);
3035 size
+=size_of_uint16( &info
->day
);
3036 size
+=size_of_uint16( &info
->hour
);
3037 size
+=size_of_uint16( &info
->minute
);
3038 size
+=size_of_uint16( &info
->second
);
3039 size
+=size_of_uint16( &info
->milliseconds
);
3041 size
+=size_of_uint32( &info
->global_counter
);
3042 size
+=size_of_uint32( &info
->total_pages
);
3044 size
+=size_of_uint16( &info
->major_version
);
3045 size
+=size_of_uint16( &info
->build_version
);
3047 size
+=size_of_uint32( &info
->unknown7
);
3048 size
+=size_of_uint32( &info
->unknown8
);
3049 size
+=size_of_uint32( &info
->unknown9
);
3050 size
+=size_of_uint32( &info
->session_counter
);
3051 size
+=size_of_uint32( &info
->unknown11
);
3052 size
+=size_of_uint32( &info
->printer_errors
);
3053 size
+=size_of_uint32( &info
->unknown13
);
3054 size
+=size_of_uint32( &info
->unknown14
);
3055 size
+=size_of_uint32( &info
->unknown15
);
3056 size
+=size_of_uint32( &info
->unknown16
);
3057 size
+=size_of_uint32( &info
->change_id
);
3058 size
+=size_of_uint32( &info
->unknown18
);
3059 size
+=size_of_uint32( &info
->status
);
3060 size
+=size_of_uint32( &info
->unknown20
);
3061 size
+=size_of_uint32( &info
->c_setprinter
);
3063 size
+=size_of_uint16( &info
->unknown22
);
3064 size
+=size_of_uint16( &info
->unknown23
);
3065 size
+=size_of_uint16( &info
->unknown24
);
3066 size
+=size_of_uint16( &info
->unknown25
);
3067 size
+=size_of_uint16( &info
->unknown26
);
3068 size
+=size_of_uint16( &info
->unknown27
);
3069 size
+=size_of_uint16( &info
->unknown28
);
3070 size
+=size_of_uint16( &info
->unknown29
);
3075 /*******************************************************************
3076 return the size required by a struct in the stream
3077 ********************************************************************/
3079 uint32
spoolss_size_printer_info_1(PRINTER_INFO_1
*info
)
3083 size
+=size_of_uint32( &info
->flags
);
3084 size
+=size_of_relative_string( &info
->description
);
3085 size
+=size_of_relative_string( &info
->name
);
3086 size
+=size_of_relative_string( &info
->comment
);
3091 /*******************************************************************
3092 return the size required by a struct in the stream
3093 ********************************************************************/
3095 uint32
spoolss_size_printer_info_2(PRINTER_INFO_2
*info
)
3101 size
+= sec_desc_size( info
->secdesc
);
3103 size
+=size_of_device_mode( info
->devmode
);
3105 size
+=size_of_relative_string( &info
->servername
);
3106 size
+=size_of_relative_string( &info
->printername
);
3107 size
+=size_of_relative_string( &info
->sharename
);
3108 size
+=size_of_relative_string( &info
->portname
);
3109 size
+=size_of_relative_string( &info
->drivername
);
3110 size
+=size_of_relative_string( &info
->comment
);
3111 size
+=size_of_relative_string( &info
->location
);
3113 size
+=size_of_relative_string( &info
->sepfile
);
3114 size
+=size_of_relative_string( &info
->printprocessor
);
3115 size
+=size_of_relative_string( &info
->datatype
);
3116 size
+=size_of_relative_string( &info
->parameters
);
3118 size
+=size_of_uint32( &info
->attributes
);
3119 size
+=size_of_uint32( &info
->priority
);
3120 size
+=size_of_uint32( &info
->defaultpriority
);
3121 size
+=size_of_uint32( &info
->starttime
);
3122 size
+=size_of_uint32( &info
->untiltime
);
3123 size
+=size_of_uint32( &info
->status
);
3124 size
+=size_of_uint32( &info
->cjobs
);
3125 size
+=size_of_uint32( &info
->averageppm
);
3128 * add any adjustments for alignment. This is
3129 * not optimal since we could be calling this
3130 * function from a loop (e.g. enumprinters), but
3131 * it is easier to maintain the calculation here and
3132 * not place the burden on the caller to remember. --jerry
3134 if ((size
% 4) != 0)
3135 size
+= 4 - (size
% 4);
3140 /*******************************************************************
3141 return the size required by a struct in the stream
3142 ********************************************************************/
3144 uint32
spoolss_size_printer_info_4(PRINTER_INFO_4
*info
)
3148 size
+=size_of_relative_string( &info
->printername
);
3149 size
+=size_of_relative_string( &info
->servername
);
3151 size
+=size_of_uint32( &info
->attributes
);
3155 /*******************************************************************
3156 return the size required by a struct in the stream
3157 ********************************************************************/
3159 uint32
spoolss_size_printer_info_5(PRINTER_INFO_5
*info
)
3163 size
+=size_of_relative_string( &info
->printername
);
3164 size
+=size_of_relative_string( &info
->portname
);
3166 size
+=size_of_uint32( &info
->attributes
);
3167 size
+=size_of_uint32( &info
->device_not_selected_timeout
);
3168 size
+=size_of_uint32( &info
->transmission_retry_timeout
);
3172 /*******************************************************************
3173 return the size required by a struct in the stream
3174 ********************************************************************/
3176 uint32
spoolss_size_printer_info_6(PRINTER_INFO_6
*info
)
3178 return sizeof(uint32
);
3181 /*******************************************************************
3182 return the size required by a struct in the stream
3183 ********************************************************************/
3185 uint32
spoolss_size_printer_info_3(PRINTER_INFO_3
*info
)
3187 /* The 8 is for the self relative pointer - 8 byte aligned.. */
3188 return 8 + (uint32
)sec_desc_size( info
->secdesc
);
3191 /*******************************************************************
3192 return the size required by a struct in the stream
3193 ********************************************************************/
3195 uint32
spoolss_size_printer_info_7(PRINTER_INFO_7
*info
)
3199 size
+=size_of_relative_string( &info
->guid
);
3200 size
+=size_of_uint32( &info
->action
);
3204 /*******************************************************************
3205 return the size required by a struct in the stream
3206 ********************************************************************/
3208 uint32
spoolss_size_printer_driver_info_1(DRIVER_INFO_1
*info
)
3211 size
+=size_of_relative_string( &info
->name
);
3216 /*******************************************************************
3217 return the size required by a struct in the stream
3218 ********************************************************************/
3220 uint32
spoolss_size_printer_driver_info_2(DRIVER_INFO_2
*info
)
3223 size
+=size_of_uint32( &info
->version
);
3224 size
+=size_of_relative_string( &info
->name
);
3225 size
+=size_of_relative_string( &info
->architecture
);
3226 size
+=size_of_relative_string( &info
->driverpath
);
3227 size
+=size_of_relative_string( &info
->datafile
);
3228 size
+=size_of_relative_string( &info
->configfile
);
3233 /*******************************************************************
3234 return the size required by a string array.
3235 ********************************************************************/
3237 uint32
spoolss_size_string_array(uint16
*string
)
3242 for (i
=0; (string
[i
]!=0x0000) || (string
[i
+1]!=0x0000); i
++);
3244 i
=i
+2; /* to count all chars including the leading zero */
3245 i
=2*i
; /* because we need the value in bytes */
3246 i
=i
+4; /* the offset pointer size */
3251 /*******************************************************************
3252 return the size required by a struct in the stream
3253 ********************************************************************/
3255 uint32
spoolss_size_printer_driver_info_3(DRIVER_INFO_3
*info
)
3259 size
+=size_of_uint32( &info
->version
);
3260 size
+=size_of_relative_string( &info
->name
);
3261 size
+=size_of_relative_string( &info
->architecture
);
3262 size
+=size_of_relative_string( &info
->driverpath
);
3263 size
+=size_of_relative_string( &info
->datafile
);
3264 size
+=size_of_relative_string( &info
->configfile
);
3265 size
+=size_of_relative_string( &info
->helpfile
);
3266 size
+=size_of_relative_string( &info
->monitorname
);
3267 size
+=size_of_relative_string( &info
->defaultdatatype
);
3269 size
+=spoolss_size_string_array(info
->dependentfiles
);
3274 /*******************************************************************
3275 return the size required by a struct in the stream
3276 ********************************************************************/
3278 uint32
spoolss_size_printer_driver_info_6(DRIVER_INFO_6
*info
)
3282 size
+=size_of_uint32( &info
->version
);
3283 size
+=size_of_relative_string( &info
->name
);
3284 size
+=size_of_relative_string( &info
->architecture
);
3285 size
+=size_of_relative_string( &info
->driverpath
);
3286 size
+=size_of_relative_string( &info
->datafile
);
3287 size
+=size_of_relative_string( &info
->configfile
);
3288 size
+=size_of_relative_string( &info
->helpfile
);
3290 size
+=spoolss_size_string_array(info
->dependentfiles
);
3292 size
+=size_of_relative_string( &info
->monitorname
);
3293 size
+=size_of_relative_string( &info
->defaultdatatype
);
3295 size
+=spoolss_size_string_array(info
->previousdrivernames
);
3297 size
+=size_of_nttime(&info
->driver_date
);
3298 size
+=size_of_uint32( &info
->padding
);
3299 size
+=size_of_uint32( &info
->driver_version_low
);
3300 size
+=size_of_uint32( &info
->driver_version_high
);
3301 size
+=size_of_relative_string( &info
->mfgname
);
3302 size
+=size_of_relative_string( &info
->oem_url
);
3303 size
+=size_of_relative_string( &info
->hardware_id
);
3304 size
+=size_of_relative_string( &info
->provider
);
3309 /*******************************************************************
3310 return the size required by a struct in the stream
3311 ********************************************************************/
3313 uint32
spoolss_size_job_info_1(JOB_INFO_1
*info
)
3316 size
+=size_of_uint32( &info
->jobid
);
3317 size
+=size_of_relative_string( &info
->printername
);
3318 size
+=size_of_relative_string( &info
->machinename
);
3319 size
+=size_of_relative_string( &info
->username
);
3320 size
+=size_of_relative_string( &info
->document
);
3321 size
+=size_of_relative_string( &info
->datatype
);
3322 size
+=size_of_relative_string( &info
->text_status
);
3323 size
+=size_of_uint32( &info
->status
);
3324 size
+=size_of_uint32( &info
->priority
);
3325 size
+=size_of_uint32( &info
->position
);
3326 size
+=size_of_uint32( &info
->totalpages
);
3327 size
+=size_of_uint32( &info
->pagesprinted
);
3328 size
+=size_of_systemtime( &info
->submitted
);
3333 /*******************************************************************
3334 return the size required by a struct in the stream
3335 ********************************************************************/
3337 uint32
spoolss_size_job_info_2(JOB_INFO_2
*info
)
3341 size
+=4; /* size of sec desc ptr */
3343 size
+=size_of_uint32( &info
->jobid
);
3344 size
+=size_of_relative_string( &info
->printername
);
3345 size
+=size_of_relative_string( &info
->machinename
);
3346 size
+=size_of_relative_string( &info
->username
);
3347 size
+=size_of_relative_string( &info
->document
);
3348 size
+=size_of_relative_string( &info
->notifyname
);
3349 size
+=size_of_relative_string( &info
->datatype
);
3350 size
+=size_of_relative_string( &info
->printprocessor
);
3351 size
+=size_of_relative_string( &info
->parameters
);
3352 size
+=size_of_relative_string( &info
->drivername
);
3353 size
+=size_of_device_mode( info
->devmode
);
3354 size
+=size_of_relative_string( &info
->text_status
);
3355 /* SEC_DESC sec_desc;*/
3356 size
+=size_of_uint32( &info
->status
);
3357 size
+=size_of_uint32( &info
->priority
);
3358 size
+=size_of_uint32( &info
->position
);
3359 size
+=size_of_uint32( &info
->starttime
);
3360 size
+=size_of_uint32( &info
->untiltime
);
3361 size
+=size_of_uint32( &info
->totalpages
);
3362 size
+=size_of_uint32( &info
->size
);
3363 size
+=size_of_systemtime( &info
->submitted
);
3364 size
+=size_of_uint32( &info
->timeelapsed
);
3365 size
+=size_of_uint32( &info
->pagesprinted
);
3370 /*******************************************************************
3371 return the size required by a struct in the stream
3372 ********************************************************************/
3374 uint32
spoolss_size_form_1(FORM_1
*info
)
3378 size
+=size_of_uint32( &info
->flag
);
3379 size
+=size_of_relative_string( &info
->name
);
3380 size
+=size_of_uint32( &info
->width
);
3381 size
+=size_of_uint32( &info
->length
);
3382 size
+=size_of_uint32( &info
->left
);
3383 size
+=size_of_uint32( &info
->top
);
3384 size
+=size_of_uint32( &info
->right
);
3385 size
+=size_of_uint32( &info
->bottom
);
3390 /*******************************************************************
3391 return the size required by a struct in the stream
3392 ********************************************************************/
3394 uint32
spoolss_size_port_info_1(PORT_INFO_1
*info
)
3398 size
+=size_of_relative_string( &info
->port_name
);
3403 /*******************************************************************
3404 return the size required by a struct in the stream
3405 ********************************************************************/
3407 uint32
spoolss_size_driverdir_info_1(DRIVER_DIRECTORY_1
*info
)
3411 size
=str_len_uni(&info
->name
); /* the string length */
3412 size
=size
+1; /* add the leading zero */
3413 size
=size
*2; /* convert in char */
3418 /*******************************************************************
3419 return the size required by a struct in the stream
3420 ********************************************************************/
3422 uint32
spoolss_size_printprocessordirectory_info_1(PRINTPROCESSOR_DIRECTORY_1
*info
)
3426 size
=str_len_uni(&info
->name
); /* the string length */
3427 size
=size
+1; /* add the leading zero */
3428 size
=size
*2; /* convert in char */
3433 /*******************************************************************
3434 return the size required by a struct in the stream
3435 ********************************************************************/
3437 uint32
spoolss_size_port_info_2(PORT_INFO_2
*info
)
3441 size
+=size_of_relative_string( &info
->port_name
);
3442 size
+=size_of_relative_string( &info
->monitor_name
);
3443 size
+=size_of_relative_string( &info
->description
);
3445 size
+=size_of_uint32( &info
->port_type
);
3446 size
+=size_of_uint32( &info
->reserved
);
3451 /*******************************************************************
3452 return the size required by a struct in the stream
3453 ********************************************************************/
3455 uint32
spoolss_size_printprocessor_info_1(PRINTPROCESSOR_1
*info
)
3458 size
+=size_of_relative_string( &info
->name
);
3463 /*******************************************************************
3464 return the size required by a struct in the stream
3465 ********************************************************************/
3467 uint32
spoolss_size_printprocdatatype_info_1(PRINTPROCDATATYPE_1
*info
)
3470 size
+=size_of_relative_string( &info
->name
);
3475 /*******************************************************************
3476 return the size required by a struct in the stream
3477 ********************************************************************/
3478 uint32
spoolss_size_printer_enum_values(PRINTER_ENUM_VALUES
*p
)
3485 /* uint32(offset) + uint32(length) + length) */
3486 size
+= (size_of_uint32(&p
->value_len
)*2) + p
->value_len
;
3487 size
+= (size_of_uint32(&p
->data_len
)*2) + p
->data_len
+ (p
->data_len
%2) ;
3489 size
+= size_of_uint32(&p
->type
);
3494 /*******************************************************************
3495 return the size required by a struct in the stream
3496 ********************************************************************/
3498 uint32
spoolss_size_printmonitor_info_1(PRINTMONITOR_1
*info
)
3501 size
+=size_of_relative_string( &info
->name
);
3506 /*******************************************************************
3507 return the size required by a struct in the stream
3508 ********************************************************************/
3510 uint32
spoolss_size_printmonitor_info_2(PRINTMONITOR_2
*info
)
3513 size
+=size_of_relative_string( &info
->name
);
3514 size
+=size_of_relative_string( &info
->environment
);
3515 size
+=size_of_relative_string( &info
->dll_name
);
3520 /*******************************************************************
3522 ********************************************************************/
3524 BOOL
make_spoolss_q_getprinterdriver2(SPOOL_Q_GETPRINTERDRIVER2
*q_u
,
3525 const POLICY_HND
*hnd
,
3526 const fstring architecture
,
3527 uint32 level
, uint32 clientmajor
, uint32 clientminor
,
3528 RPC_BUFFER
*buffer
, uint32 offered
)
3533 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
3535 init_buf_unistr2(&q_u
->architecture
, &q_u
->architecture_ptr
, architecture
);
3538 q_u
->clientmajorversion
=clientmajor
;
3539 q_u
->clientminorversion
=clientminor
;
3542 q_u
->offered
=offered
;
3547 /*******************************************************************
3549 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3550 ********************************************************************/
3552 BOOL
spoolss_io_q_getprinterdriver2(const char *desc
, SPOOL_Q_GETPRINTERDRIVER2
*q_u
, prs_struct
*ps
, int depth
)
3554 prs_debug(ps
, depth
, desc
, "spoolss_io_q_getprinterdriver2");
3560 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
3562 if(!prs_uint32("architecture_ptr", ps
, depth
, &q_u
->architecture_ptr
))
3564 if(!smb_io_unistr2("architecture", &q_u
->architecture
, q_u
->architecture_ptr
, ps
, depth
))
3569 if(!prs_uint32("level", ps
, depth
, &q_u
->level
))
3572 if(!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
3578 if(!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
3581 if(!prs_uint32("clientmajorversion", ps
, depth
, &q_u
->clientmajorversion
))
3583 if(!prs_uint32("clientminorversion", ps
, depth
, &q_u
->clientminorversion
))
3589 /*******************************************************************
3591 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3592 ********************************************************************/
3594 BOOL
spoolss_io_r_getprinterdriver2(const char *desc
, SPOOL_R_GETPRINTERDRIVER2
*r_u
, prs_struct
*ps
, int depth
)
3596 prs_debug(ps
, depth
, desc
, "spoolss_io_r_getprinterdriver2");
3602 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
3607 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
3609 if (!prs_uint32("servermajorversion", ps
, depth
, &r_u
->servermajorversion
))
3611 if (!prs_uint32("serverminorversion", ps
, depth
, &r_u
->serverminorversion
))
3613 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
3619 /*******************************************************************
3621 ********************************************************************/
3623 BOOL
make_spoolss_q_enumprinters(
3624 SPOOL_Q_ENUMPRINTERS
*q_u
,
3634 q_u
->servername_ptr
= (servername
!= NULL
) ? 1 : 0;
3635 init_buf_unistr2(&q_u
->servername
, &q_u
->servername_ptr
, servername
);
3639 q_u
->offered
=offered
;
3644 /*******************************************************************
3646 ********************************************************************/
3648 BOOL
make_spoolss_q_enumports(SPOOL_Q_ENUMPORTS
*q_u
,
3649 fstring servername
, uint32 level
,
3650 RPC_BUFFER
*buffer
, uint32 offered
)
3652 q_u
->name_ptr
= (servername
!= NULL
) ? 1 : 0;
3653 init_buf_unistr2(&q_u
->name
, &q_u
->name_ptr
, servername
);
3657 q_u
->offered
=offered
;
3662 /*******************************************************************
3664 * called from spoolss_enumprinters (srv_spoolss.c)
3665 ********************************************************************/
3667 BOOL
spoolss_io_q_enumprinters(const char *desc
, SPOOL_Q_ENUMPRINTERS
*q_u
, prs_struct
*ps
, int depth
)
3669 prs_debug(ps
, depth
, desc
, "spoolss_io_q_enumprinters");
3675 if (!prs_uint32("flags", ps
, depth
, &q_u
->flags
))
3677 if (!prs_uint32("servername_ptr", ps
, depth
, &q_u
->servername_ptr
))
3680 if (!smb_io_unistr2("", &q_u
->servername
, q_u
->servername_ptr
, ps
, depth
))
3685 if (!prs_uint32("level", ps
, depth
, &q_u
->level
))
3688 if (!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
3693 if (!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
3699 /*******************************************************************
3700 Parse a SPOOL_R_ENUMPRINTERS structure.
3701 ********************************************************************/
3703 BOOL
spoolss_io_r_enumprinters(const char *desc
, SPOOL_R_ENUMPRINTERS
*r_u
, prs_struct
*ps
, int depth
)
3705 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enumprinters");
3711 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
3717 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
3720 if (!prs_uint32("returned", ps
, depth
, &r_u
->returned
))
3723 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
3729 /*******************************************************************
3730 * write a structure.
3731 * called from spoolss_r_enum_printers (srv_spoolss.c)
3733 ********************************************************************/
3735 BOOL
spoolss_io_r_getprinter(const char *desc
, SPOOL_R_GETPRINTER
*r_u
, prs_struct
*ps
, int depth
)
3737 prs_debug(ps
, depth
, desc
, "spoolss_io_r_getprinter");
3743 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
3749 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
3752 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
3758 /*******************************************************************
3760 * called from spoolss_getprinter (srv_spoolss.c)
3761 ********************************************************************/
3763 BOOL
spoolss_io_q_getprinter(const char *desc
, SPOOL_Q_GETPRINTER
*q_u
, prs_struct
*ps
, int depth
)
3765 prs_debug(ps
, depth
, desc
, "spoolss_io_q_getprinter");
3771 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
3773 if (!prs_uint32("level", ps
, depth
, &q_u
->level
))
3776 if (!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
3781 if (!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
3787 /*******************************************************************
3789 ********************************************************************/
3791 BOOL
make_spoolss_q_getprinter(
3792 TALLOC_CTX
*mem_ctx
,
3793 SPOOL_Q_GETPRINTER
*q_u
,
3794 const POLICY_HND
*hnd
,
3804 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
3808 q_u
->offered
=offered
;
3813 /*******************************************************************
3815 ********************************************************************/
3816 BOOL
make_spoolss_q_setprinter(TALLOC_CTX
*mem_ctx
, SPOOL_Q_SETPRINTER
*q_u
,
3817 const POLICY_HND
*hnd
, uint32 level
, PRINTER_INFO_CTR
*info
,
3821 DEVICEMODE
*devmode
;
3826 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
3829 q_u
->info
.level
= level
;
3830 q_u
->info
.info_ptr
= 1; /* Info is != NULL, see above */
3833 /* There's no such thing as a setprinter level 1 */
3836 secdesc
= info
->printers_2
->secdesc
;
3837 devmode
= info
->printers_2
->devmode
;
3839 make_spoolss_printer_info_2 (mem_ctx
, &q_u
->info
.info_2
, info
->printers_2
);
3840 #if 1 /* JERRY TEST */
3841 q_u
->secdesc_ctr
= SMB_MALLOC_P(SEC_DESC_BUF
);
3842 if (!q_u
->secdesc_ctr
)
3844 q_u
->secdesc_ctr
->sd
= secdesc
;
3845 q_u
->secdesc_ctr
->sd_size
= (secdesc
) ? sizeof(SEC_DESC
) + (2*sizeof(uint32
)) : 0;
3847 q_u
->devmode_ctr
.devmode_ptr
= (devmode
!= NULL
) ? 1 : 0;
3848 q_u
->devmode_ctr
.size
= (devmode
!= NULL
) ? sizeof(DEVICEMODE
) + (3*sizeof(uint32
)) : 0;
3849 q_u
->devmode_ctr
.devmode
= devmode
;
3851 q_u
->secdesc_ctr
= NULL
;
3853 q_u
->devmode_ctr
.devmode_ptr
= 0;
3854 q_u
->devmode_ctr
.size
= 0;
3855 q_u
->devmode_ctr
.devmode
= NULL
;
3859 secdesc
= info
->printers_3
->secdesc
;
3861 make_spoolss_printer_info_3 (mem_ctx
, &q_u
->info
.info_3
, info
->printers_3
);
3863 q_u
->secdesc_ctr
= SMB_MALLOC_P(SEC_DESC_BUF
);
3864 if (!q_u
->secdesc_ctr
)
3866 q_u
->secdesc_ctr
->sd_size
= (secdesc
) ? sizeof(SEC_DESC
) + (2*sizeof(uint32
)) : 0;
3867 q_u
->secdesc_ctr
->sd
= secdesc
;
3871 make_spoolss_printer_info_7 (mem_ctx
, &q_u
->info
.info_7
, info
->printers_7
);
3875 DEBUG(0,("make_spoolss_q_setprinter: Unknown info level [%d]\n", level
));
3880 q_u
->command
= command
;
3886 /*******************************************************************
3887 ********************************************************************/
3889 BOOL
spoolss_io_r_setprinter(const char *desc
, SPOOL_R_SETPRINTER
*r_u
, prs_struct
*ps
, int depth
)
3891 prs_debug(ps
, depth
, desc
, "spoolss_io_r_setprinter");
3897 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
3903 /*******************************************************************
3904 Marshall/unmarshall a SPOOL_Q_SETPRINTER struct.
3905 ********************************************************************/
3907 BOOL
spoolss_io_q_setprinter(const char *desc
, SPOOL_Q_SETPRINTER
*q_u
, prs_struct
*ps
, int depth
)
3909 uint32 ptr_sec_desc
= 0;
3911 prs_debug(ps
, depth
, desc
, "spoolss_io_q_setprinter");
3917 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
,ps
, depth
))
3919 if(!prs_uint32("level", ps
, depth
, &q_u
->level
))
3922 /* check for supported levels and structures we know about */
3924 switch ( q_u
->level
) {
3929 /* supported levels */
3932 DEBUG(0,("spoolss_io_q_setprinter: unsupported printer info level [%d]\n",
3938 if(!spool_io_printer_info_level("", &q_u
->info
, ps
, depth
))
3941 if (!spoolss_io_devmode_cont(desc
, &q_u
->devmode_ctr
, ps
, depth
))
3951 ptr_sec_desc
= q_u
->info
.info_2
->secdesc_ptr
;
3956 /* FIXME ! Our parsing here is wrong I think,
3957 * but for a level3 it makes no sense for
3958 * ptr_sec_desc to be NULL. JRA. Based on
3959 * a Vista sniff from Martin Zielinski <mz@seh.de>.
3961 if (UNMARSHALLING(ps
)) {
3964 ptr_sec_desc
= q_u
->info
.info_3
->secdesc_ptr
;
3971 if (!sec_io_desc_buf(desc
, &q_u
->secdesc_ctr
, ps
, depth
))
3976 /* Parse a NULL security descriptor. This should really
3977 happen inside the sec_io_desc_buf() function. */
3979 prs_debug(ps
, depth
, "", "sec_io_desc_buf");
3980 if (!prs_uint32("size", ps
, depth
+ 1, &dummy
))
3982 if (!prs_uint32("ptr", ps
, depth
+ 1, &dummy
))
3986 if(!prs_uint32("command", ps
, depth
, &q_u
->command
))
3992 /*******************************************************************
3993 ********************************************************************/
3995 BOOL
spoolss_io_r_fcpn(const char *desc
, SPOOL_R_FCPN
*r_u
, prs_struct
*ps
, int depth
)
3997 prs_debug(ps
, depth
, desc
, "spoolss_io_r_fcpn");
4003 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
4009 /*******************************************************************
4010 ********************************************************************/
4012 BOOL
spoolss_io_q_fcpn(const char *desc
, SPOOL_Q_FCPN
*q_u
, prs_struct
*ps
, int depth
)
4015 prs_debug(ps
, depth
, desc
, "spoolss_io_q_fcpn");
4021 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
4028 /*******************************************************************
4029 ********************************************************************/
4031 BOOL
spoolss_io_r_addjob(const char *desc
, SPOOL_R_ADDJOB
*r_u
, prs_struct
*ps
, int depth
)
4033 prs_debug(ps
, depth
, desc
, "");
4039 if(!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
4045 if(!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
4048 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
4054 /*******************************************************************
4055 ********************************************************************/
4057 BOOL
spoolss_io_q_addjob(const char *desc
, SPOOL_Q_ADDJOB
*q_u
, prs_struct
*ps
, int depth
)
4059 prs_debug(ps
, depth
, desc
, "");
4065 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
4067 if(!prs_uint32("level", ps
, depth
, &q_u
->level
))
4070 if(!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
4076 if(!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
4082 /*******************************************************************
4083 ********************************************************************/
4085 BOOL
spoolss_io_r_enumjobs(const char *desc
, SPOOL_R_ENUMJOBS
*r_u
, prs_struct
*ps
, int depth
)
4087 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enumjobs");
4093 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
4099 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
4102 if (!prs_uint32("returned", ps
, depth
, &r_u
->returned
))
4105 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
4111 /*******************************************************************
4112 ********************************************************************/
4114 BOOL
make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS
*q_u
, const POLICY_HND
*hnd
,
4125 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
4126 q_u
->firstjob
= firstjob
;
4127 q_u
->numofjobs
= numofjobs
;
4129 q_u
->buffer
= buffer
;
4130 q_u
->offered
= offered
;
4134 /*******************************************************************
4135 ********************************************************************/
4137 BOOL
spoolss_io_q_enumjobs(const char *desc
, SPOOL_Q_ENUMJOBS
*q_u
, prs_struct
*ps
, int depth
)
4139 prs_debug(ps
, depth
, desc
, "spoolss_io_q_enumjobs");
4145 if (!smb_io_pol_hnd("printer handle",&q_u
->handle
, ps
, depth
))
4148 if (!prs_uint32("firstjob", ps
, depth
, &q_u
->firstjob
))
4150 if (!prs_uint32("numofjobs", ps
, depth
, &q_u
->numofjobs
))
4152 if (!prs_uint32("level", ps
, depth
, &q_u
->level
))
4155 if (!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
4161 if (!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
4167 /*******************************************************************
4168 ********************************************************************/
4170 BOOL
spoolss_io_r_schedulejob(const char *desc
, SPOOL_R_SCHEDULEJOB
*r_u
, prs_struct
*ps
, int depth
)
4172 prs_debug(ps
, depth
, desc
, "spoolss_io_r_schedulejob");
4178 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
4184 /*******************************************************************
4185 ********************************************************************/
4187 BOOL
spoolss_io_q_schedulejob(const char *desc
, SPOOL_Q_SCHEDULEJOB
*q_u
, prs_struct
*ps
, int depth
)
4189 prs_debug(ps
, depth
, desc
, "spoolss_io_q_schedulejob");
4195 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
4197 if(!prs_uint32("jobid", ps
, depth
, &q_u
->jobid
))
4203 /*******************************************************************
4204 ********************************************************************/
4206 BOOL
spoolss_io_r_setjob(const char *desc
, SPOOL_R_SETJOB
*r_u
, prs_struct
*ps
, int depth
)
4208 prs_debug(ps
, depth
, desc
, "spoolss_io_r_setjob");
4214 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
4220 /*******************************************************************
4221 ********************************************************************/
4223 BOOL
spoolss_io_q_setjob(const char *desc
, SPOOL_Q_SETJOB
*q_u
, prs_struct
*ps
, int depth
)
4225 prs_debug(ps
, depth
, desc
, "spoolss_io_q_setjob");
4231 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
4233 if(!prs_uint32("jobid", ps
, depth
, &q_u
->jobid
))
4236 * level is usually 0. If (level!=0) then I'm in trouble !
4237 * I will try to generate setjob command with level!=0, one day.
4239 if(!prs_uint32("level", ps
, depth
, &q_u
->level
))
4241 if(!prs_uint32("command", ps
, depth
, &q_u
->command
))
4247 /*******************************************************************
4248 Parse a SPOOL_R_ENUMPRINTERDRIVERS structure.
4249 ********************************************************************/
4251 BOOL
spoolss_io_r_enumprinterdrivers(const char *desc
, SPOOL_R_ENUMPRINTERDRIVERS
*r_u
, prs_struct
*ps
, int depth
)
4253 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enumprinterdrivers");
4259 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
4265 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
4268 if (!prs_uint32("returned", ps
, depth
, &r_u
->returned
))
4271 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
4277 /*******************************************************************
4279 ********************************************************************/
4281 BOOL
make_spoolss_q_enumprinterdrivers(SPOOL_Q_ENUMPRINTERDRIVERS
*q_u
,
4283 const char *environment
,
4285 RPC_BUFFER
*buffer
, uint32 offered
)
4287 init_buf_unistr2(&q_u
->name
, &q_u
->name_ptr
, name
);
4288 init_buf_unistr2(&q_u
->environment
, &q_u
->environment_ptr
, environment
);
4292 q_u
->offered
=offered
;
4297 /*******************************************************************
4298 Parse a SPOOL_Q_ENUMPRINTERDRIVERS structure.
4299 ********************************************************************/
4301 BOOL
spoolss_io_q_enumprinterdrivers(const char *desc
, SPOOL_Q_ENUMPRINTERDRIVERS
*q_u
, prs_struct
*ps
, int depth
)
4304 prs_debug(ps
, depth
, desc
, "spoolss_io_q_enumprinterdrivers");
4310 if (!prs_uint32("name_ptr", ps
, depth
, &q_u
->name_ptr
))
4312 if (!smb_io_unistr2("", &q_u
->name
, q_u
->name_ptr
,ps
, depth
))
4317 if (!prs_uint32("environment_ptr", ps
, depth
, &q_u
->environment_ptr
))
4319 if (!smb_io_unistr2("", &q_u
->environment
, q_u
->environment_ptr
, ps
, depth
))
4324 if (!prs_uint32("level", ps
, depth
, &q_u
->level
))
4327 if (!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
4333 if (!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
4339 /*******************************************************************
4340 ********************************************************************/
4342 BOOL
spoolss_io_q_enumforms(const char *desc
, SPOOL_Q_ENUMFORMS
*q_u
, prs_struct
*ps
, int depth
)
4345 prs_debug(ps
, depth
, desc
, "spoolss_io_q_enumforms");
4350 if (!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
4352 if (!prs_uint32("level", ps
, depth
, &q_u
->level
))
4355 if (!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
4360 if (!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
4366 /*******************************************************************
4367 ********************************************************************/
4369 BOOL
spoolss_io_r_enumforms(const char *desc
, SPOOL_R_ENUMFORMS
*r_u
, prs_struct
*ps
, int depth
)
4371 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enumforms");
4377 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
4383 if (!prs_uint32("size of buffer needed", ps
, depth
, &r_u
->needed
))
4386 if (!prs_uint32("numofforms", ps
, depth
, &r_u
->numofforms
))
4389 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
4395 /*******************************************************************
4396 ********************************************************************/
4398 BOOL
spoolss_io_q_getform(const char *desc
, SPOOL_Q_GETFORM
*q_u
, prs_struct
*ps
, int depth
)
4401 prs_debug(ps
, depth
, desc
, "spoolss_io_q_getform");
4406 if (!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
4408 if (!smb_io_unistr2("", &q_u
->formname
,True
,ps
,depth
))
4414 if (!prs_uint32("level", ps
, depth
, &q_u
->level
))
4417 if (!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
4422 if (!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
4428 /*******************************************************************
4429 ********************************************************************/
4431 BOOL
spoolss_io_r_getform(const char *desc
, SPOOL_R_GETFORM
*r_u
, prs_struct
*ps
, int depth
)
4433 prs_debug(ps
, depth
, desc
, "spoolss_io_r_getform");
4439 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
4445 if (!prs_uint32("size of buffer needed", ps
, depth
, &r_u
->needed
))
4448 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
4454 /*******************************************************************
4455 Parse a SPOOL_R_ENUMPORTS structure.
4456 ********************************************************************/
4458 BOOL
spoolss_io_r_enumports(const char *desc
, SPOOL_R_ENUMPORTS
*r_u
, prs_struct
*ps
, int depth
)
4460 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enumports");
4466 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
4472 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
4475 if (!prs_uint32("returned", ps
, depth
, &r_u
->returned
))
4478 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
4484 /*******************************************************************
4485 ********************************************************************/
4487 BOOL
spoolss_io_q_enumports(const char *desc
, SPOOL_Q_ENUMPORTS
*q_u
, prs_struct
*ps
, int depth
)
4489 prs_debug(ps
, depth
, desc
, "");
4495 if (!prs_uint32("", ps
, depth
, &q_u
->name_ptr
))
4497 if (!smb_io_unistr2("", &q_u
->name
,True
,ps
,depth
))
4502 if (!prs_uint32("level", ps
, depth
, &q_u
->level
))
4505 if (!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
4510 if (!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
4516 /*******************************************************************
4517 Parse a SPOOL_PRINTER_INFO_LEVEL_1 structure.
4518 ********************************************************************/
4520 BOOL
spool_io_printer_info_level_1(const char *desc
, SPOOL_PRINTER_INFO_LEVEL_1
*il
, prs_struct
*ps
, int depth
)
4522 prs_debug(ps
, depth
, desc
, "spool_io_printer_info_level_1");
4528 if(!prs_uint32("flags", ps
, depth
, &il
->flags
))
4530 if(!prs_uint32("description_ptr", ps
, depth
, &il
->description_ptr
))
4532 if(!prs_uint32("name_ptr", ps
, depth
, &il
->name_ptr
))
4534 if(!prs_uint32("comment_ptr", ps
, depth
, &il
->comment_ptr
))
4537 if(!smb_io_unistr2("description", &il
->description
, il
->description_ptr
, ps
, depth
))
4539 if(!smb_io_unistr2("name", &il
->name
, il
->name_ptr
, ps
, depth
))
4541 if(!smb_io_unistr2("comment", &il
->comment
, il
->comment_ptr
, ps
, depth
))
4547 /*******************************************************************
4548 Parse a SPOOL_PRINTER_INFO_LEVEL_3 structure.
4549 ********************************************************************/
4551 BOOL
spool_io_printer_info_level_3(const char *desc
, SPOOL_PRINTER_INFO_LEVEL_3
*il
, prs_struct
*ps
, int depth
)
4553 prs_debug(ps
, depth
, desc
, "spool_io_printer_info_level_3");
4559 if(!prs_uint32("secdesc_ptr", ps
, depth
, &il
->secdesc_ptr
))
4565 /*******************************************************************
4566 Parse a SPOOL_PRINTER_INFO_LEVEL_2 structure.
4567 ********************************************************************/
4569 BOOL
spool_io_printer_info_level_2(const char *desc
, SPOOL_PRINTER_INFO_LEVEL_2
*il
, prs_struct
*ps
, int depth
)
4571 prs_debug(ps
, depth
, desc
, "spool_io_printer_info_level_2");
4577 if(!prs_uint32("servername_ptr", ps
, depth
, &il
->servername_ptr
))
4579 if(!prs_uint32("printername_ptr", ps
, depth
, &il
->printername_ptr
))
4581 if(!prs_uint32("sharename_ptr", ps
, depth
, &il
->sharename_ptr
))
4583 if(!prs_uint32("portname_ptr", ps
, depth
, &il
->portname_ptr
))
4586 if(!prs_uint32("drivername_ptr", ps
, depth
, &il
->drivername_ptr
))
4588 if(!prs_uint32("comment_ptr", ps
, depth
, &il
->comment_ptr
))
4590 if(!prs_uint32("location_ptr", ps
, depth
, &il
->location_ptr
))
4592 if(!prs_uint32("devmode_ptr", ps
, depth
, &il
->devmode_ptr
))
4594 if(!prs_uint32("sepfile_ptr", ps
, depth
, &il
->sepfile_ptr
))
4596 if(!prs_uint32("printprocessor_ptr", ps
, depth
, &il
->printprocessor_ptr
))
4598 if(!prs_uint32("datatype_ptr", ps
, depth
, &il
->datatype_ptr
))
4600 if(!prs_uint32("parameters_ptr", ps
, depth
, &il
->parameters_ptr
))
4602 if(!prs_uint32("secdesc_ptr", ps
, depth
, &il
->secdesc_ptr
))
4605 if(!prs_uint32("attributes", ps
, depth
, &il
->attributes
))
4607 if(!prs_uint32("priority", ps
, depth
, &il
->priority
))
4609 if(!prs_uint32("default_priority", ps
, depth
, &il
->default_priority
))
4611 if(!prs_uint32("starttime", ps
, depth
, &il
->starttime
))
4613 if(!prs_uint32("untiltime", ps
, depth
, &il
->untiltime
))
4615 if(!prs_uint32("status", ps
, depth
, &il
->status
))
4617 if(!prs_uint32("cjobs", ps
, depth
, &il
->cjobs
))
4619 if(!prs_uint32("averageppm", ps
, depth
, &il
->averageppm
))
4622 if(!smb_io_unistr2("servername", &il
->servername
, il
->servername_ptr
, ps
, depth
))
4624 if(!smb_io_unistr2("printername", &il
->printername
, il
->printername_ptr
, ps
, depth
))
4626 if(!smb_io_unistr2("sharename", &il
->sharename
, il
->sharename_ptr
, ps
, depth
))
4628 if(!smb_io_unistr2("portname", &il
->portname
, il
->portname_ptr
, ps
, depth
))
4630 if(!smb_io_unistr2("drivername", &il
->drivername
, il
->drivername_ptr
, ps
, depth
))
4632 if(!smb_io_unistr2("comment", &il
->comment
, il
->comment_ptr
, ps
, depth
))
4634 if(!smb_io_unistr2("location", &il
->location
, il
->location_ptr
, ps
, depth
))
4636 if(!smb_io_unistr2("sepfile", &il
->sepfile
, il
->sepfile_ptr
, ps
, depth
))
4638 if(!smb_io_unistr2("printprocessor", &il
->printprocessor
, il
->printprocessor_ptr
, ps
, depth
))
4640 if(!smb_io_unistr2("datatype", &il
->datatype
, il
->datatype_ptr
, ps
, depth
))
4642 if(!smb_io_unistr2("parameters", &il
->parameters
, il
->parameters_ptr
, ps
, depth
))
4648 BOOL
spool_io_printer_info_level_7(const char *desc
, SPOOL_PRINTER_INFO_LEVEL_7
*il
, prs_struct
*ps
, int depth
)
4650 prs_debug(ps
, depth
, desc
, "spool_io_printer_info_level_7");
4656 if(!prs_uint32("guid_ptr", ps
, depth
, &il
->guid_ptr
))
4658 if(!prs_uint32("action", ps
, depth
, &il
->action
))
4661 if(!smb_io_unistr2("servername", &il
->guid
, il
->guid_ptr
, ps
, depth
))
4666 /*******************************************************************
4667 ********************************************************************/
4669 BOOL
spool_io_printer_info_level(const char *desc
, SPOOL_PRINTER_INFO_LEVEL
*il
, prs_struct
*ps
, int depth
)
4671 prs_debug(ps
, depth
, desc
, "spool_io_printer_info_level");
4676 if(!prs_uint32("level", ps
, depth
, &il
->level
))
4678 if(!prs_uint32("info_ptr", ps
, depth
, &il
->info_ptr
))
4681 /* if no struct inside just return */
4682 if (il
->info_ptr
==0) {
4683 if (UNMARSHALLING(ps
)) {
4690 switch (il
->level
) {
4692 * level 0 is used by setprinter when managing the queue
4693 * (hold, stop, start a queue)
4697 /* DOCUMENT ME!!! What is level 1 used for? */
4700 if (UNMARSHALLING(ps
)) {
4701 if ((il
->info_1
=PRS_ALLOC_MEM(ps
,SPOOL_PRINTER_INFO_LEVEL_1
,1)) == NULL
)
4704 if (!spool_io_printer_info_level_1("", il
->info_1
, ps
, depth
))
4709 * level 2 is used by addprinter
4710 * and by setprinter when updating printer's info
4713 if (UNMARSHALLING(ps
)) {
4714 if ((il
->info_2
=PRS_ALLOC_MEM(ps
,SPOOL_PRINTER_INFO_LEVEL_2
,1)) == NULL
)
4717 if (!spool_io_printer_info_level_2("", il
->info_2
, ps
, depth
))
4720 /* DOCUMENT ME!!! What is level 3 used for? */
4723 if (UNMARSHALLING(ps
)) {
4724 if ((il
->info_3
=PRS_ALLOC_MEM(ps
,SPOOL_PRINTER_INFO_LEVEL_3
,1)) == NULL
)
4727 if (!spool_io_printer_info_level_3("", il
->info_3
, ps
, depth
))
4732 if (UNMARSHALLING(ps
))
4733 if ((il
->info_7
=PRS_ALLOC_MEM(ps
,SPOOL_PRINTER_INFO_LEVEL_7
,1)) == NULL
)
4735 if (!spool_io_printer_info_level_7("", il
->info_7
, ps
, depth
))
4743 /*******************************************************************
4744 ********************************************************************/
4746 BOOL
spoolss_io_q_addprinterex(const char *desc
, SPOOL_Q_ADDPRINTEREX
*q_u
, prs_struct
*ps
, int depth
)
4748 uint32 ptr_sec_desc
= 0;
4750 prs_debug(ps
, depth
, desc
, "spoolss_io_q_addprinterex");
4756 if (!prs_io_unistr2_p("ptr", ps
, depth
, &q_u
->server_name
))
4758 if (!prs_io_unistr2("servername", ps
, depth
, q_u
->server_name
))
4764 if(!prs_uint32("info_level", ps
, depth
, &q_u
->level
))
4767 if(!spool_io_printer_info_level("", &q_u
->info
, ps
, depth
))
4770 if (!spoolss_io_devmode_cont(desc
, &q_u
->devmode_ctr
, ps
, depth
))
4776 switch (q_u
->level
) {
4778 ptr_sec_desc
= q_u
->info
.info_2
->secdesc_ptr
;
4781 ptr_sec_desc
= q_u
->info
.info_3
->secdesc_ptr
;
4785 if (!sec_io_desc_buf(desc
, &q_u
->secdesc_ctr
, ps
, depth
))
4790 /* Parse a NULL security descriptor. This should really
4791 happen inside the sec_io_desc_buf() function. */
4793 prs_debug(ps
, depth
, "", "sec_io_desc_buf");
4794 if (!prs_uint32("size", ps
, depth
+ 1, &dummy
))
4796 if (!prs_uint32("ptr", ps
, depth
+ 1, &dummy
))
4800 if(!prs_uint32("user_switch", ps
, depth
, &q_u
->user_switch
))
4802 if(!spool_io_user_level("", &q_u
->user_ctr
, ps
, depth
))
4808 /*******************************************************************
4809 ********************************************************************/
4811 BOOL
spoolss_io_r_addprinterex(const char *desc
, SPOOL_R_ADDPRINTEREX
*r_u
,
4812 prs_struct
*ps
, int depth
)
4814 prs_debug(ps
, depth
, desc
, "spoolss_io_r_addprinterex");
4817 if(!smb_io_pol_hnd("printer handle",&r_u
->handle
,ps
,depth
))
4820 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
4826 /*******************************************************************
4827 ********************************************************************/
4829 BOOL
spool_io_printer_driver_info_level_3(const char *desc
, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3
**q_u
,
4830 prs_struct
*ps
, int depth
)
4832 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3
*il
;
4834 prs_debug(ps
, depth
, desc
, "spool_io_printer_driver_info_level_3");
4838 if (UNMARSHALLING(ps
)) {
4839 il
=PRS_ALLOC_MEM(ps
,SPOOL_PRINTER_DRIVER_INFO_LEVEL_3
,1);
4851 if(!prs_uint32("cversion", ps
, depth
, &il
->cversion
))
4853 if(!prs_uint32("name", ps
, depth
, &il
->name_ptr
))
4855 if(!prs_uint32("environment", ps
, depth
, &il
->environment_ptr
))
4857 if(!prs_uint32("driverpath", ps
, depth
, &il
->driverpath_ptr
))
4859 if(!prs_uint32("datafile", ps
, depth
, &il
->datafile_ptr
))
4861 if(!prs_uint32("configfile", ps
, depth
, &il
->configfile_ptr
))
4863 if(!prs_uint32("helpfile", ps
, depth
, &il
->helpfile_ptr
))
4865 if(!prs_uint32("monitorname", ps
, depth
, &il
->monitorname_ptr
))
4867 if(!prs_uint32("defaultdatatype", ps
, depth
, &il
->defaultdatatype_ptr
))
4869 if(!prs_uint32("dependentfilessize", ps
, depth
, &il
->dependentfilessize
))
4871 if(!prs_uint32("dependentfiles", ps
, depth
, &il
->dependentfiles_ptr
))
4877 if(!smb_io_unistr2("name", &il
->name
, il
->name_ptr
, ps
, depth
))
4879 if(!smb_io_unistr2("environment", &il
->environment
, il
->environment_ptr
, ps
, depth
))
4881 if(!smb_io_unistr2("driverpath", &il
->driverpath
, il
->driverpath_ptr
, ps
, depth
))
4883 if(!smb_io_unistr2("datafile", &il
->datafile
, il
->datafile_ptr
, ps
, depth
))
4885 if(!smb_io_unistr2("configfile", &il
->configfile
, il
->configfile_ptr
, ps
, depth
))
4887 if(!smb_io_unistr2("helpfile", &il
->helpfile
, il
->helpfile_ptr
, ps
, depth
))
4889 if(!smb_io_unistr2("monitorname", &il
->monitorname
, il
->monitorname_ptr
, ps
, depth
))
4891 if(!smb_io_unistr2("defaultdatatype", &il
->defaultdatatype
, il
->defaultdatatype_ptr
, ps
, depth
))
4897 if (il
->dependentfiles_ptr
)
4898 smb_io_buffer5("", &il
->dependentfiles
, ps
, depth
);
4903 /*******************************************************************
4904 parse a SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 structure
4905 ********************************************************************/
4907 BOOL
spool_io_printer_driver_info_level_6(const char *desc
, SPOOL_PRINTER_DRIVER_INFO_LEVEL_6
**q_u
,
4908 prs_struct
*ps
, int depth
)
4910 SPOOL_PRINTER_DRIVER_INFO_LEVEL_6
*il
;
4912 prs_debug(ps
, depth
, desc
, "spool_io_printer_driver_info_level_6");
4916 if (UNMARSHALLING(ps
)) {
4917 il
=PRS_ALLOC_MEM(ps
,SPOOL_PRINTER_DRIVER_INFO_LEVEL_6
,1);
4930 * I know this seems weird, but I have no other explanation.
4931 * This is observed behavior on both NT4 and 2K servers.
4935 if (!prs_align_uint64(ps
))
4938 /* parse the main elements the packet */
4940 if(!prs_uint32("cversion ", ps
, depth
, &il
->version
))
4942 if(!prs_uint32("name ", ps
, depth
, &il
->name_ptr
))
4944 if(!prs_uint32("environment ", ps
, depth
, &il
->environment_ptr
))
4946 if(!prs_uint32("driverpath ", ps
, depth
, &il
->driverpath_ptr
))
4948 if(!prs_uint32("datafile ", ps
, depth
, &il
->datafile_ptr
))
4950 if(!prs_uint32("configfile ", ps
, depth
, &il
->configfile_ptr
))
4952 if(!prs_uint32("helpfile ", ps
, depth
, &il
->helpfile_ptr
))
4954 if(!prs_uint32("monitorname ", ps
, depth
, &il
->monitorname_ptr
))
4956 if(!prs_uint32("defaultdatatype", ps
, depth
, &il
->defaultdatatype_ptr
))
4958 if(!prs_uint32("dependentfiles ", ps
, depth
, &il
->dependentfiles_len
))
4960 if(!prs_uint32("dependentfiles ", ps
, depth
, &il
->dependentfiles_ptr
))
4962 if(!prs_uint32("previousnames ", ps
, depth
, &il
->previousnames_len
))
4964 if(!prs_uint32("previousnames ", ps
, depth
, &il
->previousnames_ptr
))
4966 if(!smb_io_time("driverdate ", &il
->driverdate
, ps
, depth
))
4968 if(!prs_uint32("dummy4 ", ps
, depth
, &il
->dummy4
))
4970 if(!prs_uint64("driverversion ", ps
, depth
, &il
->driverversion
))
4972 if(!prs_uint32("mfgname ", ps
, depth
, &il
->mfgname_ptr
))
4974 if(!prs_uint32("oemurl ", ps
, depth
, &il
->oemurl_ptr
))
4976 if(!prs_uint32("hardwareid ", ps
, depth
, &il
->hardwareid_ptr
))
4978 if(!prs_uint32("provider ", ps
, depth
, &il
->provider_ptr
))
4981 /* parse the structures in the packet */
4983 if(!smb_io_unistr2("name", &il
->name
, il
->name_ptr
, ps
, depth
))
4988 if(!smb_io_unistr2("environment", &il
->environment
, il
->environment_ptr
, ps
, depth
))
4993 if(!smb_io_unistr2("driverpath", &il
->driverpath
, il
->driverpath_ptr
, ps
, depth
))
4998 if(!smb_io_unistr2("datafile", &il
->datafile
, il
->datafile_ptr
, ps
, depth
))
5003 if(!smb_io_unistr2("configfile", &il
->configfile
, il
->configfile_ptr
, ps
, depth
))
5008 if(!smb_io_unistr2("helpfile", &il
->helpfile
, il
->helpfile_ptr
, ps
, depth
))
5013 if(!smb_io_unistr2("monitorname", &il
->monitorname
, il
->monitorname_ptr
, ps
, depth
))
5018 if(!smb_io_unistr2("defaultdatatype", &il
->defaultdatatype
, il
->defaultdatatype_ptr
, ps
, depth
))
5022 if (il
->dependentfiles_ptr
) {
5023 if(!smb_io_buffer5("dependentfiles", &il
->dependentfiles
, ps
, depth
))
5028 if (il
->previousnames_ptr
) {
5029 if(!smb_io_buffer5("previousnames", &il
->previousnames
, ps
, depth
))
5034 if(!smb_io_unistr2("mfgname", &il
->mfgname
, il
->mfgname_ptr
, ps
, depth
))
5038 if(!smb_io_unistr2("oemurl", &il
->oemurl
, il
->oemurl_ptr
, ps
, depth
))
5042 if(!smb_io_unistr2("hardwareid", &il
->hardwareid
, il
->hardwareid_ptr
, ps
, depth
))
5046 if(!smb_io_unistr2("provider", &il
->provider
, il
->provider_ptr
, ps
, depth
))
5052 /*******************************************************************
5053 convert a buffer of UNICODE strings null terminated
5054 the buffer is terminated by a NULL
5056 convert to an dos codepage array (null terminated)
5058 dynamically allocate memory
5060 ********************************************************************/
5062 static BOOL
uniarray_2_dosarray(BUFFER5
*buf5
, fstring
**ar
)
5071 src
= (char *)buf5
->buffer
;
5072 *ar
= SMB_MALLOC_ARRAY(fstring
, 1);
5077 while (src
< ((char *)buf5
->buffer
) + buf5
->buf_len
*2) {
5078 rpcstr_pull(f
, src
, sizeof(f
)-1, -1, STR_TERMINATE
);
5079 src
= skip_unibuf(src
, 2*buf5
->buf_len
- PTR_DIFF(src
,buf5
->buffer
));
5080 *ar
= SMB_REALLOC_ARRAY(*ar
, fstring
, n
+2);
5084 fstrcpy((*ar
)[n
], f
);
5088 fstrcpy((*ar
)[n
], "");
5093 /*******************************************************************
5094 read a UNICODE array with null terminated strings
5095 and null terminated array
5096 and size of array at beginning
5097 ********************************************************************/
5099 BOOL
smb_io_unibuffer(const char *desc
, UNISTR2
*buffer
, prs_struct
*ps
, int depth
)
5101 if (buffer
==NULL
) return False
;
5104 buffer
->uni_str_len
=buffer
->uni_max_len
;
5106 if(!prs_uint32("buffer_size", ps
, depth
, &buffer
->uni_max_len
))
5109 if(!prs_unistr2(True
, "buffer ", ps
, depth
, buffer
))
5115 /*******************************************************************
5116 ********************************************************************/
5118 BOOL
spool_io_printer_driver_info_level(const char *desc
, SPOOL_PRINTER_DRIVER_INFO_LEVEL
*il
, prs_struct
*ps
, int depth
)
5120 prs_debug(ps
, depth
, desc
, "spool_io_printer_driver_info_level");
5125 if(!prs_uint32("level", ps
, depth
, &il
->level
))
5127 if(!prs_uint32("ptr", ps
, depth
, &il
->ptr
))
5133 switch (il
->level
) {
5135 if(!spool_io_printer_driver_info_level_3("", &il
->info_3
, ps
, depth
))
5139 if(!spool_io_printer_driver_info_level_6("", &il
->info_6
, ps
, depth
))
5149 /*******************************************************************
5150 init a SPOOL_Q_ADDPRINTERDRIVER struct
5151 ******************************************************************/
5153 BOOL
make_spoolss_q_addprinterdriver(TALLOC_CTX
*mem_ctx
,
5154 SPOOL_Q_ADDPRINTERDRIVER
*q_u
, const char* srv_name
,
5155 uint32 level
, PRINTER_DRIVER_CTR
*info
)
5157 DEBUG(5,("make_spoolss_q_addprinterdriver\n"));
5159 if (!srv_name
|| !info
) {
5163 q_u
->server_name_ptr
= 1; /* srv_name is != NULL, see above */
5164 init_unistr2(&q_u
->server_name
, srv_name
, UNI_STR_TERMINATE
);
5168 q_u
->info
.level
= level
;
5169 q_u
->info
.ptr
= 1; /* Info is != NULL, see above */
5172 /* info level 3 is supported by Windows 95/98, WinNT and Win2k */
5174 make_spoolss_driver_info_3(mem_ctx
, &q_u
->info
.info_3
, info
->info3
);
5178 DEBUG(0,("make_spoolss_q_addprinterdriver: Unknown info level [%d]\n", level
));
5185 BOOL
make_spoolss_driver_info_3(TALLOC_CTX
*mem_ctx
,
5186 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3
**spool_drv_info
,
5187 DRIVER_INFO_3
*info3
)
5190 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3
*inf
;
5192 if (!(inf
=TALLOC_ZERO_P(mem_ctx
, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3
)))
5195 inf
->cversion
= info3
->version
;
5196 inf
->name_ptr
= (info3
->name
.buffer
!=NULL
)?1:0;
5197 inf
->environment_ptr
= (info3
->architecture
.buffer
!=NULL
)?1:0;
5198 inf
->driverpath_ptr
= (info3
->driverpath
.buffer
!=NULL
)?1:0;
5199 inf
->datafile_ptr
= (info3
->datafile
.buffer
!=NULL
)?1:0;
5200 inf
->configfile_ptr
= (info3
->configfile
.buffer
!=NULL
)?1:0;
5201 inf
->helpfile_ptr
= (info3
->helpfile
.buffer
!=NULL
)?1:0;
5202 inf
->monitorname_ptr
= (info3
->monitorname
.buffer
!=NULL
)?1:0;
5203 inf
->defaultdatatype_ptr
= (info3
->defaultdatatype
.buffer
!=NULL
)?1:0;
5205 init_unistr2_from_unistr(&inf
->name
, &info3
->name
);
5206 init_unistr2_from_unistr(&inf
->environment
, &info3
->architecture
);
5207 init_unistr2_from_unistr(&inf
->driverpath
, &info3
->driverpath
);
5208 init_unistr2_from_unistr(&inf
->datafile
, &info3
->datafile
);
5209 init_unistr2_from_unistr(&inf
->configfile
, &info3
->configfile
);
5210 init_unistr2_from_unistr(&inf
->helpfile
, &info3
->helpfile
);
5211 init_unistr2_from_unistr(&inf
->monitorname
, &info3
->monitorname
);
5212 init_unistr2_from_unistr(&inf
->defaultdatatype
, &info3
->defaultdatatype
);
5214 if (info3
->dependentfiles
) {
5216 BOOL null_char
= False
;
5217 uint16
*ptr
= info3
->dependentfiles
;
5222 /* the null_char BOOL is used to help locate
5223 two '\0's back to back */
5240 inf
->dependentfiles_ptr
= (info3
->dependentfiles
!= NULL
) ? 1 : 0;
5241 inf
->dependentfilessize
= (info3
->dependentfiles
!= NULL
) ? len
: 0;
5242 if(!make_spoolss_buffer5(mem_ctx
, &inf
->dependentfiles
, len
, info3
->dependentfiles
)) {
5247 *spool_drv_info
= inf
;
5252 /*******************************************************************
5253 make a BUFFER5 struct from a uint16*
5254 ******************************************************************/
5256 BOOL
make_spoolss_buffer5(TALLOC_CTX
*mem_ctx
, BUFFER5
*buf5
, uint32 len
, uint16
*src
)
5259 buf5
->buf_len
= len
;
5262 if((buf5
->buffer
=(uint16
*)TALLOC_MEMDUP(mem_ctx
, src
, sizeof(uint16
)*len
)) == NULL
) {
5263 DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
5267 buf5
->buffer
= NULL
;
5276 /*******************************************************************
5277 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
5278 ********************************************************************/
5280 BOOL
spoolss_io_q_addprinterdriver(const char *desc
, SPOOL_Q_ADDPRINTERDRIVER
*q_u
, prs_struct
*ps
, int depth
)
5282 prs_debug(ps
, depth
, desc
, "spoolss_io_q_addprinterdriver");
5288 if(!prs_uint32("server_name_ptr", ps
, depth
, &q_u
->server_name_ptr
))
5290 if(!smb_io_unistr2("server_name", &q_u
->server_name
, q_u
->server_name_ptr
, ps
, depth
))
5295 if(!prs_uint32("info_level", ps
, depth
, &q_u
->level
))
5298 if(!spool_io_printer_driver_info_level("", &q_u
->info
, ps
, depth
))
5304 /*******************************************************************
5305 ********************************************************************/
5307 BOOL
spoolss_io_r_addprinterdriver(const char *desc
, SPOOL_R_ADDPRINTERDRIVER
*q_u
, prs_struct
*ps
, int depth
)
5309 prs_debug(ps
, depth
, desc
, "spoolss_io_r_addprinterdriver");
5312 if(!prs_werror("status", ps
, depth
, &q_u
->status
))
5318 /*******************************************************************
5319 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
5320 ********************************************************************/
5322 BOOL
spoolss_io_q_addprinterdriverex(const char *desc
, SPOOL_Q_ADDPRINTERDRIVEREX
*q_u
, prs_struct
*ps
, int depth
)
5324 prs_debug(ps
, depth
, desc
, "spoolss_io_q_addprinterdriverex");
5330 if(!prs_uint32("server_name_ptr", ps
, depth
, &q_u
->server_name_ptr
))
5332 if(!smb_io_unistr2("server_name", &q_u
->server_name
, q_u
->server_name_ptr
, ps
, depth
))
5337 if(!prs_uint32("info_level", ps
, depth
, &q_u
->level
))
5340 if(!spool_io_printer_driver_info_level("", &q_u
->info
, ps
, depth
))
5345 if(!prs_uint32("copy flags", ps
, depth
, &q_u
->copy_flags
))
5351 /*******************************************************************
5352 ********************************************************************/
5354 BOOL
spoolss_io_r_addprinterdriverex(const char *desc
, SPOOL_R_ADDPRINTERDRIVEREX
*q_u
, prs_struct
*ps
, int depth
)
5356 prs_debug(ps
, depth
, desc
, "spoolss_io_r_addprinterdriverex");
5359 if(!prs_werror("status", ps
, depth
, &q_u
->status
))
5365 /*******************************************************************
5366 ********************************************************************/
5368 BOOL
uni_2_asc_printer_driver_3(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3
*uni
,
5369 NT_PRINTER_DRIVER_INFO_LEVEL_3
**asc
)
5371 NT_PRINTER_DRIVER_INFO_LEVEL_3
*d
;
5373 DEBUG(7,("uni_2_asc_printer_driver_3: Converting from UNICODE to ASCII\n"));
5377 *asc
=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3
);
5385 d
->cversion
=uni
->cversion
;
5387 unistr2_to_ascii(d
->name
, &uni
->name
, sizeof(d
->name
));
5388 unistr2_to_ascii(d
->environment
, &uni
->environment
, sizeof(d
->environment
));
5389 unistr2_to_ascii(d
->driverpath
, &uni
->driverpath
, sizeof(d
->driverpath
));
5390 unistr2_to_ascii(d
->datafile
, &uni
->datafile
, sizeof(d
->datafile
));
5391 unistr2_to_ascii(d
->configfile
, &uni
->configfile
, sizeof(d
->configfile
));
5392 unistr2_to_ascii(d
->helpfile
, &uni
->helpfile
, sizeof(d
->helpfile
));
5393 unistr2_to_ascii(d
->monitorname
, &uni
->monitorname
, sizeof(d
->monitorname
));
5394 unistr2_to_ascii(d
->defaultdatatype
, &uni
->defaultdatatype
, sizeof(d
->defaultdatatype
));
5396 DEBUGADD(8,( "version: %d\n", d
->cversion
));
5397 DEBUGADD(8,( "name: %s\n", d
->name
));
5398 DEBUGADD(8,( "environment: %s\n", d
->environment
));
5399 DEBUGADD(8,( "driverpath: %s\n", d
->driverpath
));
5400 DEBUGADD(8,( "datafile: %s\n", d
->datafile
));
5401 DEBUGADD(8,( "configfile: %s\n", d
->configfile
));
5402 DEBUGADD(8,( "helpfile: %s\n", d
->helpfile
));
5403 DEBUGADD(8,( "monitorname: %s\n", d
->monitorname
));
5404 DEBUGADD(8,( "defaultdatatype: %s\n", d
->defaultdatatype
));
5406 if (uniarray_2_dosarray(&uni
->dependentfiles
, &d
->dependentfiles
))
5413 /*******************************************************************
5414 ********************************************************************/
5415 BOOL
uni_2_asc_printer_driver_6(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6
*uni
,
5416 NT_PRINTER_DRIVER_INFO_LEVEL_6
**asc
)
5418 NT_PRINTER_DRIVER_INFO_LEVEL_6
*d
;
5420 DEBUG(7,("uni_2_asc_printer_driver_6: Converting from UNICODE to ASCII\n"));
5424 *asc
=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6
);
5432 d
->version
=uni
->version
;
5434 unistr2_to_ascii(d
->name
, &uni
->name
, sizeof(d
->name
));
5435 unistr2_to_ascii(d
->environment
, &uni
->environment
, sizeof(d
->environment
));
5436 unistr2_to_ascii(d
->driverpath
, &uni
->driverpath
, sizeof(d
->driverpath
));
5437 unistr2_to_ascii(d
->datafile
, &uni
->datafile
, sizeof(d
->datafile
));
5438 unistr2_to_ascii(d
->configfile
, &uni
->configfile
, sizeof(d
->configfile
));
5439 unistr2_to_ascii(d
->helpfile
, &uni
->helpfile
, sizeof(d
->helpfile
));
5440 unistr2_to_ascii(d
->monitorname
, &uni
->monitorname
, sizeof(d
->monitorname
));
5441 unistr2_to_ascii(d
->defaultdatatype
, &uni
->defaultdatatype
, sizeof(d
->defaultdatatype
));
5443 DEBUGADD(8,( "version: %d\n", d
->version
));
5444 DEBUGADD(8,( "name: %s\n", d
->name
));
5445 DEBUGADD(8,( "environment: %s\n", d
->environment
));
5446 DEBUGADD(8,( "driverpath: %s\n", d
->driverpath
));
5447 DEBUGADD(8,( "datafile: %s\n", d
->datafile
));
5448 DEBUGADD(8,( "configfile: %s\n", d
->configfile
));
5449 DEBUGADD(8,( "helpfile: %s\n", d
->helpfile
));
5450 DEBUGADD(8,( "monitorname: %s\n", d
->monitorname
));
5451 DEBUGADD(8,( "defaultdatatype: %s\n", d
->defaultdatatype
));
5453 if (!uniarray_2_dosarray(&uni
->dependentfiles
, &d
->dependentfiles
))
5455 if (!uniarray_2_dosarray(&uni
->previousnames
, &d
->previousnames
))
5465 BOOL
uni_2_asc_printer_info_2(const SPOOL_PRINTER_INFO_LEVEL_2
*uni
,
5466 NT_PRINTER_INFO_LEVEL_2
*d
)
5468 DEBUG(7,("Converting from UNICODE to ASCII\n"));
5470 d
->attributes
=uni
->attributes
;
5471 d
->priority
=uni
->priority
;
5472 d
->default_priority
=uni
->default_priority
;
5473 d
->starttime
=uni
->starttime
;
5474 d
->untiltime
=uni
->untiltime
;
5475 d
->status
=uni
->status
;
5476 d
->cjobs
=uni
->cjobs
;
5478 unistr2_to_ascii(d
->servername
, &uni
->servername
, sizeof(d
->servername
));
5479 unistr2_to_ascii(d
->printername
, &uni
->printername
, sizeof(d
->printername
));
5480 unistr2_to_ascii(d
->sharename
, &uni
->sharename
, sizeof(d
->sharename
));
5481 unistr2_to_ascii(d
->portname
, &uni
->portname
, sizeof(d
->portname
));
5482 unistr2_to_ascii(d
->drivername
, &uni
->drivername
, sizeof(d
->drivername
));
5483 unistr2_to_ascii(d
->comment
, &uni
->comment
, sizeof(d
->comment
));
5484 unistr2_to_ascii(d
->location
, &uni
->location
, sizeof(d
->location
));
5485 unistr2_to_ascii(d
->sepfile
, &uni
->sepfile
, sizeof(d
->sepfile
));
5486 unistr2_to_ascii(d
->printprocessor
, &uni
->printprocessor
, sizeof(d
->printprocessor
));
5487 unistr2_to_ascii(d
->datatype
, &uni
->datatype
, sizeof(d
->datatype
));
5488 unistr2_to_ascii(d
->parameters
, &uni
->parameters
, sizeof(d
->parameters
));
5493 /*******************************************************************
5495 ********************************************************************/
5497 BOOL
make_spoolss_q_getprinterdriverdir(SPOOL_Q_GETPRINTERDRIVERDIR
*q_u
,
5498 fstring servername
, fstring env_name
, uint32 level
,
5499 RPC_BUFFER
*buffer
, uint32 offered
)
5501 init_buf_unistr2(&q_u
->name
, &q_u
->name_ptr
, servername
);
5502 init_buf_unistr2(&q_u
->environment
, &q_u
->environment_ptr
, env_name
);
5506 q_u
->offered
=offered
;
5511 /*******************************************************************
5512 Parse a SPOOL_Q_GETPRINTERDRIVERDIR structure.
5513 ********************************************************************/
5515 BOOL
spoolss_io_q_getprinterdriverdir(const char *desc
, SPOOL_Q_GETPRINTERDRIVERDIR
*q_u
, prs_struct
*ps
, int depth
)
5517 prs_debug(ps
, depth
, desc
, "spoolss_io_q_getprinterdriverdir");
5522 if(!prs_uint32("name_ptr", ps
, depth
, &q_u
->name_ptr
))
5524 if(!smb_io_unistr2("", &q_u
->name
, q_u
->name_ptr
, ps
, depth
))
5530 if(!prs_uint32("", ps
, depth
, &q_u
->environment_ptr
))
5532 if(!smb_io_unistr2("", &q_u
->environment
, q_u
->environment_ptr
, ps
, depth
))
5538 if(!prs_uint32("level", ps
, depth
, &q_u
->level
))
5541 if(!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
5547 if(!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
5553 /*******************************************************************
5554 Parse a SPOOL_R_GETPRINTERDRIVERDIR structure.
5555 ********************************************************************/
5557 BOOL
spoolss_io_r_getprinterdriverdir(const char *desc
, SPOOL_R_GETPRINTERDRIVERDIR
*r_u
, prs_struct
*ps
, int depth
)
5559 prs_debug(ps
, depth
, desc
, "spoolss_io_r_getprinterdriverdir");
5565 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
5571 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
5574 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
5580 /*******************************************************************
5581 ********************************************************************/
5583 BOOL
spoolss_io_r_enumprintprocessors(const char *desc
, SPOOL_R_ENUMPRINTPROCESSORS
*r_u
, prs_struct
*ps
, int depth
)
5585 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enumprintprocessors");
5591 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
5597 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
5600 if (!prs_uint32("returned", ps
, depth
, &r_u
->returned
))
5603 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
5609 /*******************************************************************
5610 ********************************************************************/
5612 BOOL
spoolss_io_q_enumprintprocessors(const char *desc
, SPOOL_Q_ENUMPRINTPROCESSORS
*q_u
, prs_struct
*ps
, int depth
)
5614 prs_debug(ps
, depth
, desc
, "spoolss_io_q_enumprintprocessors");
5620 if (!prs_uint32("name_ptr", ps
, depth
, &q_u
->name_ptr
))
5622 if (!smb_io_unistr2("name", &q_u
->name
, True
, ps
, depth
))
5628 if (!prs_uint32("", ps
, depth
, &q_u
->environment_ptr
))
5630 if (!smb_io_unistr2("", &q_u
->environment
, q_u
->environment_ptr
, ps
, depth
))
5636 if (!prs_uint32("level", ps
, depth
, &q_u
->level
))
5639 if(!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
5645 if (!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
5651 /*******************************************************************
5652 ********************************************************************/
5654 BOOL
spoolss_io_q_addprintprocessor(const char *desc
, SPOOL_Q_ADDPRINTPROCESSOR
*q_u
, prs_struct
*ps
, int depth
)
5656 prs_debug(ps
, depth
, desc
, "spoolss_io_q_addprintprocessor");
5662 if (!prs_uint32("server_ptr", ps
, depth
, &q_u
->server_ptr
))
5664 if (!smb_io_unistr2("server", &q_u
->server
, q_u
->server_ptr
, ps
, depth
))
5669 if (!smb_io_unistr2("environment", &q_u
->environment
, True
, ps
, depth
))
5674 if (!smb_io_unistr2("path", &q_u
->path
, True
, ps
, depth
))
5679 if (!smb_io_unistr2("name", &q_u
->name
, True
, ps
, depth
))
5685 /*******************************************************************
5686 ********************************************************************/
5688 BOOL
spoolss_io_r_addprintprocessor(const char *desc
, SPOOL_R_ADDPRINTPROCESSOR
*r_u
, prs_struct
*ps
, int depth
)
5690 prs_debug(ps
, depth
, desc
, "spoolss_io_r_addprintproicessor");
5696 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
5702 /*******************************************************************
5703 ********************************************************************/
5705 BOOL
spoolss_io_r_enumprintprocdatatypes(const char *desc
, SPOOL_R_ENUMPRINTPROCDATATYPES
*r_u
, prs_struct
*ps
, int depth
)
5707 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enumprintprocdatatypes");
5713 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
5719 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
5722 if (!prs_uint32("returned", ps
, depth
, &r_u
->returned
))
5725 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
5731 /*******************************************************************
5732 ********************************************************************/
5734 BOOL
spoolss_io_q_enumprintprocdatatypes(const char *desc
, SPOOL_Q_ENUMPRINTPROCDATATYPES
*q_u
, prs_struct
*ps
, int depth
)
5736 prs_debug(ps
, depth
, desc
, "spoolss_io_q_enumprintprocdatatypes");
5742 if (!prs_uint32("name_ptr", ps
, depth
, &q_u
->name_ptr
))
5744 if (!smb_io_unistr2("name", &q_u
->name
, True
, ps
, depth
))
5750 if (!prs_uint32("processor_ptr", ps
, depth
, &q_u
->processor_ptr
))
5752 if (!smb_io_unistr2("processor", &q_u
->processor
, q_u
->processor_ptr
, ps
, depth
))
5758 if (!prs_uint32("level", ps
, depth
, &q_u
->level
))
5761 if(!prs_rpcbuffer_p("buffer", ps
, depth
, &q_u
->buffer
))
5767 if (!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
5773 /*******************************************************************
5774 Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
5775 ********************************************************************/
5777 BOOL
spoolss_io_q_enumprintmonitors(const char *desc
, SPOOL_Q_ENUMPRINTMONITORS
*q_u
, prs_struct
*ps
, int depth
)
5779 prs_debug(ps
, depth
, desc
, "spoolss_io_q_enumprintmonitors");
5785 if (!prs_uint32("name_ptr", ps
, depth
, &q_u
->name_ptr
))
5787 if (!smb_io_unistr2("name", &q_u
->name
, True
, ps
, depth
))
5793 if (!prs_uint32("level", ps
, depth
, &q_u
->level
))
5796 if(!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
5802 if (!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
5808 /*******************************************************************
5809 ********************************************************************/
5811 BOOL
spoolss_io_r_enumprintmonitors(const char *desc
, SPOOL_R_ENUMPRINTMONITORS
*r_u
, prs_struct
*ps
, int depth
)
5813 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enumprintmonitors");
5819 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
5825 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
5828 if (!prs_uint32("returned", ps
, depth
, &r_u
->returned
))
5831 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
5837 /*******************************************************************
5838 ********************************************************************/
5840 BOOL
spoolss_io_r_enumprinterdata(const char *desc
, SPOOL_R_ENUMPRINTERDATA
*r_u
, prs_struct
*ps
, int depth
)
5842 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enumprinterdata");
5847 if(!prs_uint32("valuesize", ps
, depth
, &r_u
->valuesize
))
5850 if (UNMARSHALLING(ps
) && r_u
->valuesize
) {
5851 r_u
->value
= PRS_ALLOC_MEM(ps
, uint16
, r_u
->valuesize
);
5853 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata value\n"));
5858 if(!prs_uint16uni(False
, "value", ps
, depth
, r_u
->value
, r_u
->valuesize
))
5864 if(!prs_uint32("realvaluesize", ps
, depth
, &r_u
->realvaluesize
))
5867 if(!prs_uint32("type", ps
, depth
, &r_u
->type
))
5870 if(!prs_uint32("datasize", ps
, depth
, &r_u
->datasize
))
5873 if (UNMARSHALLING(ps
) && r_u
->datasize
) {
5874 r_u
->data
= PRS_ALLOC_MEM(ps
, uint8
, r_u
->datasize
);
5876 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata data\n"));
5881 if(!prs_uint8s(False
, "data", ps
, depth
, r_u
->data
, r_u
->datasize
))
5886 if(!prs_uint32("realdatasize", ps
, depth
, &r_u
->realdatasize
))
5888 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
5894 /*******************************************************************
5895 ********************************************************************/
5897 BOOL
spoolss_io_q_enumprinterdata(const char *desc
, SPOOL_Q_ENUMPRINTERDATA
*q_u
, prs_struct
*ps
, int depth
)
5899 prs_debug(ps
, depth
, desc
, "spoolss_io_q_enumprinterdata");
5904 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
5906 if(!prs_uint32("index", ps
, depth
, &q_u
->index
))
5908 if(!prs_uint32("valuesize", ps
, depth
, &q_u
->valuesize
))
5910 if(!prs_uint32("datasize", ps
, depth
, &q_u
->datasize
))
5916 /*******************************************************************
5917 ********************************************************************/
5919 BOOL
make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA
*q_u
,
5920 const POLICY_HND
*hnd
,
5921 uint32 idx
, uint32 valuelen
, uint32 datalen
)
5923 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
5925 q_u
->valuesize
=valuelen
;
5926 q_u
->datasize
=datalen
;
5931 /*******************************************************************
5932 ********************************************************************/
5934 BOOL
make_spoolss_q_enumprinterdataex(SPOOL_Q_ENUMPRINTERDATAEX
*q_u
,
5935 const POLICY_HND
*hnd
, const char *key
,
5938 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
5939 init_unistr2(&q_u
->key
, key
, UNI_STR_TERMINATE
);
5945 /*******************************************************************
5946 ********************************************************************/
5947 BOOL
make_spoolss_q_setprinterdata(SPOOL_Q_SETPRINTERDATA
*q_u
, const POLICY_HND
*hnd
,
5948 char* value
, uint32 data_type
, char* data
, uint32 data_size
)
5950 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
5951 q_u
->type
= data_type
;
5952 init_unistr2(&q_u
->value
, value
, UNI_STR_TERMINATE
);
5954 q_u
->max_len
= q_u
->real_len
= data_size
;
5955 q_u
->data
= (unsigned char *)data
;
5960 /*******************************************************************
5961 ********************************************************************/
5962 BOOL
make_spoolss_q_setprinterdataex(SPOOL_Q_SETPRINTERDATAEX
*q_u
, const POLICY_HND
*hnd
,
5963 char *key
, char* value
, uint32 data_type
, char* data
,
5966 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
5967 q_u
->type
= data_type
;
5968 init_unistr2(&q_u
->value
, value
, UNI_STR_TERMINATE
);
5969 init_unistr2(&q_u
->key
, key
, UNI_STR_TERMINATE
);
5971 q_u
->max_len
= q_u
->real_len
= data_size
;
5972 q_u
->data
= (unsigned char *)data
;
5977 /*******************************************************************
5978 ********************************************************************/
5980 BOOL
spoolss_io_q_setprinterdata(const char *desc
, SPOOL_Q_SETPRINTERDATA
*q_u
, prs_struct
*ps
, int depth
)
5982 prs_debug(ps
, depth
, desc
, "spoolss_io_q_setprinterdata");
5987 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
5989 if(!smb_io_unistr2("", &q_u
->value
, True
, ps
, depth
))
5995 if(!prs_uint32("type", ps
, depth
, &q_u
->type
))
5998 if(!prs_uint32("max_len", ps
, depth
, &q_u
->max_len
))
6008 if (UNMARSHALLING(ps
))
6009 q_u
->data
=PRS_ALLOC_MEM(ps
, uint8
, q_u
->max_len
);
6010 if(q_u
->data
== NULL
)
6012 if(!prs_uint8s(False
,"data", ps
, depth
, q_u
->data
, q_u
->max_len
))
6020 if(!prs_uint32("real_len", ps
, depth
, &q_u
->real_len
))
6026 /*******************************************************************
6027 ********************************************************************/
6029 BOOL
spoolss_io_r_setprinterdata(const char *desc
, SPOOL_R_SETPRINTERDATA
*r_u
, prs_struct
*ps
, int depth
)
6031 prs_debug(ps
, depth
, desc
, "spoolss_io_r_setprinterdata");
6036 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
6042 /*******************************************************************
6043 ********************************************************************/
6044 BOOL
spoolss_io_q_resetprinter(const char *desc
, SPOOL_Q_RESETPRINTER
*q_u
, prs_struct
*ps
, int depth
)
6046 prs_debug(ps
, depth
, desc
, "spoolss_io_q_resetprinter");
6051 if (!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
6054 if (!prs_uint32("datatype_ptr", ps
, depth
, &q_u
->datatype_ptr
))
6057 if (q_u
->datatype_ptr
) {
6058 if (!smb_io_unistr2("datatype", &q_u
->datatype
, q_u
->datatype_ptr
?True
:False
, ps
, depth
))
6062 if (!spoolss_io_devmode_cont(desc
, &q_u
->devmode_ctr
, ps
, depth
))
6069 /*******************************************************************
6070 ********************************************************************/
6071 BOOL
spoolss_io_r_resetprinter(const char *desc
, SPOOL_R_RESETPRINTER
*r_u
, prs_struct
*ps
, int depth
)
6073 prs_debug(ps
, depth
, desc
, "spoolss_io_r_resetprinter");
6078 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
6084 /*******************************************************************
6085 ********************************************************************/
6087 static BOOL
spoolss_io_addform(const char *desc
, FORM
*f
, uint32 ptr
, prs_struct
*ps
, int depth
)
6089 prs_debug(ps
, depth
, desc
, "spoolss_io_addform");
6096 if(!prs_uint32("flags", ps
, depth
, &f
->flags
))
6098 if(!prs_uint32("name_ptr", ps
, depth
, &f
->name_ptr
))
6100 if(!prs_uint32("size_x", ps
, depth
, &f
->size_x
))
6102 if(!prs_uint32("size_y", ps
, depth
, &f
->size_y
))
6104 if(!prs_uint32("left", ps
, depth
, &f
->left
))
6106 if(!prs_uint32("top", ps
, depth
, &f
->top
))
6108 if(!prs_uint32("right", ps
, depth
, &f
->right
))
6110 if(!prs_uint32("bottom", ps
, depth
, &f
->bottom
))
6113 if(!smb_io_unistr2("", &f
->name
, f
->name_ptr
, ps
, depth
))
6120 /*******************************************************************
6121 ********************************************************************/
6123 BOOL
spoolss_io_q_deleteform(const char *desc
, SPOOL_Q_DELETEFORM
*q_u
, prs_struct
*ps
, int depth
)
6125 prs_debug(ps
, depth
, desc
, "spoolss_io_q_deleteform");
6130 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
6132 if(!smb_io_unistr2("form name", &q_u
->name
, True
, ps
, depth
))
6138 /*******************************************************************
6139 ********************************************************************/
6141 BOOL
spoolss_io_r_deleteform(const char *desc
, SPOOL_R_DELETEFORM
*r_u
, prs_struct
*ps
, int depth
)
6143 prs_debug(ps
, depth
, desc
, "spoolss_io_r_deleteform");
6148 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
6154 /*******************************************************************
6155 ********************************************************************/
6157 BOOL
spoolss_io_q_addform(const char *desc
, SPOOL_Q_ADDFORM
*q_u
, prs_struct
*ps
, int depth
)
6159 uint32 useless_ptr
=1;
6160 prs_debug(ps
, depth
, desc
, "spoolss_io_q_addform");
6165 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
6167 if(!prs_uint32("level", ps
, depth
, &q_u
->level
))
6169 if(!prs_uint32("level2", ps
, depth
, &q_u
->level2
))
6174 if(!prs_uint32("useless_ptr", ps
, depth
, &useless_ptr
))
6176 if(!spoolss_io_addform("", &q_u
->form
, useless_ptr
, ps
, depth
))
6183 /*******************************************************************
6184 ********************************************************************/
6186 BOOL
spoolss_io_r_addform(const char *desc
, SPOOL_R_ADDFORM
*r_u
, prs_struct
*ps
, int depth
)
6188 prs_debug(ps
, depth
, desc
, "spoolss_io_r_addform");
6193 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
6199 /*******************************************************************
6200 ********************************************************************/
6202 BOOL
spoolss_io_q_setform(const char *desc
, SPOOL_Q_SETFORM
*q_u
, prs_struct
*ps
, int depth
)
6204 uint32 useless_ptr
=1;
6205 prs_debug(ps
, depth
, desc
, "spoolss_io_q_setform");
6210 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
6212 if(!smb_io_unistr2("", &q_u
->name
, True
, ps
, depth
))
6218 if(!prs_uint32("level", ps
, depth
, &q_u
->level
))
6220 if(!prs_uint32("level2", ps
, depth
, &q_u
->level2
))
6225 if(!prs_uint32("useless_ptr", ps
, depth
, &useless_ptr
))
6227 if(!spoolss_io_addform("", &q_u
->form
, useless_ptr
, ps
, depth
))
6234 /*******************************************************************
6235 ********************************************************************/
6237 BOOL
spoolss_io_r_setform(const char *desc
, SPOOL_R_SETFORM
*r_u
, prs_struct
*ps
, int depth
)
6239 prs_debug(ps
, depth
, desc
, "spoolss_io_r_setform");
6244 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
6250 /*******************************************************************
6251 Parse a SPOOL_R_GETJOB structure.
6252 ********************************************************************/
6254 BOOL
spoolss_io_r_getjob(const char *desc
, SPOOL_R_GETJOB
*r_u
, prs_struct
*ps
, int depth
)
6256 prs_debug(ps
, depth
, desc
, "spoolss_io_r_getjob");
6262 if (!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
6268 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
6271 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
6277 /*******************************************************************
6278 Parse a SPOOL_Q_GETJOB structure.
6279 ********************************************************************/
6281 BOOL
spoolss_io_q_getjob(const char *desc
, SPOOL_Q_GETJOB
*q_u
, prs_struct
*ps
, int depth
)
6283 prs_debug(ps
, depth
, desc
, "");
6289 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
6291 if(!prs_uint32("jobid", ps
, depth
, &q_u
->jobid
))
6293 if(!prs_uint32("level", ps
, depth
, &q_u
->level
))
6296 if(!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
6302 if(!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
6308 void free_devmode(DEVICEMODE
*devmode
)
6310 if (devmode
!=NULL
) {
6311 SAFE_FREE(devmode
->dev_private
);
6316 void free_printer_info_1(PRINTER_INFO_1
*printer
)
6321 void free_printer_info_2(PRINTER_INFO_2
*printer
)
6323 if (printer
!=NULL
) {
6324 free_devmode(printer
->devmode
);
6325 printer
->devmode
= NULL
;
6330 void free_printer_info_3(PRINTER_INFO_3
*printer
)
6335 void free_printer_info_4(PRINTER_INFO_4
*printer
)
6340 void free_printer_info_5(PRINTER_INFO_5
*printer
)
6345 void free_printer_info_6(PRINTER_INFO_6
*printer
)
6350 void free_printer_info_7(PRINTER_INFO_7
*printer
)
6355 void free_job_info_2(JOB_INFO_2
*job
)
6358 free_devmode(job
->devmode
);
6361 /*******************************************************************
6363 ********************************************************************/
6365 BOOL
make_spoolss_q_replyopenprinter(SPOOL_Q_REPLYOPENPRINTER
*q_u
,
6366 const fstring string
, uint32 printer
, uint32 type
)
6371 init_unistr2(&q_u
->string
, string
, UNI_STR_TERMINATE
);
6373 q_u
->printer
=printer
;
6382 /*******************************************************************
6383 Parse a SPOOL_Q_REPLYOPENPRINTER structure.
6384 ********************************************************************/
6386 BOOL
spoolss_io_q_replyopenprinter(const char *desc
, SPOOL_Q_REPLYOPENPRINTER
*q_u
, prs_struct
*ps
, int depth
)
6388 prs_debug(ps
, depth
, desc
, "spoolss_io_q_replyopenprinter");
6394 if(!smb_io_unistr2("", &q_u
->string
, True
, ps
, depth
))
6400 if(!prs_uint32("printer", ps
, depth
, &q_u
->printer
))
6402 if(!prs_uint32("type", ps
, depth
, &q_u
->type
))
6405 if(!prs_uint32("unknown0", ps
, depth
, &q_u
->unknown0
))
6407 if(!prs_uint32("unknown1", ps
, depth
, &q_u
->unknown1
))
6413 /*******************************************************************
6414 Parse a SPOOL_R_REPLYOPENPRINTER structure.
6415 ********************************************************************/
6417 BOOL
spoolss_io_r_replyopenprinter(const char *desc
, SPOOL_R_REPLYOPENPRINTER
*r_u
, prs_struct
*ps
, int depth
)
6419 prs_debug(ps
, depth
, desc
, "spoolss_io_r_replyopenprinter");
6425 if(!smb_io_pol_hnd("printer handle",&r_u
->handle
,ps
,depth
))
6428 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
6434 /*******************************************************************
6436 ********************************************************************/
6437 BOOL
make_spoolss_q_routerreplyprinter(SPOOL_Q_ROUTERREPLYPRINTER
*q_u
, POLICY_HND
*hnd
,
6438 uint32 condition
, uint32 change_id
)
6441 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
6443 q_u
->condition
= condition
;
6444 q_u
->change_id
= change_id
;
6447 q_u
->unknown1
= 0x1;
6448 memset(q_u
->unknown2
, 0x0, 5);
6449 q_u
->unknown2
[0] = 0x1;
6454 /*******************************************************************
6455 Parse a SPOOL_Q_ROUTERREPLYPRINTER structure.
6456 ********************************************************************/
6457 BOOL
spoolss_io_q_routerreplyprinter (const char *desc
, SPOOL_Q_ROUTERREPLYPRINTER
*q_u
, prs_struct
*ps
, int depth
)
6460 prs_debug(ps
, depth
, desc
, "spoolss_io_q_routerreplyprinter");
6466 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
6469 if (!prs_uint32("condition", ps
, depth
, &q_u
->condition
))
6472 if (!prs_uint32("unknown1", ps
, depth
, &q_u
->unknown1
))
6475 if (!prs_uint32("change_id", ps
, depth
, &q_u
->change_id
))
6478 if (!prs_uint8s(False
, "dev_private", ps
, depth
, q_u
->unknown2
, 5))
6484 /*******************************************************************
6485 Parse a SPOOL_R_ROUTERREPLYPRINTER structure.
6486 ********************************************************************/
6487 BOOL
spoolss_io_r_routerreplyprinter (const char *desc
, SPOOL_R_ROUTERREPLYPRINTER
*r_u
, prs_struct
*ps
, int depth
)
6489 prs_debug(ps
, depth
, desc
, "spoolss_io_r_routerreplyprinter");
6495 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
6501 /*******************************************************************
6503 ********************************************************************/
6505 BOOL
make_spoolss_q_reply_closeprinter(SPOOL_Q_REPLYCLOSEPRINTER
*q_u
, POLICY_HND
*hnd
)
6510 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
6515 /*******************************************************************
6516 Parse a SPOOL_Q_REPLYCLOSEPRINTER structure.
6517 ********************************************************************/
6519 BOOL
spoolss_io_q_replycloseprinter(const char *desc
, SPOOL_Q_REPLYCLOSEPRINTER
*q_u
, prs_struct
*ps
, int depth
)
6521 prs_debug(ps
, depth
, desc
, "spoolss_io_q_replycloseprinter");
6527 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
6533 /*******************************************************************
6534 Parse a SPOOL_R_REPLYCLOSEPRINTER structure.
6535 ********************************************************************/
6537 BOOL
spoolss_io_r_replycloseprinter(const char *desc
, SPOOL_R_REPLYCLOSEPRINTER
*r_u
, prs_struct
*ps
, int depth
)
6539 prs_debug(ps
, depth
, desc
, "spoolss_io_r_replycloseprinter");
6545 if(!smb_io_pol_hnd("printer handle",&r_u
->handle
,ps
,depth
))
6548 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
6554 #if 0 /* JERRY - not currently used but could be :-) */
6556 /*******************************************************************
6557 Deep copy a SPOOL_NOTIFY_INFO_DATA structure
6558 ******************************************************************/
6559 static BOOL
copy_spool_notify_info_data(SPOOL_NOTIFY_INFO_DATA
*dst
,
6560 SPOOL_NOTIFY_INFO_DATA
*src
, int n
)
6564 memcpy(dst
, src
, sizeof(SPOOL_NOTIFY_INFO_DATA
)*n
);
6566 for (i
=0; i
<n
; i
++) {
6570 if (src
->size
!= POINTER
)
6572 len
= src
->notify_data
.data
.length
;
6573 s
= SMB_MALLOC_ARRAY(uint16
, len
);
6575 DEBUG(0,("copy_spool_notify_info_data: malloc() failed!\n"));
6579 memcpy(s
, src
->notify_data
.data
.string
, len
*2);
6580 dst
->notify_data
.data
.string
= s
;
6586 /*******************************************************************
6587 Deep copy a SPOOL_NOTIFY_INFO structure
6588 ******************************************************************/
6589 static BOOL
copy_spool_notify_info(SPOOL_NOTIFY_INFO
*dst
, SPOOL_NOTIFY_INFO
*src
)
6592 DEBUG(0,("copy_spool_notify_info: NULL destination pointer!\n"));
6596 dst
->version
= src
->version
;
6597 dst
->flags
= src
->flags
;
6598 dst
->count
= src
->count
;
6602 dst
->data
= SMB_MALLOC_ARRAY(SPOOL_NOTIFY_INFO_DATA
, dst
->count
);
6604 DEBUG(10,("copy_spool_notify_info: allocating space for [%d] PRINTER_NOTIFY_INFO_DATA entries\n",
6607 if (dst
->data
== NULL
) {
6608 DEBUG(0,("copy_spool_notify_info: malloc() failed for [%d] entries!\n",
6613 return (copy_spool_notify_info_data(dst
->data
, src
->data
, src
->count
));
6620 /*******************************************************************
6622 ********************************************************************/
6624 BOOL
make_spoolss_q_reply_rrpcn(SPOOL_Q_REPLY_RRPCN
*q_u
, POLICY_HND
*hnd
,
6625 uint32 change_low
, uint32 change_high
,
6626 SPOOL_NOTIFY_INFO
*info
)
6631 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
6633 q_u
->change_low
=change_low
;
6634 q_u
->change_high
=change_high
;
6639 q_u
->info_ptr
=0x0FF0ADDE;
6641 q_u
->info
.version
=2;
6644 DEBUG(10,("make_spoolss_q_reply_rrpcn: [%d] PRINTER_NOTIFY_INFO_DATA\n",
6646 q_u
->info
.version
= info
->version
;
6647 q_u
->info
.flags
= info
->flags
;
6648 q_u
->info
.count
= info
->count
;
6649 /* pointer field - be careful! */
6650 q_u
->info
.data
= info
->data
;
6653 q_u
->info
.flags
=PRINTER_NOTIFY_INFO_DISCARDED
;
6660 /*******************************************************************
6661 Parse a SPOOL_Q_REPLY_RRPCN structure.
6662 ********************************************************************/
6664 BOOL
spoolss_io_q_reply_rrpcn(const char *desc
, SPOOL_Q_REPLY_RRPCN
*q_u
, prs_struct
*ps
, int depth
)
6666 prs_debug(ps
, depth
, desc
, "spoolss_io_q_reply_rrpcn");
6672 if(!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
6675 if (!prs_uint32("change_low", ps
, depth
, &q_u
->change_low
))
6678 if (!prs_uint32("change_high", ps
, depth
, &q_u
->change_high
))
6681 if (!prs_uint32("unknown0", ps
, depth
, &q_u
->unknown0
))
6684 if (!prs_uint32("unknown1", ps
, depth
, &q_u
->unknown1
))
6687 if (!prs_uint32("info_ptr", ps
, depth
, &q_u
->info_ptr
))
6690 if(q_u
->info_ptr
!=0)
6691 if(!smb_io_notify_info(desc
, &q_u
->info
, ps
, depth
))
6697 /*******************************************************************
6698 Parse a SPOOL_R_REPLY_RRPCN structure.
6699 ********************************************************************/
6701 BOOL
spoolss_io_r_reply_rrpcn(const char *desc
, SPOOL_R_REPLY_RRPCN
*r_u
, prs_struct
*ps
, int depth
)
6703 prs_debug(ps
, depth
, desc
, "spoolss_io_r_reply_rrpcn");
6709 if (!prs_uint32("unknown0", ps
, depth
, &r_u
->unknown0
))
6712 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
6718 /*******************************************************************
6720 * called from spoolss_q_getprinterdataex (srv_spoolss.c)
6721 ********************************************************************/
6723 BOOL
spoolss_io_q_getprinterdataex(const char *desc
, SPOOL_Q_GETPRINTERDATAEX
*q_u
, prs_struct
*ps
, int depth
)
6728 prs_debug(ps
, depth
, desc
, "spoolss_io_q_getprinterdataex");
6733 if (!smb_io_pol_hnd("printer handle",&q_u
->handle
,ps
,depth
))
6737 if (!smb_io_unistr2("keyname", &q_u
->keyname
,True
,ps
,depth
))
6741 if (!smb_io_unistr2("valuename", &q_u
->valuename
,True
,ps
,depth
))
6745 if (!prs_uint32("size", ps
, depth
, &q_u
->size
))
6751 /*******************************************************************
6752 * write a structure.
6753 * called from spoolss_r_getprinterdataex (srv_spoolss.c)
6754 ********************************************************************/
6756 BOOL
spoolss_io_r_getprinterdataex(const char *desc
, SPOOL_R_GETPRINTERDATAEX
*r_u
, prs_struct
*ps
, int depth
)
6761 prs_debug(ps
, depth
, desc
, "spoolss_io_r_getprinterdataex");
6766 if (!prs_uint32("type", ps
, depth
, &r_u
->type
))
6768 if (!prs_uint32("size", ps
, depth
, &r_u
->size
))
6771 if (UNMARSHALLING(ps
) && r_u
->size
) {
6772 r_u
->data
= PRS_ALLOC_MEM(ps
, unsigned char, r_u
->size
);
6777 if (!prs_uint8s(False
,"data", ps
, depth
, r_u
->data
, r_u
->size
))
6783 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
6785 if (!prs_werror("status", ps
, depth
, &r_u
->status
))
6791 /*******************************************************************
6793 ********************************************************************/
6795 BOOL
spoolss_io_q_setprinterdataex(const char *desc
, SPOOL_Q_SETPRINTERDATAEX
*q_u
, prs_struct
*ps
, int depth
)
6797 prs_debug(ps
, depth
, desc
, "spoolss_io_q_setprinterdataex");
6802 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
6804 if(!smb_io_unistr2("", &q_u
->key
, True
, ps
, depth
))
6810 if(!smb_io_unistr2("", &q_u
->value
, True
, ps
, depth
))
6816 if(!prs_uint32("type", ps
, depth
, &q_u
->type
))
6819 if(!prs_uint32("max_len", ps
, depth
, &q_u
->max_len
))
6829 if (UNMARSHALLING(ps
))
6830 q_u
->data
=PRS_ALLOC_MEM(ps
, uint8
, q_u
->max_len
);
6831 if(q_u
->data
== NULL
)
6833 if(!prs_uint8s(False
,"data", ps
, depth
, q_u
->data
, q_u
->max_len
))
6841 if(!prs_uint32("real_len", ps
, depth
, &q_u
->real_len
))
6847 /*******************************************************************
6848 * write a structure.
6849 ********************************************************************/
6851 BOOL
spoolss_io_r_setprinterdataex(const char *desc
, SPOOL_R_SETPRINTERDATAEX
*r_u
, prs_struct
*ps
, int depth
)
6853 prs_debug(ps
, depth
, desc
, "spoolss_io_r_setprinterdataex");
6858 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
6864 /*******************************************************************
6866 ********************************************************************/
6867 BOOL
make_spoolss_q_enumprinterkey(SPOOL_Q_ENUMPRINTERKEY
*q_u
,
6868 POLICY_HND
*hnd
, const char *key
,
6871 DEBUG(5,("make_spoolss_q_enumprinterkey\n"));
6873 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
6874 init_unistr2(&q_u
->key
, key
, UNI_STR_TERMINATE
);
6880 /*******************************************************************
6882 ********************************************************************/
6884 BOOL
spoolss_io_q_enumprinterkey(const char *desc
, SPOOL_Q_ENUMPRINTERKEY
*q_u
, prs_struct
*ps
, int depth
)
6886 prs_debug(ps
, depth
, desc
, "spoolss_io_q_enumprinterkey");
6891 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
6894 if(!smb_io_unistr2("", &q_u
->key
, True
, ps
, depth
))
6900 if(!prs_uint32("size", ps
, depth
, &q_u
->size
))
6906 /*******************************************************************
6907 * write a structure.
6908 ********************************************************************/
6910 BOOL
spoolss_io_r_enumprinterkey(const char *desc
, SPOOL_R_ENUMPRINTERKEY
*r_u
, prs_struct
*ps
, int depth
)
6912 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enumprinterkey");
6918 if (!smb_io_buffer5("", &r_u
->keys
, ps
, depth
))
6924 if(!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
6927 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
6933 /*******************************************************************
6935 ********************************************************************/
6937 BOOL
make_spoolss_q_deleteprinterkey(SPOOL_Q_DELETEPRINTERKEY
*q_u
,
6938 POLICY_HND
*hnd
, char *keyname
)
6940 DEBUG(5,("make_spoolss_q_deleteprinterkey\n"));
6942 memcpy(&q_u
->handle
, hnd
, sizeof(q_u
->handle
));
6943 init_unistr2(&q_u
->keyname
, keyname
, UNI_STR_TERMINATE
);
6948 /*******************************************************************
6950 ********************************************************************/
6952 BOOL
spoolss_io_q_deleteprinterkey(const char *desc
, SPOOL_Q_DELETEPRINTERKEY
*q_u
, prs_struct
*ps
, int depth
)
6954 prs_debug(ps
, depth
, desc
, "spoolss_io_q_deleteprinterkey");
6959 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
6962 if(!smb_io_unistr2("", &q_u
->keyname
, True
, ps
, depth
))
6968 /*******************************************************************
6969 * write a structure.
6970 ********************************************************************/
6972 BOOL
spoolss_io_r_deleteprinterkey(const char *desc
, SPOOL_R_DELETEPRINTERKEY
*r_u
, prs_struct
*ps
, int depth
)
6974 prs_debug(ps
, depth
, desc
, "spoolss_io_r_deleteprinterkey");
6980 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
6987 /*******************************************************************
6989 ********************************************************************/
6991 BOOL
spoolss_io_q_enumprinterdataex(const char *desc
, SPOOL_Q_ENUMPRINTERDATAEX
*q_u
, prs_struct
*ps
, int depth
)
6993 prs_debug(ps
, depth
, desc
, "spoolss_io_q_enumprinterdataex");
6998 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
7001 if(!smb_io_unistr2("", &q_u
->key
, True
, ps
, depth
))
7007 if(!prs_uint32("size", ps
, depth
, &q_u
->size
))
7013 /*******************************************************************
7014 ********************************************************************/
7016 static BOOL
spoolss_io_printer_enum_values_ctr(const char *desc
, prs_struct
*ps
,
7017 PRINTER_ENUM_VALUES_CTR
*ctr
, int depth
)
7020 uint32 valuename_offset
,
7023 const uint32 basic_unit
= 20; /* size of static portion of enum_values */
7025 prs_debug(ps
, depth
, desc
, "spoolss_io_printer_enum_values_ctr");
7029 * offset data begins at 20 bytes per structure * size_of_array.
7030 * Don't forget the uint32 at the beginning
7033 current_offset
= basic_unit
* ctr
->size_of_array
;
7035 /* first loop to write basic enum_value information */
7037 if (UNMARSHALLING(ps
) && ctr
->size_of_array
) {
7038 ctr
->values
= PRS_ALLOC_MEM(ps
, PRINTER_ENUM_VALUES
, ctr
->size_of_array
);
7043 for (i
=0; i
<ctr
->size_of_array
; i
++) {
7044 uint32 base_offset
, return_offset
;
7046 base_offset
= prs_offset(ps
);
7048 valuename_offset
= current_offset
;
7049 if (!prs_uint32("valuename_offset", ps
, depth
, &valuename_offset
))
7052 /* Read or write the value. */
7054 return_offset
= prs_offset(ps
);
7056 if (!prs_set_offset(ps
, base_offset
+ valuename_offset
)) {
7060 if (!prs_unistr("valuename", ps
, depth
, &ctr
->values
[i
].valuename
))
7064 if (!prs_set_offset(ps
, return_offset
))
7067 if (!prs_uint32("value_len", ps
, depth
, &ctr
->values
[i
].value_len
))
7070 if (!prs_uint32("type", ps
, depth
, &ctr
->values
[i
].type
))
7073 data_offset
= ctr
->values
[i
].value_len
+ valuename_offset
;
7075 if (!prs_uint32("data_offset", ps
, depth
, &data_offset
))
7078 if (!prs_uint32("data_len", ps
, depth
, &ctr
->values
[i
].data_len
))
7081 /* Read or write the data. */
7083 return_offset
= prs_offset(ps
);
7085 if (!prs_set_offset(ps
, base_offset
+ data_offset
)) {
7089 if ( ctr
->values
[i
].data_len
) {
7090 if ( UNMARSHALLING(ps
) ) {
7091 ctr
->values
[i
].data
= PRS_ALLOC_MEM(ps
, uint8
, ctr
->values
[i
].data_len
);
7092 if (!ctr
->values
[i
].data
)
7095 if (!prs_uint8s(False
, "data", ps
, depth
, ctr
->values
[i
].data
, ctr
->values
[i
].data_len
))
7099 current_offset
= data_offset
+ ctr
->values
[i
].data_len
- basic_unit
;
7100 /* account for 2 byte alignment */
7101 current_offset
+= (current_offset
% 2);
7103 /* Remember how far we got. */
7104 data_offset
= prs_offset(ps
);
7107 if (!prs_set_offset(ps
, return_offset
))
7112 /* Go to the last data offset we got to. */
7114 if (!prs_set_offset(ps
, data_offset
))
7117 /* And ensure we're 2 byte aligned. */
7119 if ( !prs_align_uint16(ps
) )
7125 /*******************************************************************
7126 * write a structure.
7127 ********************************************************************/
7129 BOOL
spoolss_io_r_enumprinterdataex(const char *desc
, SPOOL_R_ENUMPRINTERDATAEX
*r_u
, prs_struct
*ps
, int depth
)
7131 uint32 data_offset
, end_offset
;
7132 prs_debug(ps
, depth
, desc
, "spoolss_io_r_enumprinterdataex");
7138 if (!prs_uint32("size", ps
, depth
, &r_u
->ctr
.size
))
7141 data_offset
= prs_offset(ps
);
7143 if (!prs_set_offset(ps
, data_offset
+ r_u
->ctr
.size
))
7149 if(!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
7152 if(!prs_uint32("returned", ps
, depth
, &r_u
->returned
))
7155 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
7158 r_u
->ctr
.size_of_array
= r_u
->returned
;
7160 end_offset
= prs_offset(ps
);
7162 if (!prs_set_offset(ps
, data_offset
))
7166 if (!spoolss_io_printer_enum_values_ctr("", ps
, &r_u
->ctr
, depth
))
7169 if (!prs_set_offset(ps
, end_offset
))
7174 /*******************************************************************
7175 * write a structure.
7176 ********************************************************************/
7179 uint32 GetPrintProcessorDirectory(
7181 [in] unistr2 *environment,
7183 [in,out] RPC_BUFFER buffer,
7184 [in] uint32 offered,
7185 [out] uint32 needed,
7186 [out] uint32 returned
7191 BOOL
make_spoolss_q_getprintprocessordirectory(SPOOL_Q_GETPRINTPROCESSORDIRECTORY
*q_u
, const char *name
, char *environment
, int level
, RPC_BUFFER
*buffer
, uint32 offered
)
7193 DEBUG(5,("make_spoolss_q_getprintprocessordirectory\n"));
7195 init_unistr2(&q_u
->name
, name
, UNI_STR_TERMINATE
);
7196 init_unistr2(&q_u
->environment
, environment
, UNI_STR_TERMINATE
);
7200 q_u
->buffer
= buffer
;
7201 q_u
->offered
= offered
;
7206 BOOL
spoolss_io_q_getprintprocessordirectory(const char *desc
, SPOOL_Q_GETPRINTPROCESSORDIRECTORY
*q_u
, prs_struct
*ps
, int depth
)
7210 prs_debug(ps
, depth
, desc
, "spoolss_io_q_getprintprocessordirectory");
7216 if (!prs_uint32("ptr", ps
, depth
, &ptr
))
7220 if(!smb_io_unistr2("name", &q_u
->name
, True
, ps
, depth
))
7227 if (!prs_uint32("ptr", ps
, depth
, &ptr
))
7231 if(!smb_io_unistr2("environment", &q_u
->environment
, True
,
7239 if(!prs_uint32("level", ps
, depth
, &q_u
->level
))
7242 if(!prs_rpcbuffer_p("", ps
, depth
, &q_u
->buffer
))
7248 if(!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
7254 /*******************************************************************
7255 * write a structure.
7256 ********************************************************************/
7258 BOOL
spoolss_io_r_getprintprocessordirectory(const char *desc
, SPOOL_R_GETPRINTPROCESSORDIRECTORY
*r_u
, prs_struct
*ps
, int depth
)
7260 prs_debug(ps
, depth
, desc
, "spoolss_io_r_getprintprocessordirectory");
7266 if(!prs_rpcbuffer_p("", ps
, depth
, &r_u
->buffer
))
7272 if(!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
7275 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
7281 BOOL
smb_io_printprocessordirectory_1(const char *desc
, RPC_BUFFER
*buffer
, PRINTPROCESSOR_DIRECTORY_1
*info
, int depth
)
7283 prs_struct
*ps
=&buffer
->prs
;
7285 prs_debug(ps
, depth
, desc
, "smb_io_printprocessordirectory_1");
7288 buffer
->struct_start
=prs_offset(ps
);
7290 if (!smb_io_unistr(desc
, &info
->name
, ps
, depth
))
7296 /*******************************************************************
7298 ********************************************************************/
7300 BOOL
make_spoolss_q_addform(SPOOL_Q_ADDFORM
*q_u
, POLICY_HND
*handle
,
7301 int level
, FORM
*form
)
7303 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7305 q_u
->level2
= level
;
7306 memcpy(&q_u
->form
, form
, sizeof(FORM
));
7311 /*******************************************************************
7313 ********************************************************************/
7315 BOOL
make_spoolss_q_setform(SPOOL_Q_SETFORM
*q_u
, POLICY_HND
*handle
,
7316 int level
, const char *form_name
, FORM
*form
)
7318 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7320 q_u
->level2
= level
;
7321 memcpy(&q_u
->form
, form
, sizeof(FORM
));
7322 init_unistr2(&q_u
->name
, form_name
, UNI_STR_TERMINATE
);
7327 /*******************************************************************
7329 ********************************************************************/
7331 BOOL
make_spoolss_q_deleteform(SPOOL_Q_DELETEFORM
*q_u
, POLICY_HND
*handle
,
7334 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7335 init_unistr2(&q_u
->name
, form
, UNI_STR_TERMINATE
);
7339 /*******************************************************************
7341 ********************************************************************/
7343 BOOL
make_spoolss_q_getform(SPOOL_Q_GETFORM
*q_u
, POLICY_HND
*handle
,
7344 const char *formname
, uint32 level
,
7345 RPC_BUFFER
*buffer
, uint32 offered
)
7347 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7349 init_unistr2(&q_u
->formname
, formname
, UNI_STR_TERMINATE
);
7351 q_u
->offered
=offered
;
7356 /*******************************************************************
7358 ********************************************************************/
7360 BOOL
make_spoolss_q_enumforms(SPOOL_Q_ENUMFORMS
*q_u
, POLICY_HND
*handle
,
7361 uint32 level
, RPC_BUFFER
*buffer
,
7364 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7367 q_u
->offered
=offered
;
7372 /*******************************************************************
7374 ********************************************************************/
7376 BOOL
make_spoolss_q_setjob(SPOOL_Q_SETJOB
*q_u
, POLICY_HND
*handle
,
7377 uint32 jobid
, uint32 level
, uint32 command
)
7379 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7383 /* Hmm - the SPOOL_Q_SETJOB structure has a JOB_INFO ctr in it but
7384 the server side code has it marked as unused. */
7386 q_u
->command
= command
;
7391 /*******************************************************************
7393 ********************************************************************/
7395 BOOL
make_spoolss_q_getjob(SPOOL_Q_GETJOB
*q_u
, POLICY_HND
*handle
,
7396 uint32 jobid
, uint32 level
, RPC_BUFFER
*buffer
,
7399 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7402 q_u
->buffer
= buffer
;
7403 q_u
->offered
= offered
;
7408 /*******************************************************************
7410 ********************************************************************/
7412 BOOL
make_spoolss_q_startpageprinter(SPOOL_Q_STARTPAGEPRINTER
*q_u
,
7415 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7420 /*******************************************************************
7422 ********************************************************************/
7424 BOOL
make_spoolss_q_endpageprinter(SPOOL_Q_ENDPAGEPRINTER
*q_u
,
7427 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7432 /*******************************************************************
7434 ********************************************************************/
7436 BOOL
make_spoolss_q_startdocprinter(SPOOL_Q_STARTDOCPRINTER
*q_u
,
7437 POLICY_HND
*handle
, uint32 level
,
7438 char *docname
, char *outputfile
,
7441 DOC_INFO_CONTAINER
*ctr
= &q_u
->doc_info_container
;
7443 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7449 ctr
->docinfo
.switch_value
= level
;
7451 ctr
->docinfo
.doc_info_1
.p_docname
= docname
? 1 : 0;
7452 ctr
->docinfo
.doc_info_1
.p_outputfile
= outputfile
? 1 : 0;
7453 ctr
->docinfo
.doc_info_1
.p_datatype
= datatype
? 1 : 0;
7455 init_unistr2(&ctr
->docinfo
.doc_info_1
.docname
, docname
, UNI_STR_TERMINATE
);
7456 init_unistr2(&ctr
->docinfo
.doc_info_1
.outputfile
, outputfile
, UNI_STR_TERMINATE
);
7457 init_unistr2(&ctr
->docinfo
.doc_info_1
.datatype
, datatype
, UNI_STR_TERMINATE
);
7461 /* DOC_INFO_2 is only used by Windows 9x and since it
7462 doesn't do printing over RPC we don't have to worry
7465 DEBUG(3, ("unsupported info level %d\n", level
));
7472 /*******************************************************************
7474 ********************************************************************/
7476 BOOL
make_spoolss_q_enddocprinter(SPOOL_Q_ENDDOCPRINTER
*q_u
,
7479 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7484 /*******************************************************************
7486 ********************************************************************/
7488 BOOL
make_spoolss_q_writeprinter(SPOOL_Q_WRITEPRINTER
*q_u
,
7489 POLICY_HND
*handle
, uint32 data_size
,
7492 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7493 q_u
->buffer_size
= q_u
->buffer_size2
= data_size
;
7494 q_u
->buffer
= (unsigned char *)data
;
7498 /*******************************************************************
7500 ********************************************************************/
7502 BOOL
make_spoolss_q_deleteprinterdata(SPOOL_Q_DELETEPRINTERDATA
*q_u
,
7503 POLICY_HND
*handle
, char *valuename
)
7505 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7506 init_unistr2(&q_u
->valuename
, valuename
, UNI_STR_TERMINATE
);
7511 /*******************************************************************
7513 ********************************************************************/
7515 BOOL
make_spoolss_q_deleteprinterdataex(SPOOL_Q_DELETEPRINTERDATAEX
*q_u
,
7516 POLICY_HND
*handle
, char *key
,
7519 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7520 init_unistr2(&q_u
->valuename
, value
, UNI_STR_TERMINATE
);
7521 init_unistr2(&q_u
->keyname
, key
, UNI_STR_TERMINATE
);
7526 /*******************************************************************
7528 ********************************************************************/
7530 BOOL
make_spoolss_q_rffpcnex(SPOOL_Q_RFFPCNEX
*q_u
, POLICY_HND
*handle
,
7531 uint32 flags
, uint32 options
, const char *localmachine
,
7532 uint32 printerlocal
, SPOOL_NOTIFY_OPTION
*option
)
7534 memcpy(&q_u
->handle
, handle
, sizeof(POLICY_HND
));
7537 q_u
->options
= options
;
7539 q_u
->localmachine_ptr
= 1;
7541 init_unistr2(&q_u
->localmachine
, localmachine
, UNI_STR_TERMINATE
);
7543 q_u
->printerlocal
= printerlocal
;
7546 q_u
->option_ptr
= 1;
7548 q_u
->option
= option
;
7554 /*******************************************************************
7555 ********************************************************************/
7557 BOOL
spoolss_io_q_xcvdataport(const char *desc
, SPOOL_Q_XCVDATAPORT
*q_u
, prs_struct
*ps
, int depth
)
7559 prs_debug(ps
, depth
, desc
, "spoolss_io_q_xcvdataport");
7565 if(!smb_io_pol_hnd("printer handle", &q_u
->handle
, ps
, depth
))
7568 if(!smb_io_unistr2("", &q_u
->dataname
, True
, ps
, depth
))
7574 if(!prs_rpcbuffer("", ps
, depth
, &q_u
->indata
))
7580 if (!prs_uint32("indata_len", ps
, depth
, &q_u
->indata_len
))
7582 if (!prs_uint32("offered", ps
, depth
, &q_u
->offered
))
7584 if (!prs_uint32("unknown", ps
, depth
, &q_u
->unknown
))
7590 /*******************************************************************
7591 ********************************************************************/
7593 BOOL
spoolss_io_r_xcvdataport(const char *desc
, SPOOL_R_XCVDATAPORT
*r_u
, prs_struct
*ps
, int depth
)
7595 prs_debug(ps
, depth
, desc
, "spoolss_io_r_xcvdataport");
7600 if(!prs_rpcbuffer("", ps
, depth
, &r_u
->outdata
))
7606 if (!prs_uint32("needed", ps
, depth
, &r_u
->needed
))
7608 if (!prs_uint32("unknown", ps
, depth
, &r_u
->unknown
))
7611 if(!prs_werror("status", ps
, depth
, &r_u
->status
))
7617 /*******************************************************************
7618 ********************************************************************/
7620 BOOL
make_monitorui_buf( RPC_BUFFER
*buf
, const char *dllname
)
7627 init_unistr( &string
, dllname
);
7629 if ( !prs_unistr( "ui_dll", &buf
->prs
, 0, &string
) )
7635 /*******************************************************************
7636 ********************************************************************/
7638 #define PORT_DATA_1_PAD 540
7640 static BOOL
smb_io_port_data_1( const char *desc
, RPC_BUFFER
*buf
, int depth
, SPOOL_PORT_DATA_1
*p1
)
7642 prs_struct
*ps
= &buf
->prs
;
7643 uint8 padding
[PORT_DATA_1_PAD
];
7645 prs_debug(ps
, depth
, desc
, "smb_io_port_data_1");
7651 if( !prs_uint16s(True
, "portname", ps
, depth
, p1
->portname
, MAX_PORTNAME
))
7654 if (!prs_uint32("version", ps
, depth
, &p1
->version
))
7656 if (!prs_uint32("protocol", ps
, depth
, &p1
->protocol
))
7658 if (!prs_uint32("size", ps
, depth
, &p1
->size
))
7660 if (!prs_uint32("reserved", ps
, depth
, &p1
->reserved
))
7663 if( !prs_uint16s(True
, "hostaddress", ps
, depth
, p1
->hostaddress
, MAX_NETWORK_NAME
))
7665 if( !prs_uint16s(True
, "snmpcommunity", ps
, depth
, p1
->snmpcommunity
, MAX_SNMP_COMM_NAME
))
7668 if (!prs_uint32("dblspool", ps
, depth
, &p1
->dblspool
))
7671 if( !prs_uint16s(True
, "queue", ps
, depth
, p1
->queue
, MAX_QUEUE_NAME
))
7673 if( !prs_uint16s(True
, "ipaddress", ps
, depth
, p1
->ipaddress
, MAX_IPADDR_STRING
))
7676 if( !prs_uint8s(False
, "", ps
, depth
, padding
, PORT_DATA_1_PAD
))
7679 if (!prs_uint32("port", ps
, depth
, &p1
->port
))
7681 if (!prs_uint32("snmpenabled", ps
, depth
, &p1
->snmpenabled
))
7683 if (!prs_uint32("snmpdevindex", ps
, depth
, &p1
->snmpdevindex
))
7689 /*******************************************************************
7690 ********************************************************************/
7692 BOOL
convert_port_data_1( NT_PORT_DATA_1
*port1
, RPC_BUFFER
*buf
)
7694 SPOOL_PORT_DATA_1 spdata_1
;
7696 ZERO_STRUCT( spdata_1
);
7698 if ( !smb_io_port_data_1( "port_data_1", buf
, 0, &spdata_1
) )
7701 rpcstr_pull(port1
->name
, spdata_1
.portname
, sizeof(port1
->name
), -1, 0);
7702 rpcstr_pull(port1
->queue
, spdata_1
.queue
, sizeof(port1
->queue
), -1, 0);
7703 rpcstr_pull(port1
->hostaddr
, spdata_1
.hostaddress
, sizeof(port1
->hostaddr
), -1, 0);
7705 port1
->port
= spdata_1
.port
;
7707 switch ( spdata_1
.protocol
) {
7709 port1
->protocol
= PORT_PROTOCOL_DIRECT
;
7712 port1
->protocol
= PORT_PROTOCOL_LPR
;
7715 DEBUG(3,("convert_port_data_1: unknown protocol [%d]!\n",
7716 spdata_1
.protocol
));