2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-2000,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
6 * Copyright (C) Jean François Micouleau 1998-2000,
7 * Copyright (C) Gerald Carter 2000-2002,
8 * Copyright (C) Tim Potter 2001-2002.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 #define DBGC_CLASS DBGC_RPC_PARSE
31 /*******************************************************************
32 This should be moved in a more generic lib.
33 ********************************************************************/
35 BOOL spoolss_io_system_time(const char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
37 if(!prs_uint16("year", ps, depth, &systime->year))
39 if(!prs_uint16("month", ps, depth, &systime->month))
41 if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
43 if(!prs_uint16("day", ps, depth, &systime->day))
45 if(!prs_uint16("hour", ps, depth, &systime->hour))
47 if(!prs_uint16("minute", ps, depth, &systime->minute))
49 if(!prs_uint16("second", ps, depth, &systime->second))
51 if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
57 /*******************************************************************
58 ********************************************************************/
60 BOOL make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
62 systime->year=unixtime->tm_year+1900;
63 systime->month=unixtime->tm_mon+1;
64 systime->dayofweek=unixtime->tm_wday;
65 systime->day=unixtime->tm_mday;
66 systime->hour=unixtime->tm_hour;
67 systime->minute=unixtime->tm_min;
68 systime->second=unixtime->tm_sec;
69 systime->milliseconds=0;
74 /*******************************************************************
75 reads or writes an DOC_INFO structure.
76 ********************************************************************/
78 static BOOL smb_io_doc_info_1(const char *desc, DOC_INFO_1 *info_1, prs_struct *ps, int depth)
80 if (info_1 == NULL) return False;
82 prs_debug(ps, depth, desc, "smb_io_doc_info_1");
88 if(!prs_uint32("p_docname", ps, depth, &info_1->p_docname))
90 if(!prs_uint32("p_outputfile", ps, depth, &info_1->p_outputfile))
92 if(!prs_uint32("p_datatype", ps, depth, &info_1->p_datatype))
95 if(!smb_io_unistr2("", &info_1->docname, info_1->p_docname, ps, depth))
97 if(!smb_io_unistr2("", &info_1->outputfile, info_1->p_outputfile, ps, depth))
99 if(!smb_io_unistr2("", &info_1->datatype, info_1->p_datatype, ps, depth))
105 /*******************************************************************
106 reads or writes an DOC_INFO structure.
107 ********************************************************************/
109 static BOOL smb_io_doc_info(const char *desc, DOC_INFO *info, prs_struct *ps, int depth)
111 uint32 useless_ptr=0;
113 if (info == NULL) return False;
115 prs_debug(ps, depth, desc, "smb_io_doc_info");
121 if(!prs_uint32("switch_value", ps, depth, &info->switch_value))
124 if(!prs_uint32("doc_info_X ptr", ps, depth, &useless_ptr))
127 switch (info->switch_value)
130 if(!smb_io_doc_info_1("",&info->doc_info_1, ps, depth))
135 this is just a placeholder
137 MSDN July 1998 says doc_info_2 is only on
138 Windows 95, and as Win95 doesn't do RPC to print
139 this case is nearly impossible
141 Maybe one day with Windows for dishwasher 2037 ...
144 /* smb_io_doc_info_2("",&info->doc_info_2, ps, depth); */
147 DEBUG(0,("Something is obviously wrong somewhere !\n"));
154 /*******************************************************************
155 reads or writes an DOC_INFO_CONTAINER structure.
156 ********************************************************************/
158 static BOOL smb_io_doc_info_container(const char *desc, DOC_INFO_CONTAINER *cont, prs_struct *ps, int depth)
160 if (cont == NULL) return False;
162 prs_debug(ps, depth, desc, "smb_io_doc_info_container");
168 if(!prs_uint32("level", ps, depth, &cont->level))
171 if(!smb_io_doc_info("",&cont->docinfo, ps, depth))
177 /*******************************************************************
178 reads or writes an NOTIFY OPTION TYPE structure.
179 ********************************************************************/
181 /* NOTIFY_OPTION_TYPE and NOTIFY_OPTION_TYPE_DATA are really one
182 structure. The _TYPE structure is really the deferred referrants (i.e
183 the notify fields array) of the _TYPE structure. -tpot */
185 static BOOL smb_io_notify_option_type(const char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
187 prs_debug(ps, depth, desc, "smb_io_notify_option_type");
193 if(!prs_uint16("type", ps, depth, &type->type))
195 if(!prs_uint16("reserved0", ps, depth, &type->reserved0))
197 if(!prs_uint32("reserved1", ps, depth, &type->reserved1))
199 if(!prs_uint32("reserved2", ps, depth, &type->reserved2))
201 if(!prs_uint32("count", ps, depth, &type->count))
203 if(!prs_uint32("fields_ptr", ps, depth, &type->fields_ptr))
209 /*******************************************************************
210 reads or writes an NOTIFY OPTION TYPE DATA.
211 ********************************************************************/
213 static BOOL smb_io_notify_option_type_data(const char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
217 prs_debug(ps, depth, desc, "smb_io_notify_option_type_data");
220 /* if there are no fields just return */
221 if (type->fields_ptr==0)
227 if(!prs_uint32("count2", ps, depth, &type->count2))
230 if (type->count2 != type->count)
231 DEBUG(4,("What a mess, count was %x now is %x !\n", type->count, type->count2));
233 /* parse the option type data */
234 for(i=0;i<type->count2;i++)
235 if(!prs_uint16("fields",ps,depth,&type->fields[i]))
240 /*******************************************************************
241 reads or writes an NOTIFY OPTION structure.
242 ********************************************************************/
244 static BOOL smb_io_notify_option_type_ctr(const char *desc, SPOOL_NOTIFY_OPTION_TYPE_CTR *ctr , prs_struct *ps, int depth)
248 prs_debug(ps, depth, desc, "smb_io_notify_option_type_ctr");
251 if(!prs_uint32("count", ps, depth, &ctr->count))
255 if (UNMARSHALLING(ps))
256 if((ctr->type=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION_TYPE,ctr->count)) == NULL)
259 /* the option type struct */
260 for(i=0;i<ctr->count;i++)
261 if(!smb_io_notify_option_type("", &ctr->type[i] , ps, depth))
264 /* the type associated with the option type struct */
265 for(i=0;i<ctr->count;i++)
266 if(!smb_io_notify_option_type_data("", &ctr->type[i] , ps, depth))
272 /*******************************************************************
273 reads or writes an NOTIFY OPTION structure.
274 ********************************************************************/
276 static BOOL smb_io_notify_option(const char *desc, SPOOL_NOTIFY_OPTION *option, prs_struct *ps, int depth)
278 prs_debug(ps, depth, desc, "smb_io_notify_option");
281 if(!prs_uint32("version", ps, depth, &option->version))
283 if(!prs_uint32("flags", ps, depth, &option->flags))
285 if(!prs_uint32("count", ps, depth, &option->count))
287 if(!prs_uint32("option_type_ptr", ps, depth, &option->option_type_ptr))
290 /* marshalling or unmarshalling, that would work */
291 if (option->option_type_ptr!=0) {
292 if(!smb_io_notify_option_type_ctr("", &option->ctr ,ps, depth))
296 option->ctr.type=NULL;
303 /*******************************************************************
304 reads or writes an NOTIFY INFO DATA structure.
305 ********************************************************************/
307 static BOOL smb_io_notify_info_data(const char *desc,SPOOL_NOTIFY_INFO_DATA *data, prs_struct *ps, int depth)
309 uint32 useless_ptr=0x0FF0ADDE;
311 prs_debug(ps, depth, desc, "smb_io_notify_info_data");
316 if(!prs_uint16("type", ps, depth, &data->type))
318 if(!prs_uint16("field", ps, depth, &data->field))
321 if(!prs_uint32("how many words", ps, depth, &data->size))
323 if(!prs_uint32("id", ps, depth, &data->id))
325 if(!prs_uint32("how many words", ps, depth, &data->size))
328 switch (data->enc_type) {
330 /* One and two value data has two uint32 values */
332 case NOTIFY_ONE_VALUE:
333 case NOTIFY_TWO_VALUE:
335 if(!prs_uint32("value[0]", ps, depth, &data->notify_data.value[0]))
337 if(!prs_uint32("value[1]", ps, depth, &data->notify_data.value[1]))
341 /* Pointers and strings have a string length and a
342 pointer. For a string the length is expressed as
343 the number of uint16 characters plus a trailing
348 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length ))
350 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
357 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
360 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
366 if( !prs_uint32( "sd size", ps, depth, &data->notify_data.sd.size ) )
368 if( !prs_uint32( "pointer", ps, depth, &useless_ptr ) )
374 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data\n",
382 /*******************************************************************
383 reads or writes an NOTIFY INFO DATA structure.
384 ********************************************************************/
386 BOOL smb_io_notify_info_data_strings(const char *desc,SPOOL_NOTIFY_INFO_DATA *data,
387 prs_struct *ps, int depth)
389 prs_debug(ps, depth, desc, "smb_io_notify_info_data_strings");
395 switch(data->enc_type) {
397 /* No data for values */
399 case NOTIFY_ONE_VALUE:
400 case NOTIFY_TWO_VALUE:
404 /* Strings start with a length in uint16s */
409 data->notify_data.data.length /= 2;
411 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
414 if (UNMARSHALLING(ps)) {
415 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16,
416 data->notify_data.data.length);
418 if (!data->notify_data.data.string)
422 if (!prs_uint16uni(True, "string", ps, depth, data->notify_data.data.string,
423 data->notify_data.data.length))
427 data->notify_data.data.length *= 2;
433 if (UNMARSHALLING(ps)) {
434 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16,
435 data->notify_data.data.length);
437 if (!data->notify_data.data.string)
441 if(!prs_uint8s(True,"buffer",ps,depth,(uint8*)data->notify_data.data.string,data->notify_data.data.length))
447 if( !prs_uint32("secdesc size ", ps, depth, &data->notify_data.sd.size ) )
449 if ( !sec_io_desc( "sec_desc", &data->notify_data.sd.desc, ps, depth ) )
454 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data_strings\n",
460 if (isvalue==False) {
462 /* length of string in unicode include \0 */
463 x=data->notify_data.data.length+1;
465 if (data->field != 16)
466 if(!prs_uint32("string length", ps, depth, &x ))
469 if (MARSHALLING(ps)) {
470 /* These are already in little endian format. Don't byte swap. */
473 /* No memory allocated for this string
474 therefore following the data.string
475 pointer is a bad idea. Use a pointer to
476 the uint32 length union member to
477 provide a source for a unicode NULL */
479 if(!prs_uint8s(True,"string",ps,depth, (uint8 *)&data->notify_data.data.length,x*2))
483 if (data->field == 16)
486 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
491 /* Tallocate memory for string */
493 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16, x * 2);
494 if (!data->notify_data.data.string)
497 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
505 /* Win2k does not seem to put this parse align here */
513 /*******************************************************************
514 reads or writes an NOTIFY INFO structure.
515 ********************************************************************/
517 static BOOL smb_io_notify_info(const char *desc, SPOOL_NOTIFY_INFO *info, prs_struct *ps, int depth)
521 prs_debug(ps, depth, desc, "smb_io_notify_info");
527 if(!prs_uint32("count", ps, depth, &info->count))
529 if(!prs_uint32("version", ps, depth, &info->version))
531 if(!prs_uint32("flags", ps, depth, &info->flags))
533 if(!prs_uint32("count", ps, depth, &info->count))
536 for (i=0;i<info->count;i++) {
537 if(!smb_io_notify_info_data(desc, &info->data[i], ps, depth))
541 /* now do the strings at the end of the stream */
542 for (i=0;i<info->count;i++) {
543 if(!smb_io_notify_info_data_strings(desc, &info->data[i], ps, depth))
550 /*******************************************************************
551 ********************************************************************/
553 BOOL spool_io_user_level_1( const char *desc, prs_struct *ps, int depth, SPOOL_USER_1 *q_u )
555 prs_debug(ps, depth, desc, "");
561 if (!prs_uint32("size", ps, depth, &q_u->size))
564 if (!prs_io_unistr2_p("", ps, depth, &q_u->client_name))
566 if (!prs_io_unistr2_p("", ps, depth, &q_u->user_name))
569 if (!prs_uint32("build", ps, depth, &q_u->build))
571 if (!prs_uint32("major", ps, depth, &q_u->major))
573 if (!prs_uint32("minor", ps, depth, &q_u->minor))
575 if (!prs_uint32("processor", ps, depth, &q_u->processor))
578 if (!prs_io_unistr2("", ps, depth, q_u->client_name))
583 if (!prs_io_unistr2("", ps, depth, q_u->user_name))
589 /*******************************************************************
590 ********************************************************************/
592 static BOOL spool_io_user_level(const char *desc, SPOOL_USER_CTR *q_u, prs_struct *ps, int depth)
597 prs_debug(ps, depth, desc, "spool_io_user_level");
603 if (!prs_uint32("level", ps, depth, &q_u->level))
606 switch ( q_u->level )
609 if ( !prs_pointer( "" , ps, depth, (void**)&q_u->user.user1,
610 sizeof(SPOOL_USER_1), (PRS_POINTER_CAST)spool_io_user_level_1 ))
622 /*******************************************************************
623 * read or write a DEVICEMODE struct.
624 * on reading allocate memory for the private member
625 ********************************************************************/
627 #define DM_NUM_OPTIONAL_FIELDS 8
629 BOOL spoolss_io_devmode(const char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
631 int available_space; /* size of the device mode left to parse */
632 /* only important on unmarshalling */
635 struct optional_fields {
638 } opt_fields[DM_NUM_OPTIONAL_FIELDS] = {
639 { "icmmethod", NULL },
640 { "icmintent", NULL },
641 { "mediatype", NULL },
642 { "dithertype", NULL },
643 { "reserved1", NULL },
644 { "reserved2", NULL },
645 { "panningwidth", NULL },
646 { "panningheight", NULL }
649 /* assign at run time to keep non-gcc compilers happy */
651 opt_fields[0].field = &devmode->icmmethod;
652 opt_fields[1].field = &devmode->icmintent;
653 opt_fields[2].field = &devmode->mediatype;
654 opt_fields[3].field = &devmode->dithertype;
655 opt_fields[4].field = &devmode->reserved1;
656 opt_fields[5].field = &devmode->reserved2;
657 opt_fields[6].field = &devmode->panningwidth;
658 opt_fields[7].field = &devmode->panningheight;
661 prs_debug(ps, depth, desc, "spoolss_io_devmode");
664 if (UNMARSHALLING(ps)) {
665 devmode->devicename.buffer = PRS_ALLOC_MEM(ps, uint16, 32);
666 if (devmode->devicename.buffer == NULL)
670 if (!prs_uint16uni(True,"devicename", ps, depth, devmode->devicename.buffer, MAXDEVICENAME))
673 if (!prs_uint16("specversion", ps, depth, &devmode->specversion))
676 /* Sanity Check - look for unknown specversions, but don't fail if we see one.
677 Let the size determine that */
679 switch (devmode->specversion) {
680 /* list of observed spec version's */
688 DEBUG(0,("spoolss_io_devmode: Unknown specversion in devicemode [0x%x]\n",
689 devmode->specversion));
690 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
695 if (!prs_uint16("driverversion", ps, depth, &devmode->driverversion))
697 if (!prs_uint16("size", ps, depth, &devmode->size))
699 if (!prs_uint16("driverextra", ps, depth, &devmode->driverextra))
701 if (!prs_uint32("fields", ps, depth, &devmode->fields))
703 if (!prs_uint16("orientation", ps, depth, &devmode->orientation))
705 if (!prs_uint16("papersize", ps, depth, &devmode->papersize))
707 if (!prs_uint16("paperlength", ps, depth, &devmode->paperlength))
709 if (!prs_uint16("paperwidth", ps, depth, &devmode->paperwidth))
711 if (!prs_uint16("scale", ps, depth, &devmode->scale))
713 if (!prs_uint16("copies", ps, depth, &devmode->copies))
715 if (!prs_uint16("defaultsource", ps, depth, &devmode->defaultsource))
717 if (!prs_uint16("printquality", ps, depth, &devmode->printquality))
719 if (!prs_uint16("color", ps, depth, &devmode->color))
721 if (!prs_uint16("duplex", ps, depth, &devmode->duplex))
723 if (!prs_uint16("yresolution", ps, depth, &devmode->yresolution))
725 if (!prs_uint16("ttoption", ps, depth, &devmode->ttoption))
727 if (!prs_uint16("collate", ps, depth, &devmode->collate))
730 if (UNMARSHALLING(ps)) {
731 devmode->formname.buffer = PRS_ALLOC_MEM(ps, uint16, 32);
732 if (devmode->formname.buffer == NULL)
736 if (!prs_uint16uni(True, "formname", ps, depth, devmode->formname.buffer, 32))
738 if (!prs_uint16("logpixels", ps, depth, &devmode->logpixels))
740 if (!prs_uint32("bitsperpel", ps, depth, &devmode->bitsperpel))
742 if (!prs_uint32("pelswidth", ps, depth, &devmode->pelswidth))
744 if (!prs_uint32("pelsheight", ps, depth, &devmode->pelsheight))
746 if (!prs_uint32("displayflags", ps, depth, &devmode->displayflags))
748 if (!prs_uint32("displayfrequency", ps, depth, &devmode->displayfrequency))
751 * every device mode I've ever seen on the wire at least has up
752 * to the displayfrequency field. --jerry (05-09-2002)
755 /* add uint32's + uint16's + two UNICODE strings */
757 available_space = devmode->size - (sizeof(uint32)*6 + sizeof(uint16)*18 + sizeof(uint16)*64);
759 /* Sanity check - we only have uint32's left tp parse */
761 if ( available_space && ((available_space % sizeof(uint32)) != 0) ) {
762 DEBUG(0,("spoolss_io_devmode: available_space [%d] no in multiple of 4 bytes (size = %d)!\n",
763 available_space, devmode->size));
764 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
769 * Conditional parsing. Assume that the DeviceMode has been
770 * zero'd by the caller.
773 while ((available_space > 0) && (i < DM_NUM_OPTIONAL_FIELDS))
775 DEBUG(11, ("spoolss_io_devmode: [%d] bytes left to parse in devmode\n", available_space));
776 if (!prs_uint32(opt_fields[i].name, ps, depth, opt_fields[i].field))
778 available_space -= sizeof(uint32);
782 /* Sanity Check - we should no available space at this point unless
783 MS changes the device mode structure */
785 if (available_space) {
786 DEBUG(0,("spoolss_io_devmode: I've parsed all I know and there is still stuff left|\n"));
787 DEBUG(0,("spoolss_io_devmode: available_space = [%d], devmode_size = [%d]!\n",
788 available_space, devmode->size));
789 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
794 if (devmode->driverextra!=0) {
795 if (UNMARSHALLING(ps)) {
796 devmode->private=PRS_ALLOC_MEM(ps, uint8, devmode->driverextra);
797 if(devmode->private == NULL)
799 DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for private\n",devmode->driverextra));
802 DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of private\n",devmode->driverextra));
803 if (!prs_uint8s(False, "private", ps, depth,
804 devmode->private, devmode->driverextra))
811 /*******************************************************************
812 Read or write a DEVICEMODE container
813 ********************************************************************/
815 static BOOL spoolss_io_devmode_cont(const char *desc, DEVMODE_CTR *dm_c, prs_struct *ps, int depth)
820 prs_debug(ps, depth, desc, "spoolss_io_devmode_cont");
826 if (!prs_uint32("size", ps, depth, &dm_c->size))
829 if (!prs_uint32("devmode_ptr", ps, depth, &dm_c->devmode_ptr))
832 if (dm_c->size==0 || dm_c->devmode_ptr==0) {
833 if (UNMARSHALLING(ps))
834 /* if while reading there is no DEVMODE ... */
839 /* so we have a DEVICEMODE to follow */
840 if (UNMARSHALLING(ps)) {
841 DEBUG(9,("Allocating memory for spoolss_io_devmode\n"));
842 dm_c->devmode=PRS_ALLOC_MEM(ps,DEVICEMODE,1);
843 if(dm_c->devmode == NULL)
847 /* this is bad code, shouldn't be there */
848 if (!prs_uint32("size", ps, depth, &dm_c->size))
851 if (!spoolss_io_devmode(desc, ps, depth, dm_c->devmode))
857 /*******************************************************************
858 ********************************************************************/
860 static BOOL spoolss_io_printer_default(const char *desc, PRINTER_DEFAULT *pd, prs_struct *ps, int depth)
865 prs_debug(ps, depth, desc, "spoolss_io_printer_default");
868 if (!prs_uint32("datatype_ptr", ps, depth, &pd->datatype_ptr))
871 if (!smb_io_unistr2("datatype", &pd->datatype, pd->datatype_ptr, ps,depth))
877 if (!spoolss_io_devmode_cont("", &pd->devmode_cont, ps, depth))
883 if (!prs_uint32("access_required", ps, depth, &pd->access_required))
889 /*******************************************************************
891 ********************************************************************/
893 BOOL make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX *q_u,
894 const fstring printername,
895 const fstring datatype,
896 uint32 access_required,
897 const fstring clientname,
898 const fstring user_name)
900 DEBUG(5,("make_spoolss_q_open_printer_ex\n"));
902 q_u->printername = TALLOC_P( get_talloc_ctx(), UNISTR2 );
903 init_unistr2(q_u->printername, printername, UNI_STR_TERMINATE);
905 q_u->printer_default.datatype_ptr = 0;
907 q_u->printer_default.devmode_cont.size=0;
908 q_u->printer_default.devmode_cont.devmode_ptr=0;
909 q_u->printer_default.devmode_cont.devmode=NULL;
910 q_u->printer_default.access_required=access_required;
912 q_u->user_switch = 1;
914 q_u->user_ctr.level = 1;
915 q_u->user_ctr.user.user1->size = strlen(clientname) + strlen(user_name) + 10;
916 q_u->user_ctr.user.user1->build = 1381;
917 q_u->user_ctr.user.user1->major = 2;
918 q_u->user_ctr.user.user1->minor = 0;
919 q_u->user_ctr.user.user1->processor = 0;
921 q_u->user_ctr.user.user1->client_name = TALLOC_P( get_talloc_ctx(), UNISTR2 );
922 q_u->user_ctr.user.user1->user_name = TALLOC_P( get_talloc_ctx(), UNISTR2 );
924 init_unistr2(q_u->user_ctr.user.user1->client_name, clientname, UNI_STR_TERMINATE);
925 init_unistr2(q_u->user_ctr.user.user1->user_name, user_name, UNI_STR_TERMINATE);
930 /*******************************************************************
932 ********************************************************************/
934 BOOL make_spoolss_q_addprinterex( TALLOC_CTX *mem_ctx, SPOOL_Q_ADDPRINTEREX *q_u,
935 const char *srv_name, const char* clientname, const char* user_name,
936 uint32 level, PRINTER_INFO_CTR *ctr)
938 DEBUG(5,("make_spoolss_q_addprinterex\n"));
945 q_u->server_name = TALLOC_P( mem_ctx, UNISTR2 );
946 init_unistr2(q_u->server_name, srv_name, UNI_FLAGS_NONE);
950 q_u->info.level = level;
951 q_u->info.info_ptr = (ctr->printers_2!=NULL)?1:0;
954 /* init q_u->info.info2 from *info */
955 if (!make_spoolss_printer_info_2(mem_ctx, &q_u->info.info_2, ctr->printers_2)) {
956 DEBUG(0,("make_spoolss_q_addprinterex: Unable to fill SPOOL_Q_ADDPRINTEREX struct!\n"));
966 q_u->user_ctr.level = 1;
967 q_u->user_ctr.user.user1->build = 1381;
968 q_u->user_ctr.user.user1->major = 2;
969 q_u->user_ctr.user.user1->minor = 0;
970 q_u->user_ctr.user.user1->processor = 0;
972 q_u->user_ctr.user.user1->client_name = TALLOC_P( mem_ctx, UNISTR2 );
973 q_u->user_ctr.user.user1->user_name = TALLOC_P( mem_ctx, UNISTR2 );
975 init_unistr2(q_u->user_ctr.user.user1->client_name, clientname, UNI_STR_TERMINATE);
976 init_unistr2(q_u->user_ctr.user.user1->user_name, user_name, UNI_STR_TERMINATE);
978 q_u->user_ctr.user.user1->size = q_u->user_ctr.user.user1->user_name->uni_str_len +
979 q_u->user_ctr.user.user1->client_name->uni_str_len + 2;
984 /*******************************************************************
985 create a SPOOL_PRINTER_INFO_2 stuct from a PRINTER_INFO_2 struct
986 *******************************************************************/
988 BOOL make_spoolss_printer_info_2(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_2 **spool_info2,
989 PRINTER_INFO_2 *info)
992 SPOOL_PRINTER_INFO_LEVEL_2 *inf;
994 /* allocate the necessary memory */
995 if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_2))) {
996 DEBUG(0,("make_spoolss_printer_info_2: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_2 sruct!\n"));
1000 inf->servername_ptr = (info->servername.buffer!=NULL)?1:0;
1001 inf->printername_ptr = (info->printername.buffer!=NULL)?1:0;
1002 inf->sharename_ptr = (info->sharename.buffer!=NULL)?1:0;
1003 inf->portname_ptr = (info->portname.buffer!=NULL)?1:0;
1004 inf->drivername_ptr = (info->drivername.buffer!=NULL)?1:0;
1005 inf->comment_ptr = (info->comment.buffer!=NULL)?1:0;
1006 inf->location_ptr = (info->location.buffer!=NULL)?1:0;
1007 inf->devmode_ptr = (info->devmode!=NULL)?1:0;
1008 inf->sepfile_ptr = (info->sepfile.buffer!=NULL)?1:0;
1009 inf->printprocessor_ptr = (info->printprocessor.buffer!=NULL)?1:0;
1010 inf->datatype_ptr = (info->datatype.buffer!=NULL)?1:0;
1011 inf->parameters_ptr = (info->parameters.buffer!=NULL)?1:0;
1012 inf->secdesc_ptr = (info->secdesc!=NULL)?1:0;
1013 inf->attributes = info->attributes;
1014 inf->priority = info->priority;
1015 inf->default_priority = info->defaultpriority;
1016 inf->starttime = info->starttime;
1017 inf->untiltime = info->untiltime;
1018 inf->cjobs = info->cjobs;
1019 inf->averageppm = info->averageppm;
1020 init_unistr2_from_unistr(&inf->servername, &info->servername);
1021 init_unistr2_from_unistr(&inf->printername, &info->printername);
1022 init_unistr2_from_unistr(&inf->sharename, &info->sharename);
1023 init_unistr2_from_unistr(&inf->portname, &info->portname);
1024 init_unistr2_from_unistr(&inf->drivername, &info->drivername);
1025 init_unistr2_from_unistr(&inf->comment, &info->comment);
1026 init_unistr2_from_unistr(&inf->location, &info->location);
1027 init_unistr2_from_unistr(&inf->sepfile, &info->sepfile);
1028 init_unistr2_from_unistr(&inf->printprocessor, &info->printprocessor);
1029 init_unistr2_from_unistr(&inf->datatype, &info->datatype);
1030 init_unistr2_from_unistr(&inf->parameters, &info->parameters);
1031 init_unistr2_from_unistr(&inf->datatype, &info->datatype);
1038 /*******************************************************************
1039 create a SPOOL_PRINTER_INFO_3 struct from a PRINTER_INFO_3 struct
1040 *******************************************************************/
1042 BOOL make_spoolss_printer_info_3(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_3 **spool_info3,
1043 PRINTER_INFO_3 *info)
1046 SPOOL_PRINTER_INFO_LEVEL_3 *inf;
1048 /* allocate the necessary memory */
1049 if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_3))) {
1050 DEBUG(0,("make_spoolss_printer_info_3: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_3 sruct!\n"));
1054 inf->secdesc_ptr = (info->secdesc!=NULL)?1:0;
1061 /*******************************************************************
1062 create a SPOOL_PRINTER_INFO_7 struct from a PRINTER_INFO_7 struct
1063 *******************************************************************/
1065 BOOL make_spoolss_printer_info_7(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_7 **spool_info7,
1066 PRINTER_INFO_7 *info)
1069 SPOOL_PRINTER_INFO_LEVEL_7 *inf;
1071 /* allocate the necessary memory */
1072 if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_7))) {
1073 DEBUG(0,("make_spoolss_printer_info_7: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_7 struct!\n"));
1077 inf->guid_ptr = (info->guid.buffer!=NULL)?1:0;
1078 inf->action = info->action;
1079 init_unistr2_from_unistr(&inf->guid, &info->guid);
1087 /*******************************************************************
1089 * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1090 ********************************************************************/
1092 BOOL spoolss_io_q_open_printer(const char *desc, SPOOL_Q_OPEN_PRINTER *q_u, prs_struct *ps, int depth)
1097 prs_debug(ps, depth, desc, "spoolss_io_q_open_printer");
1103 if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->printername))
1105 if (!prs_io_unistr2("printername", ps, depth, q_u->printername))
1111 if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth))
1117 /*******************************************************************
1118 * write a structure.
1119 * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1120 * called from spoolss_open_printer_ex (cli_spoolss.c)
1121 ********************************************************************/
1123 BOOL spoolss_io_r_open_printer(const char *desc, SPOOL_R_OPEN_PRINTER *r_u, prs_struct *ps, int depth)
1125 if (r_u == NULL) return False;
1127 prs_debug(ps, depth, desc, "spoolss_io_r_open_printer");
1133 if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
1136 if (!prs_werror("status code", ps, depth, &(r_u->status)))
1143 /*******************************************************************
1145 * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1146 ********************************************************************/
1148 BOOL spoolss_io_q_open_printer_ex(const char *desc, SPOOL_Q_OPEN_PRINTER_EX *q_u, prs_struct *ps, int depth)
1153 prs_debug(ps, depth, desc, "spoolss_io_q_open_printer_ex");
1159 if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->printername))
1161 if (!prs_io_unistr2("printername", ps, depth, q_u->printername))
1167 if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth))
1170 if (!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
1172 if (!spool_io_user_level("", &q_u->user_ctr, ps, depth))
1178 /*******************************************************************
1179 * write a structure.
1180 * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1181 * called from spoolss_open_printer_ex (cli_spoolss.c)
1182 ********************************************************************/
1184 BOOL spoolss_io_r_open_printer_ex(const char *desc, SPOOL_R_OPEN_PRINTER_EX *r_u, prs_struct *ps, int depth)
1186 if (r_u == NULL) return False;
1188 prs_debug(ps, depth, desc, "spoolss_io_r_open_printer_ex");
1194 if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
1197 if (!prs_werror("status code", ps, depth, &(r_u->status)))
1203 /*******************************************************************
1205 ********************************************************************/
1206 BOOL make_spoolss_q_deleteprinterdriverex( TALLOC_CTX *mem_ctx,
1207 SPOOL_Q_DELETEPRINTERDRIVEREX *q_u,
1213 DEBUG(5,("make_spoolss_q_deleteprinterdriverex\n"));
1215 q_u->server_ptr = (server!=NULL)?1:0;
1216 q_u->delete_flags = DPD_DELETE_UNUSED_FILES;
1218 /* these must be NULL terminated or else NT4 will
1219 complain about invalid parameters --jerry */
1220 init_unistr2(&q_u->server, server, UNI_STR_TERMINATE);
1221 init_unistr2(&q_u->arch, arch, UNI_STR_TERMINATE);
1222 init_unistr2(&q_u->driver, driver, UNI_STR_TERMINATE);
1225 q_u->delete_flags |= DPD_DELETE_SPECIFIC_VERSION;
1226 q_u->version = version;
1233 /*******************************************************************
1235 ********************************************************************/
1236 BOOL make_spoolss_q_deleteprinterdriver(
1237 TALLOC_CTX *mem_ctx,
1238 SPOOL_Q_DELETEPRINTERDRIVER *q_u,
1244 DEBUG(5,("make_spoolss_q_deleteprinterdriver\n"));
1246 q_u->server_ptr = (server!=NULL)?1:0;
1248 /* these must be NULL terminated or else NT4 will
1249 complain about invalid parameters --jerry */
1250 init_unistr2(&q_u->server, server, UNI_STR_TERMINATE);
1251 init_unistr2(&q_u->arch, arch, UNI_STR_TERMINATE);
1252 init_unistr2(&q_u->driver, driver, UNI_STR_TERMINATE);
1257 /*******************************************************************
1259 ********************************************************************/
1261 BOOL make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u,
1262 const POLICY_HND *handle,
1263 const char *valuename, uint32 size)
1265 if (q_u == NULL) return False;
1267 DEBUG(5,("make_spoolss_q_getprinterdata\n"));
1269 q_u->handle = *handle;
1270 init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
1276 /*******************************************************************
1278 ********************************************************************/
1280 BOOL make_spoolss_q_getprinterdataex(SPOOL_Q_GETPRINTERDATAEX *q_u,
1281 const POLICY_HND *handle,
1282 const char *keyname,
1283 const char *valuename, uint32 size)
1285 if (q_u == NULL) return False;
1287 DEBUG(5,("make_spoolss_q_getprinterdataex\n"));
1289 q_u->handle = *handle;
1290 init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
1291 init_unistr2(&q_u->keyname, keyname, UNI_STR_TERMINATE);
1297 /*******************************************************************
1299 * called from spoolss_q_getprinterdata (srv_spoolss.c)
1300 ********************************************************************/
1302 BOOL spoolss_io_q_getprinterdata(const char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_struct *ps, int depth)
1307 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdata");
1312 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1316 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1320 if (!prs_uint32("size", ps, depth, &q_u->size))
1326 /*******************************************************************
1328 * called from spoolss_q_deleteprinterdata (srv_spoolss.c)
1329 ********************************************************************/
1331 BOOL spoolss_io_q_deleteprinterdata(const char *desc, SPOOL_Q_DELETEPRINTERDATA *q_u, prs_struct *ps, int depth)
1336 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdata");
1341 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1345 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1351 /*******************************************************************
1352 * write a structure.
1353 * called from spoolss_r_deleteprinterdata (srv_spoolss.c)
1354 ********************************************************************/
1356 BOOL spoolss_io_r_deleteprinterdata(const char *desc, SPOOL_R_DELETEPRINTERDATA *r_u, prs_struct *ps, int depth)
1358 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdata");
1360 if(!prs_werror("status", ps, depth, &r_u->status))
1366 /*******************************************************************
1368 * called from spoolss_q_deleteprinterdataex (srv_spoolss.c)
1369 ********************************************************************/
1371 BOOL spoolss_io_q_deleteprinterdataex(const char *desc, SPOOL_Q_DELETEPRINTERDATAEX *q_u, prs_struct *ps, int depth)
1376 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdataex");
1381 if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1384 if (!smb_io_unistr2("keyname ", &q_u->keyname, True, ps, depth))
1386 if (!smb_io_unistr2("valuename", &q_u->valuename, True, ps, depth))
1392 /*******************************************************************
1393 * write a structure.
1394 * called from spoolss_r_deleteprinterdataex (srv_spoolss.c)
1395 ********************************************************************/
1397 BOOL spoolss_io_r_deleteprinterdataex(const char *desc, SPOOL_R_DELETEPRINTERDATAEX *r_u, prs_struct *ps, int depth)
1399 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdataex");
1402 if(!prs_werror("status", ps, depth, &r_u->status))
1408 /*******************************************************************
1409 * write a structure.
1410 * called from spoolss_r_getprinterdata (srv_spoolss.c)
1411 ********************************************************************/
1413 BOOL spoolss_io_r_getprinterdata(const char *desc, SPOOL_R_GETPRINTERDATA *r_u, prs_struct *ps, int depth)
1418 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdata");
1423 if (!prs_uint32("type", ps, depth, &r_u->type))
1425 if (!prs_uint32("size", ps, depth, &r_u->size))
1428 if (UNMARSHALLING(ps) && r_u->size) {
1429 r_u->data = PRS_ALLOC_MEM(ps, unsigned char, r_u->size);
1434 if (!prs_uint8s( False, "data", ps, depth, r_u->data, r_u->size ))
1440 if (!prs_uint32("needed", ps, depth, &r_u->needed))
1442 if (!prs_werror("status", ps, depth, &r_u->status))
1448 /*******************************************************************
1450 ********************************************************************/
1452 BOOL make_spoolss_q_closeprinter(SPOOL_Q_CLOSEPRINTER *q_u, POLICY_HND *hnd)
1454 if (q_u == NULL) return False;
1456 DEBUG(5,("make_spoolss_q_closeprinter\n"));
1458 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
1463 /*******************************************************************
1465 * called from static spoolss_q_abortprinter (srv_spoolss.c)
1466 * called from spoolss_abortprinter (cli_spoolss.c)
1467 ********************************************************************/
1469 BOOL spoolss_io_q_abortprinter(const char *desc, SPOOL_Q_ABORTPRINTER *q_u, prs_struct *ps, int depth)
1471 if (q_u == NULL) return False;
1473 prs_debug(ps, depth, desc, "spoolss_io_q_abortprinter");
1479 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1485 /*******************************************************************
1486 * write a structure.
1487 * called from spoolss_r_abortprinter (srv_spoolss.c)
1488 ********************************************************************/
1490 BOOL spoolss_io_r_abortprinter(const char *desc, SPOOL_R_ABORTPRINTER *r_u, prs_struct *ps, int depth)
1492 prs_debug(ps, depth, desc, "spoolss_io_r_abortprinter");
1494 if(!prs_werror("status", ps, depth, &r_u->status))
1500 /*******************************************************************
1502 * called from static spoolss_q_deleteprinter (srv_spoolss.c)
1503 * called from spoolss_deleteprinter (cli_spoolss.c)
1504 ********************************************************************/
1506 BOOL spoolss_io_q_deleteprinter(const char *desc, SPOOL_Q_DELETEPRINTER *q_u, prs_struct *ps, int depth)
1508 if (q_u == NULL) return False;
1510 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinter");
1516 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1522 /*******************************************************************
1523 * write a structure.
1524 * called from static spoolss_r_deleteprinter (srv_spoolss.c)
1525 * called from spoolss_deleteprinter (cli_spoolss.c)
1526 ********************************************************************/
1528 BOOL spoolss_io_r_deleteprinter(const char *desc, SPOOL_R_DELETEPRINTER *r_u, prs_struct *ps, int depth)
1530 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinter");
1536 if (!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
1538 if (!prs_werror("status", ps, depth, &r_u->status))
1545 /*******************************************************************
1547 * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1548 * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1549 ********************************************************************/
1551 BOOL spoolss_io_q_deleteprinterdriver(const char *desc, SPOOL_Q_DELETEPRINTERDRIVER *q_u, prs_struct *ps, int depth)
1553 if (q_u == NULL) return False;
1555 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriver");
1561 if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
1563 if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
1565 if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
1567 if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
1575 /*******************************************************************
1576 * write a structure.
1577 ********************************************************************/
1578 BOOL spoolss_io_r_deleteprinterdriver(const char *desc, SPOOL_R_DELETEPRINTERDRIVER *r_u, prs_struct *ps, int depth)
1580 if (r_u == NULL) return False;
1582 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriver");
1588 if (!prs_werror("status", ps, depth, &r_u->status))
1595 /*******************************************************************
1597 * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1598 * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1599 ********************************************************************/
1601 BOOL spoolss_io_q_deleteprinterdriverex(const char *desc, SPOOL_Q_DELETEPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
1603 if (q_u == NULL) return False;
1605 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriverex");
1611 if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
1613 if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
1615 if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
1617 if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
1623 if(!prs_uint32("delete_flags ", ps, depth, &q_u->delete_flags))
1625 if(!prs_uint32("version ", ps, depth, &q_u->version))
1633 /*******************************************************************
1634 * write a structure.
1635 ********************************************************************/
1636 BOOL spoolss_io_r_deleteprinterdriverex(const char *desc, SPOOL_R_DELETEPRINTERDRIVEREX *r_u, prs_struct *ps, int depth)
1638 if (r_u == NULL) return False;
1640 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriverex");
1646 if (!prs_werror("status", ps, depth, &r_u->status))
1654 /*******************************************************************
1656 * called from static spoolss_q_closeprinter (srv_spoolss.c)
1657 * called from spoolss_closeprinter (cli_spoolss.c)
1658 ********************************************************************/
1660 BOOL spoolss_io_q_closeprinter(const char *desc, SPOOL_Q_CLOSEPRINTER *q_u, prs_struct *ps, int depth)
1662 if (q_u == NULL) return False;
1664 prs_debug(ps, depth, desc, "spoolss_io_q_closeprinter");
1670 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1676 /*******************************************************************
1677 * write a structure.
1678 * called from static spoolss_r_closeprinter (srv_spoolss.c)
1679 * called from spoolss_closeprinter (cli_spoolss.c)
1680 ********************************************************************/
1682 BOOL spoolss_io_r_closeprinter(const char *desc, SPOOL_R_CLOSEPRINTER *r_u, prs_struct *ps, int depth)
1684 prs_debug(ps, depth, desc, "spoolss_io_r_closeprinter");
1690 if (!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
1692 if (!prs_werror("status", ps, depth, &r_u->status))
1698 /*******************************************************************
1700 * called from spoolss_q_startdocprinter (srv_spoolss.c)
1701 ********************************************************************/
1703 BOOL spoolss_io_q_startdocprinter(const char *desc, SPOOL_Q_STARTDOCPRINTER *q_u, prs_struct *ps, int depth)
1705 if (q_u == NULL) return False;
1707 prs_debug(ps, depth, desc, "spoolss_io_q_startdocprinter");
1713 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1716 if(!smb_io_doc_info_container("",&q_u->doc_info_container, ps, depth))
1722 /*******************************************************************
1723 * write a structure.
1724 * called from spoolss_r_startdocprinter (srv_spoolss.c)
1725 ********************************************************************/
1727 BOOL spoolss_io_r_startdocprinter(const char *desc, SPOOL_R_STARTDOCPRINTER *r_u, prs_struct *ps, int depth)
1729 prs_debug(ps, depth, desc, "spoolss_io_r_startdocprinter");
1731 if(!prs_uint32("jobid", ps, depth, &r_u->jobid))
1733 if(!prs_werror("status", ps, depth, &r_u->status))
1739 /*******************************************************************
1741 * called from spoolss_q_enddocprinter (srv_spoolss.c)
1742 ********************************************************************/
1744 BOOL spoolss_io_q_enddocprinter(const char *desc, SPOOL_Q_ENDDOCPRINTER *q_u, prs_struct *ps, int depth)
1746 if (q_u == NULL) return False;
1748 prs_debug(ps, depth, desc, "spoolss_io_q_enddocprinter");
1754 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1760 /*******************************************************************
1761 * write a structure.
1762 * called from spoolss_r_enddocprinter (srv_spoolss.c)
1763 ********************************************************************/
1765 BOOL spoolss_io_r_enddocprinter(const char *desc, SPOOL_R_ENDDOCPRINTER *r_u, prs_struct *ps, int depth)
1767 prs_debug(ps, depth, desc, "spoolss_io_r_enddocprinter");
1769 if(!prs_werror("status", ps, depth, &r_u->status))
1775 /*******************************************************************
1777 * called from spoolss_q_startpageprinter (srv_spoolss.c)
1778 ********************************************************************/
1780 BOOL spoolss_io_q_startpageprinter(const char *desc, SPOOL_Q_STARTPAGEPRINTER *q_u, prs_struct *ps, int depth)
1782 if (q_u == NULL) return False;
1784 prs_debug(ps, depth, desc, "spoolss_io_q_startpageprinter");
1790 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1796 /*******************************************************************
1797 * write a structure.
1798 * called from spoolss_r_startpageprinter (srv_spoolss.c)
1799 ********************************************************************/
1801 BOOL spoolss_io_r_startpageprinter(const char *desc, SPOOL_R_STARTPAGEPRINTER *r_u, prs_struct *ps, int depth)
1803 prs_debug(ps, depth, desc, "spoolss_io_r_startpageprinter");
1805 if(!prs_werror("status", ps, depth, &r_u->status))
1811 /*******************************************************************
1813 * called from spoolss_q_endpageprinter (srv_spoolss.c)
1814 ********************************************************************/
1816 BOOL spoolss_io_q_endpageprinter(const char *desc, SPOOL_Q_ENDPAGEPRINTER *q_u, prs_struct *ps, int depth)
1818 if (q_u == NULL) return False;
1820 prs_debug(ps, depth, desc, "spoolss_io_q_endpageprinter");
1826 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1832 /*******************************************************************
1833 * write a structure.
1834 * called from spoolss_r_endpageprinter (srv_spoolss.c)
1835 ********************************************************************/
1837 BOOL spoolss_io_r_endpageprinter(const char *desc, SPOOL_R_ENDPAGEPRINTER *r_u, prs_struct *ps, int depth)
1839 prs_debug(ps, depth, desc, "spoolss_io_r_endpageprinter");
1841 if(!prs_werror("status", ps, depth, &r_u->status))
1847 /*******************************************************************
1849 * called from spoolss_q_writeprinter (srv_spoolss.c)
1850 ********************************************************************/
1852 BOOL spoolss_io_q_writeprinter(const char *desc, SPOOL_Q_WRITEPRINTER *q_u, prs_struct *ps, int depth)
1854 if (q_u == NULL) return False;
1856 prs_debug(ps, depth, desc, "spoolss_io_q_writeprinter");
1862 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1864 if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size))
1867 if (q_u->buffer_size!=0)
1869 if (UNMARSHALLING(ps))
1870 q_u->buffer=PRS_ALLOC_MEM(ps, uint8, q_u->buffer_size);
1871 if(q_u->buffer == NULL)
1873 if(!prs_uint8s(True, "buffer", ps, depth, q_u->buffer, q_u->buffer_size))
1878 if(!prs_uint32("buffer_size2", ps, depth, &q_u->buffer_size2))
1884 /*******************************************************************
1885 * write a structure.
1886 * called from spoolss_r_writeprinter (srv_spoolss.c)
1887 ********************************************************************/
1889 BOOL spoolss_io_r_writeprinter(const char *desc, SPOOL_R_WRITEPRINTER *r_u, prs_struct *ps, int depth)
1891 prs_debug(ps, depth, desc, "spoolss_io_r_writeprinter");
1893 if(!prs_uint32("buffer_written", ps, depth, &r_u->buffer_written))
1895 if(!prs_werror("status", ps, depth, &r_u->status))
1901 /*******************************************************************
1903 * called from spoolss_q_rffpcnex (srv_spoolss.c)
1904 ********************************************************************/
1906 BOOL spoolss_io_q_rffpcnex(const char *desc, SPOOL_Q_RFFPCNEX *q_u, prs_struct *ps, int depth)
1908 prs_debug(ps, depth, desc, "spoolss_io_q_rffpcnex");
1914 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1916 if(!prs_uint32("flags", ps, depth, &q_u->flags))
1918 if(!prs_uint32("options", ps, depth, &q_u->options))
1920 if(!prs_uint32("localmachine_ptr", ps, depth, &q_u->localmachine_ptr))
1922 if(!smb_io_unistr2("localmachine", &q_u->localmachine, q_u->localmachine_ptr, ps, depth))
1928 if(!prs_uint32("printerlocal", ps, depth, &q_u->printerlocal))
1931 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1934 if (q_u->option_ptr!=0) {
1936 if (UNMARSHALLING(ps))
1937 if((q_u->option=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION,1)) == NULL)
1940 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1947 /*******************************************************************
1948 * write a structure.
1949 * called from spoolss_r_rffpcnex (srv_spoolss.c)
1950 ********************************************************************/
1952 BOOL spoolss_io_r_rffpcnex(const char *desc, SPOOL_R_RFFPCNEX *r_u, prs_struct *ps, int depth)
1954 prs_debug(ps, depth, desc, "spoolss_io_r_rffpcnex");
1957 if(!prs_werror("status", ps, depth, &r_u->status))
1963 /*******************************************************************
1965 * called from spoolss_q_rfnpcnex (srv_spoolss.c)
1966 ********************************************************************/
1968 BOOL spoolss_io_q_rfnpcnex(const char *desc, SPOOL_Q_RFNPCNEX *q_u, prs_struct *ps, int depth)
1970 prs_debug(ps, depth, desc, "spoolss_io_q_rfnpcnex");
1976 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1979 if(!prs_uint32("change", ps, depth, &q_u->change))
1982 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1985 if (q_u->option_ptr!=0) {
1987 if (UNMARSHALLING(ps))
1988 if((q_u->option=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION,1)) == NULL)
1991 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1998 /*******************************************************************
1999 * write a structure.
2000 * called from spoolss_r_rfnpcnex (srv_spoolss.c)
2001 ********************************************************************/
2003 BOOL spoolss_io_r_rfnpcnex(const char *desc, SPOOL_R_RFNPCNEX *r_u, prs_struct *ps, int depth)
2005 prs_debug(ps, depth, desc, "spoolss_io_r_rfnpcnex");
2011 if (!prs_uint32("info_ptr", ps, depth, &r_u->info_ptr))
2014 if(!smb_io_notify_info("notify info", &r_u->info ,ps,depth))
2019 if(!prs_werror("status", ps, depth, &r_u->status))
2025 /*******************************************************************
2026 * return the length of a uint16 (obvious, but the code is clean)
2027 ********************************************************************/
2029 static uint32 size_of_uint16(uint16 *value)
2031 return (sizeof(*value));
2034 /*******************************************************************
2035 * return the length of a uint32 (obvious, but the code is clean)
2036 ********************************************************************/
2038 static uint32 size_of_uint32(uint32 *value)
2040 return (sizeof(*value));
2043 /*******************************************************************
2044 * return the length of a NTTIME (obvious, but the code is clean)
2045 ********************************************************************/
2047 static uint32 size_of_nttime(NTTIME *value)
2049 return (sizeof(*value));
2052 /*******************************************************************
2053 * return the length of a uint32 (obvious, but the code is clean)
2054 ********************************************************************/
2056 static uint32 size_of_device_mode(DEVICEMODE *devmode)
2061 return (4+devmode->size+devmode->driverextra);
2064 /*******************************************************************
2065 * return the length of a uint32 (obvious, but the code is clean)
2066 ********************************************************************/
2068 static uint32 size_of_systemtime(SYSTEMTIME *systime)
2073 return (sizeof(SYSTEMTIME) +4);
2076 /*******************************************************************
2077 Parse a DEVMODE structure and its relative pointer.
2078 ********************************************************************/
2080 static BOOL smb_io_reldevmode(const char *desc, RPC_BUFFER *buffer, int depth, DEVICEMODE **devmode)
2082 prs_struct *ps=&buffer->prs;
2084 prs_debug(ps, depth, desc, "smb_io_reldevmode");
2087 if (MARSHALLING(ps)) {
2088 uint32 struct_offset = prs_offset(ps);
2089 uint32 relative_offset;
2091 if (*devmode == NULL) {
2093 if (!prs_uint32("offset", ps, depth, &relative_offset))
2095 DEBUG(8, ("boing, the devmode was NULL\n"));
2100 buffer->string_at_end -= ((*devmode)->size + (*devmode)->driverextra);
2102 if(!prs_set_offset(ps, buffer->string_at_end))
2105 /* write the DEVMODE */
2106 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
2109 if(!prs_set_offset(ps, struct_offset))
2112 relative_offset=buffer->string_at_end - buffer->struct_start;
2113 /* write its offset */
2114 if (!prs_uint32("offset", ps, depth, &relative_offset))
2120 /* read the offset */
2121 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
2123 if (buffer->string_at_end == 0) {
2128 old_offset = prs_offset(ps);
2129 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
2132 /* read the string */
2133 if((*devmode=PRS_ALLOC_MEM(ps,DEVICEMODE,1)) == NULL)
2135 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
2138 if(!prs_set_offset(ps, old_offset))
2144 /*******************************************************************
2145 Parse a PRINTER_INFO_0 structure.
2146 ********************************************************************/
2148 BOOL smb_io_printer_info_0(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_0 *info, int depth)
2150 prs_struct *ps=&buffer->prs;
2152 prs_debug(ps, depth, desc, "smb_io_printer_info_0");
2155 buffer->struct_start=prs_offset(ps);
2157 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2159 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2162 if(!prs_uint32("cjobs", ps, depth, &info->cjobs))
2164 if(!prs_uint32("total_jobs", ps, depth, &info->total_jobs))
2166 if(!prs_uint32("total_bytes", ps, depth, &info->total_bytes))
2169 if(!prs_uint16("year", ps, depth, &info->year))
2171 if(!prs_uint16("month", ps, depth, &info->month))
2173 if(!prs_uint16("dayofweek", ps, depth, &info->dayofweek))
2175 if(!prs_uint16("day", ps, depth, &info->day))
2177 if(!prs_uint16("hour", ps, depth, &info->hour))
2179 if(!prs_uint16("minute", ps, depth, &info->minute))
2181 if(!prs_uint16("second", ps, depth, &info->second))
2183 if(!prs_uint16("milliseconds", ps, depth, &info->milliseconds))
2186 if(!prs_uint32("global_counter", ps, depth, &info->global_counter))
2188 if(!prs_uint32("total_pages", ps, depth, &info->total_pages))
2191 if(!prs_uint16("major_version", ps, depth, &info->major_version))
2193 if(!prs_uint16("build_version", ps, depth, &info->build_version))
2195 if(!prs_uint32("unknown7", ps, depth, &info->unknown7))
2197 if(!prs_uint32("unknown8", ps, depth, &info->unknown8))
2199 if(!prs_uint32("unknown9", ps, depth, &info->unknown9))
2201 if(!prs_uint32("session_counter", ps, depth, &info->session_counter))
2203 if(!prs_uint32("unknown11", ps, depth, &info->unknown11))
2205 if(!prs_uint32("printer_errors", ps, depth, &info->printer_errors))
2207 if(!prs_uint32("unknown13", ps, depth, &info->unknown13))
2209 if(!prs_uint32("unknown14", ps, depth, &info->unknown14))
2211 if(!prs_uint32("unknown15", ps, depth, &info->unknown15))
2213 if(!prs_uint32("unknown16", ps, depth, &info->unknown16))
2215 if(!prs_uint32("change_id", ps, depth, &info->change_id))
2217 if(!prs_uint32("unknown18", ps, depth, &info->unknown18))
2219 if(!prs_uint32("status" , ps, depth, &info->status))
2221 if(!prs_uint32("unknown20", ps, depth, &info->unknown20))
2223 if(!prs_uint32("c_setprinter", ps, depth, &info->c_setprinter))
2225 if(!prs_uint16("unknown22", ps, depth, &info->unknown22))
2227 if(!prs_uint16("unknown23", ps, depth, &info->unknown23))
2229 if(!prs_uint16("unknown24", ps, depth, &info->unknown24))
2231 if(!prs_uint16("unknown25", ps, depth, &info->unknown25))
2233 if(!prs_uint16("unknown26", ps, depth, &info->unknown26))
2235 if(!prs_uint16("unknown27", ps, depth, &info->unknown27))
2237 if(!prs_uint16("unknown28", ps, depth, &info->unknown28))
2239 if(!prs_uint16("unknown29", ps, depth, &info->unknown29))
2245 /*******************************************************************
2246 Parse a PRINTER_INFO_1 structure.
2247 ********************************************************************/
2249 BOOL smb_io_printer_info_1(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_1 *info, int depth)
2251 prs_struct *ps=&buffer->prs;
2253 prs_debug(ps, depth, desc, "smb_io_printer_info_1");
2256 buffer->struct_start=prs_offset(ps);
2258 if (!prs_uint32("flags", ps, depth, &info->flags))
2260 if (!smb_io_relstr("description", buffer, depth, &info->description))
2262 if (!smb_io_relstr("name", buffer, depth, &info->name))
2264 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2270 /*******************************************************************
2271 Parse a PRINTER_INFO_2 structure.
2272 ********************************************************************/
2274 BOOL smb_io_printer_info_2(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_2 *info, int depth)
2276 prs_struct *ps=&buffer->prs;
2277 uint32 dm_offset, sd_offset, current_offset;
2278 uint32 dummy_value = 0, has_secdesc = 0;
2280 prs_debug(ps, depth, desc, "smb_io_printer_info_2");
2283 buffer->struct_start=prs_offset(ps);
2285 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2287 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2289 if (!smb_io_relstr("sharename", buffer, depth, &info->sharename))
2291 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2293 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2295 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2297 if (!smb_io_relstr("location", buffer, depth, &info->location))
2300 /* save current offset and wind forwared by a uint32 */
2301 dm_offset = prs_offset(ps);
2302 if (!prs_uint32("devmode", ps, depth, &dummy_value))
2305 if (!smb_io_relstr("sepfile", buffer, depth, &info->sepfile))
2307 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2309 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2311 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2314 /* save current offset for the sec_desc */
2315 sd_offset = prs_offset(ps);
2316 if (!prs_uint32("sec_desc", ps, depth, &has_secdesc))
2320 /* save current location so we can pick back up here */
2321 current_offset = prs_offset(ps);
2323 /* parse the devmode */
2324 if (!prs_set_offset(ps, dm_offset))
2326 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2329 /* parse the sec_desc */
2330 if (info->secdesc) {
2331 if (!prs_set_offset(ps, sd_offset))
2333 if (!smb_io_relsecdesc("secdesc", buffer, depth, &info->secdesc))
2337 /* pick up where we left off */
2338 if (!prs_set_offset(ps, current_offset))
2341 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2343 if (!prs_uint32("priority", ps, depth, &info->priority))
2345 if (!prs_uint32("defpriority", ps, depth, &info->defaultpriority))
2347 if (!prs_uint32("starttime", ps, depth, &info->starttime))
2349 if (!prs_uint32("untiltime", ps, depth, &info->untiltime))
2351 if (!prs_uint32("status", ps, depth, &info->status))
2353 if (!prs_uint32("jobs", ps, depth, &info->cjobs))
2355 if (!prs_uint32("averageppm", ps, depth, &info->averageppm))
2361 /*******************************************************************
2362 Parse a PRINTER_INFO_3 structure.
2363 ********************************************************************/
2365 BOOL smb_io_printer_info_3(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_3 *info, int depth)
2367 prs_struct *ps=&buffer->prs;
2369 prs_debug(ps, depth, desc, "smb_io_printer_info_3");
2372 buffer->struct_start=prs_offset(ps);
2374 if (!prs_uint32("flags", ps, depth, &info->flags))
2376 if (!sec_io_desc("sec_desc", &info->secdesc, ps, depth))
2382 /*******************************************************************
2383 Parse a PRINTER_INFO_4 structure.
2384 ********************************************************************/
2386 BOOL smb_io_printer_info_4(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_4 *info, int depth)
2388 prs_struct *ps=&buffer->prs;
2390 prs_debug(ps, depth, desc, "smb_io_printer_info_4");
2393 buffer->struct_start=prs_offset(ps);
2395 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2397 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2399 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2404 /*******************************************************************
2405 Parse a PRINTER_INFO_5 structure.
2406 ********************************************************************/
2408 BOOL smb_io_printer_info_5(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_5 *info, int depth)
2410 prs_struct *ps=&buffer->prs;
2412 prs_debug(ps, depth, desc, "smb_io_printer_info_5");
2415 buffer->struct_start=prs_offset(ps);
2417 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2419 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2421 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2423 if (!prs_uint32("device_not_selected_timeout", ps, depth, &info->device_not_selected_timeout))
2425 if (!prs_uint32("transmission_retry_timeout", ps, depth, &info->transmission_retry_timeout))
2430 /*******************************************************************
2431 Parse a PRINTER_INFO_7 structure.
2432 ********************************************************************/
2434 BOOL smb_io_printer_info_7(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_7 *info, int depth)
2436 prs_struct *ps=&buffer->prs;
2438 prs_debug(ps, depth, desc, "smb_io_printer_info_7");
2441 buffer->struct_start=prs_offset(ps);
2443 if (!smb_io_relstr("guid", buffer, depth, &info->guid))
2445 if (!prs_uint32("action", ps, depth, &info->action))
2450 /*******************************************************************
2451 Parse a PORT_INFO_1 structure.
2452 ********************************************************************/
2454 BOOL smb_io_port_info_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
2456 prs_struct *ps=&buffer->prs;
2458 prs_debug(ps, depth, desc, "smb_io_port_info_1");
2461 buffer->struct_start=prs_offset(ps);
2463 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2469 /*******************************************************************
2470 Parse a PORT_INFO_2 structure.
2471 ********************************************************************/
2473 BOOL smb_io_port_info_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2475 prs_struct *ps=&buffer->prs;
2477 prs_debug(ps, depth, desc, "smb_io_port_info_2");
2480 buffer->struct_start=prs_offset(ps);
2482 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2484 if (!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2486 if (!smb_io_relstr("description", buffer, depth, &info->description))
2488 if (!prs_uint32("port_type", ps, depth, &info->port_type))
2490 if (!prs_uint32("reserved", ps, depth, &info->reserved))
2496 /*******************************************************************
2497 Parse a DRIVER_INFO_1 structure.
2498 ********************************************************************/
2500 BOOL smb_io_printer_driver_info_1(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_1 *info, int depth)
2502 prs_struct *ps=&buffer->prs;
2504 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_1");
2507 buffer->struct_start=prs_offset(ps);
2509 if (!smb_io_relstr("name", buffer, depth, &info->name))
2515 /*******************************************************************
2516 Parse a DRIVER_INFO_2 structure.
2517 ********************************************************************/
2519 BOOL smb_io_printer_driver_info_2(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_2 *info, int depth)
2521 prs_struct *ps=&buffer->prs;
2523 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_2");
2526 buffer->struct_start=prs_offset(ps);
2528 if (!prs_uint32("version", ps, depth, &info->version))
2530 if (!smb_io_relstr("name", buffer, depth, &info->name))
2532 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2534 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2536 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2538 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2544 /*******************************************************************
2545 Parse a DRIVER_INFO_3 structure.
2546 ********************************************************************/
2548 BOOL smb_io_printer_driver_info_3(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_3 *info, int depth)
2550 prs_struct *ps=&buffer->prs;
2552 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_3");
2555 buffer->struct_start=prs_offset(ps);
2557 if (!prs_uint32("version", ps, depth, &info->version))
2559 if (!smb_io_relstr("name", buffer, depth, &info->name))
2561 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2563 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2565 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2567 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2569 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2572 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2575 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2577 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2583 /*******************************************************************
2584 Parse a DRIVER_INFO_6 structure.
2585 ********************************************************************/
2587 BOOL smb_io_printer_driver_info_6(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_6 *info, int depth)
2589 prs_struct *ps=&buffer->prs;
2591 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_6");
2594 buffer->struct_start=prs_offset(ps);
2596 if (!prs_uint32("version", ps, depth, &info->version))
2598 if (!smb_io_relstr("name", buffer, depth, &info->name))
2600 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2602 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2604 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2606 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2608 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2611 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2614 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2616 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2619 if (!smb_io_relarraystr("previousdrivernames", buffer, depth, &info->previousdrivernames))
2622 if (!prs_uint32("date.low", ps, depth, &info->driver_date.low))
2624 if (!prs_uint32("date.high", ps, depth, &info->driver_date.high))
2627 if (!prs_uint32("padding", ps, depth, &info->padding))
2630 if (!prs_uint32("driver_version_low", ps, depth, &info->driver_version_low))
2633 if (!prs_uint32("driver_version_high", ps, depth, &info->driver_version_high))
2636 if (!smb_io_relstr("mfgname", buffer, depth, &info->mfgname))
2638 if (!smb_io_relstr("oem_url", buffer, depth, &info->oem_url))
2640 if (!smb_io_relstr("hardware_id", buffer, depth, &info->hardware_id))
2642 if (!smb_io_relstr("provider", buffer, depth, &info->provider))
2648 /*******************************************************************
2649 Parse a JOB_INFO_1 structure.
2650 ********************************************************************/
2652 BOOL smb_io_job_info_1(const char *desc, RPC_BUFFER *buffer, JOB_INFO_1 *info, int depth)
2654 prs_struct *ps=&buffer->prs;
2656 prs_debug(ps, depth, desc, "smb_io_job_info_1");
2659 buffer->struct_start=prs_offset(ps);
2661 if (!prs_uint32("jobid", ps, depth, &info->jobid))
2663 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2665 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2667 if (!smb_io_relstr("username", buffer, depth, &info->username))
2669 if (!smb_io_relstr("document", buffer, depth, &info->document))
2671 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2673 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2675 if (!prs_uint32("status", ps, depth, &info->status))
2677 if (!prs_uint32("priority", ps, depth, &info->priority))
2679 if (!prs_uint32("position", ps, depth, &info->position))
2681 if (!prs_uint32("totalpages", ps, depth, &info->totalpages))
2683 if (!prs_uint32("pagesprinted", ps, depth, &info->pagesprinted))
2685 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted))
2691 /*******************************************************************
2692 Parse a JOB_INFO_2 structure.
2693 ********************************************************************/
2695 BOOL smb_io_job_info_2(const char *desc, RPC_BUFFER *buffer, JOB_INFO_2 *info, int depth)
2698 prs_struct *ps=&buffer->prs;
2700 prs_debug(ps, depth, desc, "smb_io_job_info_2");
2703 buffer->struct_start=prs_offset(ps);
2705 if (!prs_uint32("jobid",ps, depth, &info->jobid))
2707 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2709 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2711 if (!smb_io_relstr("username", buffer, depth, &info->username))
2713 if (!smb_io_relstr("document", buffer, depth, &info->document))
2715 if (!smb_io_relstr("notifyname", buffer, depth, &info->notifyname))
2717 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2720 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2722 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2724 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2726 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2728 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2731 /* SEC_DESC sec_desc;*/
2732 if (!prs_uint32("Hack! sec desc", ps, depth, &pipo))
2735 if (!prs_uint32("status",ps, depth, &info->status))
2737 if (!prs_uint32("priority",ps, depth, &info->priority))
2739 if (!prs_uint32("position",ps, depth, &info->position))
2741 if (!prs_uint32("starttime",ps, depth, &info->starttime))
2743 if (!prs_uint32("untiltime",ps, depth, &info->untiltime))
2745 if (!prs_uint32("totalpages",ps, depth, &info->totalpages))
2747 if (!prs_uint32("size",ps, depth, &info->size))
2749 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted) )
2751 if (!prs_uint32("timeelapsed",ps, depth, &info->timeelapsed))
2753 if (!prs_uint32("pagesprinted",ps, depth, &info->pagesprinted))
2759 /*******************************************************************
2760 ********************************************************************/
2762 BOOL smb_io_form_1(const char *desc, RPC_BUFFER *buffer, FORM_1 *info, int depth)
2764 prs_struct *ps=&buffer->prs;
2766 prs_debug(ps, depth, desc, "smb_io_form_1");
2769 buffer->struct_start=prs_offset(ps);
2771 if (!prs_uint32("flag", ps, depth, &info->flag))
2774 if (!smb_io_relstr("name", buffer, depth, &info->name))
2777 if (!prs_uint32("width", ps, depth, &info->width))
2779 if (!prs_uint32("length", ps, depth, &info->length))
2781 if (!prs_uint32("left", ps, depth, &info->left))
2783 if (!prs_uint32("top", ps, depth, &info->top))
2785 if (!prs_uint32("right", ps, depth, &info->right))
2787 if (!prs_uint32("bottom", ps, depth, &info->bottom))
2795 /*******************************************************************
2796 Parse a DRIVER_DIRECTORY_1 structure.
2797 ********************************************************************/
2799 BOOL smb_io_driverdir_1(const char *desc, RPC_BUFFER *buffer, DRIVER_DIRECTORY_1 *info, int depth)
2801 prs_struct *ps=&buffer->prs;
2803 prs_debug(ps, depth, desc, "smb_io_driverdir_1");
2806 buffer->struct_start=prs_offset(ps);
2808 if (!smb_io_unistr(desc, &info->name, ps, depth))
2814 /*******************************************************************
2815 Parse a PORT_INFO_1 structure.
2816 ********************************************************************/
2818 BOOL smb_io_port_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
2820 prs_struct *ps=&buffer->prs;
2822 prs_debug(ps, depth, desc, "smb_io_port_1");
2825 buffer->struct_start=prs_offset(ps);
2827 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2833 /*******************************************************************
2834 Parse a PORT_INFO_2 structure.
2835 ********************************************************************/
2837 BOOL smb_io_port_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2839 prs_struct *ps=&buffer->prs;
2841 prs_debug(ps, depth, desc, "smb_io_port_2");
2844 buffer->struct_start=prs_offset(ps);
2846 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2848 if(!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2850 if(!smb_io_relstr("description", buffer, depth, &info->description))
2852 if(!prs_uint32("port_type", ps, depth, &info->port_type))
2854 if(!prs_uint32("reserved", ps, depth, &info->reserved))
2860 /*******************************************************************
2861 ********************************************************************/
2863 BOOL smb_io_printprocessor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_1 *info, int depth)
2865 prs_struct *ps=&buffer->prs;
2867 prs_debug(ps, depth, desc, "smb_io_printprocessor_info_1");
2870 buffer->struct_start=prs_offset(ps);
2872 if (smb_io_relstr("name", buffer, depth, &info->name))
2878 /*******************************************************************
2879 ********************************************************************/
2881 BOOL smb_io_printprocdatatype_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCDATATYPE_1 *info, int depth)
2883 prs_struct *ps=&buffer->prs;
2885 prs_debug(ps, depth, desc, "smb_io_printprocdatatype_info_1");
2888 buffer->struct_start=prs_offset(ps);
2890 if (smb_io_relstr("name", buffer, depth, &info->name))
2896 /*******************************************************************
2897 ********************************************************************/
2899 BOOL smb_io_printmonitor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_1 *info, int depth)
2901 prs_struct *ps=&buffer->prs;
2903 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_1");
2906 buffer->struct_start=prs_offset(ps);
2908 if (!smb_io_relstr("name", buffer, depth, &info->name))
2914 /*******************************************************************
2915 ********************************************************************/
2917 BOOL smb_io_printmonitor_info_2(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_2 *info, int depth)
2919 prs_struct *ps=&buffer->prs;
2921 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_2");
2924 buffer->struct_start=prs_offset(ps);
2926 if (!smb_io_relstr("name", buffer, depth, &info->name))
2928 if (!smb_io_relstr("environment", buffer, depth, &info->environment))
2930 if (!smb_io_relstr("dll_name", buffer, depth, &info->dll_name))
2936 /*******************************************************************
2937 return the size required by a struct in the stream
2938 ********************************************************************/
2940 uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
2944 size+=size_of_relative_string( &info->printername );
2945 size+=size_of_relative_string( &info->servername );
2947 size+=size_of_uint32( &info->cjobs);
2948 size+=size_of_uint32( &info->total_jobs);
2949 size+=size_of_uint32( &info->total_bytes);
2951 size+=size_of_uint16( &info->year);
2952 size+=size_of_uint16( &info->month);
2953 size+=size_of_uint16( &info->dayofweek);
2954 size+=size_of_uint16( &info->day);
2955 size+=size_of_uint16( &info->hour);
2956 size+=size_of_uint16( &info->minute);
2957 size+=size_of_uint16( &info->second);
2958 size+=size_of_uint16( &info->milliseconds);
2960 size+=size_of_uint32( &info->global_counter);
2961 size+=size_of_uint32( &info->total_pages);
2963 size+=size_of_uint16( &info->major_version);
2964 size+=size_of_uint16( &info->build_version);
2966 size+=size_of_uint32( &info->unknown7);
2967 size+=size_of_uint32( &info->unknown8);
2968 size+=size_of_uint32( &info->unknown9);
2969 size+=size_of_uint32( &info->session_counter);
2970 size+=size_of_uint32( &info->unknown11);
2971 size+=size_of_uint32( &info->printer_errors);
2972 size+=size_of_uint32( &info->unknown13);
2973 size+=size_of_uint32( &info->unknown14);
2974 size+=size_of_uint32( &info->unknown15);
2975 size+=size_of_uint32( &info->unknown16);
2976 size+=size_of_uint32( &info->change_id);
2977 size+=size_of_uint32( &info->unknown18);
2978 size+=size_of_uint32( &info->status);
2979 size+=size_of_uint32( &info->unknown20);
2980 size+=size_of_uint32( &info->c_setprinter);
2982 size+=size_of_uint16( &info->unknown22);
2983 size+=size_of_uint16( &info->unknown23);
2984 size+=size_of_uint16( &info->unknown24);
2985 size+=size_of_uint16( &info->unknown25);
2986 size+=size_of_uint16( &info->unknown26);
2987 size+=size_of_uint16( &info->unknown27);
2988 size+=size_of_uint16( &info->unknown28);
2989 size+=size_of_uint16( &info->unknown29);
2994 /*******************************************************************
2995 return the size required by a struct in the stream
2996 ********************************************************************/
2998 uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
3002 size+=size_of_uint32( &info->flags );
3003 size+=size_of_relative_string( &info->description );
3004 size+=size_of_relative_string( &info->name );
3005 size+=size_of_relative_string( &info->comment );
3010 /*******************************************************************
3011 return the size required by a struct in the stream
3012 ********************************************************************/
3014 uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
3020 size += sec_desc_size( info->secdesc );
3022 size+=size_of_device_mode( info->devmode );
3024 size+=size_of_relative_string( &info->servername );
3025 size+=size_of_relative_string( &info->printername );
3026 size+=size_of_relative_string( &info->sharename );
3027 size+=size_of_relative_string( &info->portname );
3028 size+=size_of_relative_string( &info->drivername );
3029 size+=size_of_relative_string( &info->comment );
3030 size+=size_of_relative_string( &info->location );
3032 size+=size_of_relative_string( &info->sepfile );
3033 size+=size_of_relative_string( &info->printprocessor );
3034 size+=size_of_relative_string( &info->datatype );
3035 size+=size_of_relative_string( &info->parameters );
3037 size+=size_of_uint32( &info->attributes );
3038 size+=size_of_uint32( &info->priority );
3039 size+=size_of_uint32( &info->defaultpriority );
3040 size+=size_of_uint32( &info->starttime );
3041 size+=size_of_uint32( &info->untiltime );
3042 size+=size_of_uint32( &info->status );
3043 size+=size_of_uint32( &info->cjobs );
3044 size+=size_of_uint32( &info->averageppm );
3047 * add any adjustments for alignment. This is
3048 * not optimal since we could be calling this
3049 * function from a loop (e.g. enumprinters), but
3050 * it is easier to maintain the calculation here and
3051 * not place the burden on the caller to remember. --jerry
3053 if ((size % 4) != 0)
3054 size += 4 - (size % 4);
3059 /*******************************************************************
3060 return the size required by a struct in the stream
3061 ********************************************************************/
3063 uint32 spoolss_size_printer_info_4(PRINTER_INFO_4 *info)
3067 size+=size_of_relative_string( &info->printername );
3068 size+=size_of_relative_string( &info->servername );
3070 size+=size_of_uint32( &info->attributes );
3074 /*******************************************************************
3075 return the size required by a struct in the stream
3076 ********************************************************************/
3078 uint32 spoolss_size_printer_info_5(PRINTER_INFO_5 *info)
3082 size+=size_of_relative_string( &info->printername );
3083 size+=size_of_relative_string( &info->portname );
3085 size+=size_of_uint32( &info->attributes );
3086 size+=size_of_uint32( &info->device_not_selected_timeout );
3087 size+=size_of_uint32( &info->transmission_retry_timeout );
3092 /*******************************************************************
3093 return the size required by a struct in the stream
3094 ********************************************************************/
3096 uint32 spoolss_size_printer_info_3(PRINTER_INFO_3 *info)
3098 /* The 4 is for the self relative pointer.. */
3099 /* JRA !!!! TESTME - WHAT ABOUT prs_align.... !!! */
3100 return 4 + (uint32)sec_desc_size( info->secdesc );
3103 /*******************************************************************
3104 return the size required by a struct in the stream
3105 ********************************************************************/
3107 uint32 spoolss_size_printer_info_7(PRINTER_INFO_7 *info)
3111 size+=size_of_relative_string( &info->guid );
3112 size+=size_of_uint32( &info->action );
3116 /*******************************************************************
3117 return the size required by a struct in the stream
3118 ********************************************************************/
3120 uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
3123 size+=size_of_relative_string( &info->name );
3128 /*******************************************************************
3129 return the size required by a struct in the stream
3130 ********************************************************************/
3132 uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
3135 size+=size_of_uint32( &info->version );
3136 size+=size_of_relative_string( &info->name );
3137 size+=size_of_relative_string( &info->architecture );
3138 size+=size_of_relative_string( &info->driverpath );
3139 size+=size_of_relative_string( &info->datafile );
3140 size+=size_of_relative_string( &info->configfile );
3145 /*******************************************************************
3146 return the size required by a string array.
3147 ********************************************************************/
3149 uint32 spoolss_size_string_array(uint16 *string)
3154 for (i=0; (string[i]!=0x0000) || (string[i+1]!=0x0000); i++);
3156 i=i+2; /* to count all chars including the leading zero */
3157 i=2*i; /* because we need the value in bytes */
3158 i=i+4; /* the offset pointer size */
3163 /*******************************************************************
3164 return the size required by a struct in the stream
3165 ********************************************************************/
3167 uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
3171 size+=size_of_uint32( &info->version );
3172 size+=size_of_relative_string( &info->name );
3173 size+=size_of_relative_string( &info->architecture );
3174 size+=size_of_relative_string( &info->driverpath );
3175 size+=size_of_relative_string( &info->datafile );
3176 size+=size_of_relative_string( &info->configfile );
3177 size+=size_of_relative_string( &info->helpfile );
3178 size+=size_of_relative_string( &info->monitorname );
3179 size+=size_of_relative_string( &info->defaultdatatype );
3181 size+=spoolss_size_string_array(info->dependentfiles);
3186 /*******************************************************************
3187 return the size required by a struct in the stream
3188 ********************************************************************/
3190 uint32 spoolss_size_printer_driver_info_6(DRIVER_INFO_6 *info)
3194 size+=size_of_uint32( &info->version );
3195 size+=size_of_relative_string( &info->name );
3196 size+=size_of_relative_string( &info->architecture );
3197 size+=size_of_relative_string( &info->driverpath );
3198 size+=size_of_relative_string( &info->datafile );
3199 size+=size_of_relative_string( &info->configfile );
3200 size+=size_of_relative_string( &info->helpfile );
3202 size+=spoolss_size_string_array(info->dependentfiles);
3204 size+=size_of_relative_string( &info->monitorname );
3205 size+=size_of_relative_string( &info->defaultdatatype );
3207 size+=spoolss_size_string_array(info->previousdrivernames);
3209 size+=size_of_nttime(&info->driver_date);
3210 size+=size_of_uint32( &info->padding );
3211 size+=size_of_uint32( &info->driver_version_low );
3212 size+=size_of_uint32( &info->driver_version_high );
3213 size+=size_of_relative_string( &info->mfgname );
3214 size+=size_of_relative_string( &info->oem_url );
3215 size+=size_of_relative_string( &info->hardware_id );
3216 size+=size_of_relative_string( &info->provider );
3221 /*******************************************************************
3222 return the size required by a struct in the stream
3223 ********************************************************************/
3225 uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
3228 size+=size_of_uint32( &info->jobid );
3229 size+=size_of_relative_string( &info->printername );
3230 size+=size_of_relative_string( &info->machinename );
3231 size+=size_of_relative_string( &info->username );
3232 size+=size_of_relative_string( &info->document );
3233 size+=size_of_relative_string( &info->datatype );
3234 size+=size_of_relative_string( &info->text_status );
3235 size+=size_of_uint32( &info->status );
3236 size+=size_of_uint32( &info->priority );
3237 size+=size_of_uint32( &info->position );
3238 size+=size_of_uint32( &info->totalpages );
3239 size+=size_of_uint32( &info->pagesprinted );
3240 size+=size_of_systemtime( &info->submitted );
3245 /*******************************************************************
3246 return the size required by a struct in the stream
3247 ********************************************************************/
3249 uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
3253 size+=4; /* size of sec desc ptr */
3255 size+=size_of_uint32( &info->jobid );
3256 size+=size_of_relative_string( &info->printername );
3257 size+=size_of_relative_string( &info->machinename );
3258 size+=size_of_relative_string( &info->username );
3259 size+=size_of_relative_string( &info->document );
3260 size+=size_of_relative_string( &info->notifyname );
3261 size+=size_of_relative_string( &info->datatype );
3262 size+=size_of_relative_string( &info->printprocessor );
3263 size+=size_of_relative_string( &info->parameters );
3264 size+=size_of_relative_string( &info->drivername );
3265 size+=size_of_device_mode( info->devmode );
3266 size+=size_of_relative_string( &info->text_status );
3267 /* SEC_DESC sec_desc;*/
3268 size+=size_of_uint32( &info->status );
3269 size+=size_of_uint32( &info->priority );
3270 size+=size_of_uint32( &info->position );
3271 size+=size_of_uint32( &info->starttime );
3272 size+=size_of_uint32( &info->untiltime );
3273 size+=size_of_uint32( &info->totalpages );
3274 size+=size_of_uint32( &info->size );
3275 size+=size_of_systemtime( &info->submitted );
3276 size+=size_of_uint32( &info->timeelapsed );
3277 size+=size_of_uint32( &info->pagesprinted );
3282 /*******************************************************************
3283 return the size required by a struct in the stream
3284 ********************************************************************/
3286 uint32 spoolss_size_form_1(FORM_1 *info)
3290 size+=size_of_uint32( &info->flag );
3291 size+=size_of_relative_string( &info->name );
3292 size+=size_of_uint32( &info->width );
3293 size+=size_of_uint32( &info->length );
3294 size+=size_of_uint32( &info->left );
3295 size+=size_of_uint32( &info->top );
3296 size+=size_of_uint32( &info->right );
3297 size+=size_of_uint32( &info->bottom );
3302 /*******************************************************************
3303 return the size required by a struct in the stream
3304 ********************************************************************/
3306 uint32 spoolss_size_port_info_1(PORT_INFO_1 *info)
3310 size+=size_of_relative_string( &info->port_name );
3315 /*******************************************************************
3316 return the size required by a struct in the stream
3317 ********************************************************************/
3319 uint32 spoolss_size_driverdir_info_1(DRIVER_DIRECTORY_1 *info)
3323 size=str_len_uni(&info->name); /* the string length */
3324 size=size+1; /* add the leading zero */
3325 size=size*2; /* convert in char */
3330 /*******************************************************************
3331 return the size required by a struct in the stream
3332 ********************************************************************/
3334 uint32 spoolss_size_printprocessordirectory_info_1(PRINTPROCESSOR_DIRECTORY_1 *info)
3338 size=str_len_uni(&info->name); /* the string length */
3339 size=size+1; /* add the leading zero */
3340 size=size*2; /* convert in char */
3345 /*******************************************************************
3346 return the size required by a struct in the stream
3347 ********************************************************************/
3349 uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
3353 size+=size_of_relative_string( &info->port_name );
3354 size+=size_of_relative_string( &info->monitor_name );
3355 size+=size_of_relative_string( &info->description );
3357 size+=size_of_uint32( &info->port_type );
3358 size+=size_of_uint32( &info->reserved );
3363 /*******************************************************************
3364 return the size required by a struct in the stream
3365 ********************************************************************/
3367 uint32 spoolss_size_printprocessor_info_1(PRINTPROCESSOR_1 *info)
3370 size+=size_of_relative_string( &info->name );
3375 /*******************************************************************
3376 return the size required by a struct in the stream
3377 ********************************************************************/
3379 uint32 spoolss_size_printprocdatatype_info_1(PRINTPROCDATATYPE_1 *info)
3382 size+=size_of_relative_string( &info->name );
3387 /*******************************************************************
3388 return the size required by a struct in the stream
3389 ********************************************************************/
3390 uint32 spoolss_size_printer_enum_values(PRINTER_ENUM_VALUES *p)
3397 /* uint32(offset) + uint32(length) + length) */
3398 size += (size_of_uint32(&p->value_len)*2) + p->value_len;
3399 size += (size_of_uint32(&p->data_len)*2) + p->data_len + (p->data_len%2) ;
3401 size += size_of_uint32(&p->type);
3406 /*******************************************************************
3407 return the size required by a struct in the stream
3408 ********************************************************************/
3410 uint32 spoolss_size_printmonitor_info_1(PRINTMONITOR_1 *info)
3413 size+=size_of_relative_string( &info->name );
3418 /*******************************************************************
3419 return the size required by a struct in the stream
3420 ********************************************************************/
3422 uint32 spoolss_size_printmonitor_info_2(PRINTMONITOR_2 *info)
3425 size+=size_of_relative_string( &info->name);
3426 size+=size_of_relative_string( &info->environment);
3427 size+=size_of_relative_string( &info->dll_name);
3432 /*******************************************************************
3434 ********************************************************************/
3436 BOOL make_spoolss_q_getprinterdriver2(SPOOL_Q_GETPRINTERDRIVER2 *q_u,
3437 const POLICY_HND *hnd,
3438 const fstring architecture,
3439 uint32 level, uint32 clientmajor, uint32 clientminor,
3440 RPC_BUFFER *buffer, uint32 offered)
3445 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3447 init_buf_unistr2(&q_u->architecture, &q_u->architecture_ptr, architecture);
3450 q_u->clientmajorversion=clientmajor;
3451 q_u->clientminorversion=clientminor;
3454 q_u->offered=offered;
3459 /*******************************************************************
3461 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3462 ********************************************************************/
3464 BOOL spoolss_io_q_getprinterdriver2(const char *desc, SPOOL_Q_GETPRINTERDRIVER2 *q_u, prs_struct *ps, int depth)
3466 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriver2");
3472 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3474 if(!prs_uint32("architecture_ptr", ps, depth, &q_u->architecture_ptr))
3476 if(!smb_io_unistr2("architecture", &q_u->architecture, q_u->architecture_ptr, ps, depth))
3481 if(!prs_uint32("level", ps, depth, &q_u->level))
3484 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3490 if(!prs_uint32("offered", ps, depth, &q_u->offered))
3493 if(!prs_uint32("clientmajorversion", ps, depth, &q_u->clientmajorversion))
3495 if(!prs_uint32("clientminorversion", ps, depth, &q_u->clientminorversion))
3501 /*******************************************************************
3503 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3504 ********************************************************************/
3506 BOOL spoolss_io_r_getprinterdriver2(const char *desc, SPOOL_R_GETPRINTERDRIVER2 *r_u, prs_struct *ps, int depth)
3508 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriver2");
3514 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3519 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3521 if (!prs_uint32("servermajorversion", ps, depth, &r_u->servermajorversion))
3523 if (!prs_uint32("serverminorversion", ps, depth, &r_u->serverminorversion))
3525 if (!prs_werror("status", ps, depth, &r_u->status))
3531 /*******************************************************************
3533 ********************************************************************/
3535 BOOL make_spoolss_q_enumprinters(
3536 SPOOL_Q_ENUMPRINTERS *q_u,
3546 q_u->servername_ptr = (servername != NULL) ? 1 : 0;
3547 init_buf_unistr2(&q_u->servername, &q_u->servername_ptr, servername);
3551 q_u->offered=offered;
3556 /*******************************************************************
3558 ********************************************************************/
3560 BOOL make_spoolss_q_enumports(SPOOL_Q_ENUMPORTS *q_u,
3561 fstring servername, uint32 level,
3562 RPC_BUFFER *buffer, uint32 offered)
3564 q_u->name_ptr = (servername != NULL) ? 1 : 0;
3565 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
3569 q_u->offered=offered;
3574 /*******************************************************************
3576 * called from spoolss_enumprinters (srv_spoolss.c)
3577 ********************************************************************/
3579 BOOL spoolss_io_q_enumprinters(const char *desc, SPOOL_Q_ENUMPRINTERS *q_u, prs_struct *ps, int depth)
3581 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinters");
3587 if (!prs_uint32("flags", ps, depth, &q_u->flags))
3589 if (!prs_uint32("servername_ptr", ps, depth, &q_u->servername_ptr))
3592 if (!smb_io_unistr2("", &q_u->servername, q_u->servername_ptr, ps, depth))
3597 if (!prs_uint32("level", ps, depth, &q_u->level))
3600 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3605 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3611 /*******************************************************************
3612 Parse a SPOOL_R_ENUMPRINTERS structure.
3613 ********************************************************************/
3615 BOOL spoolss_io_r_enumprinters(const char *desc, SPOOL_R_ENUMPRINTERS *r_u, prs_struct *ps, int depth)
3617 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinters");
3623 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3629 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3632 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3635 if (!prs_werror("status", ps, depth, &r_u->status))
3641 /*******************************************************************
3642 * write a structure.
3643 * called from spoolss_r_enum_printers (srv_spoolss.c)
3645 ********************************************************************/
3647 BOOL spoolss_io_r_getprinter(const char *desc, SPOOL_R_GETPRINTER *r_u, prs_struct *ps, int depth)
3649 prs_debug(ps, depth, desc, "spoolss_io_r_getprinter");
3655 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3661 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3664 if (!prs_werror("status", ps, depth, &r_u->status))
3670 /*******************************************************************
3672 * called from spoolss_getprinter (srv_spoolss.c)
3673 ********************************************************************/
3675 BOOL spoolss_io_q_getprinter(const char *desc, SPOOL_Q_GETPRINTER *q_u, prs_struct *ps, int depth)
3677 prs_debug(ps, depth, desc, "spoolss_io_q_getprinter");
3683 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3685 if (!prs_uint32("level", ps, depth, &q_u->level))
3688 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3693 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3699 /*******************************************************************
3701 ********************************************************************/
3703 BOOL make_spoolss_q_getprinter(
3704 TALLOC_CTX *mem_ctx,
3705 SPOOL_Q_GETPRINTER *q_u,
3706 const POLICY_HND *hnd,
3716 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3720 q_u->offered=offered;
3725 /*******************************************************************
3727 ********************************************************************/
3728 BOOL make_spoolss_q_setprinter(TALLOC_CTX *mem_ctx, SPOOL_Q_SETPRINTER *q_u,
3729 const POLICY_HND *hnd, uint32 level, PRINTER_INFO_CTR *info,
3733 DEVICEMODE *devmode;
3738 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3741 q_u->info.level = level;
3742 q_u->info.info_ptr = (info != NULL) ? 1 : 0;
3745 /* There's no such thing as a setprinter level 1 */
3748 secdesc = info->printers_2->secdesc;
3749 devmode = info->printers_2->devmode;
3751 make_spoolss_printer_info_2 (mem_ctx, &q_u->info.info_2, info->printers_2);
3752 #if 1 /* JERRY TEST */
3753 q_u->secdesc_ctr = SMB_MALLOC_P(SEC_DESC_BUF);
3754 if (!q_u->secdesc_ctr)
3756 q_u->secdesc_ctr->ptr = (secdesc != NULL) ? 1: 0;
3757 q_u->secdesc_ctr->max_len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3758 q_u->secdesc_ctr->len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3759 q_u->secdesc_ctr->sec = secdesc;
3761 q_u->devmode_ctr.devmode_ptr = (devmode != NULL) ? 1 : 0;
3762 q_u->devmode_ctr.size = (devmode != NULL) ? sizeof(DEVICEMODE) + (3*sizeof(uint32)) : 0;
3763 q_u->devmode_ctr.devmode = devmode;
3765 q_u->secdesc_ctr = NULL;
3767 q_u->devmode_ctr.devmode_ptr = 0;
3768 q_u->devmode_ctr.size = 0;
3769 q_u->devmode_ctr.devmode = NULL;
3773 secdesc = info->printers_3->secdesc;
3775 make_spoolss_printer_info_3 (mem_ctx, &q_u->info.info_3, info->printers_3);
3777 q_u->secdesc_ctr = SMB_MALLOC_P(SEC_DESC_BUF);
3778 if (!q_u->secdesc_ctr)
3780 q_u->secdesc_ctr->ptr = (secdesc != NULL) ? 1: 0;
3781 q_u->secdesc_ctr->max_len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3782 q_u->secdesc_ctr->len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3783 q_u->secdesc_ctr->sec = secdesc;
3787 make_spoolss_printer_info_7 (mem_ctx, &q_u->info.info_7, info->printers_7);
3791 DEBUG(0,("make_spoolss_q_setprinter: Unknown info level [%d]\n", level));
3796 q_u->command = command;
3802 /*******************************************************************
3803 ********************************************************************/
3805 BOOL spoolss_io_r_setprinter(const char *desc, SPOOL_R_SETPRINTER *r_u, prs_struct *ps, int depth)
3807 prs_debug(ps, depth, desc, "spoolss_io_r_setprinter");
3813 if(!prs_werror("status", ps, depth, &r_u->status))
3819 /*******************************************************************
3820 Marshall/unmarshall a SPOOL_Q_SETPRINTER struct.
3821 ********************************************************************/
3823 BOOL spoolss_io_q_setprinter(const char *desc, SPOOL_Q_SETPRINTER *q_u, prs_struct *ps, int depth)
3825 uint32 ptr_sec_desc = 0;
3827 prs_debug(ps, depth, desc, "spoolss_io_q_setprinter");
3833 if(!smb_io_pol_hnd("printer handle", &q_u->handle ,ps, depth))
3835 if(!prs_uint32("level", ps, depth, &q_u->level))
3838 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
3841 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
3851 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
3856 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
3862 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
3867 /* Parse a NULL security descriptor. This should really
3868 happen inside the sec_io_desc_buf() function. */
3870 prs_debug(ps, depth, "", "sec_io_desc_buf");
3871 if (!prs_uint32("size", ps, depth + 1, &dummy))
3873 if (!prs_uint32("ptr", ps, depth + 1, &dummy)) return
3877 if(!prs_uint32("command", ps, depth, &q_u->command))
3883 /*******************************************************************
3884 ********************************************************************/
3886 BOOL spoolss_io_r_fcpn(const char *desc, SPOOL_R_FCPN *r_u, prs_struct *ps, int depth)
3888 prs_debug(ps, depth, desc, "spoolss_io_r_fcpn");
3894 if(!prs_werror("status", ps, depth, &r_u->status))
3900 /*******************************************************************
3901 ********************************************************************/
3903 BOOL spoolss_io_q_fcpn(const char *desc, SPOOL_Q_FCPN *q_u, prs_struct *ps, int depth)
3906 prs_debug(ps, depth, desc, "spoolss_io_q_fcpn");
3912 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
3919 /*******************************************************************
3920 ********************************************************************/
3922 BOOL spoolss_io_r_addjob(const char *desc, SPOOL_R_ADDJOB *r_u, prs_struct *ps, int depth)
3924 prs_debug(ps, depth, desc, "");
3930 if(!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3936 if(!prs_uint32("needed", ps, depth, &r_u->needed))
3939 if(!prs_werror("status", ps, depth, &r_u->status))
3945 /*******************************************************************
3946 ********************************************************************/
3948 BOOL spoolss_io_q_addjob(const char *desc, SPOOL_Q_ADDJOB *q_u, prs_struct *ps, int depth)
3950 prs_debug(ps, depth, desc, "");
3956 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3958 if(!prs_uint32("level", ps, depth, &q_u->level))
3961 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3967 if(!prs_uint32("offered", ps, depth, &q_u->offered))
3973 /*******************************************************************
3974 ********************************************************************/
3976 BOOL spoolss_io_r_enumjobs(const char *desc, SPOOL_R_ENUMJOBS *r_u, prs_struct *ps, int depth)
3978 prs_debug(ps, depth, desc, "spoolss_io_r_enumjobs");
3984 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3990 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3993 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3996 if (!prs_werror("status", ps, depth, &r_u->status))
4002 /*******************************************************************
4003 ********************************************************************/
4005 BOOL make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS *q_u, const POLICY_HND *hnd,
4016 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
4017 q_u->firstjob = firstjob;
4018 q_u->numofjobs = numofjobs;
4020 q_u->buffer= buffer;
4021 q_u->offered = offered;
4025 /*******************************************************************
4026 ********************************************************************/
4028 BOOL spoolss_io_q_enumjobs(const char *desc, SPOOL_Q_ENUMJOBS *q_u, prs_struct *ps, int depth)
4030 prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs");
4036 if (!smb_io_pol_hnd("printer handle",&q_u->handle, ps, depth))
4039 if (!prs_uint32("firstjob", ps, depth, &q_u->firstjob))
4041 if (!prs_uint32("numofjobs", ps, depth, &q_u->numofjobs))
4043 if (!prs_uint32("level", ps, depth, &q_u->level))
4046 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4052 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4058 /*******************************************************************
4059 ********************************************************************/
4061 BOOL spoolss_io_r_schedulejob(const char *desc, SPOOL_R_SCHEDULEJOB *r_u, prs_struct *ps, int depth)
4063 prs_debug(ps, depth, desc, "spoolss_io_r_schedulejob");
4069 if(!prs_werror("status", ps, depth, &r_u->status))
4075 /*******************************************************************
4076 ********************************************************************/
4078 BOOL spoolss_io_q_schedulejob(const char *desc, SPOOL_Q_SCHEDULEJOB *q_u, prs_struct *ps, int depth)
4080 prs_debug(ps, depth, desc, "spoolss_io_q_schedulejob");
4086 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4088 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
4094 /*******************************************************************
4095 ********************************************************************/
4097 BOOL spoolss_io_r_setjob(const char *desc, SPOOL_R_SETJOB *r_u, prs_struct *ps, int depth)
4099 prs_debug(ps, depth, desc, "spoolss_io_r_setjob");
4105 if(!prs_werror("status", ps, depth, &r_u->status))
4111 /*******************************************************************
4112 ********************************************************************/
4114 BOOL spoolss_io_q_setjob(const char *desc, SPOOL_Q_SETJOB *q_u, prs_struct *ps, int depth)
4116 prs_debug(ps, depth, desc, "spoolss_io_q_setjob");
4122 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4124 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
4127 * level is usually 0. If (level!=0) then I'm in trouble !
4128 * I will try to generate setjob command with level!=0, one day.
4130 if(!prs_uint32("level", ps, depth, &q_u->level))
4132 if(!prs_uint32("command", ps, depth, &q_u->command))
4138 /*******************************************************************
4139 Parse a SPOOL_R_ENUMPRINTERDRIVERS structure.
4140 ********************************************************************/
4142 BOOL spoolss_io_r_enumprinterdrivers(const char *desc, SPOOL_R_ENUMPRINTERDRIVERS *r_u, prs_struct *ps, int depth)
4144 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdrivers");
4150 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4156 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4159 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4162 if (!prs_werror("status", ps, depth, &r_u->status))
4168 /*******************************************************************
4170 ********************************************************************/
4172 BOOL make_spoolss_q_enumprinterdrivers(SPOOL_Q_ENUMPRINTERDRIVERS *q_u,
4174 const char *environment,
4176 RPC_BUFFER *buffer, uint32 offered)
4178 init_buf_unistr2(&q_u->name, &q_u->name_ptr, name);
4179 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, environment);
4183 q_u->offered=offered;
4188 /*******************************************************************
4189 Parse a SPOOL_Q_ENUMPRINTERDRIVERS structure.
4190 ********************************************************************/
4192 BOOL spoolss_io_q_enumprinterdrivers(const char *desc, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, prs_struct *ps, int depth)
4195 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdrivers");
4201 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
4203 if (!smb_io_unistr2("", &q_u->name, q_u->name_ptr,ps, depth))
4208 if (!prs_uint32("environment_ptr", ps, depth, &q_u->environment_ptr))
4210 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
4215 if (!prs_uint32("level", ps, depth, &q_u->level))
4218 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4224 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4230 /*******************************************************************
4231 ********************************************************************/
4233 BOOL spoolss_io_q_enumforms(const char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth)
4236 prs_debug(ps, depth, desc, "spoolss_io_q_enumforms");
4241 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4243 if (!prs_uint32("level", ps, depth, &q_u->level))
4246 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4251 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4257 /*******************************************************************
4258 ********************************************************************/
4260 BOOL spoolss_io_r_enumforms(const char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth)
4262 prs_debug(ps, depth, desc, "spoolss_io_r_enumforms");
4268 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4274 if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
4277 if (!prs_uint32("numofforms", ps, depth, &r_u->numofforms))
4280 if (!prs_werror("status", ps, depth, &r_u->status))
4286 /*******************************************************************
4287 ********************************************************************/
4289 BOOL spoolss_io_q_getform(const char *desc, SPOOL_Q_GETFORM *q_u, prs_struct *ps, int depth)
4292 prs_debug(ps, depth, desc, "spoolss_io_q_getform");
4297 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4299 if (!smb_io_unistr2("", &q_u->formname,True,ps,depth))
4305 if (!prs_uint32("level", ps, depth, &q_u->level))
4308 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4313 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4319 /*******************************************************************
4320 ********************************************************************/
4322 BOOL spoolss_io_r_getform(const char *desc, SPOOL_R_GETFORM *r_u, prs_struct *ps, int depth)
4324 prs_debug(ps, depth, desc, "spoolss_io_r_getform");
4330 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4336 if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
4339 if (!prs_werror("status", ps, depth, &r_u->status))
4345 /*******************************************************************
4346 Parse a SPOOL_R_ENUMPORTS structure.
4347 ********************************************************************/
4349 BOOL spoolss_io_r_enumports(const char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
4351 prs_debug(ps, depth, desc, "spoolss_io_r_enumports");
4357 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4363 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4366 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4369 if (!prs_werror("status", ps, depth, &r_u->status))
4375 /*******************************************************************
4376 ********************************************************************/
4378 BOOL spoolss_io_q_enumports(const char *desc, SPOOL_Q_ENUMPORTS *q_u, prs_struct *ps, int depth)
4380 prs_debug(ps, depth, desc, "");
4386 if (!prs_uint32("", ps, depth, &q_u->name_ptr))
4388 if (!smb_io_unistr2("", &q_u->name,True,ps,depth))
4393 if (!prs_uint32("level", ps, depth, &q_u->level))
4396 if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4401 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4407 /*******************************************************************
4408 Parse a SPOOL_PRINTER_INFO_LEVEL_1 structure.
4409 ********************************************************************/
4411 BOOL spool_io_printer_info_level_1(const char *desc, SPOOL_PRINTER_INFO_LEVEL_1 *il, prs_struct *ps, int depth)
4413 prs_debug(ps, depth, desc, "spool_io_printer_info_level_1");
4419 if(!prs_uint32("flags", ps, depth, &il->flags))
4421 if(!prs_uint32("description_ptr", ps, depth, &il->description_ptr))
4423 if(!prs_uint32("name_ptr", ps, depth, &il->name_ptr))
4425 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4428 if(!smb_io_unistr2("description", &il->description, il->description_ptr, ps, depth))
4430 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4432 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4438 /*******************************************************************
4439 Parse a SPOOL_PRINTER_INFO_LEVEL_3 structure.
4440 ********************************************************************/
4442 BOOL spool_io_printer_info_level_3(const char *desc, SPOOL_PRINTER_INFO_LEVEL_3 *il, prs_struct *ps, int depth)
4444 prs_debug(ps, depth, desc, "spool_io_printer_info_level_3");
4450 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4456 /*******************************************************************
4457 Parse a SPOOL_PRINTER_INFO_LEVEL_2 structure.
4458 ********************************************************************/
4460 BOOL spool_io_printer_info_level_2(const char *desc, SPOOL_PRINTER_INFO_LEVEL_2 *il, prs_struct *ps, int depth)
4462 prs_debug(ps, depth, desc, "spool_io_printer_info_level_2");
4468 if(!prs_uint32("servername_ptr", ps, depth, &il->servername_ptr))
4470 if(!prs_uint32("printername_ptr", ps, depth, &il->printername_ptr))
4472 if(!prs_uint32("sharename_ptr", ps, depth, &il->sharename_ptr))
4474 if(!prs_uint32("portname_ptr", ps, depth, &il->portname_ptr))
4477 if(!prs_uint32("drivername_ptr", ps, depth, &il->drivername_ptr))
4479 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4481 if(!prs_uint32("location_ptr", ps, depth, &il->location_ptr))
4483 if(!prs_uint32("devmode_ptr", ps, depth, &il->devmode_ptr))
4485 if(!prs_uint32("sepfile_ptr", ps, depth, &il->sepfile_ptr))
4487 if(!prs_uint32("printprocessor_ptr", ps, depth, &il->printprocessor_ptr))
4489 if(!prs_uint32("datatype_ptr", ps, depth, &il->datatype_ptr))
4491 if(!prs_uint32("parameters_ptr", ps, depth, &il->parameters_ptr))
4493 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4496 if(!prs_uint32("attributes", ps, depth, &il->attributes))
4498 if(!prs_uint32("priority", ps, depth, &il->priority))
4500 if(!prs_uint32("default_priority", ps, depth, &il->default_priority))
4502 if(!prs_uint32("starttime", ps, depth, &il->starttime))
4504 if(!prs_uint32("untiltime", ps, depth, &il->untiltime))
4506 if(!prs_uint32("status", ps, depth, &il->status))
4508 if(!prs_uint32("cjobs", ps, depth, &il->cjobs))
4510 if(!prs_uint32("averageppm", ps, depth, &il->averageppm))
4513 if(!smb_io_unistr2("servername", &il->servername, il->servername_ptr, ps, depth))
4515 if(!smb_io_unistr2("printername", &il->printername, il->printername_ptr, ps, depth))
4517 if(!smb_io_unistr2("sharename", &il->sharename, il->sharename_ptr, ps, depth))
4519 if(!smb_io_unistr2("portname", &il->portname, il->portname_ptr, ps, depth))
4521 if(!smb_io_unistr2("drivername", &il->drivername, il->drivername_ptr, ps, depth))
4523 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4525 if(!smb_io_unistr2("location", &il->location, il->location_ptr, ps, depth))
4527 if(!smb_io_unistr2("sepfile", &il->sepfile, il->sepfile_ptr, ps, depth))
4529 if(!smb_io_unistr2("printprocessor", &il->printprocessor, il->printprocessor_ptr, ps, depth))
4531 if(!smb_io_unistr2("datatype", &il->datatype, il->datatype_ptr, ps, depth))
4533 if(!smb_io_unistr2("parameters", &il->parameters, il->parameters_ptr, ps, depth))
4539 BOOL spool_io_printer_info_level_7(const char *desc, SPOOL_PRINTER_INFO_LEVEL_7 *il, prs_struct *ps, int depth)
4541 prs_debug(ps, depth, desc, "spool_io_printer_info_level_7");
4547 if(!prs_uint32("guid_ptr", ps, depth, &il->guid_ptr))
4549 if(!prs_uint32("action", ps, depth, &il->action))
4552 if(!smb_io_unistr2("servername", &il->guid, il->guid_ptr, ps, depth))
4557 /*******************************************************************
4558 ********************************************************************/
4560 BOOL spool_io_printer_info_level(const char *desc, SPOOL_PRINTER_INFO_LEVEL *il, prs_struct *ps, int depth)
4562 prs_debug(ps, depth, desc, "spool_io_printer_info_level");
4567 if(!prs_uint32("level", ps, depth, &il->level))
4569 if(!prs_uint32("info_ptr", ps, depth, &il->info_ptr))
4572 /* if no struct inside just return */
4573 if (il->info_ptr==0) {
4574 if (UNMARSHALLING(ps)) {
4581 switch (il->level) {
4583 * level 0 is used by setprinter when managing the queue
4584 * (hold, stop, start a queue)
4588 /* DOCUMENT ME!!! What is level 1 used for? */
4591 if (UNMARSHALLING(ps)) {
4592 if ((il->info_1=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_1,1)) == NULL)
4595 if (!spool_io_printer_info_level_1("", il->info_1, ps, depth))
4600 * level 2 is used by addprinter
4601 * and by setprinter when updating printer's info
4604 if (UNMARSHALLING(ps)) {
4605 if ((il->info_2=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_2,1)) == NULL)
4608 if (!spool_io_printer_info_level_2("", il->info_2, ps, depth))
4611 /* DOCUMENT ME!!! What is level 3 used for? */
4614 if (UNMARSHALLING(ps)) {
4615 if ((il->info_3=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_3,1)) == NULL)
4618 if (!spool_io_printer_info_level_3("", il->info_3, ps, depth))
4623 if (UNMARSHALLING(ps))
4624 if ((il->info_7=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_7,1)) == NULL)
4626 if (!spool_io_printer_info_level_7("", il->info_7, ps, depth))
4634 /*******************************************************************
4635 ********************************************************************/
4637 BOOL spoolss_io_q_addprinterex(const char *desc, SPOOL_Q_ADDPRINTEREX *q_u, prs_struct *ps, int depth)
4639 uint32 ptr_sec_desc = 0;
4641 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterex");
4647 if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->server_name))
4649 if (!prs_io_unistr2("servername", ps, depth, q_u->server_name))
4655 if(!prs_uint32("info_level", ps, depth, &q_u->level))
4658 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
4661 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
4667 switch (q_u->level) {
4669 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
4672 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
4676 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
4681 /* Parse a NULL security descriptor. This should really
4682 happen inside the sec_io_desc_buf() function. */
4684 prs_debug(ps, depth, "", "sec_io_desc_buf");
4685 if (!prs_uint32("size", ps, depth + 1, &dummy))
4687 if (!prs_uint32("ptr", ps, depth + 1, &dummy))
4691 if(!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
4693 if(!spool_io_user_level("", &q_u->user_ctr, ps, depth))
4699 /*******************************************************************
4700 ********************************************************************/
4702 BOOL spoolss_io_r_addprinterex(const char *desc, SPOOL_R_ADDPRINTEREX *r_u,
4703 prs_struct *ps, int depth)
4705 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterex");
4708 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
4711 if(!prs_werror("status", ps, depth, &r_u->status))
4717 /*******************************************************************
4718 ********************************************************************/
4720 BOOL spool_io_printer_driver_info_level_3(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **q_u,
4721 prs_struct *ps, int depth)
4723 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *il;
4725 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_3");
4729 if (UNMARSHALLING(ps)) {
4730 il=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_DRIVER_INFO_LEVEL_3,1);
4742 if(!prs_uint32("cversion", ps, depth, &il->cversion))
4744 if(!prs_uint32("name", ps, depth, &il->name_ptr))
4746 if(!prs_uint32("environment", ps, depth, &il->environment_ptr))
4748 if(!prs_uint32("driverpath", ps, depth, &il->driverpath_ptr))
4750 if(!prs_uint32("datafile", ps, depth, &il->datafile_ptr))
4752 if(!prs_uint32("configfile", ps, depth, &il->configfile_ptr))
4754 if(!prs_uint32("helpfile", ps, depth, &il->helpfile_ptr))
4756 if(!prs_uint32("monitorname", ps, depth, &il->monitorname_ptr))
4758 if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
4760 if(!prs_uint32("dependentfilessize", ps, depth, &il->dependentfilessize))
4762 if(!prs_uint32("dependentfiles", ps, depth, &il->dependentfiles_ptr))
4768 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4770 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
4772 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
4774 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
4776 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
4778 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
4780 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
4782 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
4788 if (il->dependentfiles_ptr)
4789 smb_io_buffer5("", &il->dependentfiles, ps, depth);
4794 /*******************************************************************
4795 parse a SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 structure
4796 ********************************************************************/
4798 BOOL spool_io_printer_driver_info_level_6(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 **q_u,
4799 prs_struct *ps, int depth)
4801 SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *il;
4803 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_6");
4807 if (UNMARSHALLING(ps)) {
4808 il=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_DRIVER_INFO_LEVEL_6,1);
4821 * I know this seems weird, but I have no other explanation.
4822 * This is observed behavior on both NT4 and 2K servers.
4826 if (!prs_align_uint64(ps))
4829 /* parse the main elements the packet */
4831 if(!prs_uint32("cversion ", ps, depth, &il->version))
4833 if(!prs_uint32("name ", ps, depth, &il->name_ptr))
4835 if(!prs_uint32("environment ", ps, depth, &il->environment_ptr))
4837 if(!prs_uint32("driverpath ", ps, depth, &il->driverpath_ptr))
4839 if(!prs_uint32("datafile ", ps, depth, &il->datafile_ptr))
4841 if(!prs_uint32("configfile ", ps, depth, &il->configfile_ptr))
4843 if(!prs_uint32("helpfile ", ps, depth, &il->helpfile_ptr))
4845 if(!prs_uint32("monitorname ", ps, depth, &il->monitorname_ptr))
4847 if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
4849 if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_len))
4851 if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_ptr))
4853 if(!prs_uint32("previousnames ", ps, depth, &il->previousnames_len))
4855 if(!prs_uint32("previousnames ", ps, depth, &il->previousnames_ptr))
4857 if(!smb_io_time("driverdate ", &il->driverdate, ps, depth))
4859 if(!prs_uint32("dummy4 ", ps, depth, &il->dummy4))
4861 if(!prs_uint64("driverversion ", ps, depth, &il->driverversion))
4863 if(!prs_uint32("mfgname ", ps, depth, &il->mfgname_ptr))
4865 if(!prs_uint32("oemurl ", ps, depth, &il->oemurl_ptr))
4867 if(!prs_uint32("hardwareid ", ps, depth, &il->hardwareid_ptr))
4869 if(!prs_uint32("provider ", ps, depth, &il->provider_ptr))
4872 /* parse the structures in the packet */
4874 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4879 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
4884 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
4889 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
4894 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
4899 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
4904 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
4909 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
4913 if (il->dependentfiles_ptr) {
4914 if(!smb_io_buffer5("dependentfiles", &il->dependentfiles, ps, depth))
4919 if (il->previousnames_ptr) {
4920 if(!smb_io_buffer5("previousnames", &il->previousnames, ps, depth))
4925 if(!smb_io_unistr2("mfgname", &il->mfgname, il->mfgname_ptr, ps, depth))
4929 if(!smb_io_unistr2("oemurl", &il->oemurl, il->oemurl_ptr, ps, depth))
4933 if(!smb_io_unistr2("hardwareid", &il->hardwareid, il->hardwareid_ptr, ps, depth))
4937 if(!smb_io_unistr2("provider", &il->provider, il->provider_ptr, ps, depth))
4943 /*******************************************************************
4944 convert a buffer of UNICODE strings null terminated
4945 the buffer is terminated by a NULL
4947 convert to an dos codepage array (null terminated)
4949 dynamically allocate memory
4951 ********************************************************************/
4952 static BOOL uniarray_2_dosarray(BUFFER5 *buf5, fstring **ar)
4961 src = (char *)buf5->buffer;
4964 while (src < ((char *)buf5->buffer) + buf5->buf_len*2) {
4965 rpcstr_pull(f, src, sizeof(f)-1, -1, STR_TERMINATE);
4966 src = skip_unibuf(src, 2*buf5->buf_len - PTR_DIFF(src,buf5->buffer));
4967 tar = SMB_REALLOC_ARRAY(*ar, fstring, n+2);
4972 fstrcpy((*ar)[n], f);
4975 fstrcpy((*ar)[n], "");
4983 /*******************************************************************
4984 read a UNICODE array with null terminated strings
4985 and null terminated array
4986 and size of array at beginning
4987 ********************************************************************/
4989 BOOL smb_io_unibuffer(const char *desc, UNISTR2 *buffer, prs_struct *ps, int depth)
4991 if (buffer==NULL) return False;
4994 buffer->uni_str_len=buffer->uni_max_len;
4996 if(!prs_uint32("buffer_size", ps, depth, &buffer->uni_max_len))
4999 if(!prs_unistr2(True, "buffer ", ps, depth, buffer))
5005 /*******************************************************************
5006 ********************************************************************/
5008 BOOL spool_io_printer_driver_info_level(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL *il, prs_struct *ps, int depth)
5010 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level");
5015 if(!prs_uint32("level", ps, depth, &il->level))
5017 if(!prs_uint32("ptr", ps, depth, &il->ptr))
5023 switch (il->level) {
5025 if(!spool_io_printer_driver_info_level_3("", &il->info_3, ps, depth))
5029 if(!spool_io_printer_driver_info_level_6("", &il->info_6, ps, depth))
5039 /*******************************************************************
5040 init a SPOOL_Q_ADDPRINTERDRIVER struct
5041 ******************************************************************/
5043 BOOL make_spoolss_q_addprinterdriver(TALLOC_CTX *mem_ctx,
5044 SPOOL_Q_ADDPRINTERDRIVER *q_u, const char* srv_name,
5045 uint32 level, PRINTER_DRIVER_CTR *info)
5047 DEBUG(5,("make_spoolss_q_addprinterdriver\n"));
5049 q_u->server_name_ptr = (srv_name!=NULL)?1:0;
5050 init_unistr2(&q_u->server_name, srv_name, UNI_STR_TERMINATE);
5054 q_u->info.level = level;
5055 q_u->info.ptr = (info!=NULL)?1:0;
5058 /* info level 3 is supported by Windows 95/98, WinNT and Win2k */
5060 make_spoolss_driver_info_3(mem_ctx, &q_u->info.info_3, info->info3);
5064 DEBUG(0,("make_spoolss_q_addprinterdriver: Unknown info level [%d]\n", level));
5071 BOOL make_spoolss_driver_info_3(TALLOC_CTX *mem_ctx,
5072 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **spool_drv_info,
5073 DRIVER_INFO_3 *info3)
5076 uint16 *ptr = info3->dependentfiles;
5078 BOOL null_char = False;
5079 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *inf;
5081 if (!(inf=TALLOC_ZERO_P(mem_ctx, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3)))
5084 inf->cversion = info3->version;
5085 inf->name_ptr = (info3->name.buffer!=NULL)?1:0;
5086 inf->environment_ptr = (info3->architecture.buffer!=NULL)?1:0;
5087 inf->driverpath_ptr = (info3->driverpath.buffer!=NULL)?1:0;
5088 inf->datafile_ptr = (info3->datafile.buffer!=NULL)?1:0;
5089 inf->configfile_ptr = (info3->configfile.buffer!=NULL)?1:0;
5090 inf->helpfile_ptr = (info3->helpfile.buffer!=NULL)?1:0;
5091 inf->monitorname_ptr = (info3->monitorname.buffer!=NULL)?1:0;
5092 inf->defaultdatatype_ptr = (info3->defaultdatatype.buffer!=NULL)?1:0;
5094 init_unistr2_from_unistr(&inf->name, &info3->name);
5095 init_unistr2_from_unistr(&inf->environment, &info3->architecture);
5096 init_unistr2_from_unistr(&inf->driverpath, &info3->driverpath);
5097 init_unistr2_from_unistr(&inf->datafile, &info3->datafile);
5098 init_unistr2_from_unistr(&inf->configfile, &info3->configfile);
5099 init_unistr2_from_unistr(&inf->helpfile, &info3->helpfile);
5100 init_unistr2_from_unistr(&inf->monitorname, &info3->monitorname);
5101 init_unistr2_from_unistr(&inf->defaultdatatype, &info3->defaultdatatype);
5108 /* the null_char BOOL is used to help locate
5109 two '\0's back to back */
5124 inf->dependentfiles_ptr = (info3->dependentfiles != NULL) ? 1 : 0;
5125 inf->dependentfilessize = len;
5126 if(!make_spoolss_buffer5(mem_ctx, &inf->dependentfiles, len, info3->dependentfiles))
5132 *spool_drv_info = inf;
5137 /*******************************************************************
5138 make a BUFFER5 struct from a uint16*
5139 ******************************************************************/
5140 BOOL make_spoolss_buffer5(TALLOC_CTX *mem_ctx, BUFFER5 *buf5, uint32 len, uint16 *src)
5143 buf5->buf_len = len;
5144 if((buf5->buffer=(uint16*)TALLOC_MEMDUP(mem_ctx, src, sizeof(uint16)*len)) == NULL) {
5145 DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
5152 /*******************************************************************
5153 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
5154 ********************************************************************/
5156 BOOL spoolss_io_q_addprinterdriver(const char *desc, SPOOL_Q_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
5158 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriver");
5164 if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
5166 if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
5171 if(!prs_uint32("info_level", ps, depth, &q_u->level))
5174 if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
5180 /*******************************************************************
5181 ********************************************************************/
5183 BOOL spoolss_io_r_addprinterdriver(const char *desc, SPOOL_R_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
5185 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriver");
5188 if(!prs_werror("status", ps, depth, &q_u->status))
5194 /*******************************************************************
5195 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
5196 ********************************************************************/
5198 BOOL spoolss_io_q_addprinterdriverex(const char *desc, SPOOL_Q_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
5200 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriverex");
5206 if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
5208 if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
5213 if(!prs_uint32("info_level", ps, depth, &q_u->level))
5216 if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
5221 if(!prs_uint32("copy flags", ps, depth, &q_u->copy_flags))
5227 /*******************************************************************
5228 ********************************************************************/
5230 BOOL spoolss_io_r_addprinterdriverex(const char *desc, SPOOL_R_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
5232 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriverex");
5235 if(!prs_werror("status", ps, depth, &q_u->status))
5241 /*******************************************************************
5242 ********************************************************************/
5244 BOOL uni_2_asc_printer_driver_3(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *uni,
5245 NT_PRINTER_DRIVER_INFO_LEVEL_3 **asc)
5247 NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
5249 DEBUG(7,("uni_2_asc_printer_driver_3: Converting from UNICODE to ASCII\n"));
5253 *asc=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
5261 d->cversion=uni->cversion;
5263 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name)-1);
5264 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment)-1);
5265 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath)-1);
5266 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile)-1);
5267 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile)-1);
5268 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile)-1);
5269 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname)-1);
5270 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype)-1);
5272 DEBUGADD(8,( "version: %d\n", d->cversion));
5273 DEBUGADD(8,( "name: %s\n", d->name));
5274 DEBUGADD(8,( "environment: %s\n", d->environment));
5275 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
5276 DEBUGADD(8,( "datafile: %s\n", d->datafile));
5277 DEBUGADD(8,( "configfile: %s\n", d->configfile));
5278 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
5279 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
5280 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5282 if (uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5289 /*******************************************************************
5290 ********************************************************************/
5291 BOOL uni_2_asc_printer_driver_6(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *uni,
5292 NT_PRINTER_DRIVER_INFO_LEVEL_6 **asc)
5294 NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
5296 DEBUG(7,("uni_2_asc_printer_driver_6: Converting from UNICODE to ASCII\n"));
5300 *asc=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
5308 d->version=uni->version;
5310 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name)-1);
5311 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment)-1);
5312 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath)-1);
5313 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile)-1);
5314 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile)-1);
5315 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile)-1);
5316 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname)-1);
5317 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype)-1);
5319 DEBUGADD(8,( "version: %d\n", d->version));
5320 DEBUGADD(8,( "name: %s\n", d->name));
5321 DEBUGADD(8,( "environment: %s\n", d->environment));
5322 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
5323 DEBUGADD(8,( "datafile: %s\n", d->datafile));
5324 DEBUGADD(8,( "configfile: %s\n", d->configfile));
5325 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
5326 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
5327 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5329 if (!uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5331 if (!uniarray_2_dosarray(&uni->previousnames, &d->previousnames ))
5341 BOOL uni_2_asc_printer_info_2(const SPOOL_PRINTER_INFO_LEVEL_2 *uni,
5342 NT_PRINTER_INFO_LEVEL_2 **asc)
5344 NT_PRINTER_INFO_LEVEL_2 *d;
5347 DEBUG(7,("Converting from UNICODE to ASCII\n"));
5348 time_unix=time(NULL);
5351 DEBUGADD(8,("allocating memory\n"));
5353 *asc=SMB_MALLOC_P(NT_PRINTER_INFO_LEVEL_2);
5358 /* we allocate memory iff called from
5359 * addprinter(ex) so we can do one time stuff here.
5361 (*asc)->setuptime=time_unix;
5364 DEBUGADD(8,("start converting\n"));
5368 d->attributes=uni->attributes;
5369 d->priority=uni->priority;
5370 d->default_priority=uni->default_priority;
5371 d->starttime=uni->starttime;
5372 d->untiltime=uni->untiltime;
5373 d->status=uni->status;
5374 d->cjobs=uni->cjobs;
5376 unistr2_to_ascii(d->servername, &uni->servername, sizeof(d->servername)-1);
5377 unistr2_to_ascii(d->printername, &uni->printername, sizeof(d->printername)-1);
5378 unistr2_to_ascii(d->sharename, &uni->sharename, sizeof(d->sharename)-1);
5379 unistr2_to_ascii(d->portname, &uni->portname, sizeof(d->portname)-1);
5380 unistr2_to_ascii(d->drivername, &uni->drivername, sizeof(d->drivername)-1);
5381 unistr2_to_ascii(d->comment, &uni->comment, sizeof(d->comment)-1);
5382 unistr2_to_ascii(d->location, &uni->location, sizeof(d->location)-1);
5383 unistr2_to_ascii(d->sepfile, &uni->sepfile, sizeof(d->sepfile)-1);
5384 unistr2_to_ascii(d->printprocessor, &uni->printprocessor, sizeof(d->printprocessor)-1);
5385 unistr2_to_ascii(d->datatype, &uni->datatype, sizeof(d->datatype)-1);
5386 unistr2_to_ascii(d->parameters, &uni->parameters, sizeof(d->parameters)-1);
5391 /*******************************************************************
5393 ********************************************************************/
5395 BOOL make_spoolss_q_getprinterdriverdir(SPOOL_Q_GETPRINTERDRIVERDIR *q_u,
5396 fstring servername, fstring env_name, uint32 level,
5397 RPC_BUFFER *buffer, uint32 offered)
5399 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
5400 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, env_name);
5404 q_u->offered=offered;
5409 /*******************************************************************
5410 Parse a SPOOL_Q_GETPRINTERDRIVERDIR structure.
5411 ********************************************************************/
5413 BOOL spoolss_io_q_getprinterdriverdir(const char *desc, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, prs_struct *ps, int depth)
5415 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriverdir");
5420 if(!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5422 if(!smb_io_unistr2("", &q_u->name, q_u->name_ptr, ps, depth))
5428 if(!prs_uint32("", ps, depth, &q_u->environment_ptr))
5430 if(!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5436 if(!prs_uint32("level", ps, depth, &q_u->level))
5439 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5445 if(!prs_uint32("offered", ps, depth, &q_u->offered))
5451 /*******************************************************************
5452 Parse a SPOOL_R_GETPRINTERDRIVERDIR structure.
5453 ********************************************************************/
5455 BOOL spoolss_io_r_getprinterdriverdir(const char *desc, SPOOL_R_GETPRINTERDRIVERDIR *r_u, prs_struct *ps, int depth)
5457 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriverdir");
5463 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5469 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5472 if (!prs_werror("status", ps, depth, &r_u->status))
5478 /*******************************************************************
5479 ********************************************************************/
5481 BOOL spoolss_io_r_enumprintprocessors(const char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
5483 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
5489 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5495 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5498 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5501 if (!prs_werror("status", ps, depth, &r_u->status))
5507 /*******************************************************************
5508 ********************************************************************/
5510 BOOL spoolss_io_q_enumprintprocessors(const char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
5512 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
5518 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5520 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5526 if (!prs_uint32("", ps, depth, &q_u->environment_ptr))
5528 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5534 if (!prs_uint32("level", ps, depth, &q_u->level))
5537 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5543 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5549 /*******************************************************************
5550 ********************************************************************/
5552 BOOL spoolss_io_q_addprintprocessor(const char *desc, SPOOL_Q_ADDPRINTPROCESSOR *q_u, prs_struct *ps, int depth)
5554 prs_debug(ps, depth, desc, "spoolss_io_q_addprintprocessor");
5560 if (!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
5562 if (!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
5567 if (!smb_io_unistr2("environment", &q_u->environment, True, ps, depth))
5572 if (!smb_io_unistr2("path", &q_u->path, True, ps, depth))
5577 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5583 /*******************************************************************
5584 ********************************************************************/
5586 BOOL spoolss_io_r_addprintprocessor(const char *desc, SPOOL_R_ADDPRINTPROCESSOR *r_u, prs_struct *ps, int depth)
5588 prs_debug(ps, depth, desc, "spoolss_io_r_addprintproicessor");
5594 if (!prs_werror("status", ps, depth, &r_u->status))
5600 /*******************************************************************
5601 ********************************************************************/
5603 BOOL spoolss_io_r_enumprintprocdatatypes(const char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u, prs_struct *ps, int depth)
5605 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes");
5611 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5617 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5620 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5623 if (!prs_werror("status", ps, depth, &r_u->status))
5629 /*******************************************************************
5630 ********************************************************************/
5632 BOOL spoolss_io_q_enumprintprocdatatypes(const char *desc, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, prs_struct *ps, int depth)
5634 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocdatatypes");
5640 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5642 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5648 if (!prs_uint32("processor_ptr", ps, depth, &q_u->processor_ptr))
5650 if (!smb_io_unistr2("processor", &q_u->processor, q_u->processor_ptr, ps, depth))
5656 if (!prs_uint32("level", ps, depth, &q_u->level))
5659 if(!prs_rpcbuffer_p("buffer", ps, depth, &q_u->buffer))
5665 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5671 /*******************************************************************
5672 Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
5673 ********************************************************************/
5675 BOOL spoolss_io_q_enumprintmonitors(const char *desc, SPOOL_Q_ENUMPRINTMONITORS *q_u, prs_struct *ps, int depth)
5677 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintmonitors");
5683 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5685 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5691 if (!prs_uint32("level", ps, depth, &q_u->level))
5694 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5700 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5706 /*******************************************************************
5707 ********************************************************************/
5709 BOOL spoolss_io_r_enumprintmonitors(const char *desc, SPOOL_R_ENUMPRINTMONITORS *r_u, prs_struct *ps, int depth)
5711 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintmonitors");
5717 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5723 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5726 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5729 if (!prs_werror("status", ps, depth, &r_u->status))
5735 /*******************************************************************
5736 ********************************************************************/
5738 BOOL spoolss_io_r_enumprinterdata(const char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth)
5740 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata");
5745 if(!prs_uint32("valuesize", ps, depth, &r_u->valuesize))
5748 if (UNMARSHALLING(ps) && r_u->valuesize) {
5749 r_u->value = PRS_ALLOC_MEM(ps, uint16, r_u->valuesize);
5751 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata value\n"));
5756 if(!prs_uint16uni(False, "value", ps, depth, r_u->value, r_u->valuesize ))
5762 if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
5765 if(!prs_uint32("type", ps, depth, &r_u->type))
5768 if(!prs_uint32("datasize", ps, depth, &r_u->datasize))
5771 if (UNMARSHALLING(ps) && r_u->datasize) {
5772 r_u->data = PRS_ALLOC_MEM(ps, uint8, r_u->datasize);
5774 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata data\n"));
5779 if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
5784 if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
5786 if(!prs_werror("status", ps, depth, &r_u->status))
5792 /*******************************************************************
5793 ********************************************************************/
5795 BOOL spoolss_io_q_enumprinterdata(const char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
5797 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
5802 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
5804 if(!prs_uint32("index", ps, depth, &q_u->index))
5806 if(!prs_uint32("valuesize", ps, depth, &q_u->valuesize))
5808 if(!prs_uint32("datasize", ps, depth, &q_u->datasize))
5814 /*******************************************************************
5815 ********************************************************************/
5817 BOOL make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u,
5818 const POLICY_HND *hnd,
5819 uint32 idx, uint32 valuelen, uint32 datalen)
5821 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5823 q_u->valuesize=valuelen;
5824 q_u->datasize=datalen;
5829 /*******************************************************************
5830 ********************************************************************/
5832 BOOL make_spoolss_q_enumprinterdataex(SPOOL_Q_ENUMPRINTERDATAEX *q_u,
5833 const POLICY_HND *hnd, const char *key,
5836 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5837 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
5843 /*******************************************************************
5844 ********************************************************************/
5845 BOOL make_spoolss_q_setprinterdata(SPOOL_Q_SETPRINTERDATA *q_u, const POLICY_HND *hnd,
5846 char* value, uint32 data_type, char* data, uint32 data_size)
5848 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5849 q_u->type = data_type;
5850 init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
5852 q_u->max_len = q_u->real_len = data_size;
5853 q_u->data = (unsigned char *)data;
5858 /*******************************************************************
5859 ********************************************************************/
5860 BOOL make_spoolss_q_setprinterdataex(SPOOL_Q_SETPRINTERDATAEX *q_u, const POLICY_HND *hnd,
5861 char *key, char* value, uint32 data_type, char* data,
5864 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5865 q_u->type = data_type;
5866 init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
5867 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
5869 q_u->max_len = q_u->real_len = data_size;
5870 q_u->data = (unsigned char *)data;
5875 /*******************************************************************
5876 ********************************************************************/
5878 BOOL spoolss_io_q_setprinterdata(const char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
5880 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
5885 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5887 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
5893 if(!prs_uint32("type", ps, depth, &q_u->type))
5896 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
5906 if (UNMARSHALLING(ps))
5907 q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
5908 if(q_u->data == NULL)
5910 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
5918 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
5924 /*******************************************************************
5925 ********************************************************************/
5927 BOOL spoolss_io_r_setprinterdata(const char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
5929 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
5934 if(!prs_werror("status", ps, depth, &r_u->status))
5940 /*******************************************************************
5941 ********************************************************************/
5942 BOOL spoolss_io_q_resetprinter(const char *desc, SPOOL_Q_RESETPRINTER *q_u, prs_struct *ps, int depth)
5944 prs_debug(ps, depth, desc, "spoolss_io_q_resetprinter");
5949 if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5952 if (!prs_uint32("datatype_ptr", ps, depth, &q_u->datatype_ptr))
5955 if (q_u->datatype_ptr) {
5956 if (!smb_io_unistr2("datatype", &q_u->datatype, q_u->datatype_ptr?True:False, ps, depth))
5960 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
5967 /*******************************************************************
5968 ********************************************************************/
5969 BOOL spoolss_io_r_resetprinter(const char *desc, SPOOL_R_RESETPRINTER *r_u, prs_struct *ps, int depth)
5971 prs_debug(ps, depth, desc, "spoolss_io_r_resetprinter");
5976 if(!prs_werror("status", ps, depth, &r_u->status))
5982 /*******************************************************************
5983 ********************************************************************/
5985 static BOOL spoolss_io_addform(const char *desc, FORM *f, uint32 ptr, prs_struct *ps, int depth)
5987 prs_debug(ps, depth, desc, "spoolss_io_addform");
5994 if(!prs_uint32("flags", ps, depth, &f->flags))
5996 if(!prs_uint32("name_ptr", ps, depth, &f->name_ptr))
5998 if(!prs_uint32("size_x", ps, depth, &f->size_x))
6000 if(!prs_uint32("size_y", ps, depth, &f->size_y))
6002 if(!prs_uint32("left", ps, depth, &f->left))
6004 if(!prs_uint32("top", ps, depth, &f->top))
6006 if(!prs_uint32("right", ps, depth, &f->right))
6008 if(!prs_uint32("bottom", ps, depth, &f->bottom))
6011 if(!smb_io_unistr2("", &f->name, f->name_ptr, ps, depth))
6018 /*******************************************************************
6019 ********************************************************************/
6021 BOOL spoolss_io_q_deleteform(const char *desc, SPOOL_Q_DELETEFORM *q_u, prs_struct *ps, int depth)
6023 prs_debug(ps, depth, desc, "spoolss_io_q_deleteform");
6028 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6030 if(!smb_io_unistr2("form name", &q_u->name, True, ps, depth))
6036 /*******************************************************************
6037 ********************************************************************/
6039 BOOL spoolss_io_r_deleteform(const char *desc, SPOOL_R_DELETEFORM *r_u, prs_struct *ps, int depth)
6041 prs_debug(ps, depth, desc, "spoolss_io_r_deleteform");
6046 if(!prs_werror("status", ps, depth, &r_u->status))
6052 /*******************************************************************
6053 ********************************************************************/
6055 BOOL spoolss_io_q_addform(const char *desc, SPOOL_Q_ADDFORM *q_u, prs_struct *ps, int depth)
6057 uint32 useless_ptr=1;
6058 prs_debug(ps, depth, desc, "spoolss_io_q_addform");
6063 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6065 if(!prs_uint32("level", ps, depth, &q_u->level))
6067 if(!prs_uint32("level2", ps, depth, &q_u->level2))
6072 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
6074 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
6081 /*******************************************************************
6082 ********************************************************************/
6084 BOOL spoolss_io_r_addform(const char *desc, SPOOL_R_ADDFORM *r_u, prs_struct *ps, int depth)
6086 prs_debug(ps, depth, desc, "spoolss_io_r_addform");
6091 if(!prs_werror("status", ps, depth, &r_u->status))
6097 /*******************************************************************
6098 ********************************************************************/
6100 BOOL spoolss_io_q_setform(const char *desc, SPOOL_Q_SETFORM *q_u, prs_struct *ps, int depth)
6102 uint32 useless_ptr=1;
6103 prs_debug(ps, depth, desc, "spoolss_io_q_setform");
6108 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6110 if(!smb_io_unistr2("", &q_u->name, True, ps, depth))
6116 if(!prs_uint32("level", ps, depth, &q_u->level))
6118 if(!prs_uint32("level2", ps, depth, &q_u->level2))
6123 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
6125 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
6132 /*******************************************************************
6133 ********************************************************************/
6135 BOOL spoolss_io_r_setform(const char *desc, SPOOL_R_SETFORM *r_u, prs_struct *ps, int depth)
6137 prs_debug(ps, depth, desc, "spoolss_io_r_setform");
6142 if(!prs_werror("status", ps, depth, &r_u->status))
6148 /*******************************************************************
6149 Parse a SPOOL_R_GETJOB structure.
6150 ********************************************************************/
6152 BOOL spoolss_io_r_getjob(const char *desc, SPOOL_R_GETJOB *r_u, prs_struct *ps, int depth)
6154 prs_debug(ps, depth, desc, "spoolss_io_r_getjob");
6160 if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
6166 if (!prs_uint32("needed", ps, depth, &r_u->needed))
6169 if (!prs_werror("status", ps, depth, &r_u->status))
6175 /*******************************************************************
6176 Parse a SPOOL_Q_GETJOB structure.
6177 ********************************************************************/
6179 BOOL spoolss_io_q_getjob(const char *desc, SPOOL_Q_GETJOB *q_u, prs_struct *ps, int depth)
6181 prs_debug(ps, depth, desc, "");
6187 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6189 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
6191 if(!prs_uint32("level", ps, depth, &q_u->level))
6194 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
6200 if(!prs_uint32("offered", ps, depth, &q_u->offered))
6206 void free_devmode(DEVICEMODE *devmode)
6208 if (devmode!=NULL) {
6209 SAFE_FREE(devmode->private);
6214 void free_printer_info_1(PRINTER_INFO_1 *printer)
6219 void free_printer_info_2(PRINTER_INFO_2 *printer)
6221 if (printer!=NULL) {
6222 free_devmode(printer->devmode);
6223 printer->devmode = NULL;
6228 void free_printer_info_3(PRINTER_INFO_3 *printer)
6233 void free_printer_info_4(PRINTER_INFO_4 *printer)
6238 void free_printer_info_5(PRINTER_INFO_5 *printer)
6243 void free_printer_info_7(PRINTER_INFO_7 *printer)
6248 void free_job_info_2(JOB_INFO_2 *job)
6251 free_devmode(job->devmode);
6254 /*******************************************************************
6256 ********************************************************************/
6258 BOOL make_spoolss_q_replyopenprinter(SPOOL_Q_REPLYOPENPRINTER *q_u,
6259 const fstring string, uint32 printer, uint32 type)
6264 init_unistr2(&q_u->string, string, UNI_STR_TERMINATE);
6266 q_u->printer=printer;
6275 /*******************************************************************
6276 Parse a SPOOL_Q_REPLYOPENPRINTER structure.
6277 ********************************************************************/
6279 BOOL spoolss_io_q_replyopenprinter(const char *desc, SPOOL_Q_REPLYOPENPRINTER *q_u, prs_struct *ps, int depth)
6281 prs_debug(ps, depth, desc, "spoolss_io_q_replyopenprinter");
6287 if(!smb_io_unistr2("", &q_u->string, True, ps, depth))
6293 if(!prs_uint32("printer", ps, depth, &q_u->printer))
6295 if(!prs_uint32("type", ps, depth, &q_u->type))
6298 if(!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6300 if(!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6306 /*******************************************************************
6307 Parse a SPOOL_R_REPLYOPENPRINTER structure.
6308 ********************************************************************/
6310 BOOL spoolss_io_r_replyopenprinter(const char *desc, SPOOL_R_REPLYOPENPRINTER *r_u, prs_struct *ps, int depth)
6312 prs_debug(ps, depth, desc, "spoolss_io_r_replyopenprinter");
6318 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6321 if (!prs_werror("status", ps, depth, &r_u->status))
6327 /*******************************************************************
6329 ********************************************************************/
6330 BOOL make_spoolss_q_routerreplyprinter(SPOOL_Q_ROUTERREPLYPRINTER *q_u, POLICY_HND *hnd,
6331 uint32 condition, uint32 change_id)
6334 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6336 q_u->condition = condition;
6337 q_u->change_id = change_id;
6340 q_u->unknown1 = 0x1;
6341 memset(q_u->unknown2, 0x0, 5);
6342 q_u->unknown2[0] = 0x1;
6347 /*******************************************************************
6348 Parse a SPOOL_Q_ROUTERREPLYPRINTER structure.
6349 ********************************************************************/
6350 BOOL spoolss_io_q_routerreplyprinter (const char *desc, SPOOL_Q_ROUTERREPLYPRINTER *q_u, prs_struct *ps, int depth)
6353 prs_debug(ps, depth, desc, "spoolss_io_q_routerreplyprinter");
6359 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6362 if (!prs_uint32("condition", ps, depth, &q_u->condition))
6365 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6368 if (!prs_uint32("change_id", ps, depth, &q_u->change_id))
6371 if (!prs_uint8s(False, "private", ps, depth, q_u->unknown2, 5))
6377 /*******************************************************************
6378 Parse a SPOOL_R_ROUTERREPLYPRINTER structure.
6379 ********************************************************************/
6380 BOOL spoolss_io_r_routerreplyprinter (const char *desc, SPOOL_R_ROUTERREPLYPRINTER *r_u, prs_struct *ps, int depth)
6382 prs_debug(ps, depth, desc, "spoolss_io_r_routerreplyprinter");
6388 if (!prs_werror("status", ps, depth, &r_u->status))
6394 /*******************************************************************
6396 ********************************************************************/
6398 BOOL make_spoolss_q_reply_closeprinter(SPOOL_Q_REPLYCLOSEPRINTER *q_u, POLICY_HND *hnd)
6403 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6408 /*******************************************************************
6409 Parse a SPOOL_Q_REPLYCLOSEPRINTER structure.
6410 ********************************************************************/
6412 BOOL spoolss_io_q_replycloseprinter(const char *desc, SPOOL_Q_REPLYCLOSEPRINTER *q_u, prs_struct *ps, int depth)
6414 prs_debug(ps, depth, desc, "spoolss_io_q_replycloseprinter");
6420 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6426 /*******************************************************************
6427 Parse a SPOOL_R_REPLYCLOSEPRINTER structure.
6428 ********************************************************************/
6430 BOOL spoolss_io_r_replycloseprinter(const char *desc, SPOOL_R_REPLYCLOSEPRINTER *r_u, prs_struct *ps, int depth)
6432 prs_debug(ps, depth, desc, "spoolss_io_r_replycloseprinter");
6438 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6441 if (!prs_werror("status", ps, depth, &r_u->status))
6447 #if 0 /* JERRY - not currently used but could be :-) */
6449 /*******************************************************************
6450 Deep copy a SPOOL_NOTIFY_INFO_DATA structure
6451 ******************************************************************/
6452 static BOOL copy_spool_notify_info_data(SPOOL_NOTIFY_INFO_DATA *dst,
6453 SPOOL_NOTIFY_INFO_DATA *src, int n)
6457 memcpy(dst, src, sizeof(SPOOL_NOTIFY_INFO_DATA)*n);
6459 for (i=0; i<n; i++) {
6463 if (src->size != POINTER)
6465 len = src->notify_data.data.length;
6466 s = SMB_MALLOC_ARRAY(uint16, len);
6468 DEBUG(0,("copy_spool_notify_info_data: malloc() failed!\n"));
6472 memcpy(s, src->notify_data.data.string, len*2);
6473 dst->notify_data.data.string = s;
6479 /*******************************************************************
6480 Deep copy a SPOOL_NOTIFY_INFO structure
6481 ******************************************************************/
6482 static BOOL copy_spool_notify_info(SPOOL_NOTIFY_INFO *dst, SPOOL_NOTIFY_INFO *src)
6485 DEBUG(0,("copy_spool_notify_info: NULL destination pointer!\n"));
6489 dst->version = src->version;
6490 dst->flags = src->flags;
6491 dst->count = src->count;
6495 dst->data = SMB_MALLOC_ARRAY(SPOOL_NOTIFY_INFO_DATA, dst->count);
6497 DEBUG(10,("copy_spool_notify_info: allocating space for [%d] PRINTER_NOTIFY_INFO_DATA entries\n",
6500 if (dst->data == NULL) {
6501 DEBUG(0,("copy_spool_notify_info: malloc() failed for [%d] entries!\n",
6506 return (copy_spool_notify_info_data(dst->data, src->data, src->count));
6513 /*******************************************************************
6515 ********************************************************************/
6517 BOOL make_spoolss_q_reply_rrpcn(SPOOL_Q_REPLY_RRPCN *q_u, POLICY_HND *hnd,
6518 uint32 change_low, uint32 change_high,
6519 SPOOL_NOTIFY_INFO *info)
6524 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6526 q_u->change_low=change_low;
6527 q_u->change_high=change_high;
6532 q_u->info_ptr=0x0FF0ADDE;
6534 q_u->info.version=2;
6537 DEBUG(10,("make_spoolss_q_reply_rrpcn: [%d] PRINTER_NOTIFY_INFO_DATA\n",
6539 q_u->info.version = info->version;
6540 q_u->info.flags = info->flags;
6541 q_u->info.count = info->count;
6542 /* pointer field - be careful! */
6543 q_u->info.data = info->data;
6546 q_u->info.flags=PRINTER_NOTIFY_INFO_DISCARDED;
6553 /*******************************************************************
6554 Parse a SPOOL_Q_REPLY_RRPCN structure.
6555 ********************************************************************/
6557 BOOL spoolss_io_q_reply_rrpcn(const char *desc, SPOOL_Q_REPLY_RRPCN *q_u, prs_struct *ps, int depth)
6559 prs_debug(ps, depth, desc, "spoolss_io_q_reply_rrpcn");
6565 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6568 if (!prs_uint32("change_low", ps, depth, &q_u->change_low))
6571 if (!prs_uint32("change_high", ps, depth, &q_u->change_high))
6574 if (!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6577 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6580 if (!prs_uint32("info_ptr", ps, depth, &q_u->info_ptr))
6583 if(q_u->info_ptr!=0)
6584 if(!smb_io_notify_info(desc, &q_u->info, ps, depth))
6590 /*******************************************************************
6591 Parse a SPOOL_R_REPLY_RRPCN structure.
6592 ********************************************************************/
6594 BOOL spoolss_io_r_reply_rrpcn(const char *desc, SPOOL_R_REPLY_RRPCN *r_u, prs_struct *ps, int depth)
6596 prs_debug(ps, depth, desc, "spoolss_io_r_reply_rrpcn");
6602 if (!prs_uint32("unknown0", ps, depth, &r_u->unknown0))
6605 if (!prs_werror("status", ps, depth, &r_u->status))
6611 /*******************************************************************
6613 * called from spoolss_q_getprinterdataex (srv_spoolss.c)
6614 ********************************************************************/
6616 BOOL spoolss_io_q_getprinterdataex(const char *desc, SPOOL_Q_GETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6621 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdataex");
6626 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6630 if (!smb_io_unistr2("keyname", &q_u->keyname,True,ps,depth))
6634 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
6638 if (!prs_uint32("size", ps, depth, &q_u->size))
6644 /*******************************************************************
6645 * write a structure.
6646 * called from spoolss_r_getprinterdataex (srv_spoolss.c)
6647 ********************************************************************/
6649 BOOL spoolss_io_r_getprinterdataex(const char *desc, SPOOL_R_GETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6654 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdataex");
6659 if (!prs_uint32("type", ps, depth, &r_u->type))
6661 if (!prs_uint32("size", ps, depth, &r_u->size))
6664 if (UNMARSHALLING(ps) && r_u->size) {
6665 r_u->data = PRS_ALLOC_MEM(ps, unsigned char, r_u->size);
6670 if (!prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size))
6676 if (!prs_uint32("needed", ps, depth, &r_u->needed))
6678 if (!prs_werror("status", ps, depth, &r_u->status))
6684 /*******************************************************************
6686 ********************************************************************/
6688 BOOL spoolss_io_q_setprinterdataex(const char *desc, SPOOL_Q_SETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6690 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdataex");
6695 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6697 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6703 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
6709 if(!prs_uint32("type", ps, depth, &q_u->type))
6712 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
6722 if (UNMARSHALLING(ps))
6723 q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
6724 if(q_u->data == NULL)
6726 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
6734 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
6740 /*******************************************************************
6741 * write a structure.
6742 ********************************************************************/
6744 BOOL spoolss_io_r_setprinterdataex(const char *desc, SPOOL_R_SETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6746 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdataex");
6751 if(!prs_werror("status", ps, depth, &r_u->status))
6757 /*******************************************************************
6759 ********************************************************************/
6760 BOOL make_spoolss_q_enumprinterkey(SPOOL_Q_ENUMPRINTERKEY *q_u,
6761 POLICY_HND *hnd, const char *key,
6764 DEBUG(5,("make_spoolss_q_enumprinterkey\n"));
6766 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6767 init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
6773 /*******************************************************************
6775 ********************************************************************/
6777 BOOL spoolss_io_q_enumprinterkey(const char *desc, SPOOL_Q_ENUMPRINTERKEY *q_u, prs_struct *ps, int depth)
6779 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterkey");
6784 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6787 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6793 if(!prs_uint32("size", ps, depth, &q_u->size))
6799 /*******************************************************************
6800 * write a structure.
6801 ********************************************************************/
6803 BOOL spoolss_io_r_enumprinterkey(const char *desc, SPOOL_R_ENUMPRINTERKEY *r_u, prs_struct *ps, int depth)
6805 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterkey");
6811 if (!smb_io_buffer5("", &r_u->keys, ps, depth))
6817 if(!prs_uint32("needed", ps, depth, &r_u->needed))
6820 if(!prs_werror("status", ps, depth, &r_u->status))
6826 /*******************************************************************
6828 ********************************************************************/
6830 BOOL make_spoolss_q_deleteprinterkey(SPOOL_Q_DELETEPRINTERKEY *q_u,
6831 POLICY_HND *hnd, char *keyname)
6833 DEBUG(5,("make_spoolss_q_deleteprinterkey\n"));
6835 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6836 init_unistr2(&q_u->keyname, keyname, UNI_STR_TERMINATE);
6841 /*******************************************************************
6843 ********************************************************************/
6845 BOOL spoolss_io_q_deleteprinterkey(const char *desc, SPOOL_Q_DELETEPRINTERKEY *q_u, prs_struct *ps, int depth)
6847 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterkey");
6852 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6855 if(!smb_io_unistr2("", &q_u->keyname, True, ps, depth))
6861 /*******************************************************************
6862 * write a structure.
6863 ********************************************************************/
6865 BOOL spoolss_io_r_deleteprinterkey(const char *desc, SPOOL_R_DELETEPRINTERKEY *r_u, prs_struct *ps, int depth)
6867 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterkey");
6873 if(!prs_werror("status", ps, depth, &r_u->status))
6880 /*******************************************************************
6882 ********************************************************************/
6884 BOOL spoolss_io_q_enumprinterdataex(const char *desc, SPOOL_Q_ENUMPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6886 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdataex");
6891 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6894 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6900 if(!prs_uint32("size", ps, depth, &q_u->size))
6906 /*******************************************************************
6907 ********************************************************************/
6909 static BOOL spoolss_io_printer_enum_values_ctr(const char *desc, prs_struct *ps,
6910 PRINTER_ENUM_VALUES_CTR *ctr, int depth)
6913 uint32 valuename_offset,
6916 const uint32 basic_unit = 20; /* size of static portion of enum_values */
6918 prs_debug(ps, depth, desc, "spoolss_io_printer_enum_values_ctr");
6922 * offset data begins at 20 bytes per structure * size_of_array.
6923 * Don't forget the uint32 at the beginning
6926 current_offset = basic_unit * ctr->size_of_array;
6928 /* first loop to write basic enum_value information */
6930 if (UNMARSHALLING(ps)) {
6931 ctr->values = PRS_ALLOC_MEM(ps, PRINTER_ENUM_VALUES, ctr->size_of_array);
6936 for (i=0; i<ctr->size_of_array; i++) {
6937 valuename_offset = current_offset;
6938 if (!prs_uint32("valuename_offset", ps, depth, &valuename_offset))
6941 if (!prs_uint32("value_len", ps, depth, &ctr->values[i].value_len))
6944 if (!prs_uint32("type", ps, depth, &ctr->values[i].type))
6947 data_offset = ctr->values[i].value_len + valuename_offset;
6949 if (!prs_uint32("data_offset", ps, depth, &data_offset))
6952 if (!prs_uint32("data_len", ps, depth, &ctr->values[i].data_len))
6955 current_offset = data_offset + ctr->values[i].data_len - basic_unit;
6956 /* account for 2 byte alignment */
6957 current_offset += (current_offset % 2);
6961 * loop #2 for writing the dynamically size objects; pay
6962 * attention to 2-byte alignment here....
6965 for (i=0; i<ctr->size_of_array; i++) {
6967 if (!prs_unistr("valuename", ps, depth, &ctr->values[i].valuename))
6970 if ( ctr->values[i].data_len ) {
6971 if ( UNMARSHALLING(ps) ) {
6972 ctr->values[i].data = PRS_ALLOC_MEM(ps, uint8, ctr->values[i].data_len);
6973 if (!ctr->values[i].data)
6976 if (!prs_uint8s(False, "data", ps, depth, ctr->values[i].data, ctr->values[i].data_len))
6980 if ( !prs_align_uint16(ps) )
6987 /*******************************************************************
6988 * write a structure.
6989 ********************************************************************/
6991 BOOL spoolss_io_r_enumprinterdataex(const char *desc, SPOOL_R_ENUMPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6993 uint32 data_offset, end_offset;
6994 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdataex");
7000 if (!prs_uint32("size", ps, depth, &r_u->ctr.size))
7003 data_offset = prs_offset(ps);
7005 if (!prs_set_offset(ps, data_offset + r_u->ctr.size))
7011 if(!prs_uint32("needed", ps, depth, &r_u->needed))
7014 if(!prs_uint32("returned", ps, depth, &r_u->returned))
7017 if(!prs_werror("status", ps, depth, &r_u->status))
7020 r_u->ctr.size_of_array = r_u->returned;
7022 end_offset = prs_offset(ps);
7024 if (!prs_set_offset(ps, data_offset))
7028 if (!spoolss_io_printer_enum_values_ctr("", ps, &r_u->ctr, depth ))
7031 if (!prs_set_offset(ps, end_offset))
7036 /*******************************************************************
7037 * write a structure.
7038 ********************************************************************/
7041 uint32 GetPrintProcessorDirectory(
7043 [in] unistr2 *environment,
7045 [in,out] RPC_BUFFER buffer,
7046 [in] uint32 offered,
7047 [out] uint32 needed,
7048 [out] uint32 returned
7053 BOOL make_spoolss_q_getprintprocessordirectory(SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, const char *name, char *environment, int level, RPC_BUFFER *buffer, uint32 offered)
7055 DEBUG(5,("make_spoolss_q_getprintprocessordirectory\n"));
7057 init_unistr2(&q_u->name, name, UNI_STR_TERMINATE);
7058 init_unistr2(&q_u->environment, environment, UNI_STR_TERMINATE);
7062 q_u->buffer = buffer;
7063 q_u->offered = offered;
7068 BOOL spoolss_io_q_getprintprocessordirectory(const char *desc, SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, prs_struct *ps, int depth)
7072 prs_debug(ps, depth, desc, "spoolss_io_q_getprintprocessordirectory");
7078 if (!prs_uint32("ptr", ps, depth, &ptr))
7082 if(!smb_io_unistr2("name", &q_u->name, True, ps, depth))
7089 if (!prs_uint32("ptr", ps, depth, &ptr))
7093 if(!smb_io_unistr2("environment", &q_u->environment, True,
7101 if(!prs_uint32("level", ps, depth, &q_u->level))
7104 if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
7110 if(!prs_uint32("offered", ps, depth, &q_u->offered))
7116 /*******************************************************************
7117 * write a structure.
7118 ********************************************************************/
7120 BOOL spoolss_io_r_getprintprocessordirectory(const char *desc, SPOOL_R_GETPRINTPROCESSORDIRECTORY *r_u, prs_struct *ps, int depth)
7122 prs_debug(ps, depth, desc, "spoolss_io_r_getprintprocessordirectory");
7128 if(!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
7134 if(!prs_uint32("needed", ps, depth, &r_u->needed))
7137 if(!prs_werror("status", ps, depth, &r_u->status))
7143 BOOL smb_io_printprocessordirectory_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_DIRECTORY_1 *info, int depth)
7145 prs_struct *ps=&buffer->prs;
7147 prs_debug(ps, depth, desc, "smb_io_printprocessordirectory_1");
7150 buffer->struct_start=prs_offset(ps);
7152 if (!smb_io_unistr(desc, &info->name, ps, depth))
7158 /*******************************************************************
7160 ********************************************************************/
7162 BOOL make_spoolss_q_addform(SPOOL_Q_ADDFORM *q_u, POLICY_HND *handle,
7163 int level, FORM *form)
7165 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7167 q_u->level2 = level;
7168 memcpy(&q_u->form, form, sizeof(FORM));
7173 /*******************************************************************
7175 ********************************************************************/
7177 BOOL make_spoolss_q_setform(SPOOL_Q_SETFORM *q_u, POLICY_HND *handle,
7178 int level, const char *form_name, FORM *form)
7180 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7182 q_u->level2 = level;
7183 memcpy(&q_u->form, form, sizeof(FORM));
7184 init_unistr2(&q_u->name, form_name, UNI_STR_TERMINATE);
7189 /*******************************************************************
7191 ********************************************************************/
7193 BOOL make_spoolss_q_deleteform(SPOOL_Q_DELETEFORM *q_u, POLICY_HND *handle,
7196 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7197 init_unistr2(&q_u->name, form, UNI_STR_TERMINATE);
7201 /*******************************************************************
7203 ********************************************************************/
7205 BOOL make_spoolss_q_getform(SPOOL_Q_GETFORM *q_u, POLICY_HND *handle,
7206 const char *formname, uint32 level,
7207 RPC_BUFFER *buffer, uint32 offered)
7209 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7211 init_unistr2(&q_u->formname, formname, UNI_STR_TERMINATE);
7213 q_u->offered=offered;
7218 /*******************************************************************
7220 ********************************************************************/
7222 BOOL make_spoolss_q_enumforms(SPOOL_Q_ENUMFORMS *q_u, POLICY_HND *handle,
7223 uint32 level, RPC_BUFFER *buffer,
7226 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7229 q_u->offered=offered;
7234 /*******************************************************************
7236 ********************************************************************/
7238 BOOL make_spoolss_q_setjob(SPOOL_Q_SETJOB *q_u, POLICY_HND *handle,
7239 uint32 jobid, uint32 level, uint32 command)
7241 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7245 /* Hmm - the SPOOL_Q_SETJOB structure has a JOB_INFO ctr in it but
7246 the server side code has it marked as unused. */
7248 q_u->command = command;
7253 /*******************************************************************
7255 ********************************************************************/
7257 BOOL make_spoolss_q_getjob(SPOOL_Q_GETJOB *q_u, POLICY_HND *handle,
7258 uint32 jobid, uint32 level, RPC_BUFFER *buffer,
7261 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7264 q_u->buffer = buffer;
7265 q_u->offered = offered;
7270 /*******************************************************************
7272 ********************************************************************/
7274 BOOL make_spoolss_q_startpageprinter(SPOOL_Q_STARTPAGEPRINTER *q_u,
7277 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7282 /*******************************************************************
7284 ********************************************************************/
7286 BOOL make_spoolss_q_endpageprinter(SPOOL_Q_ENDPAGEPRINTER *q_u,
7289 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7294 /*******************************************************************
7296 ********************************************************************/
7298 BOOL make_spoolss_q_startdocprinter(SPOOL_Q_STARTDOCPRINTER *q_u,
7299 POLICY_HND *handle, uint32 level,
7300 char *docname, char *outputfile,
7303 DOC_INFO_CONTAINER *ctr = &q_u->doc_info_container;
7305 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7311 ctr->docinfo.switch_value = level;
7313 ctr->docinfo.doc_info_1.p_docname = docname ? 1 : 0;
7314 ctr->docinfo.doc_info_1.p_outputfile = outputfile ? 1 : 0;
7315 ctr->docinfo.doc_info_1.p_datatype = datatype ? 1 : 0;
7317 init_unistr2(&ctr->docinfo.doc_info_1.docname, docname, UNI_STR_TERMINATE);
7318 init_unistr2(&ctr->docinfo.doc_info_1.outputfile, outputfile, UNI_STR_TERMINATE);
7319 init_unistr2(&ctr->docinfo.doc_info_1.datatype, datatype, UNI_STR_TERMINATE);
7323 /* DOC_INFO_2 is only used by Windows 9x and since it
7324 doesn't do printing over RPC we don't have to worry
7327 DEBUG(3, ("unsupported info level %d\n", level));
7334 /*******************************************************************
7336 ********************************************************************/
7338 BOOL make_spoolss_q_enddocprinter(SPOOL_Q_ENDDOCPRINTER *q_u,
7341 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7346 /*******************************************************************
7348 ********************************************************************/
7350 BOOL make_spoolss_q_writeprinter(SPOOL_Q_WRITEPRINTER *q_u,
7351 POLICY_HND *handle, uint32 data_size,
7354 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7355 q_u->buffer_size = q_u->buffer_size2 = data_size;
7356 q_u->buffer = (unsigned char *)data;
7360 /*******************************************************************
7362 ********************************************************************/
7364 BOOL make_spoolss_q_deleteprinterdata(SPOOL_Q_DELETEPRINTERDATA *q_u,
7365 POLICY_HND *handle, char *valuename)
7367 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7368 init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
7373 /*******************************************************************
7375 ********************************************************************/
7377 BOOL make_spoolss_q_deleteprinterdataex(SPOOL_Q_DELETEPRINTERDATAEX *q_u,
7378 POLICY_HND *handle, char *key,
7381 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7382 init_unistr2(&q_u->valuename, value, UNI_STR_TERMINATE);
7383 init_unistr2(&q_u->keyname, key, UNI_STR_TERMINATE);
7388 /*******************************************************************
7390 ********************************************************************/
7392 BOOL make_spoolss_q_rffpcnex(SPOOL_Q_RFFPCNEX *q_u, POLICY_HND *handle,
7393 uint32 flags, uint32 options, const char *localmachine,
7394 uint32 printerlocal, SPOOL_NOTIFY_OPTION *option)
7396 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7399 q_u->options = options;
7401 q_u->localmachine_ptr = 1;
7403 init_unistr2(&q_u->localmachine, localmachine, UNI_STR_TERMINATE);
7405 q_u->printerlocal = printerlocal;
7408 q_u->option_ptr = 1;
7410 q_u->option = option;