2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-2000,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
6 * Copyright (C) Jean François Micouleau 1998-2000,
7 * Copyright (C) Gerald Carter 2000-2002,
8 * Copyright (C) Tim Potter 2001-2002.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 3 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, see <http://www.gnu.org/licenses/>.
27 #define DBGC_CLASS DBGC_RPC_PARSE
30 /*******************************************************************
31 This should be moved in a more generic lib.
32 ********************************************************************/
34 bool spoolss_io_system_time(const char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
36 if(!prs_uint16("year", ps, depth, &systime->year))
38 if(!prs_uint16("month", ps, depth, &systime->month))
40 if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
42 if(!prs_uint16("day", ps, depth, &systime->day))
44 if(!prs_uint16("hour", ps, depth, &systime->hour))
46 if(!prs_uint16("minute", ps, depth, &systime->minute))
48 if(!prs_uint16("second", ps, depth, &systime->second))
50 if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
56 /*******************************************************************
57 ********************************************************************/
59 bool make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
61 systime->year=unixtime->tm_year+1900;
62 systime->month=unixtime->tm_mon+1;
63 systime->dayofweek=unixtime->tm_wday;
64 systime->day=unixtime->tm_mday;
65 systime->hour=unixtime->tm_hour;
66 systime->minute=unixtime->tm_min;
67 systime->second=unixtime->tm_sec;
68 systime->milliseconds=0;
73 /*******************************************************************
74 reads or writes an DOC_INFO structure.
75 ********************************************************************/
77 static bool smb_io_doc_info_1(const char *desc, DOC_INFO_1 *info_1, prs_struct *ps, int depth)
79 if (info_1 == NULL) return False;
81 prs_debug(ps, depth, desc, "smb_io_doc_info_1");
87 if(!prs_uint32("p_docname", ps, depth, &info_1->p_docname))
89 if(!prs_uint32("p_outputfile", ps, depth, &info_1->p_outputfile))
91 if(!prs_uint32("p_datatype", ps, depth, &info_1->p_datatype))
94 if(!smb_io_unistr2("", &info_1->docname, info_1->p_docname, ps, depth))
96 if(!smb_io_unistr2("", &info_1->outputfile, info_1->p_outputfile, ps, depth))
98 if(!smb_io_unistr2("", &info_1->datatype, info_1->p_datatype, ps, depth))
104 /*******************************************************************
105 reads or writes an DOC_INFO structure.
106 ********************************************************************/
108 static bool smb_io_doc_info(const char *desc, DOC_INFO *info, prs_struct *ps, int depth)
110 uint32 useless_ptr=0;
112 if (info == NULL) return False;
114 prs_debug(ps, depth, desc, "smb_io_doc_info");
120 if(!prs_uint32("switch_value", ps, depth, &info->switch_value))
123 if(!prs_uint32("doc_info_X ptr", ps, depth, &useless_ptr))
126 switch (info->switch_value)
129 if(!smb_io_doc_info_1("",&info->doc_info_1, ps, depth))
134 this is just a placeholder
136 MSDN July 1998 says doc_info_2 is only on
137 Windows 95, and as Win95 doesn't do RPC to print
138 this case is nearly impossible
140 Maybe one day with Windows for dishwasher 2037 ...
143 /* smb_io_doc_info_2("",&info->doc_info_2, ps, depth); */
146 DEBUG(0,("Something is obviously wrong somewhere !\n"));
153 /*******************************************************************
154 reads or writes an DOC_INFO_CONTAINER structure.
155 ********************************************************************/
157 static bool smb_io_doc_info_container(const char *desc, DOC_INFO_CONTAINER *cont, prs_struct *ps, int depth)
159 if (cont == NULL) return False;
161 prs_debug(ps, depth, desc, "smb_io_doc_info_container");
167 if(!prs_uint32("level", ps, depth, &cont->level))
170 if(!smb_io_doc_info("",&cont->docinfo, ps, depth))
176 /*******************************************************************
177 reads or writes an NOTIFY OPTION TYPE structure.
178 ********************************************************************/
180 /* NOTIFY_OPTION_TYPE and NOTIFY_OPTION_TYPE_DATA are really one
181 structure. The _TYPE structure is really the deferred referrants (i.e
182 the notify fields array) of the _TYPE structure. -tpot */
184 static bool smb_io_notify_option_type(const char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
186 prs_debug(ps, depth, desc, "smb_io_notify_option_type");
192 if(!prs_uint16("type", ps, depth, &type->type))
194 if(!prs_uint16("reserved0", ps, depth, &type->reserved0))
196 if(!prs_uint32("reserved1", ps, depth, &type->reserved1))
198 if(!prs_uint32("reserved2", ps, depth, &type->reserved2))
200 if(!prs_uint32("count", ps, depth, &type->count))
202 if(!prs_uint32("fields_ptr", ps, depth, &type->fields_ptr))
208 /*******************************************************************
209 reads or writes an NOTIFY OPTION TYPE DATA.
210 ********************************************************************/
212 static bool smb_io_notify_option_type_data(const char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
216 prs_debug(ps, depth, desc, "smb_io_notify_option_type_data");
219 /* if there are no fields just return */
220 if (type->fields_ptr==0)
226 if(!prs_uint32("count2", ps, depth, &type->count2))
229 if (type->count2 != type->count)
230 DEBUG(4,("What a mess, count was %x now is %x !\n", type->count, type->count2));
232 if (type->count2 > MAX_NOTIFY_TYPE_FOR_NOW) {
236 /* parse the option type data */
237 for(i=0;i<type->count2;i++)
238 if(!prs_uint16("fields",ps,depth,&type->fields[i]))
243 /*******************************************************************
244 reads or writes an NOTIFY OPTION structure.
245 ********************************************************************/
247 static bool smb_io_notify_option_type_ctr(const char *desc, SPOOL_NOTIFY_OPTION_TYPE_CTR *ctr , prs_struct *ps, int depth)
251 prs_debug(ps, depth, desc, "smb_io_notify_option_type_ctr");
254 if(!prs_uint32("count", ps, depth, &ctr->count))
258 if (UNMARSHALLING(ps) && ctr->count)
259 if((ctr->type=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION_TYPE,ctr->count)) == NULL)
262 /* the option type struct */
263 for(i=0;i<ctr->count;i++)
264 if(!smb_io_notify_option_type("", &ctr->type[i] , ps, depth))
267 /* the type associated with the option type struct */
268 for(i=0;i<ctr->count;i++)
269 if(!smb_io_notify_option_type_data("", &ctr->type[i] , ps, depth))
275 /*******************************************************************
276 reads or writes an NOTIFY OPTION structure.
277 ********************************************************************/
279 static bool smb_io_notify_option(const char *desc, SPOOL_NOTIFY_OPTION *option, prs_struct *ps, int depth)
281 prs_debug(ps, depth, desc, "smb_io_notify_option");
284 if(!prs_uint32("version", ps, depth, &option->version))
286 if(!prs_uint32("flags", ps, depth, &option->flags))
288 if(!prs_uint32("count", ps, depth, &option->count))
290 if(!prs_uint32("option_type_ptr", ps, depth, &option->option_type_ptr))
293 /* marshalling or unmarshalling, that would work */
294 if (option->option_type_ptr!=0) {
295 if(!smb_io_notify_option_type_ctr("", &option->ctr ,ps, depth))
299 option->ctr.type=NULL;
306 /*******************************************************************
307 reads or writes an NOTIFY INFO DATA structure.
308 ********************************************************************/
310 static bool smb_io_notify_info_data(const char *desc,SPOOL_NOTIFY_INFO_DATA *data, prs_struct *ps, int depth)
312 uint32 useless_ptr=0x0FF0ADDE;
314 prs_debug(ps, depth, desc, "smb_io_notify_info_data");
319 if(!prs_uint16("type", ps, depth, &data->type))
321 if(!prs_uint16("field", ps, depth, &data->field))
324 if(!prs_uint32("how many words", ps, depth, &data->size))
326 if(!prs_uint32("id", ps, depth, &data->id))
328 if(!prs_uint32("how many words", ps, depth, &data->size))
331 switch (data->enc_type) {
333 /* One and two value data has two uint32 values */
335 case NOTIFY_ONE_VALUE:
336 case NOTIFY_TWO_VALUE:
338 if(!prs_uint32("value[0]", ps, depth, &data->notify_data.value[0]))
340 if(!prs_uint32("value[1]", ps, depth, &data->notify_data.value[1]))
344 /* Pointers and strings have a string length and a
345 pointer. For a string the length is expressed as
346 the number of uint16 characters plus a trailing
351 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length ))
353 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
360 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
363 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
369 if( !prs_uint32( "sd size", ps, depth, &data->notify_data.sd.size ) )
371 if( !prs_uint32( "pointer", ps, depth, &useless_ptr ) )
377 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data\n",
385 /*******************************************************************
386 reads or writes an NOTIFY INFO DATA structure.
387 ********************************************************************/
389 bool smb_io_notify_info_data_strings(const char *desc,SPOOL_NOTIFY_INFO_DATA *data,
390 prs_struct *ps, int depth)
392 prs_debug(ps, depth, desc, "smb_io_notify_info_data_strings");
398 switch(data->enc_type) {
400 /* No data for values */
402 case NOTIFY_ONE_VALUE:
403 case NOTIFY_TWO_VALUE:
407 /* Strings start with a length in uint16s */
412 data->notify_data.data.length /= 2;
414 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
417 if (UNMARSHALLING(ps) && data->notify_data.data.length) {
418 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16,
419 data->notify_data.data.length);
421 if (!data->notify_data.data.string)
425 if (!prs_uint16uni(True, "string", ps, depth, data->notify_data.data.string,
426 data->notify_data.data.length))
430 data->notify_data.data.length *= 2;
436 if (UNMARSHALLING(ps) && data->notify_data.data.length) {
437 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16,
438 data->notify_data.data.length);
440 if (!data->notify_data.data.string)
444 if(!prs_uint8s(True,"buffer",ps,depth,(uint8*)data->notify_data.data.string,data->notify_data.data.length))
450 if( !prs_uint32("secdesc size ", ps, depth, &data->notify_data.sd.size ) )
452 if ( !sec_io_desc( "sec_desc", &data->notify_data.sd.desc, ps, depth ) )
457 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data_strings\n",
463 if (isvalue==False) {
465 /* length of string in unicode include \0 */
466 x=data->notify_data.data.length+1;
468 if (data->field != 16)
469 if(!prs_uint32("string length", ps, depth, &x ))
472 if (MARSHALLING(ps)) {
473 /* These are already in little endian format. Don't byte swap. */
476 /* No memory allocated for this string
477 therefore following the data.string
478 pointer is a bad idea. Use a pointer to
479 the uint32 length union member to
480 provide a source for a unicode NULL */
482 if(!prs_uint8s(True,"string",ps,depth, (uint8 *)&data->notify_data.data.length,x*2))
486 if (data->field == 16)
489 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
494 /* Tallocate memory for string */
497 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16, x * 2);
498 if (!data->notify_data.data.string)
501 data->notify_data.data.string = NULL;
504 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
512 /* Win2k does not seem to put this parse align here */
520 /*******************************************************************
521 reads or writes an NOTIFY INFO structure.
522 ********************************************************************/
524 static bool smb_io_notify_info(const char *desc, SPOOL_NOTIFY_INFO *info, prs_struct *ps, int depth)
528 prs_debug(ps, depth, desc, "smb_io_notify_info");
534 if(!prs_uint32("count", ps, depth, &info->count))
536 if(!prs_uint32("version", ps, depth, &info->version))
538 if(!prs_uint32("flags", ps, depth, &info->flags))
540 if(!prs_uint32("count", ps, depth, &info->count))
543 for (i=0;i<info->count;i++) {
544 if(!smb_io_notify_info_data(desc, &info->data[i], ps, depth))
548 /* now do the strings at the end of the stream */
549 for (i=0;i<info->count;i++) {
550 if(!smb_io_notify_info_data_strings(desc, &info->data[i], ps, depth))
557 /*******************************************************************
558 ********************************************************************/
560 bool spool_io_user_level_1( const char *desc, prs_struct *ps, int depth, SPOOL_USER_1 *q_u )
562 prs_debug(ps, depth, desc, "");
568 if (!prs_uint32("size", ps, depth, &q_u->size))
571 if (!prs_io_unistr2_p("", ps, depth, &q_u->client_name))
573 if (!prs_io_unistr2_p("", ps, depth, &q_u->user_name))
576 if (!prs_uint32("build", ps, depth, &q_u->build))
578 if (!prs_uint32("major", ps, depth, &q_u->major))
580 if (!prs_uint32("minor", ps, depth, &q_u->minor))
582 if (!prs_uint32("processor", ps, depth, &q_u->processor))
585 if (!prs_io_unistr2("", ps, depth, q_u->client_name))
590 if (!prs_io_unistr2("", ps, depth, q_u->user_name))
596 /*******************************************************************
597 ********************************************************************/
599 static bool spool_io_user_level(const char *desc, SPOOL_USER_CTR *q_u, prs_struct *ps, int depth)
604 prs_debug(ps, depth, desc, "spool_io_user_level");
610 if (!prs_uint32("level", ps, depth, &q_u->level))
613 switch ( q_u->level )
616 if ( !prs_pointer( "" , ps, depth, (void*)&q_u->user.user1,
617 sizeof(SPOOL_USER_1), (PRS_POINTER_CAST)spool_io_user_level_1 ))
629 /*******************************************************************
630 * read or write a DEVICEMODE struct.
631 * on reading allocate memory for the private member
632 ********************************************************************/
634 #define DM_NUM_OPTIONAL_FIELDS 8
636 bool spoolss_io_devmode(const char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
638 int available_space; /* size of the device mode left to parse */
639 /* only important on unmarshalling */
641 uint16 *unistr_buffer;
644 struct optional_fields {
647 } opt_fields[DM_NUM_OPTIONAL_FIELDS] = {
648 { "icmmethod", NULL },
649 { "icmintent", NULL },
650 { "mediatype", NULL },
651 { "dithertype", NULL },
652 { "reserved1", NULL },
653 { "reserved2", NULL },
654 { "panningwidth", NULL },
655 { "panningheight", NULL }
658 /* assign at run time to keep non-gcc compilers happy */
660 opt_fields[0].field = &devmode->icmmethod;
661 opt_fields[1].field = &devmode->icmintent;
662 opt_fields[2].field = &devmode->mediatype;
663 opt_fields[3].field = &devmode->dithertype;
664 opt_fields[4].field = &devmode->reserved1;
665 opt_fields[5].field = &devmode->reserved2;
666 opt_fields[6].field = &devmode->panningwidth;
667 opt_fields[7].field = &devmode->panningheight;
670 prs_debug(ps, depth, desc, "spoolss_io_devmode");
673 if (UNMARSHALLING(ps)) {
674 devmode->devicename.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
675 if (devmode->devicename.buffer == NULL)
677 unistr_buffer = devmode->devicename.buffer;
680 /* devicename is a static sized string but the buffer we set is not */
681 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
682 memset( unistr_buffer, 0x0, MAXDEVICENAME );
683 for ( j=0; devmode->devicename.buffer[j]; j++ )
684 unistr_buffer[j] = devmode->devicename.buffer[j];
687 if (!prs_uint16uni(True,"devicename", ps, depth, unistr_buffer, MAXDEVICENAME))
690 if (!prs_uint16("specversion", ps, depth, &devmode->specversion))
693 if (!prs_uint16("driverversion", ps, depth, &devmode->driverversion))
695 if (!prs_uint16("size", ps, depth, &devmode->size))
697 if (!prs_uint16("driverextra", ps, depth, &devmode->driverextra))
699 if (!prs_uint32("fields", ps, depth, &devmode->fields))
701 if (!prs_uint16("orientation", ps, depth, &devmode->orientation))
703 if (!prs_uint16("papersize", ps, depth, &devmode->papersize))
705 if (!prs_uint16("paperlength", ps, depth, &devmode->paperlength))
707 if (!prs_uint16("paperwidth", ps, depth, &devmode->paperwidth))
709 if (!prs_uint16("scale", ps, depth, &devmode->scale))
711 if (!prs_uint16("copies", ps, depth, &devmode->copies))
713 if (!prs_uint16("defaultsource", ps, depth, &devmode->defaultsource))
715 if (!prs_uint16("printquality", ps, depth, &devmode->printquality))
717 if (!prs_uint16("color", ps, depth, &devmode->color))
719 if (!prs_uint16("duplex", ps, depth, &devmode->duplex))
721 if (!prs_uint16("yresolution", ps, depth, &devmode->yresolution))
723 if (!prs_uint16("ttoption", ps, depth, &devmode->ttoption))
725 if (!prs_uint16("collate", ps, depth, &devmode->collate))
728 if (UNMARSHALLING(ps)) {
729 devmode->formname.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
730 if (devmode->formname.buffer == NULL)
732 unistr_buffer = devmode->formname.buffer;
735 /* devicename is a static sized string but the buffer we set is not */
736 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
737 memset( unistr_buffer, 0x0, MAXDEVICENAME );
738 for ( j=0; devmode->formname.buffer[j]; j++ )
739 unistr_buffer[j] = devmode->formname.buffer[j];
742 if (!prs_uint16uni(True, "formname", ps, depth, unistr_buffer, MAXDEVICENAME))
744 if (!prs_uint16("logpixels", ps, depth, &devmode->logpixels))
746 if (!prs_uint32("bitsperpel", ps, depth, &devmode->bitsperpel))
748 if (!prs_uint32("pelswidth", ps, depth, &devmode->pelswidth))
750 if (!prs_uint32("pelsheight", ps, depth, &devmode->pelsheight))
752 if (!prs_uint32("displayflags", ps, depth, &devmode->displayflags))
754 if (!prs_uint32("displayfrequency", ps, depth, &devmode->displayfrequency))
757 * every device mode I've ever seen on the wire at least has up
758 * to the displayfrequency field. --jerry (05-09-2002)
761 /* add uint32's + uint16's + two UNICODE strings */
763 available_space = devmode->size - (sizeof(uint32)*6 + sizeof(uint16)*18 + sizeof(uint16)*64);
765 /* Sanity check - we only have uint32's left tp parse */
767 if ( available_space && ((available_space % sizeof(uint32)) != 0) ) {
768 DEBUG(0,("spoolss_io_devmode: available_space [%d] no in multiple of 4 bytes (size = %d)!\n",
769 available_space, devmode->size));
770 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
775 * Conditional parsing. Assume that the DeviceMode has been
776 * zero'd by the caller.
779 while ((available_space > 0) && (i < DM_NUM_OPTIONAL_FIELDS))
781 DEBUG(11, ("spoolss_io_devmode: [%d] bytes left to parse in devmode\n", available_space));
782 if (!prs_uint32(opt_fields[i].name, ps, depth, opt_fields[i].field))
784 available_space -= sizeof(uint32);
788 /* Sanity Check - we should no available space at this point unless
789 MS changes the device mode structure */
791 if (available_space) {
792 DEBUG(0,("spoolss_io_devmode: I've parsed all I know and there is still stuff left|\n"));
793 DEBUG(0,("spoolss_io_devmode: available_space = [%d], devmode_size = [%d]!\n",
794 available_space, devmode->size));
795 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
800 if (devmode->driverextra!=0) {
801 if (UNMARSHALLING(ps)) {
802 devmode->dev_private=PRS_ALLOC_MEM(ps, uint8, devmode->driverextra);
803 if(devmode->dev_private == NULL)
805 DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for dev_private\n",devmode->driverextra));
808 DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of dev_private\n",devmode->driverextra));
809 if (!prs_uint8s(False, "dev_private", ps, depth,
810 devmode->dev_private, devmode->driverextra))
817 /*******************************************************************
818 Read or write a DEVICEMODE container
819 ********************************************************************/
821 static bool spoolss_io_devmode_cont(const char *desc, DEVMODE_CTR *dm_c, prs_struct *ps, int depth)
826 prs_debug(ps, depth, desc, "spoolss_io_devmode_cont");
832 if (!prs_uint32("size", ps, depth, &dm_c->size))
835 if (!prs_uint32("devmode_ptr", ps, depth, &dm_c->devmode_ptr))
838 if (dm_c->size==0 || dm_c->devmode_ptr==0) {
839 if (UNMARSHALLING(ps))
840 /* if while reading there is no DEVMODE ... */
845 /* so we have a DEVICEMODE to follow */
846 if (UNMARSHALLING(ps)) {
847 DEBUG(9,("Allocating memory for spoolss_io_devmode\n"));
848 dm_c->devmode=PRS_ALLOC_MEM(ps,DEVICEMODE,1);
849 if(dm_c->devmode == NULL)
853 /* this is bad code, shouldn't be there */
854 if (!prs_uint32("size", ps, depth, &dm_c->size))
857 if (!spoolss_io_devmode(desc, ps, depth, dm_c->devmode))
863 /*******************************************************************
864 ********************************************************************/
866 static bool spoolss_io_printer_default(const char *desc, PRINTER_DEFAULT *pd, prs_struct *ps, int depth)
871 prs_debug(ps, depth, desc, "spoolss_io_printer_default");
874 if (!prs_uint32("datatype_ptr", ps, depth, &pd->datatype_ptr))
877 if (!smb_io_unistr2("datatype", &pd->datatype, pd->datatype_ptr, ps,depth))
883 if (!spoolss_io_devmode_cont("", &pd->devmode_cont, ps, depth))
889 if (!prs_uint32("access_required", ps, depth, &pd->access_required))
895 /*******************************************************************
897 ********************************************************************/
899 bool make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX *q_u,
900 const fstring printername,
901 const fstring datatype,
902 uint32 access_required,
903 const fstring clientname,
904 const fstring user_name)
906 DEBUG(5,("make_spoolss_q_open_printer_ex\n"));
908 q_u->printername = TALLOC_P( talloc_tos(), UNISTR2 );
909 if (!q_u->printername) {
912 init_unistr2(q_u->printername, printername, UNI_STR_TERMINATE);
914 q_u->printer_default.datatype_ptr = 0;
916 q_u->printer_default.devmode_cont.size=0;
917 q_u->printer_default.devmode_cont.devmode_ptr=0;
918 q_u->printer_default.devmode_cont.devmode=NULL;
919 q_u->printer_default.access_required=access_required;
921 q_u->user_switch = 1;
923 q_u->user_ctr.level = 1;
924 q_u->user_ctr.user.user1 = TALLOC_P( talloc_tos(), SPOOL_USER_1 );
925 if (!q_u->user_ctr.user.user1) {
928 q_u->user_ctr.user.user1->size = strlen(clientname) + strlen(user_name) + 10;
929 q_u->user_ctr.user.user1->build = 1381;
930 q_u->user_ctr.user.user1->major = 2;
931 q_u->user_ctr.user.user1->minor = 0;
932 q_u->user_ctr.user.user1->processor = 0;
934 q_u->user_ctr.user.user1->client_name = TALLOC_P( talloc_tos(), UNISTR2 );
935 if (!q_u->user_ctr.user.user1->client_name) {
938 q_u->user_ctr.user.user1->user_name = TALLOC_P( talloc_tos(), UNISTR2 );
939 if (!q_u->user_ctr.user.user1->user_name) {
943 init_unistr2(q_u->user_ctr.user.user1->client_name, clientname, UNI_STR_TERMINATE);
944 init_unistr2(q_u->user_ctr.user.user1->user_name, user_name, UNI_STR_TERMINATE);
949 /*******************************************************************
951 ********************************************************************/
953 bool make_spoolss_q_addprinterex( TALLOC_CTX *mem_ctx, SPOOL_Q_ADDPRINTEREX *q_u,
954 const char *srv_name, const char* clientname, const char* user_name,
955 uint32 level, PRINTER_INFO_CTR *ctr)
957 DEBUG(5,("make_spoolss_q_addprinterex\n"));
959 if (!ctr || !ctr->printers_2)
964 q_u->server_name = TALLOC_P( mem_ctx, UNISTR2 );
965 if (!q_u->server_name) {
968 init_unistr2(q_u->server_name, srv_name, UNI_FLAGS_NONE);
972 q_u->info.level = level;
973 q_u->info.info_ptr = (ctr->printers_2!=NULL)?1:0;
976 /* init q_u->info.info2 from *info */
977 if (!make_spoolss_printer_info_2(mem_ctx, &q_u->info.info_2, ctr->printers_2)) {
978 DEBUG(0,("make_spoolss_q_addprinterex: Unable to fill SPOOL_Q_ADDPRINTEREX struct!\n"));
988 q_u->user_ctr.level = 1;
989 q_u->user_ctr.user.user1 = TALLOC_P( talloc_tos(), SPOOL_USER_1 );
990 if (!q_u->user_ctr.user.user1) {
993 q_u->user_ctr.user.user1->build = 1381;
994 q_u->user_ctr.user.user1->major = 2;
995 q_u->user_ctr.user.user1->minor = 0;
996 q_u->user_ctr.user.user1->processor = 0;
998 q_u->user_ctr.user.user1->client_name = TALLOC_P( mem_ctx, UNISTR2 );
999 if (!q_u->user_ctr.user.user1->client_name) {
1002 q_u->user_ctr.user.user1->user_name = TALLOC_P( mem_ctx, UNISTR2 );
1003 if (!q_u->user_ctr.user.user1->user_name) {
1006 init_unistr2(q_u->user_ctr.user.user1->client_name, clientname, UNI_STR_TERMINATE);
1007 init_unistr2(q_u->user_ctr.user.user1->user_name, user_name, UNI_STR_TERMINATE);
1009 q_u->user_ctr.user.user1->size = q_u->user_ctr.user.user1->user_name->uni_str_len +
1010 q_u->user_ctr.user.user1->client_name->uni_str_len + 2;
1015 /*******************************************************************
1016 create a SPOOL_PRINTER_INFO_2 stuct from a PRINTER_INFO_2 struct
1017 *******************************************************************/
1019 bool make_spoolss_printer_info_2(TALLOC_CTX *ctx, SPOOL_PRINTER_INFO_LEVEL_2 **spool_info2,
1020 PRINTER_INFO_2 *info)
1023 SPOOL_PRINTER_INFO_LEVEL_2 *inf;
1025 /* allocate the necessary memory */
1026 if (!(inf=TALLOC_P(ctx, SPOOL_PRINTER_INFO_LEVEL_2))) {
1027 DEBUG(0,("make_spoolss_printer_info_2: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_2 sruct!\n"));
1031 inf->servername_ptr = (info->servername.buffer!=NULL)?1:0;
1032 inf->printername_ptr = (info->printername.buffer!=NULL)?1:0;
1033 inf->sharename_ptr = (info->sharename.buffer!=NULL)?1:0;
1034 inf->portname_ptr = (info->portname.buffer!=NULL)?1:0;
1035 inf->drivername_ptr = (info->drivername.buffer!=NULL)?1:0;
1036 inf->comment_ptr = (info->comment.buffer!=NULL)?1:0;
1037 inf->location_ptr = (info->location.buffer!=NULL)?1:0;
1038 inf->devmode_ptr = (info->devmode!=NULL)?1:0;
1039 inf->sepfile_ptr = (info->sepfile.buffer!=NULL)?1:0;
1040 inf->printprocessor_ptr = (info->printprocessor.buffer!=NULL)?1:0;
1041 inf->datatype_ptr = (info->datatype.buffer!=NULL)?1:0;
1042 inf->parameters_ptr = (info->parameters.buffer!=NULL)?1:0;
1043 inf->secdesc_ptr = (info->secdesc!=NULL)?1:0;
1044 inf->attributes = info->attributes;
1045 inf->priority = info->priority;
1046 inf->default_priority = info->defaultpriority;
1047 inf->starttime = info->starttime;
1048 inf->untiltime = info->untiltime;
1049 inf->cjobs = info->cjobs;
1050 inf->averageppm = info->averageppm;
1051 init_unistr2_from_unistr(inf, &inf->servername, &info->servername);
1052 init_unistr2_from_unistr(inf, &inf->printername, &info->printername);
1053 init_unistr2_from_unistr(inf, &inf->sharename, &info->sharename);
1054 init_unistr2_from_unistr(inf, &inf->portname, &info->portname);
1055 init_unistr2_from_unistr(inf, &inf->drivername, &info->drivername);
1056 init_unistr2_from_unistr(inf, &inf->comment, &info->comment);
1057 init_unistr2_from_unistr(inf, &inf->location, &info->location);
1058 init_unistr2_from_unistr(inf, &inf->sepfile, &info->sepfile);
1059 init_unistr2_from_unistr(inf, &inf->printprocessor, &info->printprocessor);
1060 init_unistr2_from_unistr(inf, &inf->datatype, &info->datatype);
1061 init_unistr2_from_unistr(inf, &inf->parameters, &info->parameters);
1062 init_unistr2_from_unistr(inf, &inf->datatype, &info->datatype);
1069 /*******************************************************************
1070 create a SPOOL_PRINTER_INFO_3 struct from a PRINTER_INFO_3 struct
1071 *******************************************************************/
1073 bool make_spoolss_printer_info_3(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_3 **spool_info3,
1074 PRINTER_INFO_3 *info)
1077 SPOOL_PRINTER_INFO_LEVEL_3 *inf;
1079 /* allocate the necessary memory */
1080 if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_3))) {
1081 DEBUG(0,("make_spoolss_printer_info_3: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_3 sruct!\n"));
1085 inf->secdesc_ptr = (info->secdesc!=NULL)?1:0;
1092 /*******************************************************************
1093 create a SPOOL_PRINTER_INFO_7 struct from a PRINTER_INFO_7 struct
1094 *******************************************************************/
1096 bool make_spoolss_printer_info_7(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_7 **spool_info7,
1097 PRINTER_INFO_7 *info)
1100 SPOOL_PRINTER_INFO_LEVEL_7 *inf;
1102 /* allocate the necessary memory */
1103 if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_7))) {
1104 DEBUG(0,("make_spoolss_printer_info_7: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_7 struct!\n"));
1108 inf->guid_ptr = (info->guid.buffer!=NULL)?1:0;
1109 inf->action = info->action;
1110 init_unistr2_from_unistr(inf, &inf->guid, &info->guid);
1118 /*******************************************************************
1120 * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1121 ********************************************************************/
1123 bool spoolss_io_q_open_printer(const char *desc, SPOOL_Q_OPEN_PRINTER *q_u, prs_struct *ps, int depth)
1128 prs_debug(ps, depth, desc, "spoolss_io_q_open_printer");
1134 if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->printername))
1136 if (!prs_io_unistr2("printername", ps, depth, q_u->printername))
1142 if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth))
1148 /*******************************************************************
1149 * write a structure.
1150 * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1151 * called from spoolss_open_printer_ex (cli_spoolss.c)
1152 ********************************************************************/
1154 bool spoolss_io_r_open_printer(const char *desc, SPOOL_R_OPEN_PRINTER *r_u, prs_struct *ps, int depth)
1156 if (r_u == NULL) return False;
1158 prs_debug(ps, depth, desc, "spoolss_io_r_open_printer");
1164 if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
1167 if (!prs_werror("status", ps, depth, &(r_u->status)))
1174 /*******************************************************************
1176 * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1177 ********************************************************************/
1179 bool spoolss_io_q_open_printer_ex(const char *desc, SPOOL_Q_OPEN_PRINTER_EX *q_u, prs_struct *ps, int depth)
1184 prs_debug(ps, depth, desc, "spoolss_io_q_open_printer_ex");
1190 if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->printername))
1192 if (!prs_io_unistr2("printername", ps, depth, q_u->printername))
1198 if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth))
1201 if (!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
1203 if (!spool_io_user_level("", &q_u->user_ctr, ps, depth))
1209 /*******************************************************************
1210 * write a structure.
1211 * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1212 * called from spoolss_open_printer_ex (cli_spoolss.c)
1213 ********************************************************************/
1215 bool spoolss_io_r_open_printer_ex(const char *desc, SPOOL_R_OPEN_PRINTER_EX *r_u, prs_struct *ps, int depth)
1217 if (r_u == NULL) return False;
1219 prs_debug(ps, depth, desc, "spoolss_io_r_open_printer_ex");
1225 if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
1228 if (!prs_werror("status", ps, depth, &(r_u->status)))
1234 /*******************************************************************
1236 ********************************************************************/
1237 bool make_spoolss_q_deleteprinterdriverex( TALLOC_CTX *mem_ctx,
1238 SPOOL_Q_DELETEPRINTERDRIVEREX *q_u,
1244 DEBUG(5,("make_spoolss_q_deleteprinterdriverex\n"));
1246 q_u->server_ptr = (server!=NULL)?1:0;
1247 q_u->delete_flags = DPD_DELETE_UNUSED_FILES;
1249 /* these must be NULL terminated or else NT4 will
1250 complain about invalid parameters --jerry */
1251 init_unistr2(&q_u->server, server, UNI_STR_TERMINATE);
1252 init_unistr2(&q_u->arch, arch, UNI_STR_TERMINATE);
1253 init_unistr2(&q_u->driver, driver, UNI_STR_TERMINATE);
1256 q_u->delete_flags |= DPD_DELETE_SPECIFIC_VERSION;
1257 q_u->version = version;
1264 /*******************************************************************
1266 ********************************************************************/
1267 bool make_spoolss_q_deleteprinterdriver(
1268 TALLOC_CTX *mem_ctx,
1269 SPOOL_Q_DELETEPRINTERDRIVER *q_u,
1275 DEBUG(5,("make_spoolss_q_deleteprinterdriver\n"));
1277 q_u->server_ptr = (server!=NULL)?1:0;
1279 /* these must be NULL terminated or else NT4 will
1280 complain about invalid parameters --jerry */
1281 init_unistr2(&q_u->server, server, UNI_STR_TERMINATE);
1282 init_unistr2(&q_u->arch, arch, UNI_STR_TERMINATE);
1283 init_unistr2(&q_u->driver, driver, UNI_STR_TERMINATE);
1288 /*******************************************************************
1290 ********************************************************************/
1292 bool make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u,
1293 const POLICY_HND *handle,
1294 const char *valuename, uint32 size)
1296 if (q_u == NULL) return False;
1298 DEBUG(5,("make_spoolss_q_getprinterdata\n"));
1300 q_u->handle = *handle;
1301 init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
1307 /*******************************************************************
1309 ********************************************************************/
1311 bool make_spoolss_q_getprinterdataex(SPOOL_Q_GETPRINTERDATAEX *q_u,
1312 const POLICY_HND *handle,
1313 const char *keyname,
1314 const char *valuename, uint32 size)
1316 if (q_u == NULL) return False;
1318 DEBUG(5,("make_spoolss_q_getprinterdataex\n"));
1320 q_u->handle = *handle;
1321 init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
1322 init_unistr2(&q_u->keyname, keyname, UNI_STR_TERMINATE);
1328 /*******************************************************************
1330 * called from spoolss_q_getprinterdata (srv_spoolss.c)
1331 ********************************************************************/
1333 bool spoolss_io_q_getprinterdata(const char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_struct *ps, int depth)
1338 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdata");
1343 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1347 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1351 if (!prs_uint32("size", ps, depth, &q_u->size))
1357 /*******************************************************************
1359 * called from spoolss_q_deleteprinterdata (srv_spoolss.c)
1360 ********************************************************************/
1362 bool spoolss_io_q_deleteprinterdata(const char *desc, SPOOL_Q_DELETEPRINTERDATA *q_u, prs_struct *ps, int depth)
1367 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdata");
1372 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1376 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1382 /*******************************************************************
1383 * write a structure.
1384 * called from spoolss_r_deleteprinterdata (srv_spoolss.c)
1385 ********************************************************************/
1387 bool spoolss_io_r_deleteprinterdata(const char *desc, SPOOL_R_DELETEPRINTERDATA *r_u, prs_struct *ps, int depth)
1389 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdata");
1391 if(!prs_werror("status", ps, depth, &r_u->status))
1397 /*******************************************************************
1399 * called from spoolss_q_deleteprinterdataex (srv_spoolss.c)
1400 ********************************************************************/
1402 bool spoolss_io_q_deleteprinterdataex(const char *desc, SPOOL_Q_DELETEPRINTERDATAEX *q_u, prs_struct *ps, int depth)
1407 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdataex");
1412 if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1415 if (!smb_io_unistr2("keyname ", &q_u->keyname, True, ps, depth))
1417 if (!smb_io_unistr2("valuename", &q_u->valuename, True, ps, depth))
1423 /*******************************************************************
1424 * write a structure.
1425 * called from spoolss_r_deleteprinterdataex (srv_spoolss.c)
1426 ********************************************************************/
1428 bool spoolss_io_r_deleteprinterdataex(const char *desc, SPOOL_R_DELETEPRINTERDATAEX *r_u, prs_struct *ps, int depth)
1430 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdataex");
1433 if(!prs_werror("status", ps, depth, &r_u->status))
1439 /*******************************************************************
1440 * write a structure.
1441 * called from spoolss_r_getprinterdata (srv_spoolss.c)
1442 ********************************************************************/
1444 bool spoolss_io_r_getprinterdata(const char *desc, SPOOL_R_GETPRINTERDATA *r_u, prs_struct *ps, int depth)
1449 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdata");
1454 if (!prs_uint32("type", ps, depth, &r_u->type))
1456 if (!prs_uint32("size", ps, depth, &r_u->size))
1459 if (UNMARSHALLING(ps) && r_u->size) {
1460 r_u->data = PRS_ALLOC_MEM(ps, unsigned char, r_u->size);
1465 if (!prs_uint8s( False, "data", ps, depth, r_u->data, r_u->size ))
1471 if (!prs_uint32("needed", ps, depth, &r_u->needed))
1473 if (!prs_werror("status", ps, depth, &r_u->status))
1479 /*******************************************************************
1481 * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1482 * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1483 ********************************************************************/
1485 bool spoolss_io_q_deleteprinterdriver(const char *desc, SPOOL_Q_DELETEPRINTERDRIVER *q_u, prs_struct *ps, int depth)
1487 if (q_u == NULL) return False;
1489 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriver");
1495 if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
1497 if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
1499 if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
1501 if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
1509 /*******************************************************************
1510 * write a structure.
1511 ********************************************************************/
1512 bool spoolss_io_r_deleteprinterdriver(const char *desc, SPOOL_R_DELETEPRINTERDRIVER *r_u, prs_struct *ps, int depth)
1514 if (r_u == NULL) return False;
1516 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriver");
1522 if (!prs_werror("status", ps, depth, &r_u->status))
1529 /*******************************************************************
1531 * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1532 * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1533 ********************************************************************/
1535 bool spoolss_io_q_deleteprinterdriverex(const char *desc, SPOOL_Q_DELETEPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
1537 if (q_u == NULL) return False;
1539 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriverex");
1545 if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
1547 if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
1549 if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
1551 if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
1557 if(!prs_uint32("delete_flags ", ps, depth, &q_u->delete_flags))
1559 if(!prs_uint32("version ", ps, depth, &q_u->version))
1567 /*******************************************************************
1568 * write a structure.
1569 ********************************************************************/
1570 bool spoolss_io_r_deleteprinterdriverex(const char *desc, SPOOL_R_DELETEPRINTERDRIVEREX *r_u, prs_struct *ps, int depth)
1572 if (r_u == NULL) return False;
1574 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriverex");
1580 if (!prs_werror("status", ps, depth, &r_u->status))
1587 /*******************************************************************
1589 * called from spoolss_q_startdocprinter (srv_spoolss.c)
1590 ********************************************************************/
1592 bool spoolss_io_q_startdocprinter(const char *desc, SPOOL_Q_STARTDOCPRINTER *q_u, prs_struct *ps, int depth)
1594 if (q_u == NULL) return False;
1596 prs_debug(ps, depth, desc, "spoolss_io_q_startdocprinter");
1602 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1605 if(!smb_io_doc_info_container("",&q_u->doc_info_container, ps, depth))
1611 /*******************************************************************
1612 * write a structure.
1613 * called from spoolss_r_startdocprinter (srv_spoolss.c)
1614 ********************************************************************/
1616 bool spoolss_io_r_startdocprinter(const char *desc, SPOOL_R_STARTDOCPRINTER *r_u, prs_struct *ps, int depth)
1618 prs_debug(ps, depth, desc, "spoolss_io_r_startdocprinter");
1620 if(!prs_uint32("jobid", ps, depth, &r_u->jobid))
1622 if(!prs_werror("status", ps, depth, &r_u->status))
1628 /*******************************************************************
1630 * called from spoolss_q_rffpcnex (srv_spoolss.c)
1631 ********************************************************************/
1633 bool spoolss_io_q_rffpcnex(const char *desc, SPOOL_Q_RFFPCNEX *q_u, prs_struct *ps, int depth)
1635 prs_debug(ps, depth, desc, "spoolss_io_q_rffpcnex");
1641 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1643 if(!prs_uint32("flags", ps, depth, &q_u->flags))
1645 if(!prs_uint32("options", ps, depth, &q_u->options))
1647 if(!prs_uint32("localmachine_ptr", ps, depth, &q_u->localmachine_ptr))
1649 if(!smb_io_unistr2("localmachine", &q_u->localmachine, q_u->localmachine_ptr, ps, depth))
1655 if(!prs_uint32("printerlocal", ps, depth, &q_u->printerlocal))
1658 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1661 if (q_u->option_ptr!=0) {
1663 if (UNMARSHALLING(ps))
1664 if((q_u->option=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION,1)) == NULL)
1667 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1674 /*******************************************************************
1675 * write a structure.
1676 * called from spoolss_r_rffpcnex (srv_spoolss.c)
1677 ********************************************************************/
1679 bool spoolss_io_r_rffpcnex(const char *desc, SPOOL_R_RFFPCNEX *r_u, prs_struct *ps, int depth)
1681 prs_debug(ps, depth, desc, "spoolss_io_r_rffpcnex");
1684 if(!prs_werror("status", ps, depth, &r_u->status))
1690 /*******************************************************************
1692 * called from spoolss_q_rfnpcnex (srv_spoolss.c)
1693 ********************************************************************/
1695 bool spoolss_io_q_rfnpcnex(const char *desc, SPOOL_Q_RFNPCNEX *q_u, prs_struct *ps, int depth)
1697 prs_debug(ps, depth, desc, "spoolss_io_q_rfnpcnex");
1703 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1706 if(!prs_uint32("change", ps, depth, &q_u->change))
1709 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1712 if (q_u->option_ptr!=0) {
1714 if (UNMARSHALLING(ps))
1715 if((q_u->option=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION,1)) == NULL)
1718 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1725 /*******************************************************************
1726 * write a structure.
1727 * called from spoolss_r_rfnpcnex (srv_spoolss.c)
1728 ********************************************************************/
1730 bool spoolss_io_r_rfnpcnex(const char *desc, SPOOL_R_RFNPCNEX *r_u, prs_struct *ps, int depth)
1732 prs_debug(ps, depth, desc, "spoolss_io_r_rfnpcnex");
1738 if (!prs_uint32("info_ptr", ps, depth, &r_u->info_ptr))
1741 if(!smb_io_notify_info("notify info", &r_u->info ,ps,depth))
1746 if(!prs_werror("status", ps, depth, &r_u->status))
1752 /*******************************************************************
1753 * return the length of a uint16 (obvious, but the code is clean)
1754 ********************************************************************/
1756 static uint32 size_of_uint16(uint16 *value)
1758 return (sizeof(*value));
1761 /*******************************************************************
1762 * return the length of a uint32 (obvious, but the code is clean)
1763 ********************************************************************/
1765 static uint32 size_of_uint32(uint32 *value)
1767 return (sizeof(*value));
1770 /*******************************************************************
1771 * return the length of a NTTIME (obvious, but the code is clean)
1772 ********************************************************************/
1774 static uint32 size_of_nttime(NTTIME *value)
1776 return (sizeof(*value));
1779 /*******************************************************************
1780 * return the length of a uint32 (obvious, but the code is clean)
1781 ********************************************************************/
1783 static uint32 size_of_device_mode(DEVICEMODE *devmode)
1788 return (4+devmode->size+devmode->driverextra);
1791 /*******************************************************************
1792 * return the length of a uint32 (obvious, but the code is clean)
1793 ********************************************************************/
1795 static uint32 size_of_systemtime(SYSTEMTIME *systime)
1800 return (sizeof(SYSTEMTIME) +4);
1803 /*******************************************************************
1804 Parse a DEVMODE structure and its relative pointer.
1805 ********************************************************************/
1807 static bool smb_io_reldevmode(const char *desc, RPC_BUFFER *buffer, int depth, DEVICEMODE **devmode)
1809 prs_struct *ps=&buffer->prs;
1811 prs_debug(ps, depth, desc, "smb_io_reldevmode");
1814 if (MARSHALLING(ps)) {
1815 uint32 struct_offset = prs_offset(ps);
1816 uint32 relative_offset;
1818 if (*devmode == NULL) {
1820 if (!prs_uint32("offset", ps, depth, &relative_offset))
1822 DEBUG(8, ("boing, the devmode was NULL\n"));
1827 buffer->string_at_end -= ((*devmode)->size + (*devmode)->driverextra);
1829 /* mz: we have to align the device mode for VISTA */
1830 if (buffer->string_at_end % 4) {
1831 buffer->string_at_end += 4 - (buffer->string_at_end % 4);
1834 if(!prs_set_offset(ps, buffer->string_at_end))
1837 /* write the DEVMODE */
1838 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
1841 if(!prs_set_offset(ps, struct_offset))
1844 relative_offset=buffer->string_at_end - buffer->struct_start;
1845 /* write its offset */
1846 if (!prs_uint32("offset", ps, depth, &relative_offset))
1852 /* read the offset */
1853 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
1855 if (buffer->string_at_end == 0) {
1860 old_offset = prs_offset(ps);
1861 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
1864 /* read the string */
1865 if((*devmode=PRS_ALLOC_MEM(ps,DEVICEMODE,1)) == NULL)
1867 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
1870 if(!prs_set_offset(ps, old_offset))
1876 /*******************************************************************
1877 Parse a PRINTER_INFO_0 structure.
1878 ********************************************************************/
1880 bool smb_io_printer_info_0(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_0 *info, int depth)
1882 prs_struct *ps=&buffer->prs;
1884 prs_debug(ps, depth, desc, "smb_io_printer_info_0");
1887 buffer->struct_start=prs_offset(ps);
1889 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
1891 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
1894 if(!prs_uint32("cjobs", ps, depth, &info->cjobs))
1896 if(!prs_uint32("total_jobs", ps, depth, &info->total_jobs))
1898 if(!prs_uint32("total_bytes", ps, depth, &info->total_bytes))
1901 if(!prs_uint16("year", ps, depth, &info->year))
1903 if(!prs_uint16("month", ps, depth, &info->month))
1905 if(!prs_uint16("dayofweek", ps, depth, &info->dayofweek))
1907 if(!prs_uint16("day", ps, depth, &info->day))
1909 if(!prs_uint16("hour", ps, depth, &info->hour))
1911 if(!prs_uint16("minute", ps, depth, &info->minute))
1913 if(!prs_uint16("second", ps, depth, &info->second))
1915 if(!prs_uint16("milliseconds", ps, depth, &info->milliseconds))
1918 if(!prs_uint32("global_counter", ps, depth, &info->global_counter))
1920 if(!prs_uint32("total_pages", ps, depth, &info->total_pages))
1923 if(!prs_uint16("major_version", ps, depth, &info->major_version))
1925 if(!prs_uint16("build_version", ps, depth, &info->build_version))
1927 if(!prs_uint32("unknown7", ps, depth, &info->unknown7))
1929 if(!prs_uint32("unknown8", ps, depth, &info->unknown8))
1931 if(!prs_uint32("unknown9", ps, depth, &info->unknown9))
1933 if(!prs_uint32("session_counter", ps, depth, &info->session_counter))
1935 if(!prs_uint32("unknown11", ps, depth, &info->unknown11))
1937 if(!prs_uint32("printer_errors", ps, depth, &info->printer_errors))
1939 if(!prs_uint32("unknown13", ps, depth, &info->unknown13))
1941 if(!prs_uint32("unknown14", ps, depth, &info->unknown14))
1943 if(!prs_uint32("unknown15", ps, depth, &info->unknown15))
1945 if(!prs_uint32("unknown16", ps, depth, &info->unknown16))
1947 if(!prs_uint32("change_id", ps, depth, &info->change_id))
1949 if(!prs_uint32("unknown18", ps, depth, &info->unknown18))
1951 if(!prs_uint32("status" , ps, depth, &info->status))
1953 if(!prs_uint32("unknown20", ps, depth, &info->unknown20))
1955 if(!prs_uint32("c_setprinter", ps, depth, &info->c_setprinter))
1957 if(!prs_uint16("unknown22", ps, depth, &info->unknown22))
1959 if(!prs_uint16("unknown23", ps, depth, &info->unknown23))
1961 if(!prs_uint16("unknown24", ps, depth, &info->unknown24))
1963 if(!prs_uint16("unknown25", ps, depth, &info->unknown25))
1965 if(!prs_uint16("unknown26", ps, depth, &info->unknown26))
1967 if(!prs_uint16("unknown27", ps, depth, &info->unknown27))
1969 if(!prs_uint16("unknown28", ps, depth, &info->unknown28))
1971 if(!prs_uint16("unknown29", ps, depth, &info->unknown29))
1977 /*******************************************************************
1978 Parse a PRINTER_INFO_1 structure.
1979 ********************************************************************/
1981 bool smb_io_printer_info_1(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_1 *info, int depth)
1983 prs_struct *ps=&buffer->prs;
1985 prs_debug(ps, depth, desc, "smb_io_printer_info_1");
1988 buffer->struct_start=prs_offset(ps);
1990 if (!prs_uint32("flags", ps, depth, &info->flags))
1992 if (!smb_io_relstr("description", buffer, depth, &info->description))
1994 if (!smb_io_relstr("name", buffer, depth, &info->name))
1996 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2002 /*******************************************************************
2003 Parse a PRINTER_INFO_2 structure.
2004 ********************************************************************/
2006 bool smb_io_printer_info_2(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_2 *info, int depth)
2008 prs_struct *ps=&buffer->prs;
2009 uint32 dm_offset, sd_offset, current_offset;
2010 uint32 dummy_value = 0, has_secdesc = 0;
2012 prs_debug(ps, depth, desc, "smb_io_printer_info_2");
2015 buffer->struct_start=prs_offset(ps);
2017 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2019 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2021 if (!smb_io_relstr("sharename", buffer, depth, &info->sharename))
2023 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2025 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2027 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2029 if (!smb_io_relstr("location", buffer, depth, &info->location))
2032 /* save current offset and wind forwared by a uint32 */
2033 dm_offset = prs_offset(ps);
2034 if (!prs_uint32("devmode", ps, depth, &dummy_value))
2037 if (!smb_io_relstr("sepfile", buffer, depth, &info->sepfile))
2039 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2041 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2043 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2046 /* save current offset for the sec_desc */
2047 sd_offset = prs_offset(ps);
2048 if (!prs_uint32("sec_desc", ps, depth, &has_secdesc))
2052 /* save current location so we can pick back up here */
2053 current_offset = prs_offset(ps);
2055 /* parse the devmode */
2056 if (!prs_set_offset(ps, dm_offset))
2058 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2061 /* parse the sec_desc */
2062 if (info->secdesc) {
2063 if (!prs_set_offset(ps, sd_offset))
2065 if (!smb_io_relsecdesc("secdesc", buffer, depth, &info->secdesc))
2069 /* pick up where we left off */
2070 if (!prs_set_offset(ps, current_offset))
2073 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2075 if (!prs_uint32("priority", ps, depth, &info->priority))
2077 if (!prs_uint32("defpriority", ps, depth, &info->defaultpriority))
2079 if (!prs_uint32("starttime", ps, depth, &info->starttime))
2081 if (!prs_uint32("untiltime", ps, depth, &info->untiltime))
2083 if (!prs_uint32("status", ps, depth, &info->status))
2085 if (!prs_uint32("jobs", ps, depth, &info->cjobs))
2087 if (!prs_uint32("averageppm", ps, depth, &info->averageppm))
2093 /*******************************************************************
2094 Parse a PRINTER_INFO_3 structure.
2095 ********************************************************************/
2097 bool smb_io_printer_info_3(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_3 *info, int depth)
2100 prs_struct *ps=&buffer->prs;
2102 prs_debug(ps, depth, desc, "smb_io_printer_info_3");
2105 buffer->struct_start=prs_offset(ps);
2107 if (MARSHALLING(ps)) {
2108 /* Ensure the SD is 8 byte aligned in the buffer. */
2109 uint32 start = prs_offset(ps); /* Remember the start position. */
2112 /* Write a dummy value. */
2113 if (!prs_uint32("offset", ps, depth, &off_val))
2117 if (!prs_align_uint64(ps))
2120 /* Remember where we must seek back to write the SD. */
2121 offset = prs_offset(ps);
2123 /* Calculate the real offset for the SD. */
2125 off_val = offset - start;
2127 /* Seek back to where we store the SD offset & store. */
2128 prs_set_offset(ps, start);
2129 if (!prs_uint32("offset", ps, depth, &off_val))
2132 /* Return to after the 8 byte align. */
2133 prs_set_offset(ps, offset);
2136 if (!prs_uint32("offset", ps, depth, &offset))
2138 /* Seek within the buffer. */
2139 if (!prs_set_offset(ps, offset))
2142 if (!sec_io_desc("sec_desc", &info->secdesc, ps, depth))
2148 /*******************************************************************
2149 Parse a PRINTER_INFO_4 structure.
2150 ********************************************************************/
2152 bool smb_io_printer_info_4(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_4 *info, int depth)
2154 prs_struct *ps=&buffer->prs;
2156 prs_debug(ps, depth, desc, "smb_io_printer_info_4");
2159 buffer->struct_start=prs_offset(ps);
2161 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2163 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2165 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2170 /*******************************************************************
2171 Parse a PRINTER_INFO_5 structure.
2172 ********************************************************************/
2174 bool smb_io_printer_info_5(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_5 *info, int depth)
2176 prs_struct *ps=&buffer->prs;
2178 prs_debug(ps, depth, desc, "smb_io_printer_info_5");
2181 buffer->struct_start=prs_offset(ps);
2183 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2185 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2187 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2189 if (!prs_uint32("device_not_selected_timeout", ps, depth, &info->device_not_selected_timeout))
2191 if (!prs_uint32("transmission_retry_timeout", ps, depth, &info->transmission_retry_timeout))
2196 /*******************************************************************
2197 Parse a PRINTER_INFO_6 structure.
2198 ********************************************************************/
2200 bool smb_io_printer_info_6(const char *desc, RPC_BUFFER *buffer,
2201 PRINTER_INFO_6 *info, int depth)
2203 prs_struct *ps=&buffer->prs;
2205 prs_debug(ps, depth, desc, "smb_io_printer_info_6");
2208 if (!prs_uint32("status", ps, depth, &info->status))
2214 /*******************************************************************
2215 Parse a PRINTER_INFO_7 structure.
2216 ********************************************************************/
2218 bool smb_io_printer_info_7(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_7 *info, int depth)
2220 prs_struct *ps=&buffer->prs;
2222 prs_debug(ps, depth, desc, "smb_io_printer_info_7");
2225 buffer->struct_start=prs_offset(ps);
2227 if (!smb_io_relstr("guid", buffer, depth, &info->guid))
2229 if (!prs_uint32("action", ps, depth, &info->action))
2234 /*******************************************************************
2235 Parse a PORT_INFO_1 structure.
2236 ********************************************************************/
2238 bool smb_io_port_info_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
2240 prs_struct *ps=&buffer->prs;
2242 prs_debug(ps, depth, desc, "smb_io_port_info_1");
2245 buffer->struct_start=prs_offset(ps);
2247 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2253 /*******************************************************************
2254 Parse a PORT_INFO_2 structure.
2255 ********************************************************************/
2257 bool smb_io_port_info_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2259 prs_struct *ps=&buffer->prs;
2261 prs_debug(ps, depth, desc, "smb_io_port_info_2");
2264 buffer->struct_start=prs_offset(ps);
2266 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2268 if (!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2270 if (!smb_io_relstr("description", buffer, depth, &info->description))
2272 if (!prs_uint32("port_type", ps, depth, &info->port_type))
2274 if (!prs_uint32("reserved", ps, depth, &info->reserved))
2280 /*******************************************************************
2281 Parse a DRIVER_INFO_1 structure.
2282 ********************************************************************/
2284 bool smb_io_printer_driver_info_1(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_1 *info, int depth)
2286 prs_struct *ps=&buffer->prs;
2288 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_1");
2291 buffer->struct_start=prs_offset(ps);
2293 if (!smb_io_relstr("name", buffer, depth, &info->name))
2299 /*******************************************************************
2300 Parse a DRIVER_INFO_2 structure.
2301 ********************************************************************/
2303 bool smb_io_printer_driver_info_2(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_2 *info, int depth)
2305 prs_struct *ps=&buffer->prs;
2307 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_2");
2310 buffer->struct_start=prs_offset(ps);
2312 if (!prs_uint32("version", ps, depth, &info->version))
2314 if (!smb_io_relstr("name", buffer, depth, &info->name))
2316 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2318 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2320 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2322 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2328 /*******************************************************************
2329 Parse a DRIVER_INFO_3 structure.
2330 ********************************************************************/
2332 bool smb_io_printer_driver_info_3(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_3 *info, int depth)
2334 prs_struct *ps=&buffer->prs;
2336 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_3");
2339 buffer->struct_start=prs_offset(ps);
2341 if (!prs_uint32("version", ps, depth, &info->version))
2343 if (!smb_io_relstr("name", buffer, depth, &info->name))
2345 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2347 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2349 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2351 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2353 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2356 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2359 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2361 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2367 /*******************************************************************
2368 Parse a DRIVER_INFO_6 structure.
2369 ********************************************************************/
2371 bool smb_io_printer_driver_info_6(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_6 *info, int depth)
2373 prs_struct *ps=&buffer->prs;
2375 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_6");
2378 buffer->struct_start=prs_offset(ps);
2380 if (!prs_uint32("version", ps, depth, &info->version))
2382 if (!smb_io_relstr("name", buffer, depth, &info->name))
2384 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2386 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2388 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2390 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2392 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2395 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2398 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2400 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2403 if (!smb_io_relarraystr("previousdrivernames", buffer, depth, &info->previousdrivernames))
2406 if (!prs_uint64("date", ps, depth, &info->driver_date))
2409 if (!prs_uint32("padding", ps, depth, &info->padding))
2412 if (!prs_uint32("driver_version_low", ps, depth, &info->driver_version_low))
2415 if (!prs_uint32("driver_version_high", ps, depth, &info->driver_version_high))
2418 if (!smb_io_relstr("mfgname", buffer, depth, &info->mfgname))
2420 if (!smb_io_relstr("oem_url", buffer, depth, &info->oem_url))
2422 if (!smb_io_relstr("hardware_id", buffer, depth, &info->hardware_id))
2424 if (!smb_io_relstr("provider", buffer, depth, &info->provider))
2430 /*******************************************************************
2431 Parse a JOB_INFO_1 structure.
2432 ********************************************************************/
2434 bool smb_io_job_info_1(const char *desc, RPC_BUFFER *buffer, JOB_INFO_1 *info, int depth)
2436 prs_struct *ps=&buffer->prs;
2438 prs_debug(ps, depth, desc, "smb_io_job_info_1");
2441 buffer->struct_start=prs_offset(ps);
2443 if (!prs_uint32("jobid", ps, depth, &info->jobid))
2445 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2447 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2449 if (!smb_io_relstr("username", buffer, depth, &info->username))
2451 if (!smb_io_relstr("document", buffer, depth, &info->document))
2453 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2455 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2457 if (!prs_uint32("status", ps, depth, &info->status))
2459 if (!prs_uint32("priority", ps, depth, &info->priority))
2461 if (!prs_uint32("position", ps, depth, &info->position))
2463 if (!prs_uint32("totalpages", ps, depth, &info->totalpages))
2465 if (!prs_uint32("pagesprinted", ps, depth, &info->pagesprinted))
2467 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted))
2473 /*******************************************************************
2474 Parse a JOB_INFO_2 structure.
2475 ********************************************************************/
2477 bool smb_io_job_info_2(const char *desc, RPC_BUFFER *buffer, JOB_INFO_2 *info, int depth)
2480 prs_struct *ps=&buffer->prs;
2482 prs_debug(ps, depth, desc, "smb_io_job_info_2");
2485 buffer->struct_start=prs_offset(ps);
2487 if (!prs_uint32("jobid",ps, depth, &info->jobid))
2489 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2491 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2493 if (!smb_io_relstr("username", buffer, depth, &info->username))
2495 if (!smb_io_relstr("document", buffer, depth, &info->document))
2497 if (!smb_io_relstr("notifyname", buffer, depth, &info->notifyname))
2499 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2502 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2504 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2506 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2508 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2510 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2513 /* SEC_DESC sec_desc;*/
2514 if (!prs_uint32("Hack! sec desc", ps, depth, &pipo))
2517 if (!prs_uint32("status",ps, depth, &info->status))
2519 if (!prs_uint32("priority",ps, depth, &info->priority))
2521 if (!prs_uint32("position",ps, depth, &info->position))
2523 if (!prs_uint32("starttime",ps, depth, &info->starttime))
2525 if (!prs_uint32("untiltime",ps, depth, &info->untiltime))
2527 if (!prs_uint32("totalpages",ps, depth, &info->totalpages))
2529 if (!prs_uint32("size",ps, depth, &info->size))
2531 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted) )
2533 if (!prs_uint32("timeelapsed",ps, depth, &info->timeelapsed))
2535 if (!prs_uint32("pagesprinted",ps, depth, &info->pagesprinted))
2541 /*******************************************************************
2542 ********************************************************************/
2544 bool smb_io_form_1(const char *desc, RPC_BUFFER *buffer, FORM_1 *info, int depth)
2546 prs_struct *ps=&buffer->prs;
2548 prs_debug(ps, depth, desc, "smb_io_form_1");
2551 buffer->struct_start=prs_offset(ps);
2553 if (!prs_uint32("flag", ps, depth, &info->flag))
2556 if (!smb_io_relstr("name", buffer, depth, &info->name))
2559 if (!prs_uint32("width", ps, depth, &info->width))
2561 if (!prs_uint32("length", ps, depth, &info->length))
2563 if (!prs_uint32("left", ps, depth, &info->left))
2565 if (!prs_uint32("top", ps, depth, &info->top))
2567 if (!prs_uint32("right", ps, depth, &info->right))
2569 if (!prs_uint32("bottom", ps, depth, &info->bottom))
2577 /*******************************************************************
2578 Parse a DRIVER_DIRECTORY_1 structure.
2579 ********************************************************************/
2581 bool smb_io_driverdir_1(const char *desc, RPC_BUFFER *buffer, DRIVER_DIRECTORY_1 *info, int depth)
2583 prs_struct *ps=&buffer->prs;
2585 prs_debug(ps, depth, desc, "smb_io_driverdir_1");
2588 buffer->struct_start=prs_offset(ps);
2590 if (!smb_io_unistr(desc, &info->name, ps, depth))
2596 /*******************************************************************
2597 Parse a PORT_INFO_1 structure.
2598 ********************************************************************/
2600 bool smb_io_port_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
2602 prs_struct *ps=&buffer->prs;
2604 prs_debug(ps, depth, desc, "smb_io_port_1");
2607 buffer->struct_start=prs_offset(ps);
2609 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2615 /*******************************************************************
2616 Parse a PORT_INFO_2 structure.
2617 ********************************************************************/
2619 bool smb_io_port_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2621 prs_struct *ps=&buffer->prs;
2623 prs_debug(ps, depth, desc, "smb_io_port_2");
2626 buffer->struct_start=prs_offset(ps);
2628 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2630 if(!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2632 if(!smb_io_relstr("description", buffer, depth, &info->description))
2634 if(!prs_uint32("port_type", ps, depth, &info->port_type))
2636 if(!prs_uint32("reserved", ps, depth, &info->reserved))
2642 /*******************************************************************
2643 ********************************************************************/
2645 bool smb_io_printprocessor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_1 *info, int depth)
2647 prs_struct *ps=&buffer->prs;
2649 prs_debug(ps, depth, desc, "smb_io_printprocessor_info_1");
2652 buffer->struct_start=prs_offset(ps);
2654 if (smb_io_relstr("name", buffer, depth, &info->name))
2660 /*******************************************************************
2661 ********************************************************************/
2663 bool smb_io_printprocdatatype_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCDATATYPE_1 *info, int depth)
2665 prs_struct *ps=&buffer->prs;
2667 prs_debug(ps, depth, desc, "smb_io_printprocdatatype_info_1");
2670 buffer->struct_start=prs_offset(ps);
2672 if (smb_io_relstr("name", buffer, depth, &info->name))
2678 /*******************************************************************
2679 ********************************************************************/
2681 bool smb_io_printmonitor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_1 *info, int depth)
2683 prs_struct *ps=&buffer->prs;
2685 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_1");
2688 buffer->struct_start=prs_offset(ps);
2690 if (!smb_io_relstr("name", buffer, depth, &info->name))
2696 /*******************************************************************
2697 ********************************************************************/
2699 bool smb_io_printmonitor_info_2(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_2 *info, int depth)
2701 prs_struct *ps=&buffer->prs;
2703 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_2");
2706 buffer->struct_start=prs_offset(ps);
2708 if (!smb_io_relstr("name", buffer, depth, &info->name))
2710 if (!smb_io_relstr("environment", buffer, depth, &info->environment))
2712 if (!smb_io_relstr("dll_name", buffer, depth, &info->dll_name))
2718 /*******************************************************************
2719 return the size required by a struct in the stream
2720 ********************************************************************/
2722 uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
2726 size+=size_of_relative_string( &info->printername );
2727 size+=size_of_relative_string( &info->servername );
2729 size+=size_of_uint32( &info->cjobs);
2730 size+=size_of_uint32( &info->total_jobs);
2731 size+=size_of_uint32( &info->total_bytes);
2733 size+=size_of_uint16( &info->year);
2734 size+=size_of_uint16( &info->month);
2735 size+=size_of_uint16( &info->dayofweek);
2736 size+=size_of_uint16( &info->day);
2737 size+=size_of_uint16( &info->hour);
2738 size+=size_of_uint16( &info->minute);
2739 size+=size_of_uint16( &info->second);
2740 size+=size_of_uint16( &info->milliseconds);
2742 size+=size_of_uint32( &info->global_counter);
2743 size+=size_of_uint32( &info->total_pages);
2745 size+=size_of_uint16( &info->major_version);
2746 size+=size_of_uint16( &info->build_version);
2748 size+=size_of_uint32( &info->unknown7);
2749 size+=size_of_uint32( &info->unknown8);
2750 size+=size_of_uint32( &info->unknown9);
2751 size+=size_of_uint32( &info->session_counter);
2752 size+=size_of_uint32( &info->unknown11);
2753 size+=size_of_uint32( &info->printer_errors);
2754 size+=size_of_uint32( &info->unknown13);
2755 size+=size_of_uint32( &info->unknown14);
2756 size+=size_of_uint32( &info->unknown15);
2757 size+=size_of_uint32( &info->unknown16);
2758 size+=size_of_uint32( &info->change_id);
2759 size+=size_of_uint32( &info->unknown18);
2760 size+=size_of_uint32( &info->status);
2761 size+=size_of_uint32( &info->unknown20);
2762 size+=size_of_uint32( &info->c_setprinter);
2764 size+=size_of_uint16( &info->unknown22);
2765 size+=size_of_uint16( &info->unknown23);
2766 size+=size_of_uint16( &info->unknown24);
2767 size+=size_of_uint16( &info->unknown25);
2768 size+=size_of_uint16( &info->unknown26);
2769 size+=size_of_uint16( &info->unknown27);
2770 size+=size_of_uint16( &info->unknown28);
2771 size+=size_of_uint16( &info->unknown29);
2776 /*******************************************************************
2777 return the size required by a struct in the stream
2778 ********************************************************************/
2780 uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
2784 size+=size_of_uint32( &info->flags );
2785 size+=size_of_relative_string( &info->description );
2786 size+=size_of_relative_string( &info->name );
2787 size+=size_of_relative_string( &info->comment );
2792 /*******************************************************************
2793 return the size required by a struct in the stream
2794 ********************************************************************/
2796 uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
2802 size += ndr_size_security_descriptor( info->secdesc, NULL, 0 );
2804 size+=size_of_device_mode( info->devmode );
2806 size+=size_of_relative_string( &info->servername );
2807 size+=size_of_relative_string( &info->printername );
2808 size+=size_of_relative_string( &info->sharename );
2809 size+=size_of_relative_string( &info->portname );
2810 size+=size_of_relative_string( &info->drivername );
2811 size+=size_of_relative_string( &info->comment );
2812 size+=size_of_relative_string( &info->location );
2814 size+=size_of_relative_string( &info->sepfile );
2815 size+=size_of_relative_string( &info->printprocessor );
2816 size+=size_of_relative_string( &info->datatype );
2817 size+=size_of_relative_string( &info->parameters );
2819 size+=size_of_uint32( &info->attributes );
2820 size+=size_of_uint32( &info->priority );
2821 size+=size_of_uint32( &info->defaultpriority );
2822 size+=size_of_uint32( &info->starttime );
2823 size+=size_of_uint32( &info->untiltime );
2824 size+=size_of_uint32( &info->status );
2825 size+=size_of_uint32( &info->cjobs );
2826 size+=size_of_uint32( &info->averageppm );
2829 * add any adjustments for alignment. This is
2830 * not optimal since we could be calling this
2831 * function from a loop (e.g. enumprinters), but
2832 * it is easier to maintain the calculation here and
2833 * not place the burden on the caller to remember. --jerry
2835 if ((size % 4) != 0)
2836 size += 4 - (size % 4);
2841 /*******************************************************************
2842 return the size required by a struct in the stream
2843 ********************************************************************/
2845 uint32 spoolss_size_printer_info_4(PRINTER_INFO_4 *info)
2849 size+=size_of_relative_string( &info->printername );
2850 size+=size_of_relative_string( &info->servername );
2852 size+=size_of_uint32( &info->attributes );
2856 /*******************************************************************
2857 return the size required by a struct in the stream
2858 ********************************************************************/
2860 uint32 spoolss_size_printer_info_5(PRINTER_INFO_5 *info)
2864 size+=size_of_relative_string( &info->printername );
2865 size+=size_of_relative_string( &info->portname );
2867 size+=size_of_uint32( &info->attributes );
2868 size+=size_of_uint32( &info->device_not_selected_timeout );
2869 size+=size_of_uint32( &info->transmission_retry_timeout );
2873 /*******************************************************************
2874 return the size required by a struct in the stream
2875 ********************************************************************/
2877 uint32 spoolss_size_printer_info_6(PRINTER_INFO_6 *info)
2879 return sizeof(uint32);
2882 /*******************************************************************
2883 return the size required by a struct in the stream
2884 ********************************************************************/
2886 uint32 spoolss_size_printer_info_3(PRINTER_INFO_3 *info)
2888 /* The 8 is for the self relative pointer - 8 byte aligned.. */
2889 return 8 + (uint32)ndr_size_security_descriptor( info->secdesc, NULL, 0 );
2892 /*******************************************************************
2893 return the size required by a struct in the stream
2894 ********************************************************************/
2896 uint32 spoolss_size_printer_info_7(PRINTER_INFO_7 *info)
2900 size+=size_of_relative_string( &info->guid );
2901 size+=size_of_uint32( &info->action );
2905 /*******************************************************************
2906 return the size required by a struct in the stream
2907 ********************************************************************/
2909 uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
2912 size+=size_of_relative_string( &info->name );
2917 /*******************************************************************
2918 return the size required by a struct in the stream
2919 ********************************************************************/
2921 uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
2924 size+=size_of_uint32( &info->version );
2925 size+=size_of_relative_string( &info->name );
2926 size+=size_of_relative_string( &info->architecture );
2927 size+=size_of_relative_string( &info->driverpath );
2928 size+=size_of_relative_string( &info->datafile );
2929 size+=size_of_relative_string( &info->configfile );
2934 /*******************************************************************
2935 return the size required by a string array.
2936 ********************************************************************/
2938 uint32 spoolss_size_string_array(uint16 *string)
2943 for (i=0; (string[i]!=0x0000) || (string[i+1]!=0x0000); i++);
2945 i=i+2; /* to count all chars including the leading zero */
2946 i=2*i; /* because we need the value in bytes */
2947 i=i+4; /* the offset pointer size */
2952 /*******************************************************************
2953 return the size required by a struct in the stream
2954 ********************************************************************/
2956 uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
2960 size+=size_of_uint32( &info->version );
2961 size+=size_of_relative_string( &info->name );
2962 size+=size_of_relative_string( &info->architecture );
2963 size+=size_of_relative_string( &info->driverpath );
2964 size+=size_of_relative_string( &info->datafile );
2965 size+=size_of_relative_string( &info->configfile );
2966 size+=size_of_relative_string( &info->helpfile );
2967 size+=size_of_relative_string( &info->monitorname );
2968 size+=size_of_relative_string( &info->defaultdatatype );
2970 size+=spoolss_size_string_array(info->dependentfiles);
2975 /*******************************************************************
2976 return the size required by a struct in the stream
2977 ********************************************************************/
2979 uint32 spoolss_size_printer_driver_info_6(DRIVER_INFO_6 *info)
2983 size+=size_of_uint32( &info->version );
2984 size+=size_of_relative_string( &info->name );
2985 size+=size_of_relative_string( &info->architecture );
2986 size+=size_of_relative_string( &info->driverpath );
2987 size+=size_of_relative_string( &info->datafile );
2988 size+=size_of_relative_string( &info->configfile );
2989 size+=size_of_relative_string( &info->helpfile );
2991 size+=spoolss_size_string_array(info->dependentfiles);
2993 size+=size_of_relative_string( &info->monitorname );
2994 size+=size_of_relative_string( &info->defaultdatatype );
2996 size+=spoolss_size_string_array(info->previousdrivernames);
2998 size+=size_of_nttime(&info->driver_date);
2999 size+=size_of_uint32( &info->padding );
3000 size+=size_of_uint32( &info->driver_version_low );
3001 size+=size_of_uint32( &info->driver_version_high );
3002 size+=size_of_relative_string( &info->mfgname );
3003 size+=size_of_relative_string( &info->oem_url );
3004 size+=size_of_relative_string( &info->hardware_id );
3005 size+=size_of_relative_string( &info->provider );
3010 /*******************************************************************
3011 return the size required by a struct in the stream
3012 ********************************************************************/
3014 uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
3017 size+=size_of_uint32( &info->jobid );
3018 size+=size_of_relative_string( &info->printername );
3019 size+=size_of_relative_string( &info->machinename );
3020 size+=size_of_relative_string( &info->username );
3021 size+=size_of_relative_string( &info->document );
3022 size+=size_of_relative_string( &info->datatype );
3023 size+=size_of_relative_string( &info->text_status );
3024 size+=size_of_uint32( &info->status );
3025 size+=size_of_uint32( &info->priority );
3026 size+=size_of_uint32( &info->position );
3027 size+=size_of_uint32( &info->totalpages );
3028 size+=size_of_uint32( &info->pagesprinted );
3029 size+=size_of_systemtime( &info->submitted );
3034 /*******************************************************************
3035 return the size required by a struct in the stream
3036 ********************************************************************/
3038 uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
3042 size+=4; /* size of sec desc ptr */
3044 size+=size_of_uint32( &info->jobid );
3045 size+=size_of_relative_string( &info->printername );
3046 size+=size_of_relative_string( &info->machinename );
3047 size+=size_of_relative_string( &info->username );
3048 size+=size_of_relative_string( &info->document );
3049 size+=size_of_relative_string( &info->notifyname );
3050 size+=size_of_relative_string( &info->datatype );
3051 size+=size_of_relative_string( &info->printprocessor );
3052 size+=size_of_relative_string( &info->parameters );
3053 size+=size_of_relative_string( &info->drivername );
3054 size+=size_of_device_mode( info->devmode );
3055 size+=size_of_relative_string( &info->text_status );
3056 /* SEC_DESC sec_desc;*/
3057 size+=size_of_uint32( &info->status );
3058 size+=size_of_uint32( &info->priority );
3059 size+=size_of_uint32( &info->position );
3060 size+=size_of_uint32( &info->starttime );
3061 size+=size_of_uint32( &info->untiltime );
3062 size+=size_of_uint32( &info->totalpages );
3063 size+=size_of_uint32( &info->size );
3064 size+=size_of_systemtime( &info->submitted );
3065 size+=size_of_uint32( &info->timeelapsed );
3066 size+=size_of_uint32( &info->pagesprinted );
3071 /*******************************************************************
3072 return the size required by a struct in the stream
3073 ********************************************************************/
3075 uint32 spoolss_size_form_1(FORM_1 *info)
3079 size+=size_of_uint32( &info->flag );
3080 size+=size_of_relative_string( &info->name );
3081 size+=size_of_uint32( &info->width );
3082 size+=size_of_uint32( &info->length );
3083 size+=size_of_uint32( &info->left );
3084 size+=size_of_uint32( &info->top );
3085 size+=size_of_uint32( &info->right );
3086 size+=size_of_uint32( &info->bottom );
3091 /*******************************************************************
3092 return the size required by a struct in the stream
3093 ********************************************************************/
3095 uint32 spoolss_size_port_info_1(PORT_INFO_1 *info)
3099 size+=size_of_relative_string( &info->port_name );
3104 /*******************************************************************
3105 return the size required by a struct in the stream
3106 ********************************************************************/
3108 uint32 spoolss_size_driverdir_info_1(DRIVER_DIRECTORY_1 *info)
3112 size=str_len_uni(&info->name); /* the string length */
3113 size=size+1; /* add the leading zero */
3114 size=size*2; /* convert in char */
3119 /*******************************************************************
3120 return the size required by a struct in the stream
3121 ********************************************************************/
3123 uint32 spoolss_size_printprocessordirectory_info_1(PRINTPROCESSOR_DIRECTORY_1 *info)
3127 size=str_len_uni(&info->name); /* the string length */
3128 size=size+1; /* add the leading zero */
3129 size=size*2; /* convert in char */
3134 /*******************************************************************
3135 return the size required by a struct in the stream
3136 ********************************************************************/
3138 uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
3142 size+=size_of_relative_string( &info->port_name );
3143 size+=size_of_relative_string( &info->monitor_name );
3144 size+=size_of_relative_string( &info->description );
3146 size+=size_of_uint32( &info->port_type );
3147 size+=size_of_uint32( &info->reserved );
3152 /*******************************************************************
3153 return the size required by a struct in the stream
3154 ********************************************************************/
3156 uint32 spoolss_size_printprocessor_info_1(PRINTPROCESSOR_1 *info)
3159 size+=size_of_relative_string( &info->name );
3164 /*******************************************************************
3165 return the size required by a struct in the stream
3166 ********************************************************************/
3168 uint32 spoolss_size_printprocdatatype_info_1(PRINTPROCDATATYPE_1 *info)
3171 size+=size_of_relative_string( &info->name );
3176 /*******************************************************************
3177 return the size required by a struct in the stream
3178 ********************************************************************/
3179 uint32 spoolss_size_printer_enum_values(PRINTER_ENUM_VALUES *p)
3186 /* uint32(offset) + uint32(length) + length) */
3187 size += (size_of_uint32(&p->value_len)*2) + p->value_len;
3188 size += (size_of_uint32(&p->data_len)*2) + p->data_len + (p->data_len%2) ;
3190 size += size_of_uint32(&p->type);
3195 /*******************************************************************
3196 return the size required by a struct in the stream
3197 ********************************************************************/
3199 uint32 spoolss_size_printmonitor_info_1(PRINTMONITOR_1 *info)
3202 size+=size_of_relative_string( &info->name );
3207 /*******************************************************************
3208 return the size required by a struct in the stream
3209 ********************************************************************/
3211 uint32 spoolss_size_printmonitor_info_2(PRINTMONITOR_2 *info)
3214 size+=size_of_relative_string( &info->name);
3215 size+=size_of_relative_string( &info->environment);
3216 size+=size_of_relative_string( &info->dll_name);
3221 /*******************************************************************
3223 ********************************************************************/
3225 bool make_spoolss_q_getprinterdriver2(SPOOL_Q_GETPRINTERDRIVER2 *q_u,
3226 const POLICY_HND *hnd,
3227 const fstring architecture,
3228 uint32 level, uint32 clientmajor, uint32 clientminor,
3229 RPC_BUFFER *buffer, uint32 offered)
3234 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3236 init_buf_unistr2(&q_u->architecture, &q_u->architecture_ptr, architecture);
3239 q_u->clientmajorversion=clientmajor;
3240 q_u->clientminorversion=clientminor;
3243 q_u->offered=offered;
3248 /*******************************************************************
3250 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3251 ********************************************************************/
3253 bool spoolss_io_q_getprinterdriver2(const char *desc, SPOOL_Q_GETPRINTERDRIVER2 *q_u, prs_struct *ps, int depth)
3255 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriver2");
3261 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3263 if(!prs_uint32("architecture_ptr", ps, depth, &q_u->architecture_ptr))
3265 if(!smb_io_unistr2("architecture", &q_u->architecture, q_u->architecture_ptr, ps, depth))
3270 if(!prs_uint32("level", ps, depth, &q_u->level))
3273 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3279 if(!prs_uint32("offered", ps, depth, &q_u->offered))
3282 if(!prs_uint32("clientmajorversion", ps, depth, &q_u->clientmajorversion))
3284 if(!prs_uint32("clientminorversion", ps, depth, &q_u->clientminorversion))
3290 /*******************************************************************
3292 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3293 ********************************************************************/
3295 bool spoolss_io_r_getprinterdriver2(const char *desc, SPOOL_R_GETPRINTERDRIVER2 *r_u, prs_struct *ps, int depth)
3297 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriver2");
3303 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3308 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3310 if (!prs_uint32("servermajorversion", ps, depth, &r_u->servermajorversion))
3312 if (!prs_uint32("serverminorversion", ps, depth, &r_u->serverminorversion))
3314 if (!prs_werror("status", ps, depth, &r_u->status))
3320 /*******************************************************************
3322 ********************************************************************/
3324 bool make_spoolss_q_enumprinters(
3325 SPOOL_Q_ENUMPRINTERS *q_u,
3335 q_u->servername_ptr = (servername != NULL) ? 1 : 0;
3336 init_buf_unistr2(&q_u->servername, &q_u->servername_ptr, servername);
3340 q_u->offered=offered;
3345 /*******************************************************************
3347 ********************************************************************/
3349 bool make_spoolss_q_enumports(SPOOL_Q_ENUMPORTS *q_u,
3350 fstring servername, uint32 level,
3351 RPC_BUFFER *buffer, uint32 offered)
3353 q_u->name_ptr = (servername != NULL) ? 1 : 0;
3354 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
3358 q_u->offered=offered;
3363 /*******************************************************************
3365 * called from spoolss_enumprinters (srv_spoolss.c)
3366 ********************************************************************/
3368 bool spoolss_io_q_enumprinters(const char *desc, SPOOL_Q_ENUMPRINTERS *q_u, prs_struct *ps, int depth)
3370 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinters");
3376 if (!prs_uint32("flags", ps, depth, &q_u->flags))
3378 if (!prs_uint32("servername_ptr", ps, depth, &q_u->servername_ptr))
3381 if (!smb_io_unistr2("", &q_u->servername, q_u->servername_ptr, ps, depth))
3386 if (!prs_uint32("level", ps, depth, &q_u->level))
3389 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3394 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3400 /*******************************************************************
3401 Parse a SPOOL_R_ENUMPRINTERS structure.
3402 ********************************************************************/
3404 bool spoolss_io_r_enumprinters(const char *desc, SPOOL_R_ENUMPRINTERS *r_u, prs_struct *ps, int depth)
3406 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinters");
3412 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3418 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3421 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3424 if (!prs_werror("status", ps, depth, &r_u->status))
3430 /*******************************************************************
3431 * write a structure.
3432 * called from spoolss_r_enum_printers (srv_spoolss.c)
3434 ********************************************************************/
3436 bool spoolss_io_r_getprinter(const char *desc, SPOOL_R_GETPRINTER *r_u, prs_struct *ps, int depth)
3438 prs_debug(ps, depth, desc, "spoolss_io_r_getprinter");
3444 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3450 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3453 if (!prs_werror("status", ps, depth, &r_u->status))
3459 /*******************************************************************
3461 * called from spoolss_getprinter (srv_spoolss.c)
3462 ********************************************************************/
3464 bool spoolss_io_q_getprinter(const char *desc, SPOOL_Q_GETPRINTER *q_u, prs_struct *ps, int depth)
3466 prs_debug(ps, depth, desc, "spoolss_io_q_getprinter");
3472 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3474 if (!prs_uint32("level", ps, depth, &q_u->level))
3477 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3482 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3488 /*******************************************************************
3490 ********************************************************************/
3492 bool make_spoolss_q_getprinter(
3493 TALLOC_CTX *mem_ctx,
3494 SPOOL_Q_GETPRINTER *q_u,
3495 const POLICY_HND *hnd,
3505 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3509 q_u->offered=offered;
3514 /*******************************************************************
3516 ********************************************************************/
3517 bool make_spoolss_q_setprinter(TALLOC_CTX *mem_ctx, SPOOL_Q_SETPRINTER *q_u,
3518 const POLICY_HND *hnd, uint32 level, PRINTER_INFO_CTR *info,
3522 DEVICEMODE *devmode;
3527 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3530 q_u->info.level = level;
3531 q_u->info.info_ptr = 1; /* Info is != NULL, see above */
3534 /* There's no such thing as a setprinter level 1 */
3537 secdesc = info->printers_2->secdesc;
3538 devmode = info->printers_2->devmode;
3540 make_spoolss_printer_info_2 (mem_ctx, &q_u->info.info_2, info->printers_2);
3541 #if 1 /* JERRY TEST */
3542 q_u->secdesc_ctr = SMB_MALLOC_P(SEC_DESC_BUF);
3543 if (!q_u->secdesc_ctr)
3545 q_u->secdesc_ctr->sd = secdesc;
3546 q_u->secdesc_ctr->sd_size = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3548 q_u->devmode_ctr.devmode_ptr = (devmode != NULL) ? 1 : 0;
3549 q_u->devmode_ctr.size = (devmode != NULL) ? sizeof(DEVICEMODE) + (3*sizeof(uint32)) : 0;
3550 q_u->devmode_ctr.devmode = devmode;
3552 q_u->secdesc_ctr = NULL;
3554 q_u->devmode_ctr.devmode_ptr = 0;
3555 q_u->devmode_ctr.size = 0;
3556 q_u->devmode_ctr.devmode = NULL;
3560 secdesc = info->printers_3->secdesc;
3562 make_spoolss_printer_info_3 (mem_ctx, &q_u->info.info_3, info->printers_3);
3564 q_u->secdesc_ctr = SMB_MALLOC_P(SEC_DESC_BUF);
3565 if (!q_u->secdesc_ctr)
3567 q_u->secdesc_ctr->sd_size = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3568 q_u->secdesc_ctr->sd = secdesc;
3572 make_spoolss_printer_info_7 (mem_ctx, &q_u->info.info_7, info->printers_7);
3576 DEBUG(0,("make_spoolss_q_setprinter: Unknown info level [%d]\n", level));
3581 q_u->command = command;
3587 /*******************************************************************
3588 ********************************************************************/
3590 bool spoolss_io_r_setprinter(const char *desc, SPOOL_R_SETPRINTER *r_u, prs_struct *ps, int depth)
3592 prs_debug(ps, depth, desc, "spoolss_io_r_setprinter");
3598 if(!prs_werror("status", ps, depth, &r_u->status))
3604 /*******************************************************************
3605 Marshall/unmarshall a SPOOL_Q_SETPRINTER struct.
3606 ********************************************************************/
3608 bool spoolss_io_q_setprinter(const char *desc, SPOOL_Q_SETPRINTER *q_u, prs_struct *ps, int depth)
3610 uint32 ptr_sec_desc = 0;
3612 prs_debug(ps, depth, desc, "spoolss_io_q_setprinter");
3618 if(!smb_io_pol_hnd("printer handle", &q_u->handle ,ps, depth))
3620 if(!prs_uint32("level", ps, depth, &q_u->level))
3623 /* check for supported levels and structures we know about */
3625 switch ( q_u->level ) {
3630 /* supported levels */
3633 DEBUG(0,("spoolss_io_q_setprinter: unsupported printer info level [%d]\n",
3639 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
3642 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
3652 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
3657 /* FIXME ! Our parsing here is wrong I think,
3658 * but for a level3 it makes no sense for
3659 * ptr_sec_desc to be NULL. JRA. Based on
3660 * a Vista sniff from Martin Zielinski <mz@seh.de>.
3662 if (UNMARSHALLING(ps)) {
3665 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
3672 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
3677 /* Parse a NULL security descriptor. This should really
3678 happen inside the sec_io_desc_buf() function. */
3680 prs_debug(ps, depth, "", "sec_io_desc_buf");
3681 if (!prs_uint32("size", ps, depth + 1, &dummy))
3683 if (!prs_uint32("ptr", ps, depth + 1, &dummy))
3687 if(!prs_uint32("command", ps, depth, &q_u->command))
3693 /*******************************************************************
3694 ********************************************************************/
3696 bool spoolss_io_r_fcpn(const char *desc, SPOOL_R_FCPN *r_u, prs_struct *ps, int depth)
3698 prs_debug(ps, depth, desc, "spoolss_io_r_fcpn");
3704 if(!prs_werror("status", ps, depth, &r_u->status))
3710 /*******************************************************************
3711 ********************************************************************/
3713 bool spoolss_io_q_fcpn(const char *desc, SPOOL_Q_FCPN *q_u, prs_struct *ps, int depth)
3716 prs_debug(ps, depth, desc, "spoolss_io_q_fcpn");
3722 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
3729 /*******************************************************************
3730 ********************************************************************/
3732 bool spoolss_io_r_addjob(const char *desc, SPOOL_R_ADDJOB *r_u, prs_struct *ps, int depth)
3734 prs_debug(ps, depth, desc, "");
3740 if(!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3746 if(!prs_uint32("needed", ps, depth, &r_u->needed))
3749 if(!prs_werror("status", ps, depth, &r_u->status))
3755 /*******************************************************************
3756 ********************************************************************/
3758 bool spoolss_io_q_addjob(const char *desc, SPOOL_Q_ADDJOB *q_u, prs_struct *ps, int depth)
3760 prs_debug(ps, depth, desc, "");
3766 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3768 if(!prs_uint32("level", ps, depth, &q_u->level))
3771 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3777 if(!prs_uint32("offered", ps, depth, &q_u->offered))
3783 /*******************************************************************
3784 ********************************************************************/
3786 bool spoolss_io_r_enumjobs(const char *desc, SPOOL_R_ENUMJOBS *r_u, prs_struct *ps, int depth)
3788 prs_debug(ps, depth, desc, "spoolss_io_r_enumjobs");
3794 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3800 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3803 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3806 if (!prs_werror("status", ps, depth, &r_u->status))
3812 /*******************************************************************
3813 ********************************************************************/
3815 bool make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS *q_u, const POLICY_HND *hnd,
3826 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3827 q_u->firstjob = firstjob;
3828 q_u->numofjobs = numofjobs;
3830 q_u->buffer= buffer;
3831 q_u->offered = offered;
3835 /*******************************************************************
3836 ********************************************************************/
3838 bool spoolss_io_q_enumjobs(const char *desc, SPOOL_Q_ENUMJOBS *q_u, prs_struct *ps, int depth)
3840 prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs");
3846 if (!smb_io_pol_hnd("printer handle",&q_u->handle, ps, depth))
3849 if (!prs_uint32("firstjob", ps, depth, &q_u->firstjob))
3851 if (!prs_uint32("numofjobs", ps, depth, &q_u->numofjobs))
3853 if (!prs_uint32("level", ps, depth, &q_u->level))
3856 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3862 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3868 /*******************************************************************
3869 ********************************************************************/
3871 bool spoolss_io_r_schedulejob(const char *desc, SPOOL_R_SCHEDULEJOB *r_u, prs_struct *ps, int depth)
3873 prs_debug(ps, depth, desc, "spoolss_io_r_schedulejob");
3879 if(!prs_werror("status", ps, depth, &r_u->status))
3885 /*******************************************************************
3886 ********************************************************************/
3888 bool spoolss_io_q_schedulejob(const char *desc, SPOOL_Q_SCHEDULEJOB *q_u, prs_struct *ps, int depth)
3890 prs_debug(ps, depth, desc, "spoolss_io_q_schedulejob");
3896 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
3898 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
3904 /*******************************************************************
3905 ********************************************************************/
3907 bool spoolss_io_r_setjob(const char *desc, SPOOL_R_SETJOB *r_u, prs_struct *ps, int depth)
3909 prs_debug(ps, depth, desc, "spoolss_io_r_setjob");
3915 if(!prs_werror("status", ps, depth, &r_u->status))
3921 /*******************************************************************
3922 ********************************************************************/
3924 bool spoolss_io_q_setjob(const char *desc, SPOOL_Q_SETJOB *q_u, prs_struct *ps, int depth)
3926 prs_debug(ps, depth, desc, "spoolss_io_q_setjob");
3932 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
3934 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
3937 * level is usually 0. If (level!=0) then I'm in trouble !
3938 * I will try to generate setjob command with level!=0, one day.
3940 if(!prs_uint32("level", ps, depth, &q_u->level))
3942 if(!prs_uint32("command", ps, depth, &q_u->command))
3948 /*******************************************************************
3949 Parse a SPOOL_R_ENUMPRINTERDRIVERS structure.
3950 ********************************************************************/
3952 bool spoolss_io_r_enumprinterdrivers(const char *desc, SPOOL_R_ENUMPRINTERDRIVERS *r_u, prs_struct *ps, int depth)
3954 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdrivers");
3960 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3966 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3969 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3972 if (!prs_werror("status", ps, depth, &r_u->status))
3978 /*******************************************************************
3980 ********************************************************************/
3982 bool make_spoolss_q_enumprinterdrivers(SPOOL_Q_ENUMPRINTERDRIVERS *q_u,
3984 const char *environment,
3986 RPC_BUFFER *buffer, uint32 offered)
3988 init_buf_unistr2(&q_u->name, &q_u->name_ptr, name);
3989 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, environment);
3993 q_u->offered=offered;
3998 /*******************************************************************
3999 Parse a SPOOL_Q_ENUMPRINTERDRIVERS structure.
4000 ********************************************************************/
4002 bool spoolss_io_q_enumprinterdrivers(const char *desc, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, prs_struct *ps, int depth)
4005 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdrivers");
4011 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
4013 if (!smb_io_unistr2("", &q_u->name, q_u->name_ptr,ps, depth))
4018 if (!prs_uint32("environment_ptr", ps, depth, &q_u->environment_ptr))
4020 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
4025 if (!prs_uint32("level", ps, depth, &q_u->level))
4028 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4034 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4040 /*******************************************************************
4041 ********************************************************************/
4043 bool spoolss_io_q_enumforms(const char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth)
4046 prs_debug(ps, depth, desc, "spoolss_io_q_enumforms");
4051 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4053 if (!prs_uint32("level", ps, depth, &q_u->level))
4056 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4061 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4067 /*******************************************************************
4068 ********************************************************************/
4070 bool spoolss_io_r_enumforms(const char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth)
4072 prs_debug(ps, depth, desc, "spoolss_io_r_enumforms");
4078 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4084 if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
4087 if (!prs_uint32("numofforms", ps, depth, &r_u->numofforms))
4090 if (!prs_werror("status", ps, depth, &r_u->status))
4096 /*******************************************************************
4097 Parse a SPOOL_R_ENUMPORTS structure.
4098 ********************************************************************/
4100 bool spoolss_io_r_enumports(const char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
4102 prs_debug(ps, depth, desc, "spoolss_io_r_enumports");
4108 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4114 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4117 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4120 if (!prs_werror("status", ps, depth, &r_u->status))
4126 /*******************************************************************
4127 ********************************************************************/
4129 bool spoolss_io_q_enumports(const char *desc, SPOOL_Q_ENUMPORTS *q_u, prs_struct *ps, int depth)
4131 prs_debug(ps, depth, desc, "");
4137 if (!prs_uint32("", ps, depth, &q_u->name_ptr))
4139 if (!smb_io_unistr2("", &q_u->name,True,ps,depth))
4144 if (!prs_uint32("level", ps, depth, &q_u->level))
4147 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4152 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4158 /*******************************************************************
4159 Parse a SPOOL_PRINTER_INFO_LEVEL_1 structure.
4160 ********************************************************************/
4162 bool spool_io_printer_info_level_1(const char *desc, SPOOL_PRINTER_INFO_LEVEL_1 *il, prs_struct *ps, int depth)
4164 prs_debug(ps, depth, desc, "spool_io_printer_info_level_1");
4170 if(!prs_uint32("flags", ps, depth, &il->flags))
4172 if(!prs_uint32("description_ptr", ps, depth, &il->description_ptr))
4174 if(!prs_uint32("name_ptr", ps, depth, &il->name_ptr))
4176 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4179 if(!smb_io_unistr2("description", &il->description, il->description_ptr, ps, depth))
4181 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4183 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4189 /*******************************************************************
4190 Parse a SPOOL_PRINTER_INFO_LEVEL_3 structure.
4191 ********************************************************************/
4193 bool spool_io_printer_info_level_3(const char *desc, SPOOL_PRINTER_INFO_LEVEL_3 *il, prs_struct *ps, int depth)
4195 prs_debug(ps, depth, desc, "spool_io_printer_info_level_3");
4201 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4207 /*******************************************************************
4208 Parse a SPOOL_PRINTER_INFO_LEVEL_2 structure.
4209 ********************************************************************/
4211 bool spool_io_printer_info_level_2(const char *desc, SPOOL_PRINTER_INFO_LEVEL_2 *il, prs_struct *ps, int depth)
4213 prs_debug(ps, depth, desc, "spool_io_printer_info_level_2");
4219 if(!prs_uint32("servername_ptr", ps, depth, &il->servername_ptr))
4221 if(!prs_uint32("printername_ptr", ps, depth, &il->printername_ptr))
4223 if(!prs_uint32("sharename_ptr", ps, depth, &il->sharename_ptr))
4225 if(!prs_uint32("portname_ptr", ps, depth, &il->portname_ptr))
4228 if(!prs_uint32("drivername_ptr", ps, depth, &il->drivername_ptr))
4230 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4232 if(!prs_uint32("location_ptr", ps, depth, &il->location_ptr))
4234 if(!prs_uint32("devmode_ptr", ps, depth, &il->devmode_ptr))
4236 if(!prs_uint32("sepfile_ptr", ps, depth, &il->sepfile_ptr))
4238 if(!prs_uint32("printprocessor_ptr", ps, depth, &il->printprocessor_ptr))
4240 if(!prs_uint32("datatype_ptr", ps, depth, &il->datatype_ptr))
4242 if(!prs_uint32("parameters_ptr", ps, depth, &il->parameters_ptr))
4244 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4247 if(!prs_uint32("attributes", ps, depth, &il->attributes))
4249 if(!prs_uint32("priority", ps, depth, &il->priority))
4251 if(!prs_uint32("default_priority", ps, depth, &il->default_priority))
4253 if(!prs_uint32("starttime", ps, depth, &il->starttime))
4255 if(!prs_uint32("untiltime", ps, depth, &il->untiltime))
4257 if(!prs_uint32("status", ps, depth, &il->status))
4259 if(!prs_uint32("cjobs", ps, depth, &il->cjobs))
4261 if(!prs_uint32("averageppm", ps, depth, &il->averageppm))
4264 if(!smb_io_unistr2("servername", &il->servername, il->servername_ptr, ps, depth))
4266 if(!smb_io_unistr2("printername", &il->printername, il->printername_ptr, ps, depth))
4268 if(!smb_io_unistr2("sharename", &il->sharename, il->sharename_ptr, ps, depth))
4270 if(!smb_io_unistr2("portname", &il->portname, il->portname_ptr, ps, depth))
4272 if(!smb_io_unistr2("drivername", &il->drivername, il->drivername_ptr, ps, depth))
4274 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4276 if(!smb_io_unistr2("location", &il->location, il->location_ptr, ps, depth))
4278 if(!smb_io_unistr2("sepfile", &il->sepfile, il->sepfile_ptr, ps, depth))
4280 if(!smb_io_unistr2("printprocessor", &il->printprocessor, il->printprocessor_ptr, ps, depth))
4282 if(!smb_io_unistr2("datatype", &il->datatype, il->datatype_ptr, ps, depth))
4284 if(!smb_io_unistr2("parameters", &il->parameters, il->parameters_ptr, ps, depth))
4290 bool spool_io_printer_info_level_7(const char *desc, SPOOL_PRINTER_INFO_LEVEL_7 *il, prs_struct *ps, int depth)
4292 prs_debug(ps, depth, desc, "spool_io_printer_info_level_7");
4298 if(!prs_uint32("guid_ptr", ps, depth, &il->guid_ptr))
4300 if(!prs_uint32("action", ps, depth, &il->action))
4303 if(!smb_io_unistr2("servername", &il->guid, il->guid_ptr, ps, depth))
4308 /*******************************************************************
4309 ********************************************************************/
4311 bool spool_io_printer_info_level(const char *desc, SPOOL_PRINTER_INFO_LEVEL *il, prs_struct *ps, int depth)
4313 prs_debug(ps, depth, desc, "spool_io_printer_info_level");
4318 if(!prs_uint32("level", ps, depth, &il->level))
4320 if(!prs_uint32("info_ptr", ps, depth, &il->info_ptr))
4323 /* if no struct inside just return */
4324 if (il->info_ptr==0) {
4325 if (UNMARSHALLING(ps)) {
4332 switch (il->level) {
4334 * level 0 is used by setprinter when managing the queue
4335 * (hold, stop, start a queue)
4339 /* DOCUMENT ME!!! What is level 1 used for? */
4342 if (UNMARSHALLING(ps)) {
4343 if ((il->info_1=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_1,1)) == NULL)
4346 if (!spool_io_printer_info_level_1("", il->info_1, ps, depth))
4351 * level 2 is used by addprinter
4352 * and by setprinter when updating printer's info
4355 if (UNMARSHALLING(ps)) {
4356 if ((il->info_2=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_2,1)) == NULL)
4359 if (!spool_io_printer_info_level_2("", il->info_2, ps, depth))
4362 /* DOCUMENT ME!!! What is level 3 used for? */
4365 if (UNMARSHALLING(ps)) {
4366 if ((il->info_3=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_3,1)) == NULL)
4369 if (!spool_io_printer_info_level_3("", il->info_3, ps, depth))
4374 if (UNMARSHALLING(ps))
4375 if ((il->info_7=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_7,1)) == NULL)
4377 if (!spool_io_printer_info_level_7("", il->info_7, ps, depth))
4385 /*******************************************************************
4386 ********************************************************************/
4388 bool spoolss_io_q_addprinterex(const char *desc, SPOOL_Q_ADDPRINTEREX *q_u, prs_struct *ps, int depth)
4390 uint32 ptr_sec_desc = 0;
4392 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterex");
4398 if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->server_name))
4400 if (!prs_io_unistr2("servername", ps, depth, q_u->server_name))
4406 if(!prs_uint32("info_level", ps, depth, &q_u->level))
4409 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
4412 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
4418 switch (q_u->level) {
4420 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
4423 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
4427 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
4432 /* Parse a NULL security descriptor. This should really
4433 happen inside the sec_io_desc_buf() function. */
4435 prs_debug(ps, depth, "", "sec_io_desc_buf");
4436 if (!prs_uint32("size", ps, depth + 1, &dummy))
4438 if (!prs_uint32("ptr", ps, depth + 1, &dummy))
4442 if(!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
4444 if(!spool_io_user_level("", &q_u->user_ctr, ps, depth))
4450 /*******************************************************************
4451 ********************************************************************/
4453 bool spoolss_io_r_addprinterex(const char *desc, SPOOL_R_ADDPRINTEREX *r_u,
4454 prs_struct *ps, int depth)
4456 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterex");
4459 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
4462 if(!prs_werror("status", ps, depth, &r_u->status))
4468 /*******************************************************************
4469 ********************************************************************/
4471 bool spool_io_printer_driver_info_level_3(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **q_u,
4472 prs_struct *ps, int depth)
4474 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *il;
4476 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_3");
4480 if (UNMARSHALLING(ps)) {
4481 il=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_DRIVER_INFO_LEVEL_3,1);
4493 if(!prs_uint32("cversion", ps, depth, &il->cversion))
4495 if(!prs_uint32("name", ps, depth, &il->name_ptr))
4497 if(!prs_uint32("environment", ps, depth, &il->environment_ptr))
4499 if(!prs_uint32("driverpath", ps, depth, &il->driverpath_ptr))
4501 if(!prs_uint32("datafile", ps, depth, &il->datafile_ptr))
4503 if(!prs_uint32("configfile", ps, depth, &il->configfile_ptr))
4505 if(!prs_uint32("helpfile", ps, depth, &il->helpfile_ptr))
4507 if(!prs_uint32("monitorname", ps, depth, &il->monitorname_ptr))
4509 if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
4511 if(!prs_uint32("dependentfilessize", ps, depth, &il->dependentfilessize))
4513 if(!prs_uint32("dependentfiles", ps, depth, &il->dependentfiles_ptr))
4519 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4521 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
4523 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
4525 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
4527 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
4529 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
4531 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
4533 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
4539 if (il->dependentfiles_ptr)
4540 smb_io_buffer5("", &il->dependentfiles, ps, depth);
4545 /*******************************************************************
4546 parse a SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 structure
4547 ********************************************************************/
4549 bool spool_io_printer_driver_info_level_6(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 **q_u,
4550 prs_struct *ps, int depth)
4552 SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *il;
4554 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_6");
4558 if (UNMARSHALLING(ps)) {
4559 il=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_DRIVER_INFO_LEVEL_6,1);
4572 * I know this seems weird, but I have no other explanation.
4573 * This is observed behavior on both NT4 and 2K servers.
4577 if (!prs_align_uint64(ps))
4580 /* parse the main elements the packet */
4582 if(!prs_uint32("cversion ", ps, depth, &il->version))
4584 if(!prs_uint32("name ", ps, depth, &il->name_ptr))
4586 if(!prs_uint32("environment ", ps, depth, &il->environment_ptr))
4588 if(!prs_uint32("driverpath ", ps, depth, &il->driverpath_ptr))
4590 if(!prs_uint32("datafile ", ps, depth, &il->datafile_ptr))
4592 if(!prs_uint32("configfile ", ps, depth, &il->configfile_ptr))
4594 if(!prs_uint32("helpfile ", ps, depth, &il->helpfile_ptr))
4596 if(!prs_uint32("monitorname ", ps, depth, &il->monitorname_ptr))
4598 if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
4600 if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_len))
4602 if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_ptr))
4604 if(!prs_uint32("previousnames ", ps, depth, &il->previousnames_len))
4606 if(!prs_uint32("previousnames ", ps, depth, &il->previousnames_ptr))
4608 if(!smb_io_time("driverdate ", &il->driverdate, ps, depth))
4610 if(!prs_uint32("dummy4 ", ps, depth, &il->dummy4))
4612 if(!prs_uint64("driverversion ", ps, depth, &il->driverversion))
4614 if(!prs_uint32("mfgname ", ps, depth, &il->mfgname_ptr))
4616 if(!prs_uint32("oemurl ", ps, depth, &il->oemurl_ptr))
4618 if(!prs_uint32("hardwareid ", ps, depth, &il->hardwareid_ptr))
4620 if(!prs_uint32("provider ", ps, depth, &il->provider_ptr))
4623 /* parse the structures in the packet */
4625 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4630 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
4635 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
4640 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
4645 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
4650 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
4655 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
4660 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
4664 if (il->dependentfiles_ptr) {
4665 if(!smb_io_buffer5("dependentfiles", &il->dependentfiles, ps, depth))
4670 if (il->previousnames_ptr) {
4671 if(!smb_io_buffer5("previousnames", &il->previousnames, ps, depth))
4676 if(!smb_io_unistr2("mfgname", &il->mfgname, il->mfgname_ptr, ps, depth))
4680 if(!smb_io_unistr2("oemurl", &il->oemurl, il->oemurl_ptr, ps, depth))
4684 if(!smb_io_unistr2("hardwareid", &il->hardwareid, il->hardwareid_ptr, ps, depth))
4688 if(!smb_io_unistr2("provider", &il->provider, il->provider_ptr, ps, depth))
4694 /*******************************************************************
4695 convert a buffer of UNICODE strings null terminated
4696 the buffer is terminated by a NULL
4698 convert to an dos codepage array (null terminated)
4700 dynamically allocate memory
4702 ********************************************************************/
4704 static bool uniarray_2_dosarray(BUFFER5 *buf5, fstring **ar)
4713 src = (char *)buf5->buffer;
4714 *ar = SMB_MALLOC_ARRAY(fstring, 1);
4719 while (src < ((char *)buf5->buffer) + buf5->buf_len*2) {
4720 rpcstr_pull(f, src, sizeof(f)-1, -1, STR_TERMINATE);
4721 src = skip_unibuf(src, 2*buf5->buf_len - PTR_DIFF(src,buf5->buffer));
4722 *ar = SMB_REALLOC_ARRAY(*ar, fstring, n+2);
4726 fstrcpy((*ar)[n], f);
4730 fstrcpy((*ar)[n], "");
4735 /*******************************************************************
4736 read a UNICODE array with null terminated strings
4737 and null terminated array
4738 and size of array at beginning
4739 ********************************************************************/
4741 bool smb_io_unibuffer(const char *desc, UNISTR2 *buffer, prs_struct *ps, int depth)
4743 if (buffer==NULL) return False;
4746 buffer->uni_str_len=buffer->uni_max_len;
4748 if(!prs_uint32("buffer_size", ps, depth, &buffer->uni_max_len))
4751 if(!prs_unistr2(True, "buffer ", ps, depth, buffer))
4757 /*******************************************************************
4758 ********************************************************************/
4760 bool spool_io_printer_driver_info_level(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL *il, prs_struct *ps, int depth)
4762 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level");
4767 if(!prs_uint32("level", ps, depth, &il->level))
4769 if(!prs_uint32("ptr", ps, depth, &il->ptr))
4775 switch (il->level) {
4777 if(!spool_io_printer_driver_info_level_3("", &il->info_3, ps, depth))
4781 if(!spool_io_printer_driver_info_level_6("", &il->info_6, ps, depth))
4791 /*******************************************************************
4792 init a SPOOL_Q_ADDPRINTERDRIVER struct
4793 ******************************************************************/
4795 bool make_spoolss_q_addprinterdriver(TALLOC_CTX *mem_ctx,
4796 SPOOL_Q_ADDPRINTERDRIVER *q_u, const char* srv_name,
4797 uint32 level, PRINTER_DRIVER_CTR *info)
4799 DEBUG(5,("make_spoolss_q_addprinterdriver\n"));
4801 if (!srv_name || !info) {
4805 q_u->server_name_ptr = 1; /* srv_name is != NULL, see above */
4806 init_unistr2(&q_u->server_name, srv_name, UNI_STR_TERMINATE);
4810 q_u->info.level = level;
4811 q_u->info.ptr = 1; /* Info is != NULL, see above */
4814 /* info level 3 is supported by Windows 95/98, WinNT and Win2k */
4816 make_spoolss_driver_info_3(mem_ctx, &q_u->info.info_3, info->info3);
4820 DEBUG(0,("make_spoolss_q_addprinterdriver: Unknown info level [%d]\n", level));
4827 bool make_spoolss_driver_info_3(TALLOC_CTX *mem_ctx,
4828 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **spool_drv_info,
4829 DRIVER_INFO_3 *info3)
4832 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *inf;
4834 if (!(inf=TALLOC_ZERO_P(mem_ctx, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3)))
4837 inf->cversion = info3->version;
4838 inf->name_ptr = (info3->name.buffer!=NULL)?1:0;
4839 inf->environment_ptr = (info3->architecture.buffer!=NULL)?1:0;
4840 inf->driverpath_ptr = (info3->driverpath.buffer!=NULL)?1:0;
4841 inf->datafile_ptr = (info3->datafile.buffer!=NULL)?1:0;
4842 inf->configfile_ptr = (info3->configfile.buffer!=NULL)?1:0;
4843 inf->helpfile_ptr = (info3->helpfile.buffer!=NULL)?1:0;
4844 inf->monitorname_ptr = (info3->monitorname.buffer!=NULL)?1:0;
4845 inf->defaultdatatype_ptr = (info3->defaultdatatype.buffer!=NULL)?1:0;
4847 init_unistr2_from_unistr(inf, &inf->name, &info3->name);
4848 init_unistr2_from_unistr(inf, &inf->environment, &info3->architecture);
4849 init_unistr2_from_unistr(inf, &inf->driverpath, &info3->driverpath);
4850 init_unistr2_from_unistr(inf, &inf->datafile, &info3->datafile);
4851 init_unistr2_from_unistr(inf, &inf->configfile, &info3->configfile);
4852 init_unistr2_from_unistr(inf, &inf->helpfile, &info3->helpfile);
4853 init_unistr2_from_unistr(inf, &inf->monitorname, &info3->monitorname);
4854 init_unistr2_from_unistr(inf, &inf->defaultdatatype, &info3->defaultdatatype);
4856 if (info3->dependentfiles) {
4858 bool null_char = False;
4859 uint16 *ptr = info3->dependentfiles;
4864 /* the null_char bool is used to help locate
4865 two '\0's back to back */
4882 inf->dependentfiles_ptr = (info3->dependentfiles != NULL) ? 1 : 0;
4883 inf->dependentfilessize = (info3->dependentfiles != NULL) ? len : 0;
4884 if(!make_spoolss_buffer5(mem_ctx, &inf->dependentfiles, len, info3->dependentfiles)) {
4889 *spool_drv_info = inf;
4894 /*******************************************************************
4895 make a BUFFER5 struct from a uint16*
4896 ******************************************************************/
4898 bool make_spoolss_buffer5(TALLOC_CTX *mem_ctx, BUFFER5 *buf5, uint32 len, uint16 *src)
4901 buf5->buf_len = len;
4904 if((buf5->buffer=(uint16*)TALLOC_MEMDUP(mem_ctx, src, sizeof(uint16)*len)) == NULL) {
4905 DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
4909 buf5->buffer = NULL;
4918 /*******************************************************************
4919 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
4920 ********************************************************************/
4922 bool spoolss_io_q_addprinterdriver(const char *desc, SPOOL_Q_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
4924 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriver");
4930 if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
4932 if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
4937 if(!prs_uint32("info_level", ps, depth, &q_u->level))
4940 if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
4946 /*******************************************************************
4947 ********************************************************************/
4949 bool spoolss_io_r_addprinterdriver(const char *desc, SPOOL_R_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
4951 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriver");
4954 if(!prs_werror("status", ps, depth, &q_u->status))
4960 /*******************************************************************
4961 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
4962 ********************************************************************/
4964 bool spoolss_io_q_addprinterdriverex(const char *desc, SPOOL_Q_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
4966 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriverex");
4972 if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
4974 if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
4979 if(!prs_uint32("info_level", ps, depth, &q_u->level))
4982 if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
4987 if(!prs_uint32("copy flags", ps, depth, &q_u->copy_flags))
4993 /*******************************************************************
4994 ********************************************************************/
4996 bool spoolss_io_r_addprinterdriverex(const char *desc, SPOOL_R_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
4998 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriverex");
5001 if(!prs_werror("status", ps, depth, &q_u->status))
5007 /*******************************************************************
5008 ********************************************************************/
5010 bool uni_2_asc_printer_driver_3(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *uni,
5011 NT_PRINTER_DRIVER_INFO_LEVEL_3 **asc)
5013 NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
5015 DEBUG(7,("uni_2_asc_printer_driver_3: Converting from UNICODE to ASCII\n"));
5019 *asc=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
5027 d->cversion=uni->cversion;
5029 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name));
5030 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment));
5031 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath));
5032 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile));
5033 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile));
5034 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile));
5035 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname));
5036 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype));
5038 DEBUGADD(8,( "version: %d\n", d->cversion));
5039 DEBUGADD(8,( "name: %s\n", d->name));
5040 DEBUGADD(8,( "environment: %s\n", d->environment));
5041 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
5042 DEBUGADD(8,( "datafile: %s\n", d->datafile));
5043 DEBUGADD(8,( "configfile: %s\n", d->configfile));
5044 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
5045 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
5046 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5048 if (uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5055 /*******************************************************************
5056 ********************************************************************/
5057 bool uni_2_asc_printer_driver_6(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *uni,
5058 NT_PRINTER_DRIVER_INFO_LEVEL_6 **asc)
5060 NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
5062 DEBUG(7,("uni_2_asc_printer_driver_6: Converting from UNICODE to ASCII\n"));
5066 *asc=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
5074 d->version=uni->version;
5076 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name));
5077 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment));
5078 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath));
5079 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile));
5080 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile));
5081 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile));
5082 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname));
5083 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype));
5085 DEBUGADD(8,( "version: %d\n", d->version));
5086 DEBUGADD(8,( "name: %s\n", d->name));
5087 DEBUGADD(8,( "environment: %s\n", d->environment));
5088 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
5089 DEBUGADD(8,( "datafile: %s\n", d->datafile));
5090 DEBUGADD(8,( "configfile: %s\n", d->configfile));
5091 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
5092 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
5093 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5095 if (!uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5097 if (!uniarray_2_dosarray(&uni->previousnames, &d->previousnames ))
5107 bool uni_2_asc_printer_info_2(const SPOOL_PRINTER_INFO_LEVEL_2 *uni,
5108 NT_PRINTER_INFO_LEVEL_2 *d)
5110 DEBUG(7,("Converting from UNICODE to ASCII\n"));
5112 d->attributes=uni->attributes;
5113 d->priority=uni->priority;
5114 d->default_priority=uni->default_priority;
5115 d->starttime=uni->starttime;
5116 d->untiltime=uni->untiltime;
5117 d->status=uni->status;
5118 d->cjobs=uni->cjobs;
5120 unistr2_to_ascii(d->servername, &uni->servername, sizeof(d->servername));
5121 unistr2_to_ascii(d->printername, &uni->printername, sizeof(d->printername));
5122 unistr2_to_ascii(d->sharename, &uni->sharename, sizeof(d->sharename));
5123 unistr2_to_ascii(d->portname, &uni->portname, sizeof(d->portname));
5124 unistr2_to_ascii(d->drivername, &uni->drivername, sizeof(d->drivername));
5125 unistr2_to_ascii(d->comment, &uni->comment, sizeof(d->comment));
5126 unistr2_to_ascii(d->location, &uni->location, sizeof(d->location));
5127 unistr2_to_ascii(d->sepfile, &uni->sepfile, sizeof(d->sepfile));
5128 unistr2_to_ascii(d->printprocessor, &uni->printprocessor, sizeof(d->printprocessor));
5129 unistr2_to_ascii(d->datatype, &uni->datatype, sizeof(d->datatype));
5130 unistr2_to_ascii(d->parameters, &uni->parameters, sizeof(d->parameters));
5135 /*******************************************************************
5137 ********************************************************************/
5139 bool make_spoolss_q_getprinterdriverdir(SPOOL_Q_GETPRINTERDRIVERDIR *q_u,
5140 fstring servername, fstring env_name, uint32 level,
5141 RPC_BUFFER *buffer, uint32 offered)
5143 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
5144 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, env_name);
5148 q_u->offered=offered;
5153 /*******************************************************************
5154 Parse a SPOOL_Q_GETPRINTERDRIVERDIR structure.
5155 ********************************************************************/
5157 bool spoolss_io_q_getprinterdriverdir(const char *desc, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, prs_struct *ps, int depth)
5159 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriverdir");
5164 if(!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5166 if(!smb_io_unistr2("", &q_u->name, q_u->name_ptr, ps, depth))
5172 if(!prs_uint32("", ps, depth, &q_u->environment_ptr))
5174 if(!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5180 if(!prs_uint32("level", ps, depth, &q_u->level))
5183 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5189 if(!prs_uint32("offered", ps, depth, &q_u->offered))
5195 /*******************************************************************
5196 Parse a SPOOL_R_GETPRINTERDRIVERDIR structure.
5197 ********************************************************************/
5199 bool spoolss_io_r_getprinterdriverdir(const char *desc, SPOOL_R_GETPRINTERDRIVERDIR *r_u, prs_struct *ps, int depth)
5201 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriverdir");
5207 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5213 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5216 if (!prs_werror("status", ps, depth, &r_u->status))
5222 /*******************************************************************
5223 ********************************************************************/
5225 bool spoolss_io_r_enumprintprocessors(const char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
5227 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
5233 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5239 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5242 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5245 if (!prs_werror("status", ps, depth, &r_u->status))
5251 /*******************************************************************
5252 ********************************************************************/
5254 bool spoolss_io_q_enumprintprocessors(const char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
5256 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
5262 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5264 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5270 if (!prs_uint32("", ps, depth, &q_u->environment_ptr))
5272 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5278 if (!prs_uint32("level", ps, depth, &q_u->level))
5281 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5287 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5293 /*******************************************************************
5294 ********************************************************************/
5296 bool spoolss_io_q_addprintprocessor(const char *desc, SPOOL_Q_ADDPRINTPROCESSOR *q_u, prs_struct *ps, int depth)
5298 prs_debug(ps, depth, desc, "spoolss_io_q_addprintprocessor");
5304 if (!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
5306 if (!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
5311 if (!smb_io_unistr2("environment", &q_u->environment, True, ps, depth))
5316 if (!smb_io_unistr2("path", &q_u->path, True, ps, depth))
5321 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5327 /*******************************************************************
5328 ********************************************************************/
5330 bool spoolss_io_r_addprintprocessor(const char *desc, SPOOL_R_ADDPRINTPROCESSOR *r_u, prs_struct *ps, int depth)
5332 prs_debug(ps, depth, desc, "spoolss_io_r_addprintproicessor");
5338 if (!prs_werror("status", ps, depth, &r_u->status))
5344 /*******************************************************************
5345 ********************************************************************/
5347 bool spoolss_io_r_enumprintprocdatatypes(const char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u, prs_struct *ps, int depth)
5349 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes");
5355 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5361 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5364 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5367 if (!prs_werror("status", ps, depth, &r_u->status))
5373 /*******************************************************************
5374 ********************************************************************/
5376 bool spoolss_io_q_enumprintprocdatatypes(const char *desc, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, prs_struct *ps, int depth)
5378 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocdatatypes");
5384 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5386 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5392 if (!prs_uint32("processor_ptr", ps, depth, &q_u->processor_ptr))
5394 if (!smb_io_unistr2("processor", &q_u->processor, q_u->processor_ptr, ps, depth))
5400 if (!prs_uint32("level", ps, depth, &q_u->level))
5403 if(!prs_rpcbuffer_p("buffer", ps, depth, &q_u->buffer))
5409 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5415 /*******************************************************************
5416 Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
5417 ********************************************************************/
5419 bool spoolss_io_q_enumprintmonitors(const char *desc, SPOOL_Q_ENUMPRINTMONITORS *q_u, prs_struct *ps, int depth)
5421 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintmonitors");
5427 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5429 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5435 if (!prs_uint32("level", ps, depth, &q_u->level))
5438 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5444 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5450 /*******************************************************************
5451 ********************************************************************/
5453 bool spoolss_io_r_enumprintmonitors(const char *desc, SPOOL_R_ENUMPRINTMONITORS *r_u, prs_struct *ps, int depth)
5455 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintmonitors");
5461 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5467 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5470 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5473 if (!prs_werror("status", ps, depth, &r_u->status))
5479 /*******************************************************************
5480 ********************************************************************/
5482 bool spoolss_io_r_enumprinterdata(const char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth)
5484 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata");
5489 if(!prs_uint32("valuesize", ps, depth, &r_u->valuesize))
5492 if (UNMARSHALLING(ps) && r_u->valuesize) {
5493 r_u->value = PRS_ALLOC_MEM(ps, uint16, r_u->valuesize);
5495 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata value\n"));
5500 if(!prs_uint16uni(False, "value", ps, depth, r_u->value, r_u->valuesize ))
5506 if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
5509 if(!prs_uint32("type", ps, depth, &r_u->type))
5512 if(!prs_uint32("datasize", ps, depth, &r_u->datasize))
5515 if (UNMARSHALLING(ps) && r_u->datasize) {
5516 r_u->data = PRS_ALLOC_MEM(ps, uint8, r_u->datasize);
5518 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata data\n"));
5523 if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
5528 if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
5530 if(!prs_werror("status", ps, depth, &r_u->status))
5536 /*******************************************************************
5537 ********************************************************************/
5539 bool spoolss_io_q_enumprinterdata(const char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
5541 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
5546 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
5548 if(!prs_uint32("index", ps, depth, &q_u->index))
5550 if(!prs_uint32("valuesize", ps, depth, &q_u->valuesize))
5552 if(!prs_uint32("datasize", ps, depth, &q_u->datasize))
5558 /*******************************************************************
5559 ********************************************************************/
5561 bool make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u,
5562 const POLICY_HND *hnd,
5563 uint32 idx, uint32 valuelen, uint32 datalen)
5565 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5567 q_u->valuesize=valuelen;
5568 q_u->datasize=datalen;
5573 /*******************************************************************
5574 ********************************************************************/
5576 bool make_spoolss_q_enumprinterdataex(SPOOL_Q_ENUMPRINTERDATAEX *q_u,
5577 const POLICY_HND *hnd, const char *key,
5580 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5581 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
5587 /*******************************************************************
5588 ********************************************************************/
5589 bool make_spoolss_q_setprinterdata(SPOOL_Q_SETPRINTERDATA *q_u, const POLICY_HND *hnd,
5590 char* value, uint32 data_type, char* data, uint32 data_size)
5592 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5593 q_u->type = data_type;
5594 init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
5596 q_u->max_len = q_u->real_len = data_size;
5597 q_u->data = (unsigned char *)data;
5602 /*******************************************************************
5603 ********************************************************************/
5604 bool make_spoolss_q_setprinterdataex(SPOOL_Q_SETPRINTERDATAEX *q_u, const POLICY_HND *hnd,
5605 char *key, char* value, uint32 data_type, char* data,
5608 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5609 q_u->type = data_type;
5610 init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
5611 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
5613 q_u->max_len = q_u->real_len = data_size;
5614 q_u->data = (unsigned char *)data;
5619 /*******************************************************************
5620 ********************************************************************/
5622 bool spoolss_io_q_setprinterdata(const char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
5624 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
5629 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5631 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
5637 if(!prs_uint32("type", ps, depth, &q_u->type))
5640 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
5650 if (UNMARSHALLING(ps))
5651 q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
5652 if(q_u->data == NULL)
5654 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
5662 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
5668 /*******************************************************************
5669 ********************************************************************/
5671 bool spoolss_io_r_setprinterdata(const char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
5673 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
5678 if(!prs_werror("status", ps, depth, &r_u->status))
5684 /*******************************************************************
5685 ********************************************************************/
5686 bool spoolss_io_q_resetprinter(const char *desc, SPOOL_Q_RESETPRINTER *q_u, prs_struct *ps, int depth)
5688 prs_debug(ps, depth, desc, "spoolss_io_q_resetprinter");
5693 if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5696 if (!prs_uint32("datatype_ptr", ps, depth, &q_u->datatype_ptr))
5699 if (q_u->datatype_ptr) {
5700 if (!smb_io_unistr2("datatype", &q_u->datatype, q_u->datatype_ptr?True:False, ps, depth))
5704 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
5711 /*******************************************************************
5712 ********************************************************************/
5713 bool spoolss_io_r_resetprinter(const char *desc, SPOOL_R_RESETPRINTER *r_u, prs_struct *ps, int depth)
5715 prs_debug(ps, depth, desc, "spoolss_io_r_resetprinter");
5720 if(!prs_werror("status", ps, depth, &r_u->status))
5726 /*******************************************************************
5727 Parse a SPOOL_R_GETJOB structure.
5728 ********************************************************************/
5730 bool spoolss_io_r_getjob(const char *desc, SPOOL_R_GETJOB *r_u, prs_struct *ps, int depth)
5732 prs_debug(ps, depth, desc, "spoolss_io_r_getjob");
5738 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5744 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5747 if (!prs_werror("status", ps, depth, &r_u->status))
5753 /*******************************************************************
5754 Parse a SPOOL_Q_GETJOB structure.
5755 ********************************************************************/
5757 bool spoolss_io_q_getjob(const char *desc, SPOOL_Q_GETJOB *q_u, prs_struct *ps, int depth)
5759 prs_debug(ps, depth, desc, "");
5765 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
5767 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
5769 if(!prs_uint32("level", ps, depth, &q_u->level))
5772 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5778 if(!prs_uint32("offered", ps, depth, &q_u->offered))
5784 void free_devmode(DEVICEMODE *devmode)
5786 if (devmode!=NULL) {
5787 SAFE_FREE(devmode->dev_private);
5792 void free_printer_info_1(PRINTER_INFO_1 *printer)
5797 void free_printer_info_2(PRINTER_INFO_2 *printer)
5799 if (printer!=NULL) {
5800 free_devmode(printer->devmode);
5801 printer->devmode = NULL;
5806 void free_printer_info_3(PRINTER_INFO_3 *printer)
5811 void free_printer_info_4(PRINTER_INFO_4 *printer)
5816 void free_printer_info_5(PRINTER_INFO_5 *printer)
5821 void free_printer_info_6(PRINTER_INFO_6 *printer)
5826 void free_printer_info_7(PRINTER_INFO_7 *printer)
5831 void free_job_info_2(JOB_INFO_2 *job)
5834 free_devmode(job->devmode);
5837 /*******************************************************************
5839 ********************************************************************/
5841 bool make_spoolss_q_replyopenprinter(SPOOL_Q_REPLYOPENPRINTER *q_u,
5842 const fstring string, uint32 printer, uint32 type)
5847 init_unistr2(&q_u->string, string, UNI_STR_TERMINATE);
5849 q_u->printer=printer;
5858 /*******************************************************************
5859 Parse a SPOOL_Q_REPLYOPENPRINTER structure.
5860 ********************************************************************/
5862 bool spoolss_io_q_replyopenprinter(const char *desc, SPOOL_Q_REPLYOPENPRINTER *q_u, prs_struct *ps, int depth)
5864 prs_debug(ps, depth, desc, "spoolss_io_q_replyopenprinter");
5870 if(!smb_io_unistr2("", &q_u->string, True, ps, depth))
5876 if(!prs_uint32("printer", ps, depth, &q_u->printer))
5878 if(!prs_uint32("type", ps, depth, &q_u->type))
5881 if(!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
5883 if(!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
5889 /*******************************************************************
5890 Parse a SPOOL_R_REPLYOPENPRINTER structure.
5891 ********************************************************************/
5893 bool spoolss_io_r_replyopenprinter(const char *desc, SPOOL_R_REPLYOPENPRINTER *r_u, prs_struct *ps, int depth)
5895 prs_debug(ps, depth, desc, "spoolss_io_r_replyopenprinter");
5901 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
5904 if (!prs_werror("status", ps, depth, &r_u->status))
5910 /*******************************************************************
5912 ********************************************************************/
5913 bool make_spoolss_q_routerreplyprinter(SPOOL_Q_ROUTERREPLYPRINTER *q_u, POLICY_HND *hnd,
5914 uint32 condition, uint32 change_id)
5917 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5919 q_u->condition = condition;
5920 q_u->change_id = change_id;
5923 q_u->unknown1 = 0x1;
5924 memset(q_u->unknown2, 0x0, 5);
5925 q_u->unknown2[0] = 0x1;
5930 /*******************************************************************
5931 Parse a SPOOL_Q_ROUTERREPLYPRINTER structure.
5932 ********************************************************************/
5933 bool spoolss_io_q_routerreplyprinter (const char *desc, SPOOL_Q_ROUTERREPLYPRINTER *q_u, prs_struct *ps, int depth)
5936 prs_debug(ps, depth, desc, "spoolss_io_q_routerreplyprinter");
5942 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
5945 if (!prs_uint32("condition", ps, depth, &q_u->condition))
5948 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
5951 if (!prs_uint32("change_id", ps, depth, &q_u->change_id))
5954 if (!prs_uint8s(False, "dev_private", ps, depth, q_u->unknown2, 5))
5960 /*******************************************************************
5961 Parse a SPOOL_R_ROUTERREPLYPRINTER structure.
5962 ********************************************************************/
5963 bool spoolss_io_r_routerreplyprinter (const char *desc, SPOOL_R_ROUTERREPLYPRINTER *r_u, prs_struct *ps, int depth)
5965 prs_debug(ps, depth, desc, "spoolss_io_r_routerreplyprinter");
5971 if (!prs_werror("status", ps, depth, &r_u->status))
5977 /*******************************************************************
5979 ********************************************************************/
5981 bool make_spoolss_q_reply_closeprinter(SPOOL_Q_REPLYCLOSEPRINTER *q_u, POLICY_HND *hnd)
5986 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5991 /*******************************************************************
5992 Parse a SPOOL_Q_REPLYCLOSEPRINTER structure.
5993 ********************************************************************/
5995 bool spoolss_io_q_replycloseprinter(const char *desc, SPOOL_Q_REPLYCLOSEPRINTER *q_u, prs_struct *ps, int depth)
5997 prs_debug(ps, depth, desc, "spoolss_io_q_replycloseprinter");
6003 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6009 /*******************************************************************
6010 Parse a SPOOL_R_REPLYCLOSEPRINTER structure.
6011 ********************************************************************/
6013 bool spoolss_io_r_replycloseprinter(const char *desc, SPOOL_R_REPLYCLOSEPRINTER *r_u, prs_struct *ps, int depth)
6015 prs_debug(ps, depth, desc, "spoolss_io_r_replycloseprinter");
6021 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6024 if (!prs_werror("status", ps, depth, &r_u->status))
6030 #if 0 /* JERRY - not currently used but could be :-) */
6032 /*******************************************************************
6033 Deep copy a SPOOL_NOTIFY_INFO_DATA structure
6034 ******************************************************************/
6035 static bool copy_spool_notify_info_data(SPOOL_NOTIFY_INFO_DATA *dst,
6036 SPOOL_NOTIFY_INFO_DATA *src, int n)
6040 memcpy(dst, src, sizeof(SPOOL_NOTIFY_INFO_DATA)*n);
6042 for (i=0; i<n; i++) {
6046 if (src->size != POINTER)
6048 len = src->notify_data.data.length;
6049 s = SMB_MALLOC_ARRAY(uint16, len);
6051 DEBUG(0,("copy_spool_notify_info_data: malloc() failed!\n"));
6055 memcpy(s, src->notify_data.data.string, len*2);
6056 dst->notify_data.data.string = s;
6062 /*******************************************************************
6063 Deep copy a SPOOL_NOTIFY_INFO structure
6064 ******************************************************************/
6065 static bool copy_spool_notify_info(SPOOL_NOTIFY_INFO *dst, SPOOL_NOTIFY_INFO *src)
6068 DEBUG(0,("copy_spool_notify_info: NULL destination pointer!\n"));
6072 dst->version = src->version;
6073 dst->flags = src->flags;
6074 dst->count = src->count;
6078 dst->data = SMB_MALLOC_ARRAY(SPOOL_NOTIFY_INFO_DATA, dst->count);
6080 DEBUG(10,("copy_spool_notify_info: allocating space for [%d] PRINTER_NOTIFY_INFO_DATA entries\n",
6083 if (dst->data == NULL) {
6084 DEBUG(0,("copy_spool_notify_info: malloc() failed for [%d] entries!\n",
6089 return (copy_spool_notify_info_data(dst->data, src->data, src->count));
6096 /*******************************************************************
6098 ********************************************************************/
6100 bool make_spoolss_q_reply_rrpcn(SPOOL_Q_REPLY_RRPCN *q_u, POLICY_HND *hnd,
6101 uint32 change_low, uint32 change_high,
6102 SPOOL_NOTIFY_INFO *info)
6107 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6109 q_u->change_low=change_low;
6110 q_u->change_high=change_high;
6115 q_u->info_ptr=0x0FF0ADDE;
6117 q_u->info.version=2;
6120 DEBUG(10,("make_spoolss_q_reply_rrpcn: [%d] PRINTER_NOTIFY_INFO_DATA\n",
6122 q_u->info.version = info->version;
6123 q_u->info.flags = info->flags;
6124 q_u->info.count = info->count;
6125 /* pointer field - be careful! */
6126 q_u->info.data = info->data;
6129 q_u->info.flags=PRINTER_NOTIFY_INFO_DISCARDED;
6136 /*******************************************************************
6137 Parse a SPOOL_Q_REPLY_RRPCN structure.
6138 ********************************************************************/
6140 bool spoolss_io_q_reply_rrpcn(const char *desc, SPOOL_Q_REPLY_RRPCN *q_u, prs_struct *ps, int depth)
6142 prs_debug(ps, depth, desc, "spoolss_io_q_reply_rrpcn");
6148 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6151 if (!prs_uint32("change_low", ps, depth, &q_u->change_low))
6154 if (!prs_uint32("change_high", ps, depth, &q_u->change_high))
6157 if (!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6160 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6163 if (!prs_uint32("info_ptr", ps, depth, &q_u->info_ptr))
6166 if(q_u->info_ptr!=0)
6167 if(!smb_io_notify_info(desc, &q_u->info, ps, depth))
6173 /*******************************************************************
6174 Parse a SPOOL_R_REPLY_RRPCN structure.
6175 ********************************************************************/
6177 bool spoolss_io_r_reply_rrpcn(const char *desc, SPOOL_R_REPLY_RRPCN *r_u, prs_struct *ps, int depth)
6179 prs_debug(ps, depth, desc, "spoolss_io_r_reply_rrpcn");
6185 if (!prs_uint32("unknown0", ps, depth, &r_u->unknown0))
6188 if (!prs_werror("status", ps, depth, &r_u->status))
6194 /*******************************************************************
6196 * called from spoolss_q_getprinterdataex (srv_spoolss.c)
6197 ********************************************************************/
6199 bool spoolss_io_q_getprinterdataex(const char *desc, SPOOL_Q_GETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6204 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdataex");
6209 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6213 if (!smb_io_unistr2("keyname", &q_u->keyname,True,ps,depth))
6217 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
6221 if (!prs_uint32("size", ps, depth, &q_u->size))
6227 /*******************************************************************
6228 * write a structure.
6229 * called from spoolss_r_getprinterdataex (srv_spoolss.c)
6230 ********************************************************************/
6232 bool spoolss_io_r_getprinterdataex(const char *desc, SPOOL_R_GETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6237 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdataex");
6242 if (!prs_uint32("type", ps, depth, &r_u->type))
6244 if (!prs_uint32("size", ps, depth, &r_u->size))
6247 if (UNMARSHALLING(ps) && r_u->size) {
6248 r_u->data = PRS_ALLOC_MEM(ps, unsigned char, r_u->size);
6253 if (!prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size))
6259 if (!prs_uint32("needed", ps, depth, &r_u->needed))
6261 if (!prs_werror("status", ps, depth, &r_u->status))
6267 /*******************************************************************
6269 ********************************************************************/
6271 bool spoolss_io_q_setprinterdataex(const char *desc, SPOOL_Q_SETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6273 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdataex");
6278 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6280 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6286 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
6292 if(!prs_uint32("type", ps, depth, &q_u->type))
6295 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
6305 if (UNMARSHALLING(ps))
6306 q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
6307 if(q_u->data == NULL)
6309 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
6317 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
6323 /*******************************************************************
6324 * write a structure.
6325 ********************************************************************/
6327 bool spoolss_io_r_setprinterdataex(const char *desc, SPOOL_R_SETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6329 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdataex");
6334 if(!prs_werror("status", ps, depth, &r_u->status))
6340 /*******************************************************************
6342 ********************************************************************/
6343 bool make_spoolss_q_enumprinterkey(SPOOL_Q_ENUMPRINTERKEY *q_u,
6344 POLICY_HND *hnd, const char *key,
6347 DEBUG(5,("make_spoolss_q_enumprinterkey\n"));
6349 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6350 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
6356 /*******************************************************************
6358 ********************************************************************/
6360 bool spoolss_io_q_enumprinterkey(const char *desc, SPOOL_Q_ENUMPRINTERKEY *q_u, prs_struct *ps, int depth)
6362 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterkey");
6367 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6370 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6376 if(!prs_uint32("size", ps, depth, &q_u->size))
6382 /*******************************************************************
6383 * write a structure.
6384 ********************************************************************/
6386 bool spoolss_io_r_enumprinterkey(const char *desc, SPOOL_R_ENUMPRINTERKEY *r_u, prs_struct *ps, int depth)
6388 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterkey");
6394 if (!smb_io_buffer5("", &r_u->keys, ps, depth))
6400 if(!prs_uint32("needed", ps, depth, &r_u->needed))
6403 if(!prs_werror("status", ps, depth, &r_u->status))
6409 /*******************************************************************
6411 ********************************************************************/
6413 bool make_spoolss_q_deleteprinterkey(SPOOL_Q_DELETEPRINTERKEY *q_u,
6414 POLICY_HND *hnd, char *keyname)
6416 DEBUG(5,("make_spoolss_q_deleteprinterkey\n"));
6418 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6419 init_unistr2(&q_u->keyname, keyname, UNI_STR_TERMINATE);
6424 /*******************************************************************
6426 ********************************************************************/
6428 bool spoolss_io_q_deleteprinterkey(const char *desc, SPOOL_Q_DELETEPRINTERKEY *q_u, prs_struct *ps, int depth)
6430 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterkey");
6435 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6438 if(!smb_io_unistr2("", &q_u->keyname, True, ps, depth))
6444 /*******************************************************************
6445 * write a structure.
6446 ********************************************************************/
6448 bool spoolss_io_r_deleteprinterkey(const char *desc, SPOOL_R_DELETEPRINTERKEY *r_u, prs_struct *ps, int depth)
6450 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterkey");
6456 if(!prs_werror("status", ps, depth, &r_u->status))
6463 /*******************************************************************
6465 ********************************************************************/
6467 bool spoolss_io_q_enumprinterdataex(const char *desc, SPOOL_Q_ENUMPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6469 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdataex");
6474 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6477 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6483 if(!prs_uint32("size", ps, depth, &q_u->size))
6489 /*******************************************************************
6490 ********************************************************************/
6492 static bool spoolss_io_printer_enum_values_ctr(const char *desc, prs_struct *ps,
6493 PRINTER_ENUM_VALUES_CTR *ctr, int depth)
6496 uint32 valuename_offset,
6499 const uint32 basic_unit = 20; /* size of static portion of enum_values */
6501 prs_debug(ps, depth, desc, "spoolss_io_printer_enum_values_ctr");
6505 * offset data begins at 20 bytes per structure * size_of_array.
6506 * Don't forget the uint32 at the beginning
6509 current_offset = basic_unit * ctr->size_of_array;
6511 /* first loop to write basic enum_value information */
6513 if (UNMARSHALLING(ps) && ctr->size_of_array) {
6514 ctr->values = PRS_ALLOC_MEM(ps, PRINTER_ENUM_VALUES, ctr->size_of_array);
6519 for (i=0; i<ctr->size_of_array; i++) {
6520 uint32 base_offset, return_offset;
6522 base_offset = prs_offset(ps);
6524 valuename_offset = current_offset;
6525 if (!prs_uint32("valuename_offset", ps, depth, &valuename_offset))
6528 /* Read or write the value. */
6530 return_offset = prs_offset(ps);
6532 if (!prs_set_offset(ps, base_offset + valuename_offset)) {
6536 if (!prs_unistr("valuename", ps, depth, &ctr->values[i].valuename))
6540 if (!prs_set_offset(ps, return_offset))
6543 if (!prs_uint32("value_len", ps, depth, &ctr->values[i].value_len))
6546 if (!prs_uint32("type", ps, depth, &ctr->values[i].type))
6549 data_offset = ctr->values[i].value_len + valuename_offset;
6551 if (!prs_uint32("data_offset", ps, depth, &data_offset))
6554 if (!prs_uint32("data_len", ps, depth, &ctr->values[i].data_len))
6557 /* Read or write the data. */
6559 return_offset = prs_offset(ps);
6561 if (!prs_set_offset(ps, base_offset + data_offset)) {
6565 if ( ctr->values[i].data_len ) {
6566 if ( UNMARSHALLING(ps) ) {
6567 ctr->values[i].data = PRS_ALLOC_MEM(ps, uint8, ctr->values[i].data_len);
6568 if (!ctr->values[i].data)
6571 if (!prs_uint8s(False, "data", ps, depth, ctr->values[i].data, ctr->values[i].data_len))
6575 current_offset = data_offset + ctr->values[i].data_len - basic_unit;
6576 /* account for 2 byte alignment */
6577 current_offset += (current_offset % 2);
6579 /* Remember how far we got. */
6580 data_offset = prs_offset(ps);
6583 if (!prs_set_offset(ps, return_offset))
6588 /* Go to the last data offset we got to. */
6590 if (!prs_set_offset(ps, data_offset))
6593 /* And ensure we're 2 byte aligned. */
6595 if ( !prs_align_uint16(ps) )
6601 /*******************************************************************
6602 * write a structure.
6603 ********************************************************************/
6605 bool spoolss_io_r_enumprinterdataex(const char *desc, SPOOL_R_ENUMPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6607 uint32 data_offset, end_offset;
6608 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdataex");
6614 if (!prs_uint32("size", ps, depth, &r_u->ctr.size))
6617 data_offset = prs_offset(ps);
6619 if (!prs_set_offset(ps, data_offset + r_u->ctr.size))
6625 if(!prs_uint32("needed", ps, depth, &r_u->needed))
6628 if(!prs_uint32("returned", ps, depth, &r_u->returned))
6631 if(!prs_werror("status", ps, depth, &r_u->status))
6634 r_u->ctr.size_of_array = r_u->returned;
6636 end_offset = prs_offset(ps);
6638 if (!prs_set_offset(ps, data_offset))
6642 if (!spoolss_io_printer_enum_values_ctr("", ps, &r_u->ctr, depth ))
6645 if (!prs_set_offset(ps, end_offset))
6650 /*******************************************************************
6651 * write a structure.
6652 ********************************************************************/
6655 uint32 GetPrintProcessorDirectory(
6657 [in] unistr2 *environment,
6659 [in,out] RPC_BUFFER buffer,
6660 [in] uint32 offered,
6661 [out] uint32 needed,
6662 [out] uint32 returned
6667 bool make_spoolss_q_getprintprocessordirectory(SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, const char *name, char *environment, int level, RPC_BUFFER *buffer, uint32 offered)
6669 DEBUG(5,("make_spoolss_q_getprintprocessordirectory\n"));
6671 init_unistr2(&q_u->name, name, UNI_STR_TERMINATE);
6672 init_unistr2(&q_u->environment, environment, UNI_STR_TERMINATE);
6676 q_u->buffer = buffer;
6677 q_u->offered = offered;
6682 bool spoolss_io_q_getprintprocessordirectory(const char *desc, SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, prs_struct *ps, int depth)
6686 prs_debug(ps, depth, desc, "spoolss_io_q_getprintprocessordirectory");
6692 if (!prs_uint32("ptr", ps, depth, &ptr))
6696 if(!smb_io_unistr2("name", &q_u->name, True, ps, depth))
6703 if (!prs_uint32("ptr", ps, depth, &ptr))
6707 if(!smb_io_unistr2("environment", &q_u->environment, True,
6715 if(!prs_uint32("level", ps, depth, &q_u->level))
6718 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
6724 if(!prs_uint32("offered", ps, depth, &q_u->offered))
6730 /*******************************************************************
6731 * write a structure.
6732 ********************************************************************/
6734 bool spoolss_io_r_getprintprocessordirectory(const char *desc, SPOOL_R_GETPRINTPROCESSORDIRECTORY *r_u, prs_struct *ps, int depth)
6736 prs_debug(ps, depth, desc, "spoolss_io_r_getprintprocessordirectory");
6742 if(!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
6748 if(!prs_uint32("needed", ps, depth, &r_u->needed))
6751 if(!prs_werror("status", ps, depth, &r_u->status))
6757 bool smb_io_printprocessordirectory_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_DIRECTORY_1 *info, int depth)
6759 prs_struct *ps=&buffer->prs;
6761 prs_debug(ps, depth, desc, "smb_io_printprocessordirectory_1");
6764 buffer->struct_start=prs_offset(ps);
6766 if (!smb_io_unistr(desc, &info->name, ps, depth))
6772 /*******************************************************************
6774 ********************************************************************/
6776 bool make_spoolss_q_enumforms(SPOOL_Q_ENUMFORMS *q_u, POLICY_HND *handle,
6777 uint32 level, RPC_BUFFER *buffer,
6780 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
6783 q_u->offered=offered;
6788 /*******************************************************************
6790 ********************************************************************/
6792 bool make_spoolss_q_setjob(SPOOL_Q_SETJOB *q_u, POLICY_HND *handle,
6793 uint32 jobid, uint32 level, uint32 command)
6795 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
6799 /* Hmm - the SPOOL_Q_SETJOB structure has a JOB_INFO ctr in it but
6800 the server side code has it marked as unused. */
6802 q_u->command = command;
6807 /*******************************************************************
6809 ********************************************************************/
6811 bool make_spoolss_q_getjob(SPOOL_Q_GETJOB *q_u, POLICY_HND *handle,
6812 uint32 jobid, uint32 level, RPC_BUFFER *buffer,
6815 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
6818 q_u->buffer = buffer;
6819 q_u->offered = offered;
6824 /*******************************************************************
6826 ********************************************************************/
6828 bool make_spoolss_q_startdocprinter(SPOOL_Q_STARTDOCPRINTER *q_u,
6829 POLICY_HND *handle, uint32 level,
6830 char *docname, char *outputfile,
6833 DOC_INFO_CONTAINER *ctr = &q_u->doc_info_container;
6835 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
6841 ctr->docinfo.switch_value = level;
6843 ctr->docinfo.doc_info_1.p_docname = docname ? 1 : 0;
6844 ctr->docinfo.doc_info_1.p_outputfile = outputfile ? 1 : 0;
6845 ctr->docinfo.doc_info_1.p_datatype = datatype ? 1 : 0;
6847 init_unistr2(&ctr->docinfo.doc_info_1.docname, docname, UNI_STR_TERMINATE);
6848 init_unistr2(&ctr->docinfo.doc_info_1.outputfile, outputfile, UNI_STR_TERMINATE);
6849 init_unistr2(&ctr->docinfo.doc_info_1.datatype, datatype, UNI_STR_TERMINATE);
6853 /* DOC_INFO_2 is only used by Windows 9x and since it
6854 doesn't do printing over RPC we don't have to worry
6857 DEBUG(3, ("unsupported info level %d\n", level));
6864 /*******************************************************************
6866 ********************************************************************/
6868 bool make_spoolss_q_deleteprinterdata(SPOOL_Q_DELETEPRINTERDATA *q_u,
6869 POLICY_HND *handle, char *valuename)
6871 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
6872 init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
6877 /*******************************************************************
6879 ********************************************************************/
6881 bool make_spoolss_q_deleteprinterdataex(SPOOL_Q_DELETEPRINTERDATAEX *q_u,
6882 POLICY_HND *handle, char *key,
6885 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
6886 init_unistr2(&q_u->valuename, value, UNI_STR_TERMINATE);
6887 init_unistr2(&q_u->keyname, key, UNI_STR_TERMINATE);
6892 /*******************************************************************
6894 ********************************************************************/
6896 bool make_spoolss_q_rffpcnex(SPOOL_Q_RFFPCNEX *q_u, POLICY_HND *handle,
6897 uint32 flags, uint32 options, const char *localmachine,
6898 uint32 printerlocal, SPOOL_NOTIFY_OPTION *option)
6900 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
6903 q_u->options = options;
6905 q_u->localmachine_ptr = 1;
6907 init_unistr2(&q_u->localmachine, localmachine, UNI_STR_TERMINATE);
6909 q_u->printerlocal = printerlocal;
6912 q_u->option_ptr = 1;
6914 q_u->option = option;
6920 /*******************************************************************
6921 ********************************************************************/
6923 bool spoolss_io_q_xcvdataport(const char *desc, SPOOL_Q_XCVDATAPORT *q_u, prs_struct *ps, int depth)
6925 prs_debug(ps, depth, desc, "spoolss_io_q_xcvdataport");
6931 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6934 if(!smb_io_unistr2("", &q_u->dataname, True, ps, depth))
6940 if(!prs_rpcbuffer("", ps, depth, &q_u->indata))
6946 if (!prs_uint32("indata_len", ps, depth, &q_u->indata_len))
6948 if (!prs_uint32("offered", ps, depth, &q_u->offered))
6950 if (!prs_uint32("unknown", ps, depth, &q_u->unknown))
6956 /*******************************************************************
6957 ********************************************************************/
6959 bool spoolss_io_r_xcvdataport(const char *desc, SPOOL_R_XCVDATAPORT *r_u, prs_struct *ps, int depth)
6961 prs_debug(ps, depth, desc, "spoolss_io_r_xcvdataport");
6966 if(!prs_rpcbuffer("", ps, depth, &r_u->outdata))
6972 if (!prs_uint32("needed", ps, depth, &r_u->needed))
6974 if (!prs_uint32("unknown", ps, depth, &r_u->unknown))
6977 if(!prs_werror("status", ps, depth, &r_u->status))
6983 /*******************************************************************
6984 ********************************************************************/
6986 bool make_monitorui_buf( RPC_BUFFER *buf, const char *dllname )
6993 init_unistr( &string, dllname );
6995 if ( !prs_unistr( "ui_dll", &buf->prs, 0, &string ) )
7001 /*******************************************************************
7002 ********************************************************************/
7004 #define PORT_DATA_1_PAD 540
7006 static bool smb_io_port_data_1( const char *desc, RPC_BUFFER *buf, int depth, SPOOL_PORT_DATA_1 *p1 )
7008 prs_struct *ps = &buf->prs;
7009 uint8 padding[PORT_DATA_1_PAD];
7011 prs_debug(ps, depth, desc, "smb_io_port_data_1");
7017 if( !prs_uint16s(True, "portname", ps, depth, p1->portname, MAX_PORTNAME))
7020 if (!prs_uint32("version", ps, depth, &p1->version))
7022 if (!prs_uint32("protocol", ps, depth, &p1->protocol))
7024 if (!prs_uint32("size", ps, depth, &p1->size))
7026 if (!prs_uint32("reserved", ps, depth, &p1->reserved))
7029 if( !prs_uint16s(True, "hostaddress", ps, depth, p1->hostaddress, MAX_NETWORK_NAME))
7031 if( !prs_uint16s(True, "snmpcommunity", ps, depth, p1->snmpcommunity, MAX_SNMP_COMM_NAME))
7034 if (!prs_uint32("dblspool", ps, depth, &p1->dblspool))
7037 if( !prs_uint16s(True, "queue", ps, depth, p1->queue, MAX_QUEUE_NAME))
7039 if( !prs_uint16s(True, "ipaddress", ps, depth, p1->ipaddress, MAX_IPADDR_STRING))
7042 if( !prs_uint8s(False, "", ps, depth, padding, PORT_DATA_1_PAD))
7045 if (!prs_uint32("port", ps, depth, &p1->port))
7047 if (!prs_uint32("snmpenabled", ps, depth, &p1->snmpenabled))
7049 if (!prs_uint32("snmpdevindex", ps, depth, &p1->snmpdevindex))
7055 /*******************************************************************
7056 ********************************************************************/
7058 bool convert_port_data_1( NT_PORT_DATA_1 *port1, RPC_BUFFER *buf )
7060 SPOOL_PORT_DATA_1 spdata_1;
7062 ZERO_STRUCT( spdata_1 );
7064 if ( !smb_io_port_data_1( "port_data_1", buf, 0, &spdata_1 ) )
7067 rpcstr_pull(port1->name, spdata_1.portname, sizeof(port1->name), -1, 0);
7068 rpcstr_pull(port1->queue, spdata_1.queue, sizeof(port1->queue), -1, 0);
7069 rpcstr_pull(port1->hostaddr, spdata_1.hostaddress, sizeof(port1->hostaddr), -1, 0);
7071 port1->port = spdata_1.port;
7073 switch ( spdata_1.protocol ) {
7075 port1->protocol = PORT_PROTOCOL_DIRECT;
7078 port1->protocol = PORT_PROTOCOL_LPR;
7081 DEBUG(3,("convert_port_data_1: unknown protocol [%d]!\n",
7082 spdata_1.protocol));