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 2 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, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 #define DBGC_CLASS DBGC_RPC_PARSE
31 /*******************************************************************
32 This should be moved in a more generic lib.
33 ********************************************************************/
35 BOOL spoolss_io_system_time(const char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
37 if(!prs_uint16("year", ps, depth, &systime->year))
39 if(!prs_uint16("month", ps, depth, &systime->month))
41 if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
43 if(!prs_uint16("day", ps, depth, &systime->day))
45 if(!prs_uint16("hour", ps, depth, &systime->hour))
47 if(!prs_uint16("minute", ps, depth, &systime->minute))
49 if(!prs_uint16("second", ps, depth, &systime->second))
51 if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
57 /*******************************************************************
58 ********************************************************************/
60 BOOL make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
62 systime->year=unixtime->tm_year+1900;
63 systime->month=unixtime->tm_mon+1;
64 systime->dayofweek=unixtime->tm_wday;
65 systime->day=unixtime->tm_mday;
66 systime->hour=unixtime->tm_hour;
67 systime->minute=unixtime->tm_min;
68 systime->second=unixtime->tm_sec;
69 systime->milliseconds=0;
74 /*******************************************************************
75 reads or writes an DOC_INFO structure.
76 ********************************************************************/
78 static BOOL smb_io_doc_info_1(const char *desc, DOC_INFO_1 *info_1, prs_struct *ps, int depth)
80 if (info_1 == NULL) return False;
82 prs_debug(ps, depth, desc, "smb_io_doc_info_1");
88 if(!prs_uint32("p_docname", ps, depth, &info_1->p_docname))
90 if(!prs_uint32("p_outputfile", ps, depth, &info_1->p_outputfile))
92 if(!prs_uint32("p_datatype", ps, depth, &info_1->p_datatype))
95 if(!smb_io_unistr2("", &info_1->docname, info_1->p_docname, ps, depth))
97 if(!smb_io_unistr2("", &info_1->outputfile, info_1->p_outputfile, ps, depth))
99 if(!smb_io_unistr2("", &info_1->datatype, info_1->p_datatype, ps, depth))
105 /*******************************************************************
106 reads or writes an DOC_INFO structure.
107 ********************************************************************/
109 static BOOL smb_io_doc_info(const char *desc, DOC_INFO *info, prs_struct *ps, int depth)
111 uint32 useless_ptr=0;
113 if (info == NULL) return False;
115 prs_debug(ps, depth, desc, "smb_io_doc_info");
121 if(!prs_uint32("switch_value", ps, depth, &info->switch_value))
124 if(!prs_uint32("doc_info_X ptr", ps, depth, &useless_ptr))
127 switch (info->switch_value)
130 if(!smb_io_doc_info_1("",&info->doc_info_1, ps, depth))
135 this is just a placeholder
137 MSDN July 1998 says doc_info_2 is only on
138 Windows 95, and as Win95 doesn't do RPC to print
139 this case is nearly impossible
141 Maybe one day with Windows for dishwasher 2037 ...
144 /* smb_io_doc_info_2("",&info->doc_info_2, ps, depth); */
147 DEBUG(0,("Something is obviously wrong somewhere !\n"));
154 /*******************************************************************
155 reads or writes an DOC_INFO_CONTAINER structure.
156 ********************************************************************/
158 static BOOL smb_io_doc_info_container(const char *desc, DOC_INFO_CONTAINER *cont, prs_struct *ps, int depth)
160 if (cont == NULL) return False;
162 prs_debug(ps, depth, desc, "smb_io_doc_info_container");
168 if(!prs_uint32("level", ps, depth, &cont->level))
171 if(!smb_io_doc_info("",&cont->docinfo, ps, depth))
177 /*******************************************************************
178 reads or writes an NOTIFY OPTION TYPE structure.
179 ********************************************************************/
181 /* NOTIFY_OPTION_TYPE and NOTIFY_OPTION_TYPE_DATA are really one
182 structure. The _TYPE structure is really the deferred referrants (i.e
183 the notify fields array) of the _TYPE structure. -tpot */
185 static BOOL smb_io_notify_option_type(const char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
187 prs_debug(ps, depth, desc, "smb_io_notify_option_type");
193 if(!prs_uint16("type", ps, depth, &type->type))
195 if(!prs_uint16("reserved0", ps, depth, &type->reserved0))
197 if(!prs_uint32("reserved1", ps, depth, &type->reserved1))
199 if(!prs_uint32("reserved2", ps, depth, &type->reserved2))
201 if(!prs_uint32("count", ps, depth, &type->count))
203 if(!prs_uint32("fields_ptr", ps, depth, &type->fields_ptr))
209 /*******************************************************************
210 reads or writes an NOTIFY OPTION TYPE DATA.
211 ********************************************************************/
213 static BOOL smb_io_notify_option_type_data(const char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
217 prs_debug(ps, depth, desc, "smb_io_notify_option_type_data");
220 /* if there are no fields just return */
221 if (type->fields_ptr==0)
227 if(!prs_uint32("count2", ps, depth, &type->count2))
230 if (type->count2 != type->count)
231 DEBUG(4,("What a mess, count was %x now is %x !\n", type->count, type->count2));
233 /* parse the option type data */
234 for(i=0;i<type->count2;i++)
235 if(!prs_uint16("fields",ps,depth,&type->fields[i]))
240 /*******************************************************************
241 reads or writes an NOTIFY OPTION structure.
242 ********************************************************************/
244 static BOOL smb_io_notify_option_type_ctr(const char *desc, SPOOL_NOTIFY_OPTION_TYPE_CTR *ctr , prs_struct *ps, int depth)
248 prs_debug(ps, depth, desc, "smb_io_notify_option_type_ctr");
251 if(!prs_uint32("count", ps, depth, &ctr->count))
255 if (UNMARSHALLING(ps))
256 if((ctr->type=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION_TYPE,ctr->count)) == NULL)
259 /* the option type struct */
260 for(i=0;i<ctr->count;i++)
261 if(!smb_io_notify_option_type("", &ctr->type[i] , ps, depth))
264 /* the type associated with the option type struct */
265 for(i=0;i<ctr->count;i++)
266 if(!smb_io_notify_option_type_data("", &ctr->type[i] , ps, depth))
272 /*******************************************************************
273 reads or writes an NOTIFY OPTION structure.
274 ********************************************************************/
276 static BOOL smb_io_notify_option(const char *desc, SPOOL_NOTIFY_OPTION *option, prs_struct *ps, int depth)
278 prs_debug(ps, depth, desc, "smb_io_notify_option");
281 if(!prs_uint32("version", ps, depth, &option->version))
283 if(!prs_uint32("flags", ps, depth, &option->flags))
285 if(!prs_uint32("count", ps, depth, &option->count))
287 if(!prs_uint32("option_type_ptr", ps, depth, &option->option_type_ptr))
290 /* marshalling or unmarshalling, that would work */
291 if (option->option_type_ptr!=0) {
292 if(!smb_io_notify_option_type_ctr("", &option->ctr ,ps, depth))
296 option->ctr.type=NULL;
303 /*******************************************************************
304 reads or writes an NOTIFY INFO DATA structure.
305 ********************************************************************/
307 static BOOL smb_io_notify_info_data(const char *desc,SPOOL_NOTIFY_INFO_DATA *data, prs_struct *ps, int depth)
309 uint32 useless_ptr=0x0FF0ADDE;
311 prs_debug(ps, depth, desc, "smb_io_notify_info_data");
316 if(!prs_uint16("type", ps, depth, &data->type))
318 if(!prs_uint16("field", ps, depth, &data->field))
321 if(!prs_uint32("how many words", ps, depth, &data->size))
323 if(!prs_uint32("id", ps, depth, &data->id))
325 if(!prs_uint32("how many words", ps, depth, &data->size))
328 switch (data->enc_type) {
330 /* One and two value data has two uint32 values */
332 case NOTIFY_ONE_VALUE:
333 case NOTIFY_TWO_VALUE:
335 if(!prs_uint32("value[0]", ps, depth, &data->notify_data.value[0]))
337 if(!prs_uint32("value[1]", ps, depth, &data->notify_data.value[1]))
341 /* Pointers and strings have a string length and a
342 pointer. For a string the length is expressed as
343 the number of uint16 characters plus a trailing
348 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length ))
350 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
357 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
360 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
366 if( !prs_uint32( "sd size", ps, depth, &data->notify_data.sd.size ) )
368 if( !prs_uint32( "pointer", ps, depth, &useless_ptr ) )
374 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data\n",
382 /*******************************************************************
383 reads or writes an NOTIFY INFO DATA structure.
384 ********************************************************************/
386 BOOL smb_io_notify_info_data_strings(const char *desc,SPOOL_NOTIFY_INFO_DATA *data,
387 prs_struct *ps, int depth)
389 prs_debug(ps, depth, desc, "smb_io_notify_info_data_strings");
395 switch(data->enc_type) {
397 /* No data for values */
399 case NOTIFY_ONE_VALUE:
400 case NOTIFY_TWO_VALUE:
404 /* Strings start with a length in uint16s */
409 data->notify_data.data.length /= 2;
411 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
414 if (UNMARSHALLING(ps)) {
415 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16,
416 data->notify_data.data.length);
418 if (!data->notify_data.data.string)
422 if (!prs_uint16uni(True, "string", ps, depth, data->notify_data.data.string,
423 data->notify_data.data.length))
427 data->notify_data.data.length *= 2;
433 if (UNMARSHALLING(ps)) {
434 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16,
435 data->notify_data.data.length);
437 if (!data->notify_data.data.string)
441 if(!prs_uint8s(True,"buffer",ps,depth,(uint8*)data->notify_data.data.string,data->notify_data.data.length))
447 if( !prs_uint32("secdesc size ", ps, depth, &data->notify_data.sd.size ) )
449 if ( !sec_io_desc( "sec_desc", &data->notify_data.sd.desc, ps, depth ) )
454 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data_strings\n",
460 if (isvalue==False) {
462 /* length of string in unicode include \0 */
463 x=data->notify_data.data.length+1;
465 if (data->field != 16)
466 if(!prs_uint32("string length", ps, depth, &x ))
469 if (MARSHALLING(ps)) {
470 /* These are already in little endian format. Don't byte swap. */
473 /* No memory allocated for this string
474 therefore following the data.string
475 pointer is a bad idea. Use a pointer to
476 the uint32 length union member to
477 provide a source for a unicode NULL */
479 if(!prs_uint8s(True,"string",ps,depth, (uint8 *)&data->notify_data.data.length,x*2))
483 if (data->field == 16)
486 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
491 /* Tallocate memory for string */
493 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16, x * 2);
494 if (!data->notify_data.data.string)
497 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
505 /* Win2k does not seem to put this parse align here */
513 /*******************************************************************
514 reads or writes an NOTIFY INFO structure.
515 ********************************************************************/
517 static BOOL smb_io_notify_info(const char *desc, SPOOL_NOTIFY_INFO *info, prs_struct *ps, int depth)
521 prs_debug(ps, depth, desc, "smb_io_notify_info");
527 if(!prs_uint32("count", ps, depth, &info->count))
529 if(!prs_uint32("version", ps, depth, &info->version))
531 if(!prs_uint32("flags", ps, depth, &info->flags))
533 if(!prs_uint32("count", ps, depth, &info->count))
536 for (i=0;i<info->count;i++) {
537 if(!smb_io_notify_info_data(desc, &info->data[i], ps, depth))
541 /* now do the strings at the end of the stream */
542 for (i=0;i<info->count;i++) {
543 if(!smb_io_notify_info_data_strings(desc, &info->data[i], ps, depth))
550 /*******************************************************************
551 ********************************************************************/
553 BOOL spool_io_user_level_1( const char *desc, prs_struct *ps, int depth, SPOOL_USER_1 *q_u )
555 prs_debug(ps, depth, desc, "");
561 if (!prs_uint32("size", ps, depth, &q_u->size))
564 if (!prs_io_unistr2_p("", ps, depth, &q_u->client_name))
566 if (!prs_io_unistr2_p("", ps, depth, &q_u->user_name))
569 if (!prs_uint32("build", ps, depth, &q_u->build))
571 if (!prs_uint32("major", ps, depth, &q_u->major))
573 if (!prs_uint32("minor", ps, depth, &q_u->minor))
575 if (!prs_uint32("processor", ps, depth, &q_u->processor))
578 if (!prs_io_unistr2("", ps, depth, q_u->client_name))
583 if (!prs_io_unistr2("", ps, depth, q_u->user_name))
589 /*******************************************************************
590 ********************************************************************/
592 static BOOL spool_io_user_level(const char *desc, SPOOL_USER_CTR *q_u, prs_struct *ps, int depth)
597 prs_debug(ps, depth, desc, "spool_io_user_level");
603 if (!prs_uint32("level", ps, depth, &q_u->level))
606 switch ( q_u->level )
609 if ( !prs_pointer( "" , ps, depth, (void**)&q_u->user.user1,
610 sizeof(SPOOL_USER_1), (PRS_POINTER_CAST)spool_io_user_level_1 ))
622 /*******************************************************************
623 * read or write a DEVICEMODE struct.
624 * on reading allocate memory for the private member
625 ********************************************************************/
627 #define DM_NUM_OPTIONAL_FIELDS 8
629 BOOL spoolss_io_devmode(const char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
631 int available_space; /* size of the device mode left to parse */
632 /* only important on unmarshalling */
634 uint16 *unistr_buffer;
637 struct optional_fields {
640 } opt_fields[DM_NUM_OPTIONAL_FIELDS] = {
641 { "icmmethod", NULL },
642 { "icmintent", NULL },
643 { "mediatype", NULL },
644 { "dithertype", NULL },
645 { "reserved1", NULL },
646 { "reserved2", NULL },
647 { "panningwidth", NULL },
648 { "panningheight", NULL }
651 /* assign at run time to keep non-gcc compilers happy */
653 opt_fields[0].field = &devmode->icmmethod;
654 opt_fields[1].field = &devmode->icmintent;
655 opt_fields[2].field = &devmode->mediatype;
656 opt_fields[3].field = &devmode->dithertype;
657 opt_fields[4].field = &devmode->reserved1;
658 opt_fields[5].field = &devmode->reserved2;
659 opt_fields[6].field = &devmode->panningwidth;
660 opt_fields[7].field = &devmode->panningheight;
663 prs_debug(ps, depth, desc, "spoolss_io_devmode");
666 if (UNMARSHALLING(ps)) {
667 devmode->devicename.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
668 if (devmode->devicename.buffer == NULL)
670 unistr_buffer = devmode->devicename.buffer;
673 /* devicename is a static sized string but the buffer we set is not */
674 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
675 memset( unistr_buffer, 0x0, MAXDEVICENAME );
676 for ( j=0; devmode->devicename.buffer[j]; j++ )
677 unistr_buffer[j] = devmode->devicename.buffer[j];
680 if (!prs_uint16uni(True,"devicename", ps, depth, unistr_buffer, MAXDEVICENAME))
683 if (!prs_uint16("specversion", ps, depth, &devmode->specversion))
686 if (!prs_uint16("driverversion", ps, depth, &devmode->driverversion))
688 if (!prs_uint16("size", ps, depth, &devmode->size))
690 if (!prs_uint16("driverextra", ps, depth, &devmode->driverextra))
692 if (!prs_uint32("fields", ps, depth, &devmode->fields))
694 if (!prs_uint16("orientation", ps, depth, &devmode->orientation))
696 if (!prs_uint16("papersize", ps, depth, &devmode->papersize))
698 if (!prs_uint16("paperlength", ps, depth, &devmode->paperlength))
700 if (!prs_uint16("paperwidth", ps, depth, &devmode->paperwidth))
702 if (!prs_uint16("scale", ps, depth, &devmode->scale))
704 if (!prs_uint16("copies", ps, depth, &devmode->copies))
706 if (!prs_uint16("defaultsource", ps, depth, &devmode->defaultsource))
708 if (!prs_uint16("printquality", ps, depth, &devmode->printquality))
710 if (!prs_uint16("color", ps, depth, &devmode->color))
712 if (!prs_uint16("duplex", ps, depth, &devmode->duplex))
714 if (!prs_uint16("yresolution", ps, depth, &devmode->yresolution))
716 if (!prs_uint16("ttoption", ps, depth, &devmode->ttoption))
718 if (!prs_uint16("collate", ps, depth, &devmode->collate))
721 if (UNMARSHALLING(ps)) {
722 devmode->formname.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
723 if (devmode->formname.buffer == NULL)
725 unistr_buffer = devmode->formname.buffer;
728 /* devicename is a static sized string but the buffer we set is not */
729 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
730 memset( unistr_buffer, 0x0, MAXDEVICENAME );
731 for ( j=0; devmode->formname.buffer[j]; j++ )
732 unistr_buffer[j] = devmode->formname.buffer[j];
735 if (!prs_uint16uni(True, "formname", ps, depth, unistr_buffer, MAXDEVICENAME))
737 if (!prs_uint16("logpixels", ps, depth, &devmode->logpixels))
739 if (!prs_uint32("bitsperpel", ps, depth, &devmode->bitsperpel))
741 if (!prs_uint32("pelswidth", ps, depth, &devmode->pelswidth))
743 if (!prs_uint32("pelsheight", ps, depth, &devmode->pelsheight))
745 if (!prs_uint32("displayflags", ps, depth, &devmode->displayflags))
747 if (!prs_uint32("displayfrequency", ps, depth, &devmode->displayfrequency))
750 * every device mode I've ever seen on the wire at least has up
751 * to the displayfrequency field. --jerry (05-09-2002)
754 /* add uint32's + uint16's + two UNICODE strings */
756 available_space = devmode->size - (sizeof(uint32)*6 + sizeof(uint16)*18 + sizeof(uint16)*64);
758 /* Sanity check - we only have uint32's left tp parse */
760 if ( available_space && ((available_space % sizeof(uint32)) != 0) ) {
761 DEBUG(0,("spoolss_io_devmode: available_space [%d] no in multiple of 4 bytes (size = %d)!\n",
762 available_space, devmode->size));
763 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
768 * Conditional parsing. Assume that the DeviceMode has been
769 * zero'd by the caller.
772 while ((available_space > 0) && (i < DM_NUM_OPTIONAL_FIELDS))
774 DEBUG(11, ("spoolss_io_devmode: [%d] bytes left to parse in devmode\n", available_space));
775 if (!prs_uint32(opt_fields[i].name, ps, depth, opt_fields[i].field))
777 available_space -= sizeof(uint32);
781 /* Sanity Check - we should no available space at this point unless
782 MS changes the device mode structure */
784 if (available_space) {
785 DEBUG(0,("spoolss_io_devmode: I've parsed all I know and there is still stuff left|\n"));
786 DEBUG(0,("spoolss_io_devmode: available_space = [%d], devmode_size = [%d]!\n",
787 available_space, devmode->size));
788 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
793 if (devmode->driverextra!=0) {
794 if (UNMARSHALLING(ps)) {
795 devmode->dev_private=PRS_ALLOC_MEM(ps, uint8, devmode->driverextra);
796 if(devmode->dev_private == NULL)
798 DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for dev_private\n",devmode->driverextra));
801 DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of dev_private\n",devmode->driverextra));
802 if (!prs_uint8s(False, "dev_private", ps, depth,
803 devmode->dev_private, devmode->driverextra))
810 /*******************************************************************
811 Read or write a DEVICEMODE container
812 ********************************************************************/
814 static BOOL spoolss_io_devmode_cont(const char *desc, DEVMODE_CTR *dm_c, prs_struct *ps, int depth)
819 prs_debug(ps, depth, desc, "spoolss_io_devmode_cont");
825 if (!prs_uint32("size", ps, depth, &dm_c->size))
828 if (!prs_uint32("devmode_ptr", ps, depth, &dm_c->devmode_ptr))
831 if (dm_c->size==0 || dm_c->devmode_ptr==0) {
832 if (UNMARSHALLING(ps))
833 /* if while reading there is no DEVMODE ... */
838 /* so we have a DEVICEMODE to follow */
839 if (UNMARSHALLING(ps)) {
840 DEBUG(9,("Allocating memory for spoolss_io_devmode\n"));
841 dm_c->devmode=PRS_ALLOC_MEM(ps,DEVICEMODE,1);
842 if(dm_c->devmode == NULL)
846 /* this is bad code, shouldn't be there */
847 if (!prs_uint32("size", ps, depth, &dm_c->size))
850 if (!spoolss_io_devmode(desc, ps, depth, dm_c->devmode))
856 /*******************************************************************
857 ********************************************************************/
859 static BOOL spoolss_io_printer_default(const char *desc, PRINTER_DEFAULT *pd, prs_struct *ps, int depth)
864 prs_debug(ps, depth, desc, "spoolss_io_printer_default");
867 if (!prs_uint32("datatype_ptr", ps, depth, &pd->datatype_ptr))
870 if (!smb_io_unistr2("datatype", &pd->datatype, pd->datatype_ptr, ps,depth))
876 if (!spoolss_io_devmode_cont("", &pd->devmode_cont, ps, depth))
882 if (!prs_uint32("access_required", ps, depth, &pd->access_required))
888 /*******************************************************************
890 ********************************************************************/
892 BOOL make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX *q_u,
893 const fstring printername,
894 const fstring datatype,
895 uint32 access_required,
896 const fstring clientname,
897 const fstring user_name)
899 DEBUG(5,("make_spoolss_q_open_printer_ex\n"));
901 q_u->printername = TALLOC_P( get_talloc_ctx(), UNISTR2 );
902 if (!q_u->printername) {
905 init_unistr2(q_u->printername, printername, UNI_STR_TERMINATE);
907 q_u->printer_default.datatype_ptr = 0;
909 q_u->printer_default.devmode_cont.size=0;
910 q_u->printer_default.devmode_cont.devmode_ptr=0;
911 q_u->printer_default.devmode_cont.devmode=NULL;
912 q_u->printer_default.access_required=access_required;
914 q_u->user_switch = 1;
916 q_u->user_ctr.level = 1;
917 q_u->user_ctr.user.user1 = TALLOC_P( get_talloc_ctx(), SPOOL_USER_1 );
918 if (!q_u->user_ctr.user.user1) {
921 q_u->user_ctr.user.user1->size = strlen(clientname) + strlen(user_name) + 10;
922 q_u->user_ctr.user.user1->build = 1381;
923 q_u->user_ctr.user.user1->major = 2;
924 q_u->user_ctr.user.user1->minor = 0;
925 q_u->user_ctr.user.user1->processor = 0;
927 q_u->user_ctr.user.user1->client_name = TALLOC_P( get_talloc_ctx(), UNISTR2 );
928 if (!q_u->user_ctr.user.user1->client_name) {
931 q_u->user_ctr.user.user1->user_name = TALLOC_P( get_talloc_ctx(), UNISTR2 );
932 if (!q_u->user_ctr.user.user1->user_name) {
936 init_unistr2(q_u->user_ctr.user.user1->client_name, clientname, UNI_STR_TERMINATE);
937 init_unistr2(q_u->user_ctr.user.user1->user_name, user_name, UNI_STR_TERMINATE);
942 /*******************************************************************
944 ********************************************************************/
946 BOOL make_spoolss_q_addprinterex( TALLOC_CTX *mem_ctx, SPOOL_Q_ADDPRINTEREX *q_u,
947 const char *srv_name, const char* clientname, const char* user_name,
948 uint32 level, PRINTER_INFO_CTR *ctr)
950 DEBUG(5,("make_spoolss_q_addprinterex\n"));
952 if (!ctr || !ctr->printers_2)
957 q_u->server_name = TALLOC_P( mem_ctx, UNISTR2 );
958 if (!q_u->server_name) {
961 init_unistr2(q_u->server_name, srv_name, UNI_FLAGS_NONE);
965 q_u->info.level = level;
966 q_u->info.info_ptr = (ctr->printers_2!=NULL)?1:0;
969 /* init q_u->info.info2 from *info */
970 if (!make_spoolss_printer_info_2(mem_ctx, &q_u->info.info_2, ctr->printers_2)) {
971 DEBUG(0,("make_spoolss_q_addprinterex: Unable to fill SPOOL_Q_ADDPRINTEREX struct!\n"));
981 q_u->user_ctr.level = 1;
982 q_u->user_ctr.user.user1 = TALLOC_P( get_talloc_ctx(), SPOOL_USER_1 );
983 if (!q_u->user_ctr.user.user1) {
986 q_u->user_ctr.user.user1->build = 1381;
987 q_u->user_ctr.user.user1->major = 2;
988 q_u->user_ctr.user.user1->minor = 0;
989 q_u->user_ctr.user.user1->processor = 0;
991 q_u->user_ctr.user.user1->client_name = TALLOC_P( mem_ctx, UNISTR2 );
992 if (!q_u->user_ctr.user.user1->client_name) {
995 q_u->user_ctr.user.user1->user_name = TALLOC_P( mem_ctx, UNISTR2 );
996 if (!q_u->user_ctr.user.user1->user_name) {
999 init_unistr2(q_u->user_ctr.user.user1->client_name, clientname, UNI_STR_TERMINATE);
1000 init_unistr2(q_u->user_ctr.user.user1->user_name, user_name, UNI_STR_TERMINATE);
1002 q_u->user_ctr.user.user1->size = q_u->user_ctr.user.user1->user_name->uni_str_len +
1003 q_u->user_ctr.user.user1->client_name->uni_str_len + 2;
1008 /*******************************************************************
1009 create a SPOOL_PRINTER_INFO_2 stuct from a PRINTER_INFO_2 struct
1010 *******************************************************************/
1012 BOOL make_spoolss_printer_info_2(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_2 **spool_info2,
1013 PRINTER_INFO_2 *info)
1016 SPOOL_PRINTER_INFO_LEVEL_2 *inf;
1018 /* allocate the necessary memory */
1019 if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_2))) {
1020 DEBUG(0,("make_spoolss_printer_info_2: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_2 sruct!\n"));
1024 inf->servername_ptr = (info->servername.buffer!=NULL)?1:0;
1025 inf->printername_ptr = (info->printername.buffer!=NULL)?1:0;
1026 inf->sharename_ptr = (info->sharename.buffer!=NULL)?1:0;
1027 inf->portname_ptr = (info->portname.buffer!=NULL)?1:0;
1028 inf->drivername_ptr = (info->drivername.buffer!=NULL)?1:0;
1029 inf->comment_ptr = (info->comment.buffer!=NULL)?1:0;
1030 inf->location_ptr = (info->location.buffer!=NULL)?1:0;
1031 inf->devmode_ptr = (info->devmode!=NULL)?1:0;
1032 inf->sepfile_ptr = (info->sepfile.buffer!=NULL)?1:0;
1033 inf->printprocessor_ptr = (info->printprocessor.buffer!=NULL)?1:0;
1034 inf->datatype_ptr = (info->datatype.buffer!=NULL)?1:0;
1035 inf->parameters_ptr = (info->parameters.buffer!=NULL)?1:0;
1036 inf->secdesc_ptr = (info->secdesc!=NULL)?1:0;
1037 inf->attributes = info->attributes;
1038 inf->priority = info->priority;
1039 inf->default_priority = info->defaultpriority;
1040 inf->starttime = info->starttime;
1041 inf->untiltime = info->untiltime;
1042 inf->cjobs = info->cjobs;
1043 inf->averageppm = info->averageppm;
1044 init_unistr2_from_unistr(&inf->servername, &info->servername);
1045 init_unistr2_from_unistr(&inf->printername, &info->printername);
1046 init_unistr2_from_unistr(&inf->sharename, &info->sharename);
1047 init_unistr2_from_unistr(&inf->portname, &info->portname);
1048 init_unistr2_from_unistr(&inf->drivername, &info->drivername);
1049 init_unistr2_from_unistr(&inf->comment, &info->comment);
1050 init_unistr2_from_unistr(&inf->location, &info->location);
1051 init_unistr2_from_unistr(&inf->sepfile, &info->sepfile);
1052 init_unistr2_from_unistr(&inf->printprocessor, &info->printprocessor);
1053 init_unistr2_from_unistr(&inf->datatype, &info->datatype);
1054 init_unistr2_from_unistr(&inf->parameters, &info->parameters);
1055 init_unistr2_from_unistr(&inf->datatype, &info->datatype);
1062 /*******************************************************************
1063 create a SPOOL_PRINTER_INFO_3 struct from a PRINTER_INFO_3 struct
1064 *******************************************************************/
1066 BOOL make_spoolss_printer_info_3(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_3 **spool_info3,
1067 PRINTER_INFO_3 *info)
1070 SPOOL_PRINTER_INFO_LEVEL_3 *inf;
1072 /* allocate the necessary memory */
1073 if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_3))) {
1074 DEBUG(0,("make_spoolss_printer_info_3: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_3 sruct!\n"));
1078 inf->secdesc_ptr = (info->secdesc!=NULL)?1:0;
1085 /*******************************************************************
1086 create a SPOOL_PRINTER_INFO_7 struct from a PRINTER_INFO_7 struct
1087 *******************************************************************/
1089 BOOL make_spoolss_printer_info_7(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_7 **spool_info7,
1090 PRINTER_INFO_7 *info)
1093 SPOOL_PRINTER_INFO_LEVEL_7 *inf;
1095 /* allocate the necessary memory */
1096 if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_7))) {
1097 DEBUG(0,("make_spoolss_printer_info_7: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_7 struct!\n"));
1101 inf->guid_ptr = (info->guid.buffer!=NULL)?1:0;
1102 inf->action = info->action;
1103 init_unistr2_from_unistr(&inf->guid, &info->guid);
1111 /*******************************************************************
1113 * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1114 ********************************************************************/
1116 BOOL spoolss_io_q_open_printer(const char *desc, SPOOL_Q_OPEN_PRINTER *q_u, prs_struct *ps, int depth)
1121 prs_debug(ps, depth, desc, "spoolss_io_q_open_printer");
1127 if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->printername))
1129 if (!prs_io_unistr2("printername", ps, depth, q_u->printername))
1135 if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth))
1141 /*******************************************************************
1142 * write a structure.
1143 * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1144 * called from spoolss_open_printer_ex (cli_spoolss.c)
1145 ********************************************************************/
1147 BOOL spoolss_io_r_open_printer(const char *desc, SPOOL_R_OPEN_PRINTER *r_u, prs_struct *ps, int depth)
1149 if (r_u == NULL) return False;
1151 prs_debug(ps, depth, desc, "spoolss_io_r_open_printer");
1157 if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
1160 if (!prs_werror("status code", ps, depth, &(r_u->status)))
1167 /*******************************************************************
1169 * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1170 ********************************************************************/
1172 BOOL spoolss_io_q_open_printer_ex(const char *desc, SPOOL_Q_OPEN_PRINTER_EX *q_u, prs_struct *ps, int depth)
1177 prs_debug(ps, depth, desc, "spoolss_io_q_open_printer_ex");
1183 if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->printername))
1185 if (!prs_io_unistr2("printername", ps, depth, q_u->printername))
1191 if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth))
1194 if (!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
1196 if (!spool_io_user_level("", &q_u->user_ctr, ps, depth))
1202 /*******************************************************************
1203 * write a structure.
1204 * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1205 * called from spoolss_open_printer_ex (cli_spoolss.c)
1206 ********************************************************************/
1208 BOOL spoolss_io_r_open_printer_ex(const char *desc, SPOOL_R_OPEN_PRINTER_EX *r_u, prs_struct *ps, int depth)
1210 if (r_u == NULL) return False;
1212 prs_debug(ps, depth, desc, "spoolss_io_r_open_printer_ex");
1218 if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
1221 if (!prs_werror("status code", ps, depth, &(r_u->status)))
1227 /*******************************************************************
1229 ********************************************************************/
1230 BOOL make_spoolss_q_deleteprinterdriverex( TALLOC_CTX *mem_ctx,
1231 SPOOL_Q_DELETEPRINTERDRIVEREX *q_u,
1237 DEBUG(5,("make_spoolss_q_deleteprinterdriverex\n"));
1239 q_u->server_ptr = (server!=NULL)?1:0;
1240 q_u->delete_flags = DPD_DELETE_UNUSED_FILES;
1242 /* these must be NULL terminated or else NT4 will
1243 complain about invalid parameters --jerry */
1244 init_unistr2(&q_u->server, server, UNI_STR_TERMINATE);
1245 init_unistr2(&q_u->arch, arch, UNI_STR_TERMINATE);
1246 init_unistr2(&q_u->driver, driver, UNI_STR_TERMINATE);
1249 q_u->delete_flags |= DPD_DELETE_SPECIFIC_VERSION;
1250 q_u->version = version;
1257 /*******************************************************************
1259 ********************************************************************/
1260 BOOL make_spoolss_q_deleteprinterdriver(
1261 TALLOC_CTX *mem_ctx,
1262 SPOOL_Q_DELETEPRINTERDRIVER *q_u,
1268 DEBUG(5,("make_spoolss_q_deleteprinterdriver\n"));
1270 q_u->server_ptr = (server!=NULL)?1:0;
1272 /* these must be NULL terminated or else NT4 will
1273 complain about invalid parameters --jerry */
1274 init_unistr2(&q_u->server, server, UNI_STR_TERMINATE);
1275 init_unistr2(&q_u->arch, arch, UNI_STR_TERMINATE);
1276 init_unistr2(&q_u->driver, driver, UNI_STR_TERMINATE);
1281 /*******************************************************************
1283 ********************************************************************/
1285 BOOL make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u,
1286 const POLICY_HND *handle,
1287 const char *valuename, uint32 size)
1289 if (q_u == NULL) return False;
1291 DEBUG(5,("make_spoolss_q_getprinterdata\n"));
1293 q_u->handle = *handle;
1294 init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
1300 /*******************************************************************
1302 ********************************************************************/
1304 BOOL make_spoolss_q_getprinterdataex(SPOOL_Q_GETPRINTERDATAEX *q_u,
1305 const POLICY_HND *handle,
1306 const char *keyname,
1307 const char *valuename, uint32 size)
1309 if (q_u == NULL) return False;
1311 DEBUG(5,("make_spoolss_q_getprinterdataex\n"));
1313 q_u->handle = *handle;
1314 init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
1315 init_unistr2(&q_u->keyname, keyname, UNI_STR_TERMINATE);
1321 /*******************************************************************
1323 * called from spoolss_q_getprinterdata (srv_spoolss.c)
1324 ********************************************************************/
1326 BOOL spoolss_io_q_getprinterdata(const char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_struct *ps, int depth)
1331 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdata");
1336 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1340 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1344 if (!prs_uint32("size", ps, depth, &q_u->size))
1350 /*******************************************************************
1352 * called from spoolss_q_deleteprinterdata (srv_spoolss.c)
1353 ********************************************************************/
1355 BOOL spoolss_io_q_deleteprinterdata(const char *desc, SPOOL_Q_DELETEPRINTERDATA *q_u, prs_struct *ps, int depth)
1360 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdata");
1365 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1369 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1375 /*******************************************************************
1376 * write a structure.
1377 * called from spoolss_r_deleteprinterdata (srv_spoolss.c)
1378 ********************************************************************/
1380 BOOL spoolss_io_r_deleteprinterdata(const char *desc, SPOOL_R_DELETEPRINTERDATA *r_u, prs_struct *ps, int depth)
1382 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdata");
1384 if(!prs_werror("status", ps, depth, &r_u->status))
1390 /*******************************************************************
1392 * called from spoolss_q_deleteprinterdataex (srv_spoolss.c)
1393 ********************************************************************/
1395 BOOL spoolss_io_q_deleteprinterdataex(const char *desc, SPOOL_Q_DELETEPRINTERDATAEX *q_u, prs_struct *ps, int depth)
1400 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdataex");
1405 if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1408 if (!smb_io_unistr2("keyname ", &q_u->keyname, True, ps, depth))
1410 if (!smb_io_unistr2("valuename", &q_u->valuename, True, ps, depth))
1416 /*******************************************************************
1417 * write a structure.
1418 * called from spoolss_r_deleteprinterdataex (srv_spoolss.c)
1419 ********************************************************************/
1421 BOOL spoolss_io_r_deleteprinterdataex(const char *desc, SPOOL_R_DELETEPRINTERDATAEX *r_u, prs_struct *ps, int depth)
1423 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdataex");
1426 if(!prs_werror("status", ps, depth, &r_u->status))
1432 /*******************************************************************
1433 * write a structure.
1434 * called from spoolss_r_getprinterdata (srv_spoolss.c)
1435 ********************************************************************/
1437 BOOL spoolss_io_r_getprinterdata(const char *desc, SPOOL_R_GETPRINTERDATA *r_u, prs_struct *ps, int depth)
1442 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdata");
1447 if (!prs_uint32("type", ps, depth, &r_u->type))
1449 if (!prs_uint32("size", ps, depth, &r_u->size))
1452 if (UNMARSHALLING(ps) && r_u->size) {
1453 r_u->data = PRS_ALLOC_MEM(ps, unsigned char, r_u->size);
1458 if (!prs_uint8s( False, "data", ps, depth, r_u->data, r_u->size ))
1464 if (!prs_uint32("needed", ps, depth, &r_u->needed))
1466 if (!prs_werror("status", ps, depth, &r_u->status))
1472 /*******************************************************************
1474 ********************************************************************/
1476 BOOL make_spoolss_q_closeprinter(SPOOL_Q_CLOSEPRINTER *q_u, POLICY_HND *hnd)
1478 if (q_u == NULL) return False;
1480 DEBUG(5,("make_spoolss_q_closeprinter\n"));
1482 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
1487 /*******************************************************************
1489 * called from static spoolss_q_abortprinter (srv_spoolss.c)
1490 * called from spoolss_abortprinter (cli_spoolss.c)
1491 ********************************************************************/
1493 BOOL spoolss_io_q_abortprinter(const char *desc, SPOOL_Q_ABORTPRINTER *q_u, prs_struct *ps, int depth)
1495 if (q_u == NULL) return False;
1497 prs_debug(ps, depth, desc, "spoolss_io_q_abortprinter");
1503 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1509 /*******************************************************************
1510 * write a structure.
1511 * called from spoolss_r_abortprinter (srv_spoolss.c)
1512 ********************************************************************/
1514 BOOL spoolss_io_r_abortprinter(const char *desc, SPOOL_R_ABORTPRINTER *r_u, prs_struct *ps, int depth)
1516 prs_debug(ps, depth, desc, "spoolss_io_r_abortprinter");
1518 if(!prs_werror("status", ps, depth, &r_u->status))
1524 /*******************************************************************
1526 * called from static spoolss_q_deleteprinter (srv_spoolss.c)
1527 * called from spoolss_deleteprinter (cli_spoolss.c)
1528 ********************************************************************/
1530 BOOL spoolss_io_q_deleteprinter(const char *desc, SPOOL_Q_DELETEPRINTER *q_u, prs_struct *ps, int depth)
1532 if (q_u == NULL) return False;
1534 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinter");
1540 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1546 /*******************************************************************
1547 * write a structure.
1548 * called from static spoolss_r_deleteprinter (srv_spoolss.c)
1549 * called from spoolss_deleteprinter (cli_spoolss.c)
1550 ********************************************************************/
1552 BOOL spoolss_io_r_deleteprinter(const char *desc, SPOOL_R_DELETEPRINTER *r_u, prs_struct *ps, int depth)
1554 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinter");
1560 if (!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
1562 if (!prs_werror("status", ps, depth, &r_u->status))
1569 /*******************************************************************
1571 * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1572 * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1573 ********************************************************************/
1575 BOOL spoolss_io_q_deleteprinterdriver(const char *desc, SPOOL_Q_DELETEPRINTERDRIVER *q_u, prs_struct *ps, int depth)
1577 if (q_u == NULL) return False;
1579 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriver");
1585 if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
1587 if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
1589 if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
1591 if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
1599 /*******************************************************************
1600 * write a structure.
1601 ********************************************************************/
1602 BOOL spoolss_io_r_deleteprinterdriver(const char *desc, SPOOL_R_DELETEPRINTERDRIVER *r_u, prs_struct *ps, int depth)
1604 if (r_u == NULL) return False;
1606 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriver");
1612 if (!prs_werror("status", ps, depth, &r_u->status))
1619 /*******************************************************************
1621 * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1622 * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1623 ********************************************************************/
1625 BOOL spoolss_io_q_deleteprinterdriverex(const char *desc, SPOOL_Q_DELETEPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
1627 if (q_u == NULL) return False;
1629 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriverex");
1635 if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
1637 if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
1639 if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
1641 if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
1647 if(!prs_uint32("delete_flags ", ps, depth, &q_u->delete_flags))
1649 if(!prs_uint32("version ", ps, depth, &q_u->version))
1657 /*******************************************************************
1658 * write a structure.
1659 ********************************************************************/
1660 BOOL spoolss_io_r_deleteprinterdriverex(const char *desc, SPOOL_R_DELETEPRINTERDRIVEREX *r_u, prs_struct *ps, int depth)
1662 if (r_u == NULL) return False;
1664 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriverex");
1670 if (!prs_werror("status", ps, depth, &r_u->status))
1678 /*******************************************************************
1680 * called from static spoolss_q_closeprinter (srv_spoolss.c)
1681 * called from spoolss_closeprinter (cli_spoolss.c)
1682 ********************************************************************/
1684 BOOL spoolss_io_q_closeprinter(const char *desc, SPOOL_Q_CLOSEPRINTER *q_u, prs_struct *ps, int depth)
1686 if (q_u == NULL) return False;
1688 prs_debug(ps, depth, desc, "spoolss_io_q_closeprinter");
1694 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1700 /*******************************************************************
1701 * write a structure.
1702 * called from static spoolss_r_closeprinter (srv_spoolss.c)
1703 * called from spoolss_closeprinter (cli_spoolss.c)
1704 ********************************************************************/
1706 BOOL spoolss_io_r_closeprinter(const char *desc, SPOOL_R_CLOSEPRINTER *r_u, prs_struct *ps, int depth)
1708 prs_debug(ps, depth, desc, "spoolss_io_r_closeprinter");
1714 if (!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
1716 if (!prs_werror("status", ps, depth, &r_u->status))
1722 /*******************************************************************
1724 * called from spoolss_q_startdocprinter (srv_spoolss.c)
1725 ********************************************************************/
1727 BOOL spoolss_io_q_startdocprinter(const char *desc, SPOOL_Q_STARTDOCPRINTER *q_u, prs_struct *ps, int depth)
1729 if (q_u == NULL) return False;
1731 prs_debug(ps, depth, desc, "spoolss_io_q_startdocprinter");
1737 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1740 if(!smb_io_doc_info_container("",&q_u->doc_info_container, ps, depth))
1746 /*******************************************************************
1747 * write a structure.
1748 * called from spoolss_r_startdocprinter (srv_spoolss.c)
1749 ********************************************************************/
1751 BOOL spoolss_io_r_startdocprinter(const char *desc, SPOOL_R_STARTDOCPRINTER *r_u, prs_struct *ps, int depth)
1753 prs_debug(ps, depth, desc, "spoolss_io_r_startdocprinter");
1755 if(!prs_uint32("jobid", ps, depth, &r_u->jobid))
1757 if(!prs_werror("status", ps, depth, &r_u->status))
1763 /*******************************************************************
1765 * called from spoolss_q_enddocprinter (srv_spoolss.c)
1766 ********************************************************************/
1768 BOOL spoolss_io_q_enddocprinter(const char *desc, SPOOL_Q_ENDDOCPRINTER *q_u, prs_struct *ps, int depth)
1770 if (q_u == NULL) return False;
1772 prs_debug(ps, depth, desc, "spoolss_io_q_enddocprinter");
1778 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1784 /*******************************************************************
1785 * write a structure.
1786 * called from spoolss_r_enddocprinter (srv_spoolss.c)
1787 ********************************************************************/
1789 BOOL spoolss_io_r_enddocprinter(const char *desc, SPOOL_R_ENDDOCPRINTER *r_u, prs_struct *ps, int depth)
1791 prs_debug(ps, depth, desc, "spoolss_io_r_enddocprinter");
1793 if(!prs_werror("status", ps, depth, &r_u->status))
1799 /*******************************************************************
1801 * called from spoolss_q_startpageprinter (srv_spoolss.c)
1802 ********************************************************************/
1804 BOOL spoolss_io_q_startpageprinter(const char *desc, SPOOL_Q_STARTPAGEPRINTER *q_u, prs_struct *ps, int depth)
1806 if (q_u == NULL) return False;
1808 prs_debug(ps, depth, desc, "spoolss_io_q_startpageprinter");
1814 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1820 /*******************************************************************
1821 * write a structure.
1822 * called from spoolss_r_startpageprinter (srv_spoolss.c)
1823 ********************************************************************/
1825 BOOL spoolss_io_r_startpageprinter(const char *desc, SPOOL_R_STARTPAGEPRINTER *r_u, prs_struct *ps, int depth)
1827 prs_debug(ps, depth, desc, "spoolss_io_r_startpageprinter");
1829 if(!prs_werror("status", ps, depth, &r_u->status))
1835 /*******************************************************************
1837 * called from spoolss_q_endpageprinter (srv_spoolss.c)
1838 ********************************************************************/
1840 BOOL spoolss_io_q_endpageprinter(const char *desc, SPOOL_Q_ENDPAGEPRINTER *q_u, prs_struct *ps, int depth)
1842 if (q_u == NULL) return False;
1844 prs_debug(ps, depth, desc, "spoolss_io_q_endpageprinter");
1850 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1856 /*******************************************************************
1857 * write a structure.
1858 * called from spoolss_r_endpageprinter (srv_spoolss.c)
1859 ********************************************************************/
1861 BOOL spoolss_io_r_endpageprinter(const char *desc, SPOOL_R_ENDPAGEPRINTER *r_u, prs_struct *ps, int depth)
1863 prs_debug(ps, depth, desc, "spoolss_io_r_endpageprinter");
1865 if(!prs_werror("status", ps, depth, &r_u->status))
1871 /*******************************************************************
1873 * called from spoolss_q_writeprinter (srv_spoolss.c)
1874 ********************************************************************/
1876 BOOL spoolss_io_q_writeprinter(const char *desc, SPOOL_Q_WRITEPRINTER *q_u, prs_struct *ps, int depth)
1878 if (q_u == NULL) return False;
1880 prs_debug(ps, depth, desc, "spoolss_io_q_writeprinter");
1886 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1888 if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size))
1891 if (q_u->buffer_size!=0)
1893 if (UNMARSHALLING(ps))
1894 q_u->buffer=PRS_ALLOC_MEM(ps, uint8, q_u->buffer_size);
1895 if(q_u->buffer == NULL)
1897 if(!prs_uint8s(True, "buffer", ps, depth, q_u->buffer, q_u->buffer_size))
1902 if(!prs_uint32("buffer_size2", ps, depth, &q_u->buffer_size2))
1908 /*******************************************************************
1909 * write a structure.
1910 * called from spoolss_r_writeprinter (srv_spoolss.c)
1911 ********************************************************************/
1913 BOOL spoolss_io_r_writeprinter(const char *desc, SPOOL_R_WRITEPRINTER *r_u, prs_struct *ps, int depth)
1915 prs_debug(ps, depth, desc, "spoolss_io_r_writeprinter");
1917 if(!prs_uint32("buffer_written", ps, depth, &r_u->buffer_written))
1919 if(!prs_werror("status", ps, depth, &r_u->status))
1925 /*******************************************************************
1927 * called from spoolss_q_rffpcnex (srv_spoolss.c)
1928 ********************************************************************/
1930 BOOL spoolss_io_q_rffpcnex(const char *desc, SPOOL_Q_RFFPCNEX *q_u, prs_struct *ps, int depth)
1932 prs_debug(ps, depth, desc, "spoolss_io_q_rffpcnex");
1938 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1940 if(!prs_uint32("flags", ps, depth, &q_u->flags))
1942 if(!prs_uint32("options", ps, depth, &q_u->options))
1944 if(!prs_uint32("localmachine_ptr", ps, depth, &q_u->localmachine_ptr))
1946 if(!smb_io_unistr2("localmachine", &q_u->localmachine, q_u->localmachine_ptr, ps, depth))
1952 if(!prs_uint32("printerlocal", ps, depth, &q_u->printerlocal))
1955 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1958 if (q_u->option_ptr!=0) {
1960 if (UNMARSHALLING(ps))
1961 if((q_u->option=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION,1)) == NULL)
1964 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1971 /*******************************************************************
1972 * write a structure.
1973 * called from spoolss_r_rffpcnex (srv_spoolss.c)
1974 ********************************************************************/
1976 BOOL spoolss_io_r_rffpcnex(const char *desc, SPOOL_R_RFFPCNEX *r_u, prs_struct *ps, int depth)
1978 prs_debug(ps, depth, desc, "spoolss_io_r_rffpcnex");
1981 if(!prs_werror("status", ps, depth, &r_u->status))
1987 /*******************************************************************
1989 * called from spoolss_q_rfnpcnex (srv_spoolss.c)
1990 ********************************************************************/
1992 BOOL spoolss_io_q_rfnpcnex(const char *desc, SPOOL_Q_RFNPCNEX *q_u, prs_struct *ps, int depth)
1994 prs_debug(ps, depth, desc, "spoolss_io_q_rfnpcnex");
2000 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
2003 if(!prs_uint32("change", ps, depth, &q_u->change))
2006 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
2009 if (q_u->option_ptr!=0) {
2011 if (UNMARSHALLING(ps))
2012 if((q_u->option=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION,1)) == NULL)
2015 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
2022 /*******************************************************************
2023 * write a structure.
2024 * called from spoolss_r_rfnpcnex (srv_spoolss.c)
2025 ********************************************************************/
2027 BOOL spoolss_io_r_rfnpcnex(const char *desc, SPOOL_R_RFNPCNEX *r_u, prs_struct *ps, int depth)
2029 prs_debug(ps, depth, desc, "spoolss_io_r_rfnpcnex");
2035 if (!prs_uint32("info_ptr", ps, depth, &r_u->info_ptr))
2038 if(!smb_io_notify_info("notify info", &r_u->info ,ps,depth))
2043 if(!prs_werror("status", ps, depth, &r_u->status))
2049 /*******************************************************************
2050 * return the length of a uint16 (obvious, but the code is clean)
2051 ********************************************************************/
2053 static uint32 size_of_uint16(uint16 *value)
2055 return (sizeof(*value));
2058 /*******************************************************************
2059 * return the length of a uint32 (obvious, but the code is clean)
2060 ********************************************************************/
2062 static uint32 size_of_uint32(uint32 *value)
2064 return (sizeof(*value));
2067 /*******************************************************************
2068 * return the length of a NTTIME (obvious, but the code is clean)
2069 ********************************************************************/
2071 static uint32 size_of_nttime(NTTIME *value)
2073 return (sizeof(*value));
2076 /*******************************************************************
2077 * return the length of a uint32 (obvious, but the code is clean)
2078 ********************************************************************/
2080 static uint32 size_of_device_mode(DEVICEMODE *devmode)
2085 return (4+devmode->size+devmode->driverextra);
2088 /*******************************************************************
2089 * return the length of a uint32 (obvious, but the code is clean)
2090 ********************************************************************/
2092 static uint32 size_of_systemtime(SYSTEMTIME *systime)
2097 return (sizeof(SYSTEMTIME) +4);
2100 /*******************************************************************
2101 Parse a DEVMODE structure and its relative pointer.
2102 ********************************************************************/
2104 static BOOL smb_io_reldevmode(const char *desc, RPC_BUFFER *buffer, int depth, DEVICEMODE **devmode)
2106 prs_struct *ps=&buffer->prs;
2108 prs_debug(ps, depth, desc, "smb_io_reldevmode");
2111 if (MARSHALLING(ps)) {
2112 uint32 struct_offset = prs_offset(ps);
2113 uint32 relative_offset;
2115 if (*devmode == NULL) {
2117 if (!prs_uint32("offset", ps, depth, &relative_offset))
2119 DEBUG(8, ("boing, the devmode was NULL\n"));
2124 buffer->string_at_end -= ((*devmode)->size + (*devmode)->driverextra);
2126 if(!prs_set_offset(ps, buffer->string_at_end))
2129 /* write the DEVMODE */
2130 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
2133 if(!prs_set_offset(ps, struct_offset))
2136 relative_offset=buffer->string_at_end - buffer->struct_start;
2137 /* write its offset */
2138 if (!prs_uint32("offset", ps, depth, &relative_offset))
2144 /* read the offset */
2145 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
2147 if (buffer->string_at_end == 0) {
2152 old_offset = prs_offset(ps);
2153 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
2156 /* read the string */
2157 if((*devmode=PRS_ALLOC_MEM(ps,DEVICEMODE,1)) == NULL)
2159 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
2162 if(!prs_set_offset(ps, old_offset))
2168 /*******************************************************************
2169 Parse a PRINTER_INFO_0 structure.
2170 ********************************************************************/
2172 BOOL smb_io_printer_info_0(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_0 *info, int depth)
2174 prs_struct *ps=&buffer->prs;
2176 prs_debug(ps, depth, desc, "smb_io_printer_info_0");
2179 buffer->struct_start=prs_offset(ps);
2181 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2183 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2186 if(!prs_uint32("cjobs", ps, depth, &info->cjobs))
2188 if(!prs_uint32("total_jobs", ps, depth, &info->total_jobs))
2190 if(!prs_uint32("total_bytes", ps, depth, &info->total_bytes))
2193 if(!prs_uint16("year", ps, depth, &info->year))
2195 if(!prs_uint16("month", ps, depth, &info->month))
2197 if(!prs_uint16("dayofweek", ps, depth, &info->dayofweek))
2199 if(!prs_uint16("day", ps, depth, &info->day))
2201 if(!prs_uint16("hour", ps, depth, &info->hour))
2203 if(!prs_uint16("minute", ps, depth, &info->minute))
2205 if(!prs_uint16("second", ps, depth, &info->second))
2207 if(!prs_uint16("milliseconds", ps, depth, &info->milliseconds))
2210 if(!prs_uint32("global_counter", ps, depth, &info->global_counter))
2212 if(!prs_uint32("total_pages", ps, depth, &info->total_pages))
2215 if(!prs_uint16("major_version", ps, depth, &info->major_version))
2217 if(!prs_uint16("build_version", ps, depth, &info->build_version))
2219 if(!prs_uint32("unknown7", ps, depth, &info->unknown7))
2221 if(!prs_uint32("unknown8", ps, depth, &info->unknown8))
2223 if(!prs_uint32("unknown9", ps, depth, &info->unknown9))
2225 if(!prs_uint32("session_counter", ps, depth, &info->session_counter))
2227 if(!prs_uint32("unknown11", ps, depth, &info->unknown11))
2229 if(!prs_uint32("printer_errors", ps, depth, &info->printer_errors))
2231 if(!prs_uint32("unknown13", ps, depth, &info->unknown13))
2233 if(!prs_uint32("unknown14", ps, depth, &info->unknown14))
2235 if(!prs_uint32("unknown15", ps, depth, &info->unknown15))
2237 if(!prs_uint32("unknown16", ps, depth, &info->unknown16))
2239 if(!prs_uint32("change_id", ps, depth, &info->change_id))
2241 if(!prs_uint32("unknown18", ps, depth, &info->unknown18))
2243 if(!prs_uint32("status" , ps, depth, &info->status))
2245 if(!prs_uint32("unknown20", ps, depth, &info->unknown20))
2247 if(!prs_uint32("c_setprinter", ps, depth, &info->c_setprinter))
2249 if(!prs_uint16("unknown22", ps, depth, &info->unknown22))
2251 if(!prs_uint16("unknown23", ps, depth, &info->unknown23))
2253 if(!prs_uint16("unknown24", ps, depth, &info->unknown24))
2255 if(!prs_uint16("unknown25", ps, depth, &info->unknown25))
2257 if(!prs_uint16("unknown26", ps, depth, &info->unknown26))
2259 if(!prs_uint16("unknown27", ps, depth, &info->unknown27))
2261 if(!prs_uint16("unknown28", ps, depth, &info->unknown28))
2263 if(!prs_uint16("unknown29", ps, depth, &info->unknown29))
2269 /*******************************************************************
2270 Parse a PRINTER_INFO_1 structure.
2271 ********************************************************************/
2273 BOOL smb_io_printer_info_1(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_1 *info, int depth)
2275 prs_struct *ps=&buffer->prs;
2277 prs_debug(ps, depth, desc, "smb_io_printer_info_1");
2280 buffer->struct_start=prs_offset(ps);
2282 if (!prs_uint32("flags", ps, depth, &info->flags))
2284 if (!smb_io_relstr("description", buffer, depth, &info->description))
2286 if (!smb_io_relstr("name", buffer, depth, &info->name))
2288 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2294 /*******************************************************************
2295 Parse a PRINTER_INFO_2 structure.
2296 ********************************************************************/
2298 BOOL smb_io_printer_info_2(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_2 *info, int depth)
2300 prs_struct *ps=&buffer->prs;
2301 uint32 dm_offset, sd_offset, current_offset;
2302 uint32 dummy_value = 0, has_secdesc = 0;
2304 prs_debug(ps, depth, desc, "smb_io_printer_info_2");
2307 buffer->struct_start=prs_offset(ps);
2309 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2311 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2313 if (!smb_io_relstr("sharename", buffer, depth, &info->sharename))
2315 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2317 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2319 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2321 if (!smb_io_relstr("location", buffer, depth, &info->location))
2324 /* save current offset and wind forwared by a uint32 */
2325 dm_offset = prs_offset(ps);
2326 if (!prs_uint32("devmode", ps, depth, &dummy_value))
2329 if (!smb_io_relstr("sepfile", buffer, depth, &info->sepfile))
2331 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2333 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2335 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2338 /* save current offset for the sec_desc */
2339 sd_offset = prs_offset(ps);
2340 if (!prs_uint32("sec_desc", ps, depth, &has_secdesc))
2344 /* save current location so we can pick back up here */
2345 current_offset = prs_offset(ps);
2347 /* parse the devmode */
2348 if (!prs_set_offset(ps, dm_offset))
2350 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2353 /* parse the sec_desc */
2354 if (info->secdesc) {
2355 if (!prs_set_offset(ps, sd_offset))
2357 if (!smb_io_relsecdesc("secdesc", buffer, depth, &info->secdesc))
2361 /* pick up where we left off */
2362 if (!prs_set_offset(ps, current_offset))
2365 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2367 if (!prs_uint32("priority", ps, depth, &info->priority))
2369 if (!prs_uint32("defpriority", ps, depth, &info->defaultpriority))
2371 if (!prs_uint32("starttime", ps, depth, &info->starttime))
2373 if (!prs_uint32("untiltime", ps, depth, &info->untiltime))
2375 if (!prs_uint32("status", ps, depth, &info->status))
2377 if (!prs_uint32("jobs", ps, depth, &info->cjobs))
2379 if (!prs_uint32("averageppm", ps, depth, &info->averageppm))
2385 /*******************************************************************
2386 Parse a PRINTER_INFO_3 structure.
2387 ********************************************************************/
2389 BOOL smb_io_printer_info_3(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_3 *info, int depth)
2391 prs_struct *ps=&buffer->prs;
2393 prs_debug(ps, depth, desc, "smb_io_printer_info_3");
2396 buffer->struct_start=prs_offset(ps);
2398 if (!prs_uint32("flags", ps, depth, &info->flags))
2400 if (!sec_io_desc("sec_desc", &info->secdesc, ps, depth))
2406 /*******************************************************************
2407 Parse a PRINTER_INFO_4 structure.
2408 ********************************************************************/
2410 BOOL smb_io_printer_info_4(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_4 *info, int depth)
2412 prs_struct *ps=&buffer->prs;
2414 prs_debug(ps, depth, desc, "smb_io_printer_info_4");
2417 buffer->struct_start=prs_offset(ps);
2419 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2421 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2423 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2428 /*******************************************************************
2429 Parse a PRINTER_INFO_5 structure.
2430 ********************************************************************/
2432 BOOL smb_io_printer_info_5(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_5 *info, int depth)
2434 prs_struct *ps=&buffer->prs;
2436 prs_debug(ps, depth, desc, "smb_io_printer_info_5");
2439 buffer->struct_start=prs_offset(ps);
2441 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2443 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2445 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2447 if (!prs_uint32("device_not_selected_timeout", ps, depth, &info->device_not_selected_timeout))
2449 if (!prs_uint32("transmission_retry_timeout", ps, depth, &info->transmission_retry_timeout))
2454 /*******************************************************************
2455 Parse a PRINTER_INFO_7 structure.
2456 ********************************************************************/
2458 BOOL smb_io_printer_info_7(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_7 *info, int depth)
2460 prs_struct *ps=&buffer->prs;
2462 prs_debug(ps, depth, desc, "smb_io_printer_info_7");
2465 buffer->struct_start=prs_offset(ps);
2467 if (!smb_io_relstr("guid", buffer, depth, &info->guid))
2469 if (!prs_uint32("action", ps, depth, &info->action))
2474 /*******************************************************************
2475 Parse a PORT_INFO_1 structure.
2476 ********************************************************************/
2478 BOOL smb_io_port_info_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
2480 prs_struct *ps=&buffer->prs;
2482 prs_debug(ps, depth, desc, "smb_io_port_info_1");
2485 buffer->struct_start=prs_offset(ps);
2487 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2493 /*******************************************************************
2494 Parse a PORT_INFO_2 structure.
2495 ********************************************************************/
2497 BOOL smb_io_port_info_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2499 prs_struct *ps=&buffer->prs;
2501 prs_debug(ps, depth, desc, "smb_io_port_info_2");
2504 buffer->struct_start=prs_offset(ps);
2506 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2508 if (!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2510 if (!smb_io_relstr("description", buffer, depth, &info->description))
2512 if (!prs_uint32("port_type", ps, depth, &info->port_type))
2514 if (!prs_uint32("reserved", ps, depth, &info->reserved))
2520 /*******************************************************************
2521 Parse a DRIVER_INFO_1 structure.
2522 ********************************************************************/
2524 BOOL smb_io_printer_driver_info_1(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_1 *info, int depth)
2526 prs_struct *ps=&buffer->prs;
2528 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_1");
2531 buffer->struct_start=prs_offset(ps);
2533 if (!smb_io_relstr("name", buffer, depth, &info->name))
2539 /*******************************************************************
2540 Parse a DRIVER_INFO_2 structure.
2541 ********************************************************************/
2543 BOOL smb_io_printer_driver_info_2(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_2 *info, int depth)
2545 prs_struct *ps=&buffer->prs;
2547 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_2");
2550 buffer->struct_start=prs_offset(ps);
2552 if (!prs_uint32("version", ps, depth, &info->version))
2554 if (!smb_io_relstr("name", buffer, depth, &info->name))
2556 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2558 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2560 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2562 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2568 /*******************************************************************
2569 Parse a DRIVER_INFO_3 structure.
2570 ********************************************************************/
2572 BOOL smb_io_printer_driver_info_3(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_3 *info, int depth)
2574 prs_struct *ps=&buffer->prs;
2576 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_3");
2579 buffer->struct_start=prs_offset(ps);
2581 if (!prs_uint32("version", ps, depth, &info->version))
2583 if (!smb_io_relstr("name", buffer, depth, &info->name))
2585 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2587 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2589 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2591 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2593 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2596 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2599 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2601 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2607 /*******************************************************************
2608 Parse a DRIVER_INFO_6 structure.
2609 ********************************************************************/
2611 BOOL smb_io_printer_driver_info_6(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_6 *info, int depth)
2613 prs_struct *ps=&buffer->prs;
2615 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_6");
2618 buffer->struct_start=prs_offset(ps);
2620 if (!prs_uint32("version", ps, depth, &info->version))
2622 if (!smb_io_relstr("name", buffer, depth, &info->name))
2624 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2626 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2628 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2630 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2632 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2635 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2638 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2640 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2643 if (!smb_io_relarraystr("previousdrivernames", buffer, depth, &info->previousdrivernames))
2646 if (!prs_uint32("date.low", ps, depth, &info->driver_date.low))
2648 if (!prs_uint32("date.high", ps, depth, &info->driver_date.high))
2651 if (!prs_uint32("padding", ps, depth, &info->padding))
2654 if (!prs_uint32("driver_version_low", ps, depth, &info->driver_version_low))
2657 if (!prs_uint32("driver_version_high", ps, depth, &info->driver_version_high))
2660 if (!smb_io_relstr("mfgname", buffer, depth, &info->mfgname))
2662 if (!smb_io_relstr("oem_url", buffer, depth, &info->oem_url))
2664 if (!smb_io_relstr("hardware_id", buffer, depth, &info->hardware_id))
2666 if (!smb_io_relstr("provider", buffer, depth, &info->provider))
2672 /*******************************************************************
2673 Parse a JOB_INFO_1 structure.
2674 ********************************************************************/
2676 BOOL smb_io_job_info_1(const char *desc, RPC_BUFFER *buffer, JOB_INFO_1 *info, int depth)
2678 prs_struct *ps=&buffer->prs;
2680 prs_debug(ps, depth, desc, "smb_io_job_info_1");
2683 buffer->struct_start=prs_offset(ps);
2685 if (!prs_uint32("jobid", ps, depth, &info->jobid))
2687 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2689 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2691 if (!smb_io_relstr("username", buffer, depth, &info->username))
2693 if (!smb_io_relstr("document", buffer, depth, &info->document))
2695 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2697 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2699 if (!prs_uint32("status", ps, depth, &info->status))
2701 if (!prs_uint32("priority", ps, depth, &info->priority))
2703 if (!prs_uint32("position", ps, depth, &info->position))
2705 if (!prs_uint32("totalpages", ps, depth, &info->totalpages))
2707 if (!prs_uint32("pagesprinted", ps, depth, &info->pagesprinted))
2709 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted))
2715 /*******************************************************************
2716 Parse a JOB_INFO_2 structure.
2717 ********************************************************************/
2719 BOOL smb_io_job_info_2(const char *desc, RPC_BUFFER *buffer, JOB_INFO_2 *info, int depth)
2722 prs_struct *ps=&buffer->prs;
2724 prs_debug(ps, depth, desc, "smb_io_job_info_2");
2727 buffer->struct_start=prs_offset(ps);
2729 if (!prs_uint32("jobid",ps, depth, &info->jobid))
2731 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2733 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2735 if (!smb_io_relstr("username", buffer, depth, &info->username))
2737 if (!smb_io_relstr("document", buffer, depth, &info->document))
2739 if (!smb_io_relstr("notifyname", buffer, depth, &info->notifyname))
2741 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2744 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2746 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2748 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2750 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2752 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2755 /* SEC_DESC sec_desc;*/
2756 if (!prs_uint32("Hack! sec desc", ps, depth, &pipo))
2759 if (!prs_uint32("status",ps, depth, &info->status))
2761 if (!prs_uint32("priority",ps, depth, &info->priority))
2763 if (!prs_uint32("position",ps, depth, &info->position))
2765 if (!prs_uint32("starttime",ps, depth, &info->starttime))
2767 if (!prs_uint32("untiltime",ps, depth, &info->untiltime))
2769 if (!prs_uint32("totalpages",ps, depth, &info->totalpages))
2771 if (!prs_uint32("size",ps, depth, &info->size))
2773 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted) )
2775 if (!prs_uint32("timeelapsed",ps, depth, &info->timeelapsed))
2777 if (!prs_uint32("pagesprinted",ps, depth, &info->pagesprinted))
2783 /*******************************************************************
2784 ********************************************************************/
2786 BOOL smb_io_form_1(const char *desc, RPC_BUFFER *buffer, FORM_1 *info, int depth)
2788 prs_struct *ps=&buffer->prs;
2790 prs_debug(ps, depth, desc, "smb_io_form_1");
2793 buffer->struct_start=prs_offset(ps);
2795 if (!prs_uint32("flag", ps, depth, &info->flag))
2798 if (!smb_io_relstr("name", buffer, depth, &info->name))
2801 if (!prs_uint32("width", ps, depth, &info->width))
2803 if (!prs_uint32("length", ps, depth, &info->length))
2805 if (!prs_uint32("left", ps, depth, &info->left))
2807 if (!prs_uint32("top", ps, depth, &info->top))
2809 if (!prs_uint32("right", ps, depth, &info->right))
2811 if (!prs_uint32("bottom", ps, depth, &info->bottom))
2819 /*******************************************************************
2820 Parse a DRIVER_DIRECTORY_1 structure.
2821 ********************************************************************/
2823 BOOL smb_io_driverdir_1(const char *desc, RPC_BUFFER *buffer, DRIVER_DIRECTORY_1 *info, int depth)
2825 prs_struct *ps=&buffer->prs;
2827 prs_debug(ps, depth, desc, "smb_io_driverdir_1");
2830 buffer->struct_start=prs_offset(ps);
2832 if (!smb_io_unistr(desc, &info->name, ps, depth))
2838 /*******************************************************************
2839 Parse a PORT_INFO_1 structure.
2840 ********************************************************************/
2842 BOOL smb_io_port_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
2844 prs_struct *ps=&buffer->prs;
2846 prs_debug(ps, depth, desc, "smb_io_port_1");
2849 buffer->struct_start=prs_offset(ps);
2851 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2857 /*******************************************************************
2858 Parse a PORT_INFO_2 structure.
2859 ********************************************************************/
2861 BOOL smb_io_port_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2863 prs_struct *ps=&buffer->prs;
2865 prs_debug(ps, depth, desc, "smb_io_port_2");
2868 buffer->struct_start=prs_offset(ps);
2870 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2872 if(!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2874 if(!smb_io_relstr("description", buffer, depth, &info->description))
2876 if(!prs_uint32("port_type", ps, depth, &info->port_type))
2878 if(!prs_uint32("reserved", ps, depth, &info->reserved))
2884 /*******************************************************************
2885 ********************************************************************/
2887 BOOL smb_io_printprocessor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_1 *info, int depth)
2889 prs_struct *ps=&buffer->prs;
2891 prs_debug(ps, depth, desc, "smb_io_printprocessor_info_1");
2894 buffer->struct_start=prs_offset(ps);
2896 if (smb_io_relstr("name", buffer, depth, &info->name))
2902 /*******************************************************************
2903 ********************************************************************/
2905 BOOL smb_io_printprocdatatype_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCDATATYPE_1 *info, int depth)
2907 prs_struct *ps=&buffer->prs;
2909 prs_debug(ps, depth, desc, "smb_io_printprocdatatype_info_1");
2912 buffer->struct_start=prs_offset(ps);
2914 if (smb_io_relstr("name", buffer, depth, &info->name))
2920 /*******************************************************************
2921 ********************************************************************/
2923 BOOL smb_io_printmonitor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_1 *info, int depth)
2925 prs_struct *ps=&buffer->prs;
2927 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_1");
2930 buffer->struct_start=prs_offset(ps);
2932 if (!smb_io_relstr("name", buffer, depth, &info->name))
2938 /*******************************************************************
2939 ********************************************************************/
2941 BOOL smb_io_printmonitor_info_2(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_2 *info, int depth)
2943 prs_struct *ps=&buffer->prs;
2945 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_2");
2948 buffer->struct_start=prs_offset(ps);
2950 if (!smb_io_relstr("name", buffer, depth, &info->name))
2952 if (!smb_io_relstr("environment", buffer, depth, &info->environment))
2954 if (!smb_io_relstr("dll_name", buffer, depth, &info->dll_name))
2960 /*******************************************************************
2961 return the size required by a struct in the stream
2962 ********************************************************************/
2964 uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
2968 size+=size_of_relative_string( &info->printername );
2969 size+=size_of_relative_string( &info->servername );
2971 size+=size_of_uint32( &info->cjobs);
2972 size+=size_of_uint32( &info->total_jobs);
2973 size+=size_of_uint32( &info->total_bytes);
2975 size+=size_of_uint16( &info->year);
2976 size+=size_of_uint16( &info->month);
2977 size+=size_of_uint16( &info->dayofweek);
2978 size+=size_of_uint16( &info->day);
2979 size+=size_of_uint16( &info->hour);
2980 size+=size_of_uint16( &info->minute);
2981 size+=size_of_uint16( &info->second);
2982 size+=size_of_uint16( &info->milliseconds);
2984 size+=size_of_uint32( &info->global_counter);
2985 size+=size_of_uint32( &info->total_pages);
2987 size+=size_of_uint16( &info->major_version);
2988 size+=size_of_uint16( &info->build_version);
2990 size+=size_of_uint32( &info->unknown7);
2991 size+=size_of_uint32( &info->unknown8);
2992 size+=size_of_uint32( &info->unknown9);
2993 size+=size_of_uint32( &info->session_counter);
2994 size+=size_of_uint32( &info->unknown11);
2995 size+=size_of_uint32( &info->printer_errors);
2996 size+=size_of_uint32( &info->unknown13);
2997 size+=size_of_uint32( &info->unknown14);
2998 size+=size_of_uint32( &info->unknown15);
2999 size+=size_of_uint32( &info->unknown16);
3000 size+=size_of_uint32( &info->change_id);
3001 size+=size_of_uint32( &info->unknown18);
3002 size+=size_of_uint32( &info->status);
3003 size+=size_of_uint32( &info->unknown20);
3004 size+=size_of_uint32( &info->c_setprinter);
3006 size+=size_of_uint16( &info->unknown22);
3007 size+=size_of_uint16( &info->unknown23);
3008 size+=size_of_uint16( &info->unknown24);
3009 size+=size_of_uint16( &info->unknown25);
3010 size+=size_of_uint16( &info->unknown26);
3011 size+=size_of_uint16( &info->unknown27);
3012 size+=size_of_uint16( &info->unknown28);
3013 size+=size_of_uint16( &info->unknown29);
3018 /*******************************************************************
3019 return the size required by a struct in the stream
3020 ********************************************************************/
3022 uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
3026 size+=size_of_uint32( &info->flags );
3027 size+=size_of_relative_string( &info->description );
3028 size+=size_of_relative_string( &info->name );
3029 size+=size_of_relative_string( &info->comment );
3034 /*******************************************************************
3035 return the size required by a struct in the stream
3036 ********************************************************************/
3038 uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
3044 size += sec_desc_size( info->secdesc );
3046 size+=size_of_device_mode( info->devmode );
3048 size+=size_of_relative_string( &info->servername );
3049 size+=size_of_relative_string( &info->printername );
3050 size+=size_of_relative_string( &info->sharename );
3051 size+=size_of_relative_string( &info->portname );
3052 size+=size_of_relative_string( &info->drivername );
3053 size+=size_of_relative_string( &info->comment );
3054 size+=size_of_relative_string( &info->location );
3056 size+=size_of_relative_string( &info->sepfile );
3057 size+=size_of_relative_string( &info->printprocessor );
3058 size+=size_of_relative_string( &info->datatype );
3059 size+=size_of_relative_string( &info->parameters );
3061 size+=size_of_uint32( &info->attributes );
3062 size+=size_of_uint32( &info->priority );
3063 size+=size_of_uint32( &info->defaultpriority );
3064 size+=size_of_uint32( &info->starttime );
3065 size+=size_of_uint32( &info->untiltime );
3066 size+=size_of_uint32( &info->status );
3067 size+=size_of_uint32( &info->cjobs );
3068 size+=size_of_uint32( &info->averageppm );
3071 * add any adjustments for alignment. This is
3072 * not optimal since we could be calling this
3073 * function from a loop (e.g. enumprinters), but
3074 * it is easier to maintain the calculation here and
3075 * not place the burden on the caller to remember. --jerry
3077 if ((size % 4) != 0)
3078 size += 4 - (size % 4);
3083 /*******************************************************************
3084 return the size required by a struct in the stream
3085 ********************************************************************/
3087 uint32 spoolss_size_printer_info_4(PRINTER_INFO_4 *info)
3091 size+=size_of_relative_string( &info->printername );
3092 size+=size_of_relative_string( &info->servername );
3094 size+=size_of_uint32( &info->attributes );
3098 /*******************************************************************
3099 return the size required by a struct in the stream
3100 ********************************************************************/
3102 uint32 spoolss_size_printer_info_5(PRINTER_INFO_5 *info)
3106 size+=size_of_relative_string( &info->printername );
3107 size+=size_of_relative_string( &info->portname );
3109 size+=size_of_uint32( &info->attributes );
3110 size+=size_of_uint32( &info->device_not_selected_timeout );
3111 size+=size_of_uint32( &info->transmission_retry_timeout );
3116 /*******************************************************************
3117 return the size required by a struct in the stream
3118 ********************************************************************/
3120 uint32 spoolss_size_printer_info_3(PRINTER_INFO_3 *info)
3122 /* The 4 is for the self relative pointer.. */
3123 /* JRA !!!! TESTME - WHAT ABOUT prs_align.... !!! */
3124 return 4 + (uint32)sec_desc_size( info->secdesc );
3127 /*******************************************************************
3128 return the size required by a struct in the stream
3129 ********************************************************************/
3131 uint32 spoolss_size_printer_info_7(PRINTER_INFO_7 *info)
3135 size+=size_of_relative_string( &info->guid );
3136 size+=size_of_uint32( &info->action );
3140 /*******************************************************************
3141 return the size required by a struct in the stream
3142 ********************************************************************/
3144 uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
3147 size+=size_of_relative_string( &info->name );
3152 /*******************************************************************
3153 return the size required by a struct in the stream
3154 ********************************************************************/
3156 uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
3159 size+=size_of_uint32( &info->version );
3160 size+=size_of_relative_string( &info->name );
3161 size+=size_of_relative_string( &info->architecture );
3162 size+=size_of_relative_string( &info->driverpath );
3163 size+=size_of_relative_string( &info->datafile );
3164 size+=size_of_relative_string( &info->configfile );
3169 /*******************************************************************
3170 return the size required by a string array.
3171 ********************************************************************/
3173 uint32 spoolss_size_string_array(uint16 *string)
3178 for (i=0; (string[i]!=0x0000) || (string[i+1]!=0x0000); i++);
3180 i=i+2; /* to count all chars including the leading zero */
3181 i=2*i; /* because we need the value in bytes */
3182 i=i+4; /* the offset pointer size */
3187 /*******************************************************************
3188 return the size required by a struct in the stream
3189 ********************************************************************/
3191 uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
3195 size+=size_of_uint32( &info->version );
3196 size+=size_of_relative_string( &info->name );
3197 size+=size_of_relative_string( &info->architecture );
3198 size+=size_of_relative_string( &info->driverpath );
3199 size+=size_of_relative_string( &info->datafile );
3200 size+=size_of_relative_string( &info->configfile );
3201 size+=size_of_relative_string( &info->helpfile );
3202 size+=size_of_relative_string( &info->monitorname );
3203 size+=size_of_relative_string( &info->defaultdatatype );
3205 size+=spoolss_size_string_array(info->dependentfiles);
3210 /*******************************************************************
3211 return the size required by a struct in the stream
3212 ********************************************************************/
3214 uint32 spoolss_size_printer_driver_info_6(DRIVER_INFO_6 *info)
3218 size+=size_of_uint32( &info->version );
3219 size+=size_of_relative_string( &info->name );
3220 size+=size_of_relative_string( &info->architecture );
3221 size+=size_of_relative_string( &info->driverpath );
3222 size+=size_of_relative_string( &info->datafile );
3223 size+=size_of_relative_string( &info->configfile );
3224 size+=size_of_relative_string( &info->helpfile );
3226 size+=spoolss_size_string_array(info->dependentfiles);
3228 size+=size_of_relative_string( &info->monitorname );
3229 size+=size_of_relative_string( &info->defaultdatatype );
3231 size+=spoolss_size_string_array(info->previousdrivernames);
3233 size+=size_of_nttime(&info->driver_date);
3234 size+=size_of_uint32( &info->padding );
3235 size+=size_of_uint32( &info->driver_version_low );
3236 size+=size_of_uint32( &info->driver_version_high );
3237 size+=size_of_relative_string( &info->mfgname );
3238 size+=size_of_relative_string( &info->oem_url );
3239 size+=size_of_relative_string( &info->hardware_id );
3240 size+=size_of_relative_string( &info->provider );
3245 /*******************************************************************
3246 return the size required by a struct in the stream
3247 ********************************************************************/
3249 uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
3252 size+=size_of_uint32( &info->jobid );
3253 size+=size_of_relative_string( &info->printername );
3254 size+=size_of_relative_string( &info->machinename );
3255 size+=size_of_relative_string( &info->username );
3256 size+=size_of_relative_string( &info->document );
3257 size+=size_of_relative_string( &info->datatype );
3258 size+=size_of_relative_string( &info->text_status );
3259 size+=size_of_uint32( &info->status );
3260 size+=size_of_uint32( &info->priority );
3261 size+=size_of_uint32( &info->position );
3262 size+=size_of_uint32( &info->totalpages );
3263 size+=size_of_uint32( &info->pagesprinted );
3264 size+=size_of_systemtime( &info->submitted );
3269 /*******************************************************************
3270 return the size required by a struct in the stream
3271 ********************************************************************/
3273 uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
3277 size+=4; /* size of sec desc ptr */
3279 size+=size_of_uint32( &info->jobid );
3280 size+=size_of_relative_string( &info->printername );
3281 size+=size_of_relative_string( &info->machinename );
3282 size+=size_of_relative_string( &info->username );
3283 size+=size_of_relative_string( &info->document );
3284 size+=size_of_relative_string( &info->notifyname );
3285 size+=size_of_relative_string( &info->datatype );
3286 size+=size_of_relative_string( &info->printprocessor );
3287 size+=size_of_relative_string( &info->parameters );
3288 size+=size_of_relative_string( &info->drivername );
3289 size+=size_of_device_mode( info->devmode );
3290 size+=size_of_relative_string( &info->text_status );
3291 /* SEC_DESC sec_desc;*/
3292 size+=size_of_uint32( &info->status );
3293 size+=size_of_uint32( &info->priority );
3294 size+=size_of_uint32( &info->position );
3295 size+=size_of_uint32( &info->starttime );
3296 size+=size_of_uint32( &info->untiltime );
3297 size+=size_of_uint32( &info->totalpages );
3298 size+=size_of_uint32( &info->size );
3299 size+=size_of_systemtime( &info->submitted );
3300 size+=size_of_uint32( &info->timeelapsed );
3301 size+=size_of_uint32( &info->pagesprinted );
3306 /*******************************************************************
3307 return the size required by a struct in the stream
3308 ********************************************************************/
3310 uint32 spoolss_size_form_1(FORM_1 *info)
3314 size+=size_of_uint32( &info->flag );
3315 size+=size_of_relative_string( &info->name );
3316 size+=size_of_uint32( &info->width );
3317 size+=size_of_uint32( &info->length );
3318 size+=size_of_uint32( &info->left );
3319 size+=size_of_uint32( &info->top );
3320 size+=size_of_uint32( &info->right );
3321 size+=size_of_uint32( &info->bottom );
3326 /*******************************************************************
3327 return the size required by a struct in the stream
3328 ********************************************************************/
3330 uint32 spoolss_size_port_info_1(PORT_INFO_1 *info)
3334 size+=size_of_relative_string( &info->port_name );
3339 /*******************************************************************
3340 return the size required by a struct in the stream
3341 ********************************************************************/
3343 uint32 spoolss_size_driverdir_info_1(DRIVER_DIRECTORY_1 *info)
3347 size=str_len_uni(&info->name); /* the string length */
3348 size=size+1; /* add the leading zero */
3349 size=size*2; /* convert in char */
3354 /*******************************************************************
3355 return the size required by a struct in the stream
3356 ********************************************************************/
3358 uint32 spoolss_size_printprocessordirectory_info_1(PRINTPROCESSOR_DIRECTORY_1 *info)
3362 size=str_len_uni(&info->name); /* the string length */
3363 size=size+1; /* add the leading zero */
3364 size=size*2; /* convert in char */
3369 /*******************************************************************
3370 return the size required by a struct in the stream
3371 ********************************************************************/
3373 uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
3377 size+=size_of_relative_string( &info->port_name );
3378 size+=size_of_relative_string( &info->monitor_name );
3379 size+=size_of_relative_string( &info->description );
3381 size+=size_of_uint32( &info->port_type );
3382 size+=size_of_uint32( &info->reserved );
3387 /*******************************************************************
3388 return the size required by a struct in the stream
3389 ********************************************************************/
3391 uint32 spoolss_size_printprocessor_info_1(PRINTPROCESSOR_1 *info)
3394 size+=size_of_relative_string( &info->name );
3399 /*******************************************************************
3400 return the size required by a struct in the stream
3401 ********************************************************************/
3403 uint32 spoolss_size_printprocdatatype_info_1(PRINTPROCDATATYPE_1 *info)
3406 size+=size_of_relative_string( &info->name );
3411 /*******************************************************************
3412 return the size required by a struct in the stream
3413 ********************************************************************/
3414 uint32 spoolss_size_printer_enum_values(PRINTER_ENUM_VALUES *p)
3421 /* uint32(offset) + uint32(length) + length) */
3422 size += (size_of_uint32(&p->value_len)*2) + p->value_len;
3423 size += (size_of_uint32(&p->data_len)*2) + p->data_len + (p->data_len%2) ;
3425 size += size_of_uint32(&p->type);
3430 /*******************************************************************
3431 return the size required by a struct in the stream
3432 ********************************************************************/
3434 uint32 spoolss_size_printmonitor_info_1(PRINTMONITOR_1 *info)
3437 size+=size_of_relative_string( &info->name );
3442 /*******************************************************************
3443 return the size required by a struct in the stream
3444 ********************************************************************/
3446 uint32 spoolss_size_printmonitor_info_2(PRINTMONITOR_2 *info)
3449 size+=size_of_relative_string( &info->name);
3450 size+=size_of_relative_string( &info->environment);
3451 size+=size_of_relative_string( &info->dll_name);
3456 /*******************************************************************
3458 ********************************************************************/
3460 BOOL make_spoolss_q_getprinterdriver2(SPOOL_Q_GETPRINTERDRIVER2 *q_u,
3461 const POLICY_HND *hnd,
3462 const fstring architecture,
3463 uint32 level, uint32 clientmajor, uint32 clientminor,
3464 RPC_BUFFER *buffer, uint32 offered)
3469 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3471 init_buf_unistr2(&q_u->architecture, &q_u->architecture_ptr, architecture);
3474 q_u->clientmajorversion=clientmajor;
3475 q_u->clientminorversion=clientminor;
3478 q_u->offered=offered;
3483 /*******************************************************************
3485 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3486 ********************************************************************/
3488 BOOL spoolss_io_q_getprinterdriver2(const char *desc, SPOOL_Q_GETPRINTERDRIVER2 *q_u, prs_struct *ps, int depth)
3490 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriver2");
3496 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3498 if(!prs_uint32("architecture_ptr", ps, depth, &q_u->architecture_ptr))
3500 if(!smb_io_unistr2("architecture", &q_u->architecture, q_u->architecture_ptr, ps, depth))
3505 if(!prs_uint32("level", ps, depth, &q_u->level))
3508 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3514 if(!prs_uint32("offered", ps, depth, &q_u->offered))
3517 if(!prs_uint32("clientmajorversion", ps, depth, &q_u->clientmajorversion))
3519 if(!prs_uint32("clientminorversion", ps, depth, &q_u->clientminorversion))
3525 /*******************************************************************
3527 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3528 ********************************************************************/
3530 BOOL spoolss_io_r_getprinterdriver2(const char *desc, SPOOL_R_GETPRINTERDRIVER2 *r_u, prs_struct *ps, int depth)
3532 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriver2");
3538 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3543 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3545 if (!prs_uint32("servermajorversion", ps, depth, &r_u->servermajorversion))
3547 if (!prs_uint32("serverminorversion", ps, depth, &r_u->serverminorversion))
3549 if (!prs_werror("status", ps, depth, &r_u->status))
3555 /*******************************************************************
3557 ********************************************************************/
3559 BOOL make_spoolss_q_enumprinters(
3560 SPOOL_Q_ENUMPRINTERS *q_u,
3570 q_u->servername_ptr = (servername != NULL) ? 1 : 0;
3571 init_buf_unistr2(&q_u->servername, &q_u->servername_ptr, servername);
3575 q_u->offered=offered;
3580 /*******************************************************************
3582 ********************************************************************/
3584 BOOL make_spoolss_q_enumports(SPOOL_Q_ENUMPORTS *q_u,
3585 fstring servername, uint32 level,
3586 RPC_BUFFER *buffer, uint32 offered)
3588 q_u->name_ptr = (servername != NULL) ? 1 : 0;
3589 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
3593 q_u->offered=offered;
3598 /*******************************************************************
3600 * called from spoolss_enumprinters (srv_spoolss.c)
3601 ********************************************************************/
3603 BOOL spoolss_io_q_enumprinters(const char *desc, SPOOL_Q_ENUMPRINTERS *q_u, prs_struct *ps, int depth)
3605 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinters");
3611 if (!prs_uint32("flags", ps, depth, &q_u->flags))
3613 if (!prs_uint32("servername_ptr", ps, depth, &q_u->servername_ptr))
3616 if (!smb_io_unistr2("", &q_u->servername, q_u->servername_ptr, ps, depth))
3621 if (!prs_uint32("level", ps, depth, &q_u->level))
3624 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3629 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3635 /*******************************************************************
3636 Parse a SPOOL_R_ENUMPRINTERS structure.
3637 ********************************************************************/
3639 BOOL spoolss_io_r_enumprinters(const char *desc, SPOOL_R_ENUMPRINTERS *r_u, prs_struct *ps, int depth)
3641 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinters");
3647 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3653 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3656 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3659 if (!prs_werror("status", ps, depth, &r_u->status))
3665 /*******************************************************************
3666 * write a structure.
3667 * called from spoolss_r_enum_printers (srv_spoolss.c)
3669 ********************************************************************/
3671 BOOL spoolss_io_r_getprinter(const char *desc, SPOOL_R_GETPRINTER *r_u, prs_struct *ps, int depth)
3673 prs_debug(ps, depth, desc, "spoolss_io_r_getprinter");
3679 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3685 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3688 if (!prs_werror("status", ps, depth, &r_u->status))
3694 /*******************************************************************
3696 * called from spoolss_getprinter (srv_spoolss.c)
3697 ********************************************************************/
3699 BOOL spoolss_io_q_getprinter(const char *desc, SPOOL_Q_GETPRINTER *q_u, prs_struct *ps, int depth)
3701 prs_debug(ps, depth, desc, "spoolss_io_q_getprinter");
3707 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3709 if (!prs_uint32("level", ps, depth, &q_u->level))
3712 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3717 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3723 /*******************************************************************
3725 ********************************************************************/
3727 BOOL make_spoolss_q_getprinter(
3728 TALLOC_CTX *mem_ctx,
3729 SPOOL_Q_GETPRINTER *q_u,
3730 const POLICY_HND *hnd,
3740 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3744 q_u->offered=offered;
3749 /*******************************************************************
3751 ********************************************************************/
3752 BOOL make_spoolss_q_setprinter(TALLOC_CTX *mem_ctx, SPOOL_Q_SETPRINTER *q_u,
3753 const POLICY_HND *hnd, uint32 level, PRINTER_INFO_CTR *info,
3757 DEVICEMODE *devmode;
3762 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3765 q_u->info.level = level;
3766 q_u->info.info_ptr = 1; /* Info is != NULL, see above */
3769 /* There's no such thing as a setprinter level 1 */
3772 secdesc = info->printers_2->secdesc;
3773 devmode = info->printers_2->devmode;
3775 make_spoolss_printer_info_2 (mem_ctx, &q_u->info.info_2, info->printers_2);
3776 #if 1 /* JERRY TEST */
3777 q_u->secdesc_ctr = SMB_MALLOC_P(SEC_DESC_BUF);
3778 if (!q_u->secdesc_ctr)
3780 q_u->secdesc_ctr->ptr = (secdesc != NULL) ? 1: 0;
3781 q_u->secdesc_ctr->max_len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3782 q_u->secdesc_ctr->len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3783 q_u->secdesc_ctr->sec = secdesc;
3785 q_u->devmode_ctr.devmode_ptr = (devmode != NULL) ? 1 : 0;
3786 q_u->devmode_ctr.size = (devmode != NULL) ? sizeof(DEVICEMODE) + (3*sizeof(uint32)) : 0;
3787 q_u->devmode_ctr.devmode = devmode;
3789 q_u->secdesc_ctr = NULL;
3791 q_u->devmode_ctr.devmode_ptr = 0;
3792 q_u->devmode_ctr.size = 0;
3793 q_u->devmode_ctr.devmode = NULL;
3797 secdesc = info->printers_3->secdesc;
3799 make_spoolss_printer_info_3 (mem_ctx, &q_u->info.info_3, info->printers_3);
3801 q_u->secdesc_ctr = SMB_MALLOC_P(SEC_DESC_BUF);
3802 if (!q_u->secdesc_ctr)
3804 q_u->secdesc_ctr->ptr = (secdesc != NULL) ? 1: 0;
3805 q_u->secdesc_ctr->max_len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3806 q_u->secdesc_ctr->len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3807 q_u->secdesc_ctr->sec = secdesc;
3811 make_spoolss_printer_info_7 (mem_ctx, &q_u->info.info_7, info->printers_7);
3815 DEBUG(0,("make_spoolss_q_setprinter: Unknown info level [%d]\n", level));
3820 q_u->command = command;
3826 /*******************************************************************
3827 ********************************************************************/
3829 BOOL spoolss_io_r_setprinter(const char *desc, SPOOL_R_SETPRINTER *r_u, prs_struct *ps, int depth)
3831 prs_debug(ps, depth, desc, "spoolss_io_r_setprinter");
3837 if(!prs_werror("status", ps, depth, &r_u->status))
3843 /*******************************************************************
3844 Marshall/unmarshall a SPOOL_Q_SETPRINTER struct.
3845 ********************************************************************/
3847 BOOL spoolss_io_q_setprinter(const char *desc, SPOOL_Q_SETPRINTER *q_u, prs_struct *ps, int depth)
3849 uint32 ptr_sec_desc = 0;
3851 prs_debug(ps, depth, desc, "spoolss_io_q_setprinter");
3857 if(!smb_io_pol_hnd("printer handle", &q_u->handle ,ps, depth))
3859 if(!prs_uint32("level", ps, depth, &q_u->level))
3862 /* check for supported levels and structures we know about */
3864 switch ( q_u->level ) {
3869 /* supported levels */
3872 DEBUG(0,("spoolss_io_q_setprinter: unsupported printer info level [%d]\n",
3878 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
3881 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
3891 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
3896 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
3902 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
3907 /* Parse a NULL security descriptor. This should really
3908 happen inside the sec_io_desc_buf() function. */
3910 prs_debug(ps, depth, "", "sec_io_desc_buf");
3911 if (!prs_uint32("size", ps, depth + 1, &dummy))
3913 if (!prs_uint32("ptr", ps, depth + 1, &dummy)) return
3917 if(!prs_uint32("command", ps, depth, &q_u->command))
3923 /*******************************************************************
3924 ********************************************************************/
3926 BOOL spoolss_io_r_fcpn(const char *desc, SPOOL_R_FCPN *r_u, prs_struct *ps, int depth)
3928 prs_debug(ps, depth, desc, "spoolss_io_r_fcpn");
3934 if(!prs_werror("status", ps, depth, &r_u->status))
3940 /*******************************************************************
3941 ********************************************************************/
3943 BOOL spoolss_io_q_fcpn(const char *desc, SPOOL_Q_FCPN *q_u, prs_struct *ps, int depth)
3946 prs_debug(ps, depth, desc, "spoolss_io_q_fcpn");
3952 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
3959 /*******************************************************************
3960 ********************************************************************/
3962 BOOL spoolss_io_r_addjob(const char *desc, SPOOL_R_ADDJOB *r_u, prs_struct *ps, int depth)
3964 prs_debug(ps, depth, desc, "");
3970 if(!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3976 if(!prs_uint32("needed", ps, depth, &r_u->needed))
3979 if(!prs_werror("status", ps, depth, &r_u->status))
3985 /*******************************************************************
3986 ********************************************************************/
3988 BOOL spoolss_io_q_addjob(const char *desc, SPOOL_Q_ADDJOB *q_u, prs_struct *ps, int depth)
3990 prs_debug(ps, depth, desc, "");
3996 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3998 if(!prs_uint32("level", ps, depth, &q_u->level))
4001 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4007 if(!prs_uint32("offered", ps, depth, &q_u->offered))
4013 /*******************************************************************
4014 ********************************************************************/
4016 BOOL spoolss_io_r_enumjobs(const char *desc, SPOOL_R_ENUMJOBS *r_u, prs_struct *ps, int depth)
4018 prs_debug(ps, depth, desc, "spoolss_io_r_enumjobs");
4024 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4030 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4033 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4036 if (!prs_werror("status", ps, depth, &r_u->status))
4042 /*******************************************************************
4043 ********************************************************************/
4045 BOOL make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS *q_u, const POLICY_HND *hnd,
4056 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
4057 q_u->firstjob = firstjob;
4058 q_u->numofjobs = numofjobs;
4060 q_u->buffer= buffer;
4061 q_u->offered = offered;
4065 /*******************************************************************
4066 ********************************************************************/
4068 BOOL spoolss_io_q_enumjobs(const char *desc, SPOOL_Q_ENUMJOBS *q_u, prs_struct *ps, int depth)
4070 prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs");
4076 if (!smb_io_pol_hnd("printer handle",&q_u->handle, ps, depth))
4079 if (!prs_uint32("firstjob", ps, depth, &q_u->firstjob))
4081 if (!prs_uint32("numofjobs", ps, depth, &q_u->numofjobs))
4083 if (!prs_uint32("level", ps, depth, &q_u->level))
4086 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4092 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4098 /*******************************************************************
4099 ********************************************************************/
4101 BOOL spoolss_io_r_schedulejob(const char *desc, SPOOL_R_SCHEDULEJOB *r_u, prs_struct *ps, int depth)
4103 prs_debug(ps, depth, desc, "spoolss_io_r_schedulejob");
4109 if(!prs_werror("status", ps, depth, &r_u->status))
4115 /*******************************************************************
4116 ********************************************************************/
4118 BOOL spoolss_io_q_schedulejob(const char *desc, SPOOL_Q_SCHEDULEJOB *q_u, prs_struct *ps, int depth)
4120 prs_debug(ps, depth, desc, "spoolss_io_q_schedulejob");
4126 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4128 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
4134 /*******************************************************************
4135 ********************************************************************/
4137 BOOL spoolss_io_r_setjob(const char *desc, SPOOL_R_SETJOB *r_u, prs_struct *ps, int depth)
4139 prs_debug(ps, depth, desc, "spoolss_io_r_setjob");
4145 if(!prs_werror("status", ps, depth, &r_u->status))
4151 /*******************************************************************
4152 ********************************************************************/
4154 BOOL spoolss_io_q_setjob(const char *desc, SPOOL_Q_SETJOB *q_u, prs_struct *ps, int depth)
4156 prs_debug(ps, depth, desc, "spoolss_io_q_setjob");
4162 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4164 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
4167 * level is usually 0. If (level!=0) then I'm in trouble !
4168 * I will try to generate setjob command with level!=0, one day.
4170 if(!prs_uint32("level", ps, depth, &q_u->level))
4172 if(!prs_uint32("command", ps, depth, &q_u->command))
4178 /*******************************************************************
4179 Parse a SPOOL_R_ENUMPRINTERDRIVERS structure.
4180 ********************************************************************/
4182 BOOL spoolss_io_r_enumprinterdrivers(const char *desc, SPOOL_R_ENUMPRINTERDRIVERS *r_u, prs_struct *ps, int depth)
4184 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdrivers");
4190 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4196 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4199 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4202 if (!prs_werror("status", ps, depth, &r_u->status))
4208 /*******************************************************************
4210 ********************************************************************/
4212 BOOL make_spoolss_q_enumprinterdrivers(SPOOL_Q_ENUMPRINTERDRIVERS *q_u,
4214 const char *environment,
4216 RPC_BUFFER *buffer, uint32 offered)
4218 init_buf_unistr2(&q_u->name, &q_u->name_ptr, name);
4219 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, environment);
4223 q_u->offered=offered;
4228 /*******************************************************************
4229 Parse a SPOOL_Q_ENUMPRINTERDRIVERS structure.
4230 ********************************************************************/
4232 BOOL spoolss_io_q_enumprinterdrivers(const char *desc, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, prs_struct *ps, int depth)
4235 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdrivers");
4241 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
4243 if (!smb_io_unistr2("", &q_u->name, q_u->name_ptr,ps, depth))
4248 if (!prs_uint32("environment_ptr", ps, depth, &q_u->environment_ptr))
4250 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
4255 if (!prs_uint32("level", ps, depth, &q_u->level))
4258 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4264 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4270 /*******************************************************************
4271 ********************************************************************/
4273 BOOL spoolss_io_q_enumforms(const char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth)
4276 prs_debug(ps, depth, desc, "spoolss_io_q_enumforms");
4281 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4283 if (!prs_uint32("level", ps, depth, &q_u->level))
4286 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4291 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4297 /*******************************************************************
4298 ********************************************************************/
4300 BOOL spoolss_io_r_enumforms(const char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth)
4302 prs_debug(ps, depth, desc, "spoolss_io_r_enumforms");
4308 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4314 if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
4317 if (!prs_uint32("numofforms", ps, depth, &r_u->numofforms))
4320 if (!prs_werror("status", ps, depth, &r_u->status))
4326 /*******************************************************************
4327 ********************************************************************/
4329 BOOL spoolss_io_q_getform(const char *desc, SPOOL_Q_GETFORM *q_u, prs_struct *ps, int depth)
4332 prs_debug(ps, depth, desc, "spoolss_io_q_getform");
4337 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4339 if (!smb_io_unistr2("", &q_u->formname,True,ps,depth))
4345 if (!prs_uint32("level", ps, depth, &q_u->level))
4348 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4353 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4359 /*******************************************************************
4360 ********************************************************************/
4362 BOOL spoolss_io_r_getform(const char *desc, SPOOL_R_GETFORM *r_u, prs_struct *ps, int depth)
4364 prs_debug(ps, depth, desc, "spoolss_io_r_getform");
4370 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4376 if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
4379 if (!prs_werror("status", ps, depth, &r_u->status))
4385 /*******************************************************************
4386 Parse a SPOOL_R_ENUMPORTS structure.
4387 ********************************************************************/
4389 BOOL spoolss_io_r_enumports(const char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
4391 prs_debug(ps, depth, desc, "spoolss_io_r_enumports");
4397 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4403 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4406 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4409 if (!prs_werror("status", ps, depth, &r_u->status))
4415 /*******************************************************************
4416 ********************************************************************/
4418 BOOL spoolss_io_q_enumports(const char *desc, SPOOL_Q_ENUMPORTS *q_u, prs_struct *ps, int depth)
4420 prs_debug(ps, depth, desc, "");
4426 if (!prs_uint32("", ps, depth, &q_u->name_ptr))
4428 if (!smb_io_unistr2("", &q_u->name,True,ps,depth))
4433 if (!prs_uint32("level", ps, depth, &q_u->level))
4436 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4441 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4447 /*******************************************************************
4448 Parse a SPOOL_PRINTER_INFO_LEVEL_1 structure.
4449 ********************************************************************/
4451 BOOL spool_io_printer_info_level_1(const char *desc, SPOOL_PRINTER_INFO_LEVEL_1 *il, prs_struct *ps, int depth)
4453 prs_debug(ps, depth, desc, "spool_io_printer_info_level_1");
4459 if(!prs_uint32("flags", ps, depth, &il->flags))
4461 if(!prs_uint32("description_ptr", ps, depth, &il->description_ptr))
4463 if(!prs_uint32("name_ptr", ps, depth, &il->name_ptr))
4465 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4468 if(!smb_io_unistr2("description", &il->description, il->description_ptr, ps, depth))
4470 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4472 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4478 /*******************************************************************
4479 Parse a SPOOL_PRINTER_INFO_LEVEL_3 structure.
4480 ********************************************************************/
4482 BOOL spool_io_printer_info_level_3(const char *desc, SPOOL_PRINTER_INFO_LEVEL_3 *il, prs_struct *ps, int depth)
4484 prs_debug(ps, depth, desc, "spool_io_printer_info_level_3");
4490 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4496 /*******************************************************************
4497 Parse a SPOOL_PRINTER_INFO_LEVEL_2 structure.
4498 ********************************************************************/
4500 BOOL spool_io_printer_info_level_2(const char *desc, SPOOL_PRINTER_INFO_LEVEL_2 *il, prs_struct *ps, int depth)
4502 prs_debug(ps, depth, desc, "spool_io_printer_info_level_2");
4508 if(!prs_uint32("servername_ptr", ps, depth, &il->servername_ptr))
4510 if(!prs_uint32("printername_ptr", ps, depth, &il->printername_ptr))
4512 if(!prs_uint32("sharename_ptr", ps, depth, &il->sharename_ptr))
4514 if(!prs_uint32("portname_ptr", ps, depth, &il->portname_ptr))
4517 if(!prs_uint32("drivername_ptr", ps, depth, &il->drivername_ptr))
4519 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4521 if(!prs_uint32("location_ptr", ps, depth, &il->location_ptr))
4523 if(!prs_uint32("devmode_ptr", ps, depth, &il->devmode_ptr))
4525 if(!prs_uint32("sepfile_ptr", ps, depth, &il->sepfile_ptr))
4527 if(!prs_uint32("printprocessor_ptr", ps, depth, &il->printprocessor_ptr))
4529 if(!prs_uint32("datatype_ptr", ps, depth, &il->datatype_ptr))
4531 if(!prs_uint32("parameters_ptr", ps, depth, &il->parameters_ptr))
4533 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4536 if(!prs_uint32("attributes", ps, depth, &il->attributes))
4538 if(!prs_uint32("priority", ps, depth, &il->priority))
4540 if(!prs_uint32("default_priority", ps, depth, &il->default_priority))
4542 if(!prs_uint32("starttime", ps, depth, &il->starttime))
4544 if(!prs_uint32("untiltime", ps, depth, &il->untiltime))
4546 if(!prs_uint32("status", ps, depth, &il->status))
4548 if(!prs_uint32("cjobs", ps, depth, &il->cjobs))
4550 if(!prs_uint32("averageppm", ps, depth, &il->averageppm))
4553 if(!smb_io_unistr2("servername", &il->servername, il->servername_ptr, ps, depth))
4555 if(!smb_io_unistr2("printername", &il->printername, il->printername_ptr, ps, depth))
4557 if(!smb_io_unistr2("sharename", &il->sharename, il->sharename_ptr, ps, depth))
4559 if(!smb_io_unistr2("portname", &il->portname, il->portname_ptr, ps, depth))
4561 if(!smb_io_unistr2("drivername", &il->drivername, il->drivername_ptr, ps, depth))
4563 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4565 if(!smb_io_unistr2("location", &il->location, il->location_ptr, ps, depth))
4567 if(!smb_io_unistr2("sepfile", &il->sepfile, il->sepfile_ptr, ps, depth))
4569 if(!smb_io_unistr2("printprocessor", &il->printprocessor, il->printprocessor_ptr, ps, depth))
4571 if(!smb_io_unistr2("datatype", &il->datatype, il->datatype_ptr, ps, depth))
4573 if(!smb_io_unistr2("parameters", &il->parameters, il->parameters_ptr, ps, depth))
4579 BOOL spool_io_printer_info_level_7(const char *desc, SPOOL_PRINTER_INFO_LEVEL_7 *il, prs_struct *ps, int depth)
4581 prs_debug(ps, depth, desc, "spool_io_printer_info_level_7");
4587 if(!prs_uint32("guid_ptr", ps, depth, &il->guid_ptr))
4589 if(!prs_uint32("action", ps, depth, &il->action))
4592 if(!smb_io_unistr2("servername", &il->guid, il->guid_ptr, ps, depth))
4597 /*******************************************************************
4598 ********************************************************************/
4600 BOOL spool_io_printer_info_level(const char *desc, SPOOL_PRINTER_INFO_LEVEL *il, prs_struct *ps, int depth)
4602 prs_debug(ps, depth, desc, "spool_io_printer_info_level");
4607 if(!prs_uint32("level", ps, depth, &il->level))
4609 if(!prs_uint32("info_ptr", ps, depth, &il->info_ptr))
4612 /* if no struct inside just return */
4613 if (il->info_ptr==0) {
4614 if (UNMARSHALLING(ps)) {
4621 switch (il->level) {
4623 * level 0 is used by setprinter when managing the queue
4624 * (hold, stop, start a queue)
4628 /* DOCUMENT ME!!! What is level 1 used for? */
4631 if (UNMARSHALLING(ps)) {
4632 if ((il->info_1=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_1,1)) == NULL)
4635 if (!spool_io_printer_info_level_1("", il->info_1, ps, depth))
4640 * level 2 is used by addprinter
4641 * and by setprinter when updating printer's info
4644 if (UNMARSHALLING(ps)) {
4645 if ((il->info_2=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_2,1)) == NULL)
4648 if (!spool_io_printer_info_level_2("", il->info_2, ps, depth))
4651 /* DOCUMENT ME!!! What is level 3 used for? */
4654 if (UNMARSHALLING(ps)) {
4655 if ((il->info_3=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_3,1)) == NULL)
4658 if (!spool_io_printer_info_level_3("", il->info_3, ps, depth))
4663 if (UNMARSHALLING(ps))
4664 if ((il->info_7=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_7,1)) == NULL)
4666 if (!spool_io_printer_info_level_7("", il->info_7, ps, depth))
4674 /*******************************************************************
4675 ********************************************************************/
4677 BOOL spoolss_io_q_addprinterex(const char *desc, SPOOL_Q_ADDPRINTEREX *q_u, prs_struct *ps, int depth)
4679 uint32 ptr_sec_desc = 0;
4681 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterex");
4687 if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->server_name))
4689 if (!prs_io_unistr2("servername", ps, depth, q_u->server_name))
4695 if(!prs_uint32("info_level", ps, depth, &q_u->level))
4698 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
4701 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
4707 switch (q_u->level) {
4709 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
4712 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
4716 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
4721 /* Parse a NULL security descriptor. This should really
4722 happen inside the sec_io_desc_buf() function. */
4724 prs_debug(ps, depth, "", "sec_io_desc_buf");
4725 if (!prs_uint32("size", ps, depth + 1, &dummy))
4727 if (!prs_uint32("ptr", ps, depth + 1, &dummy))
4731 if(!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
4733 if(!spool_io_user_level("", &q_u->user_ctr, ps, depth))
4739 /*******************************************************************
4740 ********************************************************************/
4742 BOOL spoolss_io_r_addprinterex(const char *desc, SPOOL_R_ADDPRINTEREX *r_u,
4743 prs_struct *ps, int depth)
4745 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterex");
4748 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
4751 if(!prs_werror("status", ps, depth, &r_u->status))
4757 /*******************************************************************
4758 ********************************************************************/
4760 BOOL spool_io_printer_driver_info_level_3(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **q_u,
4761 prs_struct *ps, int depth)
4763 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *il;
4765 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_3");
4769 if (UNMARSHALLING(ps)) {
4770 il=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_DRIVER_INFO_LEVEL_3,1);
4782 if(!prs_uint32("cversion", ps, depth, &il->cversion))
4784 if(!prs_uint32("name", ps, depth, &il->name_ptr))
4786 if(!prs_uint32("environment", ps, depth, &il->environment_ptr))
4788 if(!prs_uint32("driverpath", ps, depth, &il->driverpath_ptr))
4790 if(!prs_uint32("datafile", ps, depth, &il->datafile_ptr))
4792 if(!prs_uint32("configfile", ps, depth, &il->configfile_ptr))
4794 if(!prs_uint32("helpfile", ps, depth, &il->helpfile_ptr))
4796 if(!prs_uint32("monitorname", ps, depth, &il->monitorname_ptr))
4798 if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
4800 if(!prs_uint32("dependentfilessize", ps, depth, &il->dependentfilessize))
4802 if(!prs_uint32("dependentfiles", ps, depth, &il->dependentfiles_ptr))
4808 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4810 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
4812 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
4814 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
4816 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
4818 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
4820 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
4822 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
4828 if (il->dependentfiles_ptr)
4829 smb_io_buffer5("", &il->dependentfiles, ps, depth);
4834 /*******************************************************************
4835 parse a SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 structure
4836 ********************************************************************/
4838 BOOL spool_io_printer_driver_info_level_6(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 **q_u,
4839 prs_struct *ps, int depth)
4841 SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *il;
4843 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_6");
4847 if (UNMARSHALLING(ps)) {
4848 il=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_DRIVER_INFO_LEVEL_6,1);
4861 * I know this seems weird, but I have no other explanation.
4862 * This is observed behavior on both NT4 and 2K servers.
4866 if (!prs_align_uint64(ps))
4869 /* parse the main elements the packet */
4871 if(!prs_uint32("cversion ", ps, depth, &il->version))
4873 if(!prs_uint32("name ", ps, depth, &il->name_ptr))
4875 if(!prs_uint32("environment ", ps, depth, &il->environment_ptr))
4877 if(!prs_uint32("driverpath ", ps, depth, &il->driverpath_ptr))
4879 if(!prs_uint32("datafile ", ps, depth, &il->datafile_ptr))
4881 if(!prs_uint32("configfile ", ps, depth, &il->configfile_ptr))
4883 if(!prs_uint32("helpfile ", ps, depth, &il->helpfile_ptr))
4885 if(!prs_uint32("monitorname ", ps, depth, &il->monitorname_ptr))
4887 if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
4889 if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_len))
4891 if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_ptr))
4893 if(!prs_uint32("previousnames ", ps, depth, &il->previousnames_len))
4895 if(!prs_uint32("previousnames ", ps, depth, &il->previousnames_ptr))
4897 if(!smb_io_time("driverdate ", &il->driverdate, ps, depth))
4899 if(!prs_uint32("dummy4 ", ps, depth, &il->dummy4))
4901 if(!prs_uint64("driverversion ", ps, depth, &il->driverversion))
4903 if(!prs_uint32("mfgname ", ps, depth, &il->mfgname_ptr))
4905 if(!prs_uint32("oemurl ", ps, depth, &il->oemurl_ptr))
4907 if(!prs_uint32("hardwareid ", ps, depth, &il->hardwareid_ptr))
4909 if(!prs_uint32("provider ", ps, depth, &il->provider_ptr))
4912 /* parse the structures in the packet */
4914 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4919 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
4924 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
4929 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
4934 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
4939 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
4944 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
4949 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
4953 if (il->dependentfiles_ptr) {
4954 if(!smb_io_buffer5("dependentfiles", &il->dependentfiles, ps, depth))
4959 if (il->previousnames_ptr) {
4960 if(!smb_io_buffer5("previousnames", &il->previousnames, ps, depth))
4965 if(!smb_io_unistr2("mfgname", &il->mfgname, il->mfgname_ptr, ps, depth))
4969 if(!smb_io_unistr2("oemurl", &il->oemurl, il->oemurl_ptr, ps, depth))
4973 if(!smb_io_unistr2("hardwareid", &il->hardwareid, il->hardwareid_ptr, ps, depth))
4977 if(!smb_io_unistr2("provider", &il->provider, il->provider_ptr, ps, depth))
4983 /*******************************************************************
4984 convert a buffer of UNICODE strings null terminated
4985 the buffer is terminated by a NULL
4987 convert to an dos codepage array (null terminated)
4989 dynamically allocate memory
4991 ********************************************************************/
4992 static BOOL uniarray_2_dosarray(BUFFER5 *buf5, fstring **ar)
5001 src = (char *)buf5->buffer;
5004 while (src < ((char *)buf5->buffer) + buf5->buf_len*2) {
5005 rpcstr_pull(f, src, sizeof(f)-1, -1, STR_TERMINATE);
5006 src = skip_unibuf(src, 2*buf5->buf_len - PTR_DIFF(src,buf5->buffer));
5007 *ar = SMB_REALLOC_ARRAY(*ar, fstring, n+2);
5010 fstrcpy((*ar)[n], f);
5013 fstrcpy((*ar)[n], "");
5021 /*******************************************************************
5022 read a UNICODE array with null terminated strings
5023 and null terminated array
5024 and size of array at beginning
5025 ********************************************************************/
5027 BOOL smb_io_unibuffer(const char *desc, UNISTR2 *buffer, prs_struct *ps, int depth)
5029 if (buffer==NULL) return False;
5032 buffer->uni_str_len=buffer->uni_max_len;
5034 if(!prs_uint32("buffer_size", ps, depth, &buffer->uni_max_len))
5037 if(!prs_unistr2(True, "buffer ", ps, depth, buffer))
5043 /*******************************************************************
5044 ********************************************************************/
5046 BOOL spool_io_printer_driver_info_level(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL *il, prs_struct *ps, int depth)
5048 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level");
5053 if(!prs_uint32("level", ps, depth, &il->level))
5055 if(!prs_uint32("ptr", ps, depth, &il->ptr))
5061 switch (il->level) {
5063 if(!spool_io_printer_driver_info_level_3("", &il->info_3, ps, depth))
5067 if(!spool_io_printer_driver_info_level_6("", &il->info_6, ps, depth))
5077 /*******************************************************************
5078 init a SPOOL_Q_ADDPRINTERDRIVER struct
5079 ******************************************************************/
5081 BOOL make_spoolss_q_addprinterdriver(TALLOC_CTX *mem_ctx,
5082 SPOOL_Q_ADDPRINTERDRIVER *q_u, const char* srv_name,
5083 uint32 level, PRINTER_DRIVER_CTR *info)
5085 DEBUG(5,("make_spoolss_q_addprinterdriver\n"));
5087 if (!srv_name || !info) {
5091 q_u->server_name_ptr = 1; /* srv_name is != NULL, see above */
5092 init_unistr2(&q_u->server_name, srv_name, UNI_STR_TERMINATE);
5096 q_u->info.level = level;
5097 q_u->info.ptr = 1; /* Info is != NULL, see above */
5100 /* info level 3 is supported by Windows 95/98, WinNT and Win2k */
5102 make_spoolss_driver_info_3(mem_ctx, &q_u->info.info_3, info->info3);
5106 DEBUG(0,("make_spoolss_q_addprinterdriver: Unknown info level [%d]\n", level));
5113 BOOL make_spoolss_driver_info_3(TALLOC_CTX *mem_ctx,
5114 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **spool_drv_info,
5115 DRIVER_INFO_3 *info3)
5118 uint16 *ptr = info3->dependentfiles;
5120 BOOL null_char = False;
5121 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *inf;
5123 if (!(inf=TALLOC_ZERO_P(mem_ctx, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3)))
5126 inf->cversion = info3->version;
5127 inf->name_ptr = (info3->name.buffer!=NULL)?1:0;
5128 inf->environment_ptr = (info3->architecture.buffer!=NULL)?1:0;
5129 inf->driverpath_ptr = (info3->driverpath.buffer!=NULL)?1:0;
5130 inf->datafile_ptr = (info3->datafile.buffer!=NULL)?1:0;
5131 inf->configfile_ptr = (info3->configfile.buffer!=NULL)?1:0;
5132 inf->helpfile_ptr = (info3->helpfile.buffer!=NULL)?1:0;
5133 inf->monitorname_ptr = (info3->monitorname.buffer!=NULL)?1:0;
5134 inf->defaultdatatype_ptr = (info3->defaultdatatype.buffer!=NULL)?1:0;
5136 init_unistr2_from_unistr(&inf->name, &info3->name);
5137 init_unistr2_from_unistr(&inf->environment, &info3->architecture);
5138 init_unistr2_from_unistr(&inf->driverpath, &info3->driverpath);
5139 init_unistr2_from_unistr(&inf->datafile, &info3->datafile);
5140 init_unistr2_from_unistr(&inf->configfile, &info3->configfile);
5141 init_unistr2_from_unistr(&inf->helpfile, &info3->helpfile);
5142 init_unistr2_from_unistr(&inf->monitorname, &info3->monitorname);
5143 init_unistr2_from_unistr(&inf->defaultdatatype, &info3->defaultdatatype);
5150 /* the null_char BOOL is used to help locate
5151 two '\0's back to back */
5166 inf->dependentfiles_ptr = (info3->dependentfiles != NULL) ? 1 : 0;
5167 inf->dependentfilessize = len;
5168 if(!make_spoolss_buffer5(mem_ctx, &inf->dependentfiles, len, info3->dependentfiles))
5174 *spool_drv_info = inf;
5179 /*******************************************************************
5180 make a BUFFER5 struct from a uint16*
5181 ******************************************************************/
5182 BOOL make_spoolss_buffer5(TALLOC_CTX *mem_ctx, BUFFER5 *buf5, uint32 len, uint16 *src)
5185 buf5->buf_len = len;
5186 if((buf5->buffer=(uint16*)TALLOC_MEMDUP(mem_ctx, src, sizeof(uint16)*len)) == NULL) {
5187 DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
5194 /*******************************************************************
5195 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
5196 ********************************************************************/
5198 BOOL spoolss_io_q_addprinterdriver(const char *desc, SPOOL_Q_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
5200 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriver");
5206 if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
5208 if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
5213 if(!prs_uint32("info_level", ps, depth, &q_u->level))
5216 if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
5222 /*******************************************************************
5223 ********************************************************************/
5225 BOOL spoolss_io_r_addprinterdriver(const char *desc, SPOOL_R_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
5227 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriver");
5230 if(!prs_werror("status", ps, depth, &q_u->status))
5236 /*******************************************************************
5237 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
5238 ********************************************************************/
5240 BOOL spoolss_io_q_addprinterdriverex(const char *desc, SPOOL_Q_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
5242 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriverex");
5248 if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
5250 if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
5255 if(!prs_uint32("info_level", ps, depth, &q_u->level))
5258 if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
5263 if(!prs_uint32("copy flags", ps, depth, &q_u->copy_flags))
5269 /*******************************************************************
5270 ********************************************************************/
5272 BOOL spoolss_io_r_addprinterdriverex(const char *desc, SPOOL_R_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
5274 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriverex");
5277 if(!prs_werror("status", ps, depth, &q_u->status))
5283 /*******************************************************************
5284 ********************************************************************/
5286 BOOL uni_2_asc_printer_driver_3(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *uni,
5287 NT_PRINTER_DRIVER_INFO_LEVEL_3 **asc)
5289 NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
5291 DEBUG(7,("uni_2_asc_printer_driver_3: Converting from UNICODE to ASCII\n"));
5295 *asc=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
5303 d->cversion=uni->cversion;
5305 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name)-1);
5306 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment)-1);
5307 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath)-1);
5308 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile)-1);
5309 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile)-1);
5310 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile)-1);
5311 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname)-1);
5312 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype)-1);
5314 DEBUGADD(8,( "version: %d\n", d->cversion));
5315 DEBUGADD(8,( "name: %s\n", d->name));
5316 DEBUGADD(8,( "environment: %s\n", d->environment));
5317 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
5318 DEBUGADD(8,( "datafile: %s\n", d->datafile));
5319 DEBUGADD(8,( "configfile: %s\n", d->configfile));
5320 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
5321 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
5322 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5324 if (uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5331 /*******************************************************************
5332 ********************************************************************/
5333 BOOL uni_2_asc_printer_driver_6(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *uni,
5334 NT_PRINTER_DRIVER_INFO_LEVEL_6 **asc)
5336 NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
5338 DEBUG(7,("uni_2_asc_printer_driver_6: Converting from UNICODE to ASCII\n"));
5342 *asc=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
5350 d->version=uni->version;
5352 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name)-1);
5353 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment)-1);
5354 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath)-1);
5355 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile)-1);
5356 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile)-1);
5357 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile)-1);
5358 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname)-1);
5359 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype)-1);
5361 DEBUGADD(8,( "version: %d\n", d->version));
5362 DEBUGADD(8,( "name: %s\n", d->name));
5363 DEBUGADD(8,( "environment: %s\n", d->environment));
5364 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
5365 DEBUGADD(8,( "datafile: %s\n", d->datafile));
5366 DEBUGADD(8,( "configfile: %s\n", d->configfile));
5367 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
5368 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
5369 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5371 if (!uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5373 if (!uniarray_2_dosarray(&uni->previousnames, &d->previousnames ))
5383 BOOL uni_2_asc_printer_info_2(const SPOOL_PRINTER_INFO_LEVEL_2 *uni,
5384 NT_PRINTER_INFO_LEVEL_2 *d)
5386 DEBUG(7,("Converting from UNICODE to ASCII\n"));
5388 d->attributes=uni->attributes;
5389 d->priority=uni->priority;
5390 d->default_priority=uni->default_priority;
5391 d->starttime=uni->starttime;
5392 d->untiltime=uni->untiltime;
5393 d->status=uni->status;
5394 d->cjobs=uni->cjobs;
5396 unistr2_to_ascii(d->servername, &uni->servername, sizeof(d->servername)-1);
5397 unistr2_to_ascii(d->printername, &uni->printername, sizeof(d->printername)-1);
5398 unistr2_to_ascii(d->sharename, &uni->sharename, sizeof(d->sharename)-1);
5399 unistr2_to_ascii(d->portname, &uni->portname, sizeof(d->portname)-1);
5400 unistr2_to_ascii(d->drivername, &uni->drivername, sizeof(d->drivername)-1);
5401 unistr2_to_ascii(d->comment, &uni->comment, sizeof(d->comment)-1);
5402 unistr2_to_ascii(d->location, &uni->location, sizeof(d->location)-1);
5403 unistr2_to_ascii(d->sepfile, &uni->sepfile, sizeof(d->sepfile)-1);
5404 unistr2_to_ascii(d->printprocessor, &uni->printprocessor, sizeof(d->printprocessor)-1);
5405 unistr2_to_ascii(d->datatype, &uni->datatype, sizeof(d->datatype)-1);
5406 unistr2_to_ascii(d->parameters, &uni->parameters, sizeof(d->parameters)-1);
5411 /*******************************************************************
5413 ********************************************************************/
5415 BOOL make_spoolss_q_getprinterdriverdir(SPOOL_Q_GETPRINTERDRIVERDIR *q_u,
5416 fstring servername, fstring env_name, uint32 level,
5417 RPC_BUFFER *buffer, uint32 offered)
5419 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
5420 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, env_name);
5424 q_u->offered=offered;
5429 /*******************************************************************
5430 Parse a SPOOL_Q_GETPRINTERDRIVERDIR structure.
5431 ********************************************************************/
5433 BOOL spoolss_io_q_getprinterdriverdir(const char *desc, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, prs_struct *ps, int depth)
5435 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriverdir");
5440 if(!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5442 if(!smb_io_unistr2("", &q_u->name, q_u->name_ptr, ps, depth))
5448 if(!prs_uint32("", ps, depth, &q_u->environment_ptr))
5450 if(!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5456 if(!prs_uint32("level", ps, depth, &q_u->level))
5459 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5465 if(!prs_uint32("offered", ps, depth, &q_u->offered))
5471 /*******************************************************************
5472 Parse a SPOOL_R_GETPRINTERDRIVERDIR structure.
5473 ********************************************************************/
5475 BOOL spoolss_io_r_getprinterdriverdir(const char *desc, SPOOL_R_GETPRINTERDRIVERDIR *r_u, prs_struct *ps, int depth)
5477 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriverdir");
5483 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5489 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5492 if (!prs_werror("status", ps, depth, &r_u->status))
5498 /*******************************************************************
5499 ********************************************************************/
5501 BOOL spoolss_io_r_enumprintprocessors(const char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
5503 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
5509 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5515 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5518 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5521 if (!prs_werror("status", ps, depth, &r_u->status))
5527 /*******************************************************************
5528 ********************************************************************/
5530 BOOL spoolss_io_q_enumprintprocessors(const char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
5532 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
5538 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5540 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5546 if (!prs_uint32("", ps, depth, &q_u->environment_ptr))
5548 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5554 if (!prs_uint32("level", ps, depth, &q_u->level))
5557 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5563 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5569 /*******************************************************************
5570 ********************************************************************/
5572 BOOL spoolss_io_q_addprintprocessor(const char *desc, SPOOL_Q_ADDPRINTPROCESSOR *q_u, prs_struct *ps, int depth)
5574 prs_debug(ps, depth, desc, "spoolss_io_q_addprintprocessor");
5580 if (!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
5582 if (!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
5587 if (!smb_io_unistr2("environment", &q_u->environment, True, ps, depth))
5592 if (!smb_io_unistr2("path", &q_u->path, True, ps, depth))
5597 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5603 /*******************************************************************
5604 ********************************************************************/
5606 BOOL spoolss_io_r_addprintprocessor(const char *desc, SPOOL_R_ADDPRINTPROCESSOR *r_u, prs_struct *ps, int depth)
5608 prs_debug(ps, depth, desc, "spoolss_io_r_addprintproicessor");
5614 if (!prs_werror("status", ps, depth, &r_u->status))
5620 /*******************************************************************
5621 ********************************************************************/
5623 BOOL spoolss_io_r_enumprintprocdatatypes(const char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u, prs_struct *ps, int depth)
5625 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes");
5631 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5637 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5640 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5643 if (!prs_werror("status", ps, depth, &r_u->status))
5649 /*******************************************************************
5650 ********************************************************************/
5652 BOOL spoolss_io_q_enumprintprocdatatypes(const char *desc, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, prs_struct *ps, int depth)
5654 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocdatatypes");
5660 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5662 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5668 if (!prs_uint32("processor_ptr", ps, depth, &q_u->processor_ptr))
5670 if (!smb_io_unistr2("processor", &q_u->processor, q_u->processor_ptr, ps, depth))
5676 if (!prs_uint32("level", ps, depth, &q_u->level))
5679 if(!prs_rpcbuffer_p("buffer", ps, depth, &q_u->buffer))
5685 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5691 /*******************************************************************
5692 Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
5693 ********************************************************************/
5695 BOOL spoolss_io_q_enumprintmonitors(const char *desc, SPOOL_Q_ENUMPRINTMONITORS *q_u, prs_struct *ps, int depth)
5697 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintmonitors");
5703 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5705 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5711 if (!prs_uint32("level", ps, depth, &q_u->level))
5714 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5720 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5726 /*******************************************************************
5727 ********************************************************************/
5729 BOOL spoolss_io_r_enumprintmonitors(const char *desc, SPOOL_R_ENUMPRINTMONITORS *r_u, prs_struct *ps, int depth)
5731 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintmonitors");
5737 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5743 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5746 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5749 if (!prs_werror("status", ps, depth, &r_u->status))
5755 /*******************************************************************
5756 ********************************************************************/
5758 BOOL spoolss_io_r_enumprinterdata(const char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth)
5760 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata");
5765 if(!prs_uint32("valuesize", ps, depth, &r_u->valuesize))
5768 if (UNMARSHALLING(ps) && r_u->valuesize) {
5769 r_u->value = PRS_ALLOC_MEM(ps, uint16, r_u->valuesize);
5771 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata value\n"));
5776 if(!prs_uint16uni(False, "value", ps, depth, r_u->value, r_u->valuesize ))
5782 if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
5785 if(!prs_uint32("type", ps, depth, &r_u->type))
5788 if(!prs_uint32("datasize", ps, depth, &r_u->datasize))
5791 if (UNMARSHALLING(ps) && r_u->datasize) {
5792 r_u->data = PRS_ALLOC_MEM(ps, uint8, r_u->datasize);
5794 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata data\n"));
5799 if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
5804 if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
5806 if(!prs_werror("status", ps, depth, &r_u->status))
5812 /*******************************************************************
5813 ********************************************************************/
5815 BOOL spoolss_io_q_enumprinterdata(const char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
5817 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
5822 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
5824 if(!prs_uint32("index", ps, depth, &q_u->index))
5826 if(!prs_uint32("valuesize", ps, depth, &q_u->valuesize))
5828 if(!prs_uint32("datasize", ps, depth, &q_u->datasize))
5834 /*******************************************************************
5835 ********************************************************************/
5837 BOOL make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u,
5838 const POLICY_HND *hnd,
5839 uint32 idx, uint32 valuelen, uint32 datalen)
5841 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5843 q_u->valuesize=valuelen;
5844 q_u->datasize=datalen;
5849 /*******************************************************************
5850 ********************************************************************/
5852 BOOL make_spoolss_q_enumprinterdataex(SPOOL_Q_ENUMPRINTERDATAEX *q_u,
5853 const POLICY_HND *hnd, const char *key,
5856 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5857 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
5863 /*******************************************************************
5864 ********************************************************************/
5865 BOOL make_spoolss_q_setprinterdata(SPOOL_Q_SETPRINTERDATA *q_u, const POLICY_HND *hnd,
5866 char* value, uint32 data_type, char* data, uint32 data_size)
5868 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5869 q_u->type = data_type;
5870 init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
5872 q_u->max_len = q_u->real_len = data_size;
5873 q_u->data = (unsigned char *)data;
5878 /*******************************************************************
5879 ********************************************************************/
5880 BOOL make_spoolss_q_setprinterdataex(SPOOL_Q_SETPRINTERDATAEX *q_u, const POLICY_HND *hnd,
5881 char *key, char* value, uint32 data_type, char* data,
5884 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5885 q_u->type = data_type;
5886 init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
5887 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
5889 q_u->max_len = q_u->real_len = data_size;
5890 q_u->data = (unsigned char *)data;
5895 /*******************************************************************
5896 ********************************************************************/
5898 BOOL spoolss_io_q_setprinterdata(const char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
5900 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
5905 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5907 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
5913 if(!prs_uint32("type", ps, depth, &q_u->type))
5916 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
5926 if (UNMARSHALLING(ps))
5927 q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
5928 if(q_u->data == NULL)
5930 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
5938 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
5944 /*******************************************************************
5945 ********************************************************************/
5947 BOOL spoolss_io_r_setprinterdata(const char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
5949 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
5954 if(!prs_werror("status", ps, depth, &r_u->status))
5960 /*******************************************************************
5961 ********************************************************************/
5962 BOOL spoolss_io_q_resetprinter(const char *desc, SPOOL_Q_RESETPRINTER *q_u, prs_struct *ps, int depth)
5964 prs_debug(ps, depth, desc, "spoolss_io_q_resetprinter");
5969 if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5972 if (!prs_uint32("datatype_ptr", ps, depth, &q_u->datatype_ptr))
5975 if (q_u->datatype_ptr) {
5976 if (!smb_io_unistr2("datatype", &q_u->datatype, q_u->datatype_ptr?True:False, ps, depth))
5980 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
5987 /*******************************************************************
5988 ********************************************************************/
5989 BOOL spoolss_io_r_resetprinter(const char *desc, SPOOL_R_RESETPRINTER *r_u, prs_struct *ps, int depth)
5991 prs_debug(ps, depth, desc, "spoolss_io_r_resetprinter");
5996 if(!prs_werror("status", ps, depth, &r_u->status))
6002 /*******************************************************************
6003 ********************************************************************/
6005 static BOOL spoolss_io_addform(const char *desc, FORM *f, uint32 ptr, prs_struct *ps, int depth)
6007 prs_debug(ps, depth, desc, "spoolss_io_addform");
6014 if(!prs_uint32("flags", ps, depth, &f->flags))
6016 if(!prs_uint32("name_ptr", ps, depth, &f->name_ptr))
6018 if(!prs_uint32("size_x", ps, depth, &f->size_x))
6020 if(!prs_uint32("size_y", ps, depth, &f->size_y))
6022 if(!prs_uint32("left", ps, depth, &f->left))
6024 if(!prs_uint32("top", ps, depth, &f->top))
6026 if(!prs_uint32("right", ps, depth, &f->right))
6028 if(!prs_uint32("bottom", ps, depth, &f->bottom))
6031 if(!smb_io_unistr2("", &f->name, f->name_ptr, ps, depth))
6038 /*******************************************************************
6039 ********************************************************************/
6041 BOOL spoolss_io_q_deleteform(const char *desc, SPOOL_Q_DELETEFORM *q_u, prs_struct *ps, int depth)
6043 prs_debug(ps, depth, desc, "spoolss_io_q_deleteform");
6048 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6050 if(!smb_io_unistr2("form name", &q_u->name, True, ps, depth))
6056 /*******************************************************************
6057 ********************************************************************/
6059 BOOL spoolss_io_r_deleteform(const char *desc, SPOOL_R_DELETEFORM *r_u, prs_struct *ps, int depth)
6061 prs_debug(ps, depth, desc, "spoolss_io_r_deleteform");
6066 if(!prs_werror("status", ps, depth, &r_u->status))
6072 /*******************************************************************
6073 ********************************************************************/
6075 BOOL spoolss_io_q_addform(const char *desc, SPOOL_Q_ADDFORM *q_u, prs_struct *ps, int depth)
6077 uint32 useless_ptr=1;
6078 prs_debug(ps, depth, desc, "spoolss_io_q_addform");
6083 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6085 if(!prs_uint32("level", ps, depth, &q_u->level))
6087 if(!prs_uint32("level2", ps, depth, &q_u->level2))
6092 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
6094 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
6101 /*******************************************************************
6102 ********************************************************************/
6104 BOOL spoolss_io_r_addform(const char *desc, SPOOL_R_ADDFORM *r_u, prs_struct *ps, int depth)
6106 prs_debug(ps, depth, desc, "spoolss_io_r_addform");
6111 if(!prs_werror("status", ps, depth, &r_u->status))
6117 /*******************************************************************
6118 ********************************************************************/
6120 BOOL spoolss_io_q_setform(const char *desc, SPOOL_Q_SETFORM *q_u, prs_struct *ps, int depth)
6122 uint32 useless_ptr=1;
6123 prs_debug(ps, depth, desc, "spoolss_io_q_setform");
6128 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6130 if(!smb_io_unistr2("", &q_u->name, True, ps, depth))
6136 if(!prs_uint32("level", ps, depth, &q_u->level))
6138 if(!prs_uint32("level2", ps, depth, &q_u->level2))
6143 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
6145 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
6152 /*******************************************************************
6153 ********************************************************************/
6155 BOOL spoolss_io_r_setform(const char *desc, SPOOL_R_SETFORM *r_u, prs_struct *ps, int depth)
6157 prs_debug(ps, depth, desc, "spoolss_io_r_setform");
6162 if(!prs_werror("status", ps, depth, &r_u->status))
6168 /*******************************************************************
6169 Parse a SPOOL_R_GETJOB structure.
6170 ********************************************************************/
6172 BOOL spoolss_io_r_getjob(const char *desc, SPOOL_R_GETJOB *r_u, prs_struct *ps, int depth)
6174 prs_debug(ps, depth, desc, "spoolss_io_r_getjob");
6180 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
6186 if (!prs_uint32("needed", ps, depth, &r_u->needed))
6189 if (!prs_werror("status", ps, depth, &r_u->status))
6195 /*******************************************************************
6196 Parse a SPOOL_Q_GETJOB structure.
6197 ********************************************************************/
6199 BOOL spoolss_io_q_getjob(const char *desc, SPOOL_Q_GETJOB *q_u, prs_struct *ps, int depth)
6201 prs_debug(ps, depth, desc, "");
6207 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6209 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
6211 if(!prs_uint32("level", ps, depth, &q_u->level))
6214 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
6220 if(!prs_uint32("offered", ps, depth, &q_u->offered))
6226 void free_devmode(DEVICEMODE *devmode)
6228 if (devmode!=NULL) {
6229 SAFE_FREE(devmode->dev_private);
6234 void free_printer_info_1(PRINTER_INFO_1 *printer)
6239 void free_printer_info_2(PRINTER_INFO_2 *printer)
6241 if (printer!=NULL) {
6242 free_devmode(printer->devmode);
6243 printer->devmode = NULL;
6248 void free_printer_info_3(PRINTER_INFO_3 *printer)
6253 void free_printer_info_4(PRINTER_INFO_4 *printer)
6258 void free_printer_info_5(PRINTER_INFO_5 *printer)
6263 void free_printer_info_7(PRINTER_INFO_7 *printer)
6268 void free_job_info_2(JOB_INFO_2 *job)
6271 free_devmode(job->devmode);
6274 /*******************************************************************
6276 ********************************************************************/
6278 BOOL make_spoolss_q_replyopenprinter(SPOOL_Q_REPLYOPENPRINTER *q_u,
6279 const fstring string, uint32 printer, uint32 type)
6284 init_unistr2(&q_u->string, string, UNI_STR_TERMINATE);
6286 q_u->printer=printer;
6295 /*******************************************************************
6296 Parse a SPOOL_Q_REPLYOPENPRINTER structure.
6297 ********************************************************************/
6299 BOOL spoolss_io_q_replyopenprinter(const char *desc, SPOOL_Q_REPLYOPENPRINTER *q_u, prs_struct *ps, int depth)
6301 prs_debug(ps, depth, desc, "spoolss_io_q_replyopenprinter");
6307 if(!smb_io_unistr2("", &q_u->string, True, ps, depth))
6313 if(!prs_uint32("printer", ps, depth, &q_u->printer))
6315 if(!prs_uint32("type", ps, depth, &q_u->type))
6318 if(!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6320 if(!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6326 /*******************************************************************
6327 Parse a SPOOL_R_REPLYOPENPRINTER structure.
6328 ********************************************************************/
6330 BOOL spoolss_io_r_replyopenprinter(const char *desc, SPOOL_R_REPLYOPENPRINTER *r_u, prs_struct *ps, int depth)
6332 prs_debug(ps, depth, desc, "spoolss_io_r_replyopenprinter");
6338 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6341 if (!prs_werror("status", ps, depth, &r_u->status))
6347 /*******************************************************************
6349 ********************************************************************/
6350 BOOL make_spoolss_q_routerreplyprinter(SPOOL_Q_ROUTERREPLYPRINTER *q_u, POLICY_HND *hnd,
6351 uint32 condition, uint32 change_id)
6354 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6356 q_u->condition = condition;
6357 q_u->change_id = change_id;
6360 q_u->unknown1 = 0x1;
6361 memset(q_u->unknown2, 0x0, 5);
6362 q_u->unknown2[0] = 0x1;
6367 /*******************************************************************
6368 Parse a SPOOL_Q_ROUTERREPLYPRINTER structure.
6369 ********************************************************************/
6370 BOOL spoolss_io_q_routerreplyprinter (const char *desc, SPOOL_Q_ROUTERREPLYPRINTER *q_u, prs_struct *ps, int depth)
6373 prs_debug(ps, depth, desc, "spoolss_io_q_routerreplyprinter");
6379 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6382 if (!prs_uint32("condition", ps, depth, &q_u->condition))
6385 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6388 if (!prs_uint32("change_id", ps, depth, &q_u->change_id))
6391 if (!prs_uint8s(False, "dev_private", ps, depth, q_u->unknown2, 5))
6397 /*******************************************************************
6398 Parse a SPOOL_R_ROUTERREPLYPRINTER structure.
6399 ********************************************************************/
6400 BOOL spoolss_io_r_routerreplyprinter (const char *desc, SPOOL_R_ROUTERREPLYPRINTER *r_u, prs_struct *ps, int depth)
6402 prs_debug(ps, depth, desc, "spoolss_io_r_routerreplyprinter");
6408 if (!prs_werror("status", ps, depth, &r_u->status))
6414 /*******************************************************************
6416 ********************************************************************/
6418 BOOL make_spoolss_q_reply_closeprinter(SPOOL_Q_REPLYCLOSEPRINTER *q_u, POLICY_HND *hnd)
6423 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6428 /*******************************************************************
6429 Parse a SPOOL_Q_REPLYCLOSEPRINTER structure.
6430 ********************************************************************/
6432 BOOL spoolss_io_q_replycloseprinter(const char *desc, SPOOL_Q_REPLYCLOSEPRINTER *q_u, prs_struct *ps, int depth)
6434 prs_debug(ps, depth, desc, "spoolss_io_q_replycloseprinter");
6440 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6446 /*******************************************************************
6447 Parse a SPOOL_R_REPLYCLOSEPRINTER structure.
6448 ********************************************************************/
6450 BOOL spoolss_io_r_replycloseprinter(const char *desc, SPOOL_R_REPLYCLOSEPRINTER *r_u, prs_struct *ps, int depth)
6452 prs_debug(ps, depth, desc, "spoolss_io_r_replycloseprinter");
6458 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6461 if (!prs_werror("status", ps, depth, &r_u->status))
6467 #if 0 /* JERRY - not currently used but could be :-) */
6469 /*******************************************************************
6470 Deep copy a SPOOL_NOTIFY_INFO_DATA structure
6471 ******************************************************************/
6472 static BOOL copy_spool_notify_info_data(SPOOL_NOTIFY_INFO_DATA *dst,
6473 SPOOL_NOTIFY_INFO_DATA *src, int n)
6477 memcpy(dst, src, sizeof(SPOOL_NOTIFY_INFO_DATA)*n);
6479 for (i=0; i<n; i++) {
6483 if (src->size != POINTER)
6485 len = src->notify_data.data.length;
6486 s = SMB_MALLOC_ARRAY(uint16, len);
6488 DEBUG(0,("copy_spool_notify_info_data: malloc() failed!\n"));
6492 memcpy(s, src->notify_data.data.string, len*2);
6493 dst->notify_data.data.string = s;
6499 /*******************************************************************
6500 Deep copy a SPOOL_NOTIFY_INFO structure
6501 ******************************************************************/
6502 static BOOL copy_spool_notify_info(SPOOL_NOTIFY_INFO *dst, SPOOL_NOTIFY_INFO *src)
6505 DEBUG(0,("copy_spool_notify_info: NULL destination pointer!\n"));
6509 dst->version = src->version;
6510 dst->flags = src->flags;
6511 dst->count = src->count;
6515 dst->data = SMB_MALLOC_ARRAY(SPOOL_NOTIFY_INFO_DATA, dst->count);
6517 DEBUG(10,("copy_spool_notify_info: allocating space for [%d] PRINTER_NOTIFY_INFO_DATA entries\n",
6520 if (dst->data == NULL) {
6521 DEBUG(0,("copy_spool_notify_info: malloc() failed for [%d] entries!\n",
6526 return (copy_spool_notify_info_data(dst->data, src->data, src->count));
6533 /*******************************************************************
6535 ********************************************************************/
6537 BOOL make_spoolss_q_reply_rrpcn(SPOOL_Q_REPLY_RRPCN *q_u, POLICY_HND *hnd,
6538 uint32 change_low, uint32 change_high,
6539 SPOOL_NOTIFY_INFO *info)
6544 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6546 q_u->change_low=change_low;
6547 q_u->change_high=change_high;
6552 q_u->info_ptr=0x0FF0ADDE;
6554 q_u->info.version=2;
6557 DEBUG(10,("make_spoolss_q_reply_rrpcn: [%d] PRINTER_NOTIFY_INFO_DATA\n",
6559 q_u->info.version = info->version;
6560 q_u->info.flags = info->flags;
6561 q_u->info.count = info->count;
6562 /* pointer field - be careful! */
6563 q_u->info.data = info->data;
6566 q_u->info.flags=PRINTER_NOTIFY_INFO_DISCARDED;
6573 /*******************************************************************
6574 Parse a SPOOL_Q_REPLY_RRPCN structure.
6575 ********************************************************************/
6577 BOOL spoolss_io_q_reply_rrpcn(const char *desc, SPOOL_Q_REPLY_RRPCN *q_u, prs_struct *ps, int depth)
6579 prs_debug(ps, depth, desc, "spoolss_io_q_reply_rrpcn");
6585 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6588 if (!prs_uint32("change_low", ps, depth, &q_u->change_low))
6591 if (!prs_uint32("change_high", ps, depth, &q_u->change_high))
6594 if (!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6597 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6600 if (!prs_uint32("info_ptr", ps, depth, &q_u->info_ptr))
6603 if(q_u->info_ptr!=0)
6604 if(!smb_io_notify_info(desc, &q_u->info, ps, depth))
6610 /*******************************************************************
6611 Parse a SPOOL_R_REPLY_RRPCN structure.
6612 ********************************************************************/
6614 BOOL spoolss_io_r_reply_rrpcn(const char *desc, SPOOL_R_REPLY_RRPCN *r_u, prs_struct *ps, int depth)
6616 prs_debug(ps, depth, desc, "spoolss_io_r_reply_rrpcn");
6622 if (!prs_uint32("unknown0", ps, depth, &r_u->unknown0))
6625 if (!prs_werror("status", ps, depth, &r_u->status))
6631 /*******************************************************************
6633 * called from spoolss_q_getprinterdataex (srv_spoolss.c)
6634 ********************************************************************/
6636 BOOL spoolss_io_q_getprinterdataex(const char *desc, SPOOL_Q_GETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6641 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdataex");
6646 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6650 if (!smb_io_unistr2("keyname", &q_u->keyname,True,ps,depth))
6654 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
6658 if (!prs_uint32("size", ps, depth, &q_u->size))
6664 /*******************************************************************
6665 * write a structure.
6666 * called from spoolss_r_getprinterdataex (srv_spoolss.c)
6667 ********************************************************************/
6669 BOOL spoolss_io_r_getprinterdataex(const char *desc, SPOOL_R_GETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6674 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdataex");
6679 if (!prs_uint32("type", ps, depth, &r_u->type))
6681 if (!prs_uint32("size", ps, depth, &r_u->size))
6684 if (UNMARSHALLING(ps) && r_u->size) {
6685 r_u->data = PRS_ALLOC_MEM(ps, unsigned char, r_u->size);
6690 if (!prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size))
6696 if (!prs_uint32("needed", ps, depth, &r_u->needed))
6698 if (!prs_werror("status", ps, depth, &r_u->status))
6704 /*******************************************************************
6706 ********************************************************************/
6708 BOOL spoolss_io_q_setprinterdataex(const char *desc, SPOOL_Q_SETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6710 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdataex");
6715 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6717 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6723 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
6729 if(!prs_uint32("type", ps, depth, &q_u->type))
6732 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
6742 if (UNMARSHALLING(ps))
6743 q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
6744 if(q_u->data == NULL)
6746 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
6754 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
6760 /*******************************************************************
6761 * write a structure.
6762 ********************************************************************/
6764 BOOL spoolss_io_r_setprinterdataex(const char *desc, SPOOL_R_SETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6766 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdataex");
6771 if(!prs_werror("status", ps, depth, &r_u->status))
6777 /*******************************************************************
6779 ********************************************************************/
6780 BOOL make_spoolss_q_enumprinterkey(SPOOL_Q_ENUMPRINTERKEY *q_u,
6781 POLICY_HND *hnd, const char *key,
6784 DEBUG(5,("make_spoolss_q_enumprinterkey\n"));
6786 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6787 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
6793 /*******************************************************************
6795 ********************************************************************/
6797 BOOL spoolss_io_q_enumprinterkey(const char *desc, SPOOL_Q_ENUMPRINTERKEY *q_u, prs_struct *ps, int depth)
6799 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterkey");
6804 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6807 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6813 if(!prs_uint32("size", ps, depth, &q_u->size))
6819 /*******************************************************************
6820 * write a structure.
6821 ********************************************************************/
6823 BOOL spoolss_io_r_enumprinterkey(const char *desc, SPOOL_R_ENUMPRINTERKEY *r_u, prs_struct *ps, int depth)
6825 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterkey");
6831 if (!smb_io_buffer5("", &r_u->keys, ps, depth))
6837 if(!prs_uint32("needed", ps, depth, &r_u->needed))
6840 if(!prs_werror("status", ps, depth, &r_u->status))
6846 /*******************************************************************
6848 ********************************************************************/
6850 BOOL make_spoolss_q_deleteprinterkey(SPOOL_Q_DELETEPRINTERKEY *q_u,
6851 POLICY_HND *hnd, char *keyname)
6853 DEBUG(5,("make_spoolss_q_deleteprinterkey\n"));
6855 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6856 init_unistr2(&q_u->keyname, keyname, UNI_STR_TERMINATE);
6861 /*******************************************************************
6863 ********************************************************************/
6865 BOOL spoolss_io_q_deleteprinterkey(const char *desc, SPOOL_Q_DELETEPRINTERKEY *q_u, prs_struct *ps, int depth)
6867 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterkey");
6872 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6875 if(!smb_io_unistr2("", &q_u->keyname, True, ps, depth))
6881 /*******************************************************************
6882 * write a structure.
6883 ********************************************************************/
6885 BOOL spoolss_io_r_deleteprinterkey(const char *desc, SPOOL_R_DELETEPRINTERKEY *r_u, prs_struct *ps, int depth)
6887 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterkey");
6893 if(!prs_werror("status", ps, depth, &r_u->status))
6900 /*******************************************************************
6902 ********************************************************************/
6904 BOOL spoolss_io_q_enumprinterdataex(const char *desc, SPOOL_Q_ENUMPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6906 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdataex");
6911 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6914 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6920 if(!prs_uint32("size", ps, depth, &q_u->size))
6926 /*******************************************************************
6927 ********************************************************************/
6929 static BOOL spoolss_io_printer_enum_values_ctr(const char *desc, prs_struct *ps,
6930 PRINTER_ENUM_VALUES_CTR *ctr, int depth)
6933 uint32 valuename_offset,
6936 const uint32 basic_unit = 20; /* size of static portion of enum_values */
6938 prs_debug(ps, depth, desc, "spoolss_io_printer_enum_values_ctr");
6942 * offset data begins at 20 bytes per structure * size_of_array.
6943 * Don't forget the uint32 at the beginning
6946 current_offset = basic_unit * ctr->size_of_array;
6948 /* first loop to write basic enum_value information */
6950 if (UNMARSHALLING(ps)) {
6951 ctr->values = PRS_ALLOC_MEM(ps, PRINTER_ENUM_VALUES, ctr->size_of_array);
6956 for (i=0; i<ctr->size_of_array; i++) {
6957 valuename_offset = current_offset;
6958 if (!prs_uint32("valuename_offset", ps, depth, &valuename_offset))
6961 if (!prs_uint32("value_len", ps, depth, &ctr->values[i].value_len))
6964 if (!prs_uint32("type", ps, depth, &ctr->values[i].type))
6967 data_offset = ctr->values[i].value_len + valuename_offset;
6969 if (!prs_uint32("data_offset", ps, depth, &data_offset))
6972 if (!prs_uint32("data_len", ps, depth, &ctr->values[i].data_len))
6975 current_offset = data_offset + ctr->values[i].data_len - basic_unit;
6976 /* account for 2 byte alignment */
6977 current_offset += (current_offset % 2);
6981 * loop #2 for writing the dynamically size objects; pay
6982 * attention to 2-byte alignment here....
6985 for (i=0; i<ctr->size_of_array; i++) {
6987 if (!prs_unistr("valuename", ps, depth, &ctr->values[i].valuename))
6990 if ( ctr->values[i].data_len ) {
6991 if ( UNMARSHALLING(ps) ) {
6992 ctr->values[i].data = PRS_ALLOC_MEM(ps, uint8, ctr->values[i].data_len);
6993 if (!ctr->values[i].data)
6996 if (!prs_uint8s(False, "data", ps, depth, ctr->values[i].data, ctr->values[i].data_len))
7000 if ( !prs_align_uint16(ps) )
7007 /*******************************************************************
7008 * write a structure.
7009 ********************************************************************/
7011 BOOL spoolss_io_r_enumprinterdataex(const char *desc, SPOOL_R_ENUMPRINTERDATAEX *r_u, prs_struct *ps, int depth)
7013 uint32 data_offset, end_offset;
7014 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdataex");
7020 if (!prs_uint32("size", ps, depth, &r_u->ctr.size))
7023 data_offset = prs_offset(ps);
7025 if (!prs_set_offset(ps, data_offset + r_u->ctr.size))
7031 if(!prs_uint32("needed", ps, depth, &r_u->needed))
7034 if(!prs_uint32("returned", ps, depth, &r_u->returned))
7037 if(!prs_werror("status", ps, depth, &r_u->status))
7040 r_u->ctr.size_of_array = r_u->returned;
7042 end_offset = prs_offset(ps);
7044 if (!prs_set_offset(ps, data_offset))
7048 if (!spoolss_io_printer_enum_values_ctr("", ps, &r_u->ctr, depth ))
7051 if (!prs_set_offset(ps, end_offset))
7056 /*******************************************************************
7057 * write a structure.
7058 ********************************************************************/
7061 uint32 GetPrintProcessorDirectory(
7063 [in] unistr2 *environment,
7065 [in,out] RPC_BUFFER buffer,
7066 [in] uint32 offered,
7067 [out] uint32 needed,
7068 [out] uint32 returned
7073 BOOL make_spoolss_q_getprintprocessordirectory(SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, const char *name, char *environment, int level, RPC_BUFFER *buffer, uint32 offered)
7075 DEBUG(5,("make_spoolss_q_getprintprocessordirectory\n"));
7077 init_unistr2(&q_u->name, name, UNI_STR_TERMINATE);
7078 init_unistr2(&q_u->environment, environment, UNI_STR_TERMINATE);
7082 q_u->buffer = buffer;
7083 q_u->offered = offered;
7088 BOOL spoolss_io_q_getprintprocessordirectory(const char *desc, SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, prs_struct *ps, int depth)
7092 prs_debug(ps, depth, desc, "spoolss_io_q_getprintprocessordirectory");
7098 if (!prs_uint32("ptr", ps, depth, &ptr))
7102 if(!smb_io_unistr2("name", &q_u->name, True, ps, depth))
7109 if (!prs_uint32("ptr", ps, depth, &ptr))
7113 if(!smb_io_unistr2("environment", &q_u->environment, True,
7121 if(!prs_uint32("level", ps, depth, &q_u->level))
7124 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
7130 if(!prs_uint32("offered", ps, depth, &q_u->offered))
7136 /*******************************************************************
7137 * write a structure.
7138 ********************************************************************/
7140 BOOL spoolss_io_r_getprintprocessordirectory(const char *desc, SPOOL_R_GETPRINTPROCESSORDIRECTORY *r_u, prs_struct *ps, int depth)
7142 prs_debug(ps, depth, desc, "spoolss_io_r_getprintprocessordirectory");
7148 if(!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
7154 if(!prs_uint32("needed", ps, depth, &r_u->needed))
7157 if(!prs_werror("status", ps, depth, &r_u->status))
7163 BOOL smb_io_printprocessordirectory_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_DIRECTORY_1 *info, int depth)
7165 prs_struct *ps=&buffer->prs;
7167 prs_debug(ps, depth, desc, "smb_io_printprocessordirectory_1");
7170 buffer->struct_start=prs_offset(ps);
7172 if (!smb_io_unistr(desc, &info->name, ps, depth))
7178 /*******************************************************************
7180 ********************************************************************/
7182 BOOL make_spoolss_q_addform(SPOOL_Q_ADDFORM *q_u, POLICY_HND *handle,
7183 int level, FORM *form)
7185 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7187 q_u->level2 = level;
7188 memcpy(&q_u->form, form, sizeof(FORM));
7193 /*******************************************************************
7195 ********************************************************************/
7197 BOOL make_spoolss_q_setform(SPOOL_Q_SETFORM *q_u, POLICY_HND *handle,
7198 int level, const char *form_name, FORM *form)
7200 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7202 q_u->level2 = level;
7203 memcpy(&q_u->form, form, sizeof(FORM));
7204 init_unistr2(&q_u->name, form_name, UNI_STR_TERMINATE);
7209 /*******************************************************************
7211 ********************************************************************/
7213 BOOL make_spoolss_q_deleteform(SPOOL_Q_DELETEFORM *q_u, POLICY_HND *handle,
7216 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7217 init_unistr2(&q_u->name, form, UNI_STR_TERMINATE);
7221 /*******************************************************************
7223 ********************************************************************/
7225 BOOL make_spoolss_q_getform(SPOOL_Q_GETFORM *q_u, POLICY_HND *handle,
7226 const char *formname, uint32 level,
7227 RPC_BUFFER *buffer, uint32 offered)
7229 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7231 init_unistr2(&q_u->formname, formname, UNI_STR_TERMINATE);
7233 q_u->offered=offered;
7238 /*******************************************************************
7240 ********************************************************************/
7242 BOOL make_spoolss_q_enumforms(SPOOL_Q_ENUMFORMS *q_u, POLICY_HND *handle,
7243 uint32 level, RPC_BUFFER *buffer,
7246 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7249 q_u->offered=offered;
7254 /*******************************************************************
7256 ********************************************************************/
7258 BOOL make_spoolss_q_setjob(SPOOL_Q_SETJOB *q_u, POLICY_HND *handle,
7259 uint32 jobid, uint32 level, uint32 command)
7261 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7265 /* Hmm - the SPOOL_Q_SETJOB structure has a JOB_INFO ctr in it but
7266 the server side code has it marked as unused. */
7268 q_u->command = command;
7273 /*******************************************************************
7275 ********************************************************************/
7277 BOOL make_spoolss_q_getjob(SPOOL_Q_GETJOB *q_u, POLICY_HND *handle,
7278 uint32 jobid, uint32 level, RPC_BUFFER *buffer,
7281 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7284 q_u->buffer = buffer;
7285 q_u->offered = offered;
7290 /*******************************************************************
7292 ********************************************************************/
7294 BOOL make_spoolss_q_startpageprinter(SPOOL_Q_STARTPAGEPRINTER *q_u,
7297 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7302 /*******************************************************************
7304 ********************************************************************/
7306 BOOL make_spoolss_q_endpageprinter(SPOOL_Q_ENDPAGEPRINTER *q_u,
7309 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7314 /*******************************************************************
7316 ********************************************************************/
7318 BOOL make_spoolss_q_startdocprinter(SPOOL_Q_STARTDOCPRINTER *q_u,
7319 POLICY_HND *handle, uint32 level,
7320 char *docname, char *outputfile,
7323 DOC_INFO_CONTAINER *ctr = &q_u->doc_info_container;
7325 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7331 ctr->docinfo.switch_value = level;
7333 ctr->docinfo.doc_info_1.p_docname = docname ? 1 : 0;
7334 ctr->docinfo.doc_info_1.p_outputfile = outputfile ? 1 : 0;
7335 ctr->docinfo.doc_info_1.p_datatype = datatype ? 1 : 0;
7337 init_unistr2(&ctr->docinfo.doc_info_1.docname, docname, UNI_STR_TERMINATE);
7338 init_unistr2(&ctr->docinfo.doc_info_1.outputfile, outputfile, UNI_STR_TERMINATE);
7339 init_unistr2(&ctr->docinfo.doc_info_1.datatype, datatype, UNI_STR_TERMINATE);
7343 /* DOC_INFO_2 is only used by Windows 9x and since it
7344 doesn't do printing over RPC we don't have to worry
7347 DEBUG(3, ("unsupported info level %d\n", level));
7354 /*******************************************************************
7356 ********************************************************************/
7358 BOOL make_spoolss_q_enddocprinter(SPOOL_Q_ENDDOCPRINTER *q_u,
7361 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7366 /*******************************************************************
7368 ********************************************************************/
7370 BOOL make_spoolss_q_writeprinter(SPOOL_Q_WRITEPRINTER *q_u,
7371 POLICY_HND *handle, uint32 data_size,
7374 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7375 q_u->buffer_size = q_u->buffer_size2 = data_size;
7376 q_u->buffer = (unsigned char *)data;
7380 /*******************************************************************
7382 ********************************************************************/
7384 BOOL make_spoolss_q_deleteprinterdata(SPOOL_Q_DELETEPRINTERDATA *q_u,
7385 POLICY_HND *handle, char *valuename)
7387 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7388 init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
7393 /*******************************************************************
7395 ********************************************************************/
7397 BOOL make_spoolss_q_deleteprinterdataex(SPOOL_Q_DELETEPRINTERDATAEX *q_u,
7398 POLICY_HND *handle, char *key,
7401 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7402 init_unistr2(&q_u->valuename, value, UNI_STR_TERMINATE);
7403 init_unistr2(&q_u->keyname, key, UNI_STR_TERMINATE);
7408 /*******************************************************************
7410 ********************************************************************/
7412 BOOL make_spoolss_q_rffpcnex(SPOOL_Q_RFFPCNEX *q_u, POLICY_HND *handle,
7413 uint32 flags, uint32 options, const char *localmachine,
7414 uint32 printerlocal, SPOOL_NOTIFY_OPTION *option)
7416 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7419 q_u->options = options;
7421 q_u->localmachine_ptr = 1;
7423 init_unistr2(&q_u->localmachine, localmachine, UNI_STR_TERMINATE);
7425 q_u->printerlocal = printerlocal;
7428 q_u->option_ptr = 1;
7430 q_u->option = option;
7436 /*******************************************************************
7437 ********************************************************************/
7439 BOOL spoolss_io_q_xcvdataport(const char *desc, SPOOL_Q_XCVDATAPORT *q_u, prs_struct *ps, int depth)
7441 prs_debug(ps, depth, desc, "spoolss_io_q_xcvdataport");
7447 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
7450 if(!smb_io_unistr2("", &q_u->dataname, True, ps, depth))
7456 if(!prs_rpcbuffer("", ps, depth, &q_u->indata))
7462 if (!prs_uint32("indata_len", ps, depth, &q_u->indata_len))
7464 if (!prs_uint32("offered", ps, depth, &q_u->offered))
7466 if (!prs_uint32("unknown", ps, depth, &q_u->unknown))
7472 /*******************************************************************
7473 ********************************************************************/
7475 BOOL spoolss_io_r_xcvdataport(const char *desc, SPOOL_R_XCVDATAPORT *r_u, prs_struct *ps, int depth)
7477 prs_debug(ps, depth, desc, "spoolss_io_r_xcvdataport");
7482 if(!prs_rpcbuffer("", ps, depth, &r_u->outdata))
7488 if (!prs_uint32("needed", ps, depth, &r_u->needed))
7490 if (!prs_uint32("unknown", ps, depth, &r_u->unknown))
7493 if(!prs_werror("status", ps, depth, &r_u->status))
7499 /*******************************************************************
7500 ********************************************************************/
7502 BOOL make_monitorui_buf( RPC_BUFFER *buf, const char *dllname )
7509 init_unistr( &string, dllname );
7511 if ( !prs_unistr( "ui_dll", &buf->prs, 0, &string ) )
7517 /*******************************************************************
7518 ********************************************************************/
7520 #define PORT_DATA_1_PAD 540
7522 static BOOL smb_io_port_data_1( const char *desc, RPC_BUFFER *buf, int depth, SPOOL_PORT_DATA_1 *p1 )
7524 prs_struct *ps = &buf->prs;
7525 uint8 padding[PORT_DATA_1_PAD];
7527 prs_debug(ps, depth, desc, "smb_io_port_data_1");
7533 if( !prs_uint16s(True, "portname", ps, depth, p1->portname, MAX_PORTNAME))
7536 if (!prs_uint32("version", ps, depth, &p1->version))
7538 if (!prs_uint32("protocol", ps, depth, &p1->protocol))
7540 if (!prs_uint32("size", ps, depth, &p1->size))
7542 if (!prs_uint32("reserved", ps, depth, &p1->reserved))
7545 if( !prs_uint16s(True, "hostaddress", ps, depth, p1->hostaddress, MAX_NETWORK_NAME))
7547 if( !prs_uint16s(True, "snmpcommunity", ps, depth, p1->snmpcommunity, MAX_SNMP_COMM_NAME))
7550 if (!prs_uint32("dblspool", ps, depth, &p1->dblspool))
7553 if( !prs_uint16s(True, "queue", ps, depth, p1->queue, MAX_QUEUE_NAME))
7555 if( !prs_uint16s(True, "ipaddress", ps, depth, p1->ipaddress, MAX_IPADDR_STRING))
7558 if( !prs_uint8s(False, "", ps, depth, padding, PORT_DATA_1_PAD))
7561 if (!prs_uint32("port", ps, depth, &p1->port))
7563 if (!prs_uint32("snmpenabled", ps, depth, &p1->snmpenabled))
7565 if (!prs_uint32("snmpdevindex", ps, depth, &p1->snmpdevindex))
7571 /*******************************************************************
7572 ********************************************************************/
7574 BOOL convert_port_data_1( NT_PORT_DATA_1 *port1, RPC_BUFFER *buf )
7576 SPOOL_PORT_DATA_1 spdata_1;
7578 ZERO_STRUCT( spdata_1 );
7580 if ( !smb_io_port_data_1( "port_data_1", buf, 0, &spdata_1 ) )
7583 rpcstr_pull(port1->name, spdata_1.portname, sizeof(port1->name), -1, 0);
7584 rpcstr_pull(port1->queue, spdata_1.queue, sizeof(port1->queue), -1, 0);
7585 rpcstr_pull(port1->hostaddr, spdata_1.hostaddress, sizeof(port1->hostaddr), -1, 0);
7587 port1->port = spdata_1.port;
7589 switch ( spdata_1.protocol ) {
7591 port1->protocol = PORT_PROTOCOL_DIRECT;
7594 port1->protocol = PORT_PROTOCOL_LPR;
7597 DEBUG(3,("convert_port_data_1: unknown protocol [%d]!\n",
7598 spdata_1.protocol));