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
30 /*******************************************************************
31 return the length of a UNISTR string.
32 ********************************************************************/
34 static uint32 str_len_uni(UNISTR *source)
41 while (source->buffer[i])
47 /*******************************************************************
48 This should be moved in a more generic lib.
49 ********************************************************************/
51 BOOL spoolss_io_system_time(char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
53 if(!prs_uint16("year", ps, depth, &systime->year))
55 if(!prs_uint16("month", ps, depth, &systime->month))
57 if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
59 if(!prs_uint16("day", ps, depth, &systime->day))
61 if(!prs_uint16("hour", ps, depth, &systime->hour))
63 if(!prs_uint16("minute", ps, depth, &systime->minute))
65 if(!prs_uint16("second", ps, depth, &systime->second))
67 if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
73 /*******************************************************************
74 ********************************************************************/
76 BOOL make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
78 systime->year=unixtime->tm_year+1900;
79 systime->month=unixtime->tm_mon+1;
80 systime->dayofweek=unixtime->tm_wday;
81 systime->day=unixtime->tm_mday;
82 systime->hour=unixtime->tm_hour;
83 systime->minute=unixtime->tm_min;
84 systime->second=unixtime->tm_sec;
85 systime->milliseconds=0;
90 /*******************************************************************
91 reads or writes an DOC_INFO structure.
92 ********************************************************************/
94 static BOOL smb_io_doc_info_1(char *desc, DOC_INFO_1 *info_1, prs_struct *ps, int depth)
96 if (info_1 == NULL) return False;
98 prs_debug(ps, depth, desc, "smb_io_doc_info_1");
104 if(!prs_uint32("p_docname", ps, depth, &info_1->p_docname))
106 if(!prs_uint32("p_outputfile", ps, depth, &info_1->p_outputfile))
108 if(!prs_uint32("p_datatype", ps, depth, &info_1->p_datatype))
111 if(!smb_io_unistr2("", &info_1->docname, info_1->p_docname, ps, depth))
113 if(!smb_io_unistr2("", &info_1->outputfile, info_1->p_outputfile, ps, depth))
115 if(!smb_io_unistr2("", &info_1->datatype, info_1->p_datatype, ps, depth))
121 /*******************************************************************
122 reads or writes an DOC_INFO structure.
123 ********************************************************************/
125 static BOOL smb_io_doc_info(char *desc, DOC_INFO *info, prs_struct *ps, int depth)
127 uint32 useless_ptr=0;
129 if (info == NULL) return False;
131 prs_debug(ps, depth, desc, "smb_io_doc_info");
137 if(!prs_uint32("switch_value", ps, depth, &info->switch_value))
140 if(!prs_uint32("doc_info_X ptr", ps, depth, &useless_ptr))
143 switch (info->switch_value)
146 if(!smb_io_doc_info_1("",&info->doc_info_1, ps, depth))
151 this is just a placeholder
153 MSDN July 1998 says doc_info_2 is only on
154 Windows 95, and as Win95 doesn't do RPC to print
155 this case is nearly impossible
157 Maybe one day with Windows for dishwasher 2037 ...
160 /* smb_io_doc_info_2("",&info->doc_info_2, ps, depth); */
163 DEBUG(0,("Something is obviously wrong somewhere !\n"));
170 /*******************************************************************
171 reads or writes an DOC_INFO_CONTAINER structure.
172 ********************************************************************/
174 static BOOL smb_io_doc_info_container(char *desc, DOC_INFO_CONTAINER *cont, prs_struct *ps, int depth)
176 if (cont == NULL) return False;
178 prs_debug(ps, depth, desc, "smb_io_doc_info_container");
184 if(!prs_uint32("level", ps, depth, &cont->level))
187 if(!smb_io_doc_info("",&cont->docinfo, ps, depth))
193 /*******************************************************************
194 reads or writes an NOTIFY OPTION TYPE structure.
195 ********************************************************************/
197 /* NOTIFY_OPTION_TYPE and NOTIFY_OPTION_TYPE_DATA are really one
198 structure. The _TYPE structure is really the deferred referrants (i.e
199 the notify fields array) of the _TYPE structure. -tpot */
201 static BOOL smb_io_notify_option_type(char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
203 prs_debug(ps, depth, desc, "smb_io_notify_option_type");
209 if(!prs_uint16("type", ps, depth, &type->type))
211 if(!prs_uint16("reserved0", ps, depth, &type->reserved0))
213 if(!prs_uint32("reserved1", ps, depth, &type->reserved1))
215 if(!prs_uint32("reserved2", ps, depth, &type->reserved2))
217 if(!prs_uint32("count", ps, depth, &type->count))
219 if(!prs_uint32("fields_ptr", ps, depth, &type->fields_ptr))
225 /*******************************************************************
226 reads or writes an NOTIFY OPTION TYPE DATA.
227 ********************************************************************/
229 static BOOL smb_io_notify_option_type_data(char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
233 prs_debug(ps, depth, desc, "smb_io_notify_option_type_data");
236 /* if there are no fields just return */
237 if (type->fields_ptr==0)
243 if(!prs_uint32("count2", ps, depth, &type->count2))
246 if (type->count2 != type->count)
247 DEBUG(4,("What a mess, count was %x now is %x !\n", type->count, type->count2));
249 /* parse the option type data */
250 for(i=0;i<type->count2;i++)
251 if(!prs_uint16("fields",ps,depth,&type->fields[i]))
256 /*******************************************************************
257 reads or writes an NOTIFY OPTION structure.
258 ********************************************************************/
260 static BOOL smb_io_notify_option_type_ctr(char *desc, SPOOL_NOTIFY_OPTION_TYPE_CTR *ctr , prs_struct *ps, int depth)
264 prs_debug(ps, depth, desc, "smb_io_notify_option_type_ctr");
267 if(!prs_uint32("count", ps, depth, &ctr->count))
271 if (UNMARSHALLING(ps))
272 if((ctr->type=(SPOOL_NOTIFY_OPTION_TYPE *)prs_alloc_mem(ps,ctr->count*sizeof(SPOOL_NOTIFY_OPTION_TYPE))) == NULL)
275 /* the option type struct */
276 for(i=0;i<ctr->count;i++)
277 if(!smb_io_notify_option_type("", &ctr->type[i] , ps, depth))
280 /* the type associated with the option type struct */
281 for(i=0;i<ctr->count;i++)
282 if(!smb_io_notify_option_type_data("", &ctr->type[i] , ps, depth))
288 /*******************************************************************
289 reads or writes an NOTIFY OPTION structure.
290 ********************************************************************/
292 static BOOL smb_io_notify_option(char *desc, SPOOL_NOTIFY_OPTION *option, prs_struct *ps, int depth)
294 prs_debug(ps, depth, desc, "smb_io_notify_option");
297 if(!prs_uint32("version", ps, depth, &option->version))
299 if(!prs_uint32("flags", ps, depth, &option->flags))
301 if(!prs_uint32("count", ps, depth, &option->count))
303 if(!prs_uint32("option_type_ptr", ps, depth, &option->option_type_ptr))
306 /* marshalling or unmarshalling, that would work */
307 if (option->option_type_ptr!=0) {
308 if(!smb_io_notify_option_type_ctr("", &option->ctr ,ps, depth))
312 option->ctr.type=NULL;
319 /*******************************************************************
320 reads or writes an NOTIFY INFO DATA structure.
321 ********************************************************************/
323 static BOOL smb_io_notify_info_data(char *desc,SPOOL_NOTIFY_INFO_DATA *data, prs_struct *ps, int depth)
325 uint32 useless_ptr=0x0FF0ADDE;
327 prs_debug(ps, depth, desc, "smb_io_notify_info_data");
332 if(!prs_uint16("type", ps, depth, &data->type))
334 if(!prs_uint16("field", ps, depth, &data->field))
337 if(!prs_uint32("how many words", ps, depth, &data->size))
339 if(!prs_uint32("id", ps, depth, &data->id))
341 if(!prs_uint32("how many words", ps, depth, &data->size))
344 switch (data->enc_type) {
346 /* One and two value data has two uint32 values */
348 case NOTIFY_ONE_VALUE:
349 case NOTIFY_TWO_VALUE:
351 if(!prs_uint32("value[0]", ps, depth, &data->notify_data.value[0]))
353 if(!prs_uint32("value[1]", ps, depth, &data->notify_data.value[1]))
357 /* Pointers and strings have a string length and a
358 pointer. For a string the length is expressed as
359 the number of uint16 characters plus a trailing
364 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length ))
366 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
373 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
376 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
382 if( !prs_uint32( "sd size", ps, depth, &data->notify_data.sd.size ) )
384 if( !prs_uint32( "pointer", ps, depth, &useless_ptr ) )
390 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data\n",
398 /*******************************************************************
399 reads or writes an NOTIFY INFO DATA structure.
400 ********************************************************************/
402 BOOL smb_io_notify_info_data_strings(char *desc,SPOOL_NOTIFY_INFO_DATA *data,
403 prs_struct *ps, int depth)
405 prs_debug(ps, depth, desc, "smb_io_notify_info_data_strings");
411 switch(data->enc_type) {
413 /* No data for values */
415 case NOTIFY_ONE_VALUE:
416 case NOTIFY_TWO_VALUE:
420 /* Strings start with a length in uint16s */
424 if (UNMARSHALLING(ps)) {
425 data->notify_data.data.string =
426 (uint16 *)prs_alloc_mem(ps, data->notify_data.data.length);
428 if (!data->notify_data.data.string)
433 data->notify_data.data.length /= 2;
435 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
438 if (!prs_uint16uni(True, "string", ps, depth, data->notify_data.data.string,
439 data->notify_data.data.length))
443 data->notify_data.data.length *= 2;
449 if (UNMARSHALLING(ps)) {
450 data->notify_data.data.string =
451 (uint16 *)prs_alloc_mem(ps, data->notify_data.data.length);
453 if (!data->notify_data.data.string)
457 if(!prs_uint8s(True,"buffer",ps,depth,(uint8*)data->notify_data.data.string,data->notify_data.data.length))
463 if( !prs_uint32("secdesc size ", ps, depth, &data->notify_data.sd.size ) )
465 if ( !sec_io_desc( "sec_desc", &data->notify_data.sd.desc, ps, depth ) )
470 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data_strings\n",
476 if (isvalue==False) {
478 /* length of string in unicode include \0 */
479 x=data->notify_data.data.length+1;
481 if (data->field != 16)
482 if(!prs_uint32("string length", ps, depth, &x ))
485 if (MARSHALLING(ps)) {
486 /* These are already in little endian format. Don't byte swap. */
489 /* No memory allocated for this string
490 therefore following the data.string
491 pointer is a bad idea. Use a pointer to
492 the uint32 length union member to
493 provide a source for a unicode NULL */
495 if(!prs_uint8s(True,"string",ps,depth, (uint8 *)&data->notify_data.data.length,x*2))
499 if (data->field == 16)
502 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
507 /* Tallocate memory for string */
509 data->notify_data.data.string = (uint16 *)prs_alloc_mem(ps, x * 2);
510 if (!data->notify_data.data.string)
513 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
521 /* Win2k does not seem to put this parse align here */
529 /*******************************************************************
530 reads or writes an NOTIFY INFO structure.
531 ********************************************************************/
533 static BOOL smb_io_notify_info(char *desc, SPOOL_NOTIFY_INFO *info, prs_struct *ps, int depth)
537 prs_debug(ps, depth, desc, "smb_io_notify_info");
543 if(!prs_uint32("count", ps, depth, &info->count))
545 if(!prs_uint32("version", ps, depth, &info->version))
547 if(!prs_uint32("flags", ps, depth, &info->flags))
549 if(!prs_uint32("count", ps, depth, &info->count))
552 for (i=0;i<info->count;i++) {
553 if(!smb_io_notify_info_data(desc, &info->data[i], ps, depth))
557 /* now do the strings at the end of the stream */
558 for (i=0;i<info->count;i++) {
559 if(!smb_io_notify_info_data_strings(desc, &info->data[i], ps, depth))
566 /*******************************************************************
567 ********************************************************************/
569 static BOOL spool_io_user_level_1(char *desc, SPOOL_USER_1 *q_u, prs_struct *ps, int depth)
571 prs_debug(ps, depth, desc, "");
575 if (UNMARSHALLING(ps))
580 if (!prs_uint32("size", ps, depth, &q_u->size))
582 if (!prs_uint32("client_name_ptr", ps, depth, &q_u->client_name_ptr))
584 if (!prs_uint32("user_name_ptr", ps, depth, &q_u->user_name_ptr))
586 if (!prs_uint32("build", ps, depth, &q_u->build))
588 if (!prs_uint32("major", ps, depth, &q_u->major))
590 if (!prs_uint32("minor", ps, depth, &q_u->minor))
592 if (!prs_uint32("processor", ps, depth, &q_u->processor))
595 if (!smb_io_unistr2("", &q_u->client_name, q_u->client_name_ptr, ps, depth))
599 if (!smb_io_unistr2("", &q_u->user_name, q_u->user_name_ptr, ps, depth))
605 /*******************************************************************
606 ********************************************************************/
608 static BOOL spool_io_user_level(char *desc, SPOOL_USER_CTR *q_u, prs_struct *ps, int depth)
613 prs_debug(ps, depth, desc, "spool_io_user_level");
618 if (!prs_uint32("level", ps, depth, &q_u->level))
620 if (!prs_uint32("ptr", ps, depth, &q_u->ptr))
623 switch (q_u->level) {
625 if (!spool_io_user_level_1("", &q_u->user1, ps, depth))
635 /*******************************************************************
636 * read or write a DEVICEMODE struct.
637 * on reading allocate memory for the private member
638 ********************************************************************/
640 #define DM_NUM_OPTIONAL_FIELDS 8
642 BOOL spoolss_io_devmode(char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
644 uint32 available_space; /* size of the device mode left to parse */
645 /* only important on unmarshalling */
648 struct optional_fields {
651 } opt_fields[DM_NUM_OPTIONAL_FIELDS] = {
652 { "icmmethod", NULL },
653 { "icmintent", NULL },
654 { "mediatype", NULL },
655 { "dithertype", NULL },
656 { "reserved1", NULL },
657 { "reserved2", NULL },
658 { "panningwidth", NULL },
659 { "panningheight", NULL }
662 /* assign at run time to keep non-gcc compilers happy */
664 opt_fields[0].field = &devmode->icmmethod;
665 opt_fields[1].field = &devmode->icmintent;
666 opt_fields[2].field = &devmode->mediatype;
667 opt_fields[3].field = &devmode->dithertype;
668 opt_fields[4].field = &devmode->reserved1;
669 opt_fields[5].field = &devmode->reserved2;
670 opt_fields[6].field = &devmode->panningwidth;
671 opt_fields[7].field = &devmode->panningheight;
674 prs_debug(ps, depth, desc, "spoolss_io_devmode");
677 if (UNMARSHALLING(ps)) {
678 devmode->devicename.buffer = (uint16 *)prs_alloc_mem(ps, 32 * sizeof(uint16) );
679 if (devmode->devicename.buffer == NULL)
683 if (!prs_uint16uni(True,"devicename", ps, depth, devmode->devicename.buffer, 32))
686 if (!prs_uint16("specversion", ps, depth, &devmode->specversion))
689 /* Sanity Check - look for unknown specversions, but don't fail if we see one.
690 Let the size determine that */
692 switch (devmode->specversion) {
693 /* list of observed spec version's */
701 DEBUG(0,("spoolss_io_devmode: Unknown specversion in devicemode [0x%x]\n",
702 devmode->specversion));
703 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
708 if (!prs_uint16("driverversion", ps, depth, &devmode->driverversion))
710 if (!prs_uint16("size", ps, depth, &devmode->size))
712 if (!prs_uint16("driverextra", ps, depth, &devmode->driverextra))
714 if (!prs_uint32("fields", ps, depth, &devmode->fields))
716 if (!prs_uint16("orientation", ps, depth, &devmode->orientation))
718 if (!prs_uint16("papersize", ps, depth, &devmode->papersize))
720 if (!prs_uint16("paperlength", ps, depth, &devmode->paperlength))
722 if (!prs_uint16("paperwidth", ps, depth, &devmode->paperwidth))
724 if (!prs_uint16("scale", ps, depth, &devmode->scale))
726 if (!prs_uint16("copies", ps, depth, &devmode->copies))
728 if (!prs_uint16("defaultsource", ps, depth, &devmode->defaultsource))
730 if (!prs_uint16("printquality", ps, depth, &devmode->printquality))
732 if (!prs_uint16("color", ps, depth, &devmode->color))
734 if (!prs_uint16("duplex", ps, depth, &devmode->duplex))
736 if (!prs_uint16("yresolution", ps, depth, &devmode->yresolution))
738 if (!prs_uint16("ttoption", ps, depth, &devmode->ttoption))
740 if (!prs_uint16("collate", ps, depth, &devmode->collate))
743 if (UNMARSHALLING(ps)) {
744 devmode->formname.buffer = (uint16 *)prs_alloc_mem(ps, 32 * sizeof(uint16) );
745 if (devmode->formname.buffer == NULL)
749 if (!prs_uint16uni(True, "formname", ps, depth, devmode->formname.buffer, 32))
751 if (!prs_uint16("logpixels", ps, depth, &devmode->logpixels))
753 if (!prs_uint32("bitsperpel", ps, depth, &devmode->bitsperpel))
755 if (!prs_uint32("pelswidth", ps, depth, &devmode->pelswidth))
757 if (!prs_uint32("pelsheight", ps, depth, &devmode->pelsheight))
759 if (!prs_uint32("displayflags", ps, depth, &devmode->displayflags))
761 if (!prs_uint32("displayfrequency", ps, depth, &devmode->displayfrequency))
764 * every device mode I've ever seen on the wire at least has up
765 * to the displayfrequency field. --jerry (05-09-2002)
768 /* add uint32's + uint16's + two UNICODE strings */
770 available_space = devmode->size - (sizeof(uint32)*6 + sizeof(uint16)*18 + sizeof(uint16)*64);
772 /* Sanity check - we only have uint32's left tp parse */
774 if ( available_space && ((available_space % sizeof(uint32)) != 0) ) {
775 DEBUG(0,("spoolss_io_devmode: available_space [%d] no in multiple of 4 bytes (size = %d)!\n",
776 available_space, devmode->size));
777 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
782 * Conditional parsing. Assume that the DeviceMode has been
783 * zero'd by the caller.
786 while ((available_space > 0) && (i < DM_NUM_OPTIONAL_FIELDS))
788 DEBUG(10, ("spoolss_io_devmode: [%d] bytes left to parse in devmode\n", available_space));
789 if (!prs_uint32(opt_fields[i].name, ps, depth, opt_fields[i].field))
791 available_space -= sizeof(uint32);
795 /* Sanity Check - we should no available space at this point unless
796 MS changes the device mode structure */
798 if (available_space) {
799 DEBUG(0,("spoolss_io_devmode: I've parsed all I know and there is still stuff left|\n"));
800 DEBUG(0,("spoolss_io_devmode: available_space = [%d], devmode_size = [%d]!\n",
801 available_space, devmode->size));
802 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
807 if (devmode->driverextra!=0) {
808 if (UNMARSHALLING(ps)) {
809 devmode->private=(uint8 *)prs_alloc_mem(ps, devmode->driverextra*sizeof(uint8));
810 if(devmode->private == NULL)
812 DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for private\n",devmode->driverextra));
815 DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of private\n",devmode->driverextra));
816 if (!prs_uint8s(False, "private", ps, depth,
817 devmode->private, devmode->driverextra))
824 /*******************************************************************
825 Read or write a DEVICEMODE container
826 ********************************************************************/
828 static BOOL spoolss_io_devmode_cont(char *desc, DEVMODE_CTR *dm_c, prs_struct *ps, int depth)
833 prs_debug(ps, depth, desc, "spoolss_io_devmode_cont");
839 if (!prs_uint32("size", ps, depth, &dm_c->size))
842 if (!prs_uint32("devmode_ptr", ps, depth, &dm_c->devmode_ptr))
845 if (dm_c->size==0 || dm_c->devmode_ptr==0) {
846 if (UNMARSHALLING(ps))
847 /* if while reading there is no DEVMODE ... */
852 /* so we have a DEVICEMODE to follow */
853 if (UNMARSHALLING(ps)) {
854 DEBUG(9,("Allocating memory for spoolss_io_devmode\n"));
855 dm_c->devmode=(DEVICEMODE *)prs_alloc_mem(ps,sizeof(DEVICEMODE));
856 if(dm_c->devmode == NULL)
860 /* this is bad code, shouldn't be there */
861 if (!prs_uint32("size", ps, depth, &dm_c->size))
864 if (!spoolss_io_devmode(desc, ps, depth, dm_c->devmode))
870 /*******************************************************************
871 ********************************************************************/
873 static BOOL spoolss_io_printer_default(char *desc, PRINTER_DEFAULT *pd, prs_struct *ps, int depth)
878 prs_debug(ps, depth, desc, "spoolss_io_printer_default");
881 if (!prs_uint32("datatype_ptr", ps, depth, &pd->datatype_ptr))
884 if (!smb_io_unistr2("datatype", &pd->datatype, pd->datatype_ptr, ps,depth))
890 if (!spoolss_io_devmode_cont("", &pd->devmode_cont, ps, depth))
896 if (!prs_uint32("access_required", ps, depth, &pd->access_required))
902 /*******************************************************************
904 ********************************************************************/
906 BOOL make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX *q_u,
907 const fstring printername,
908 const fstring datatype,
909 uint32 access_required,
910 const fstring clientname,
911 const fstring user_name)
913 DEBUG(5,("make_spoolss_q_open_printer_ex\n"));
914 q_u->printername_ptr = (printername!=NULL)?1:0;
915 init_unistr2(&q_u->printername, printername, strlen(printername)+1);
917 q_u->printer_default.datatype_ptr = 0;
919 q_u->printer_default.datatype_ptr = (datatype!=NULL)?1:0;
920 init_unistr2(&q_u->printer_default.datatype, datatype, strlen(datatype));
922 q_u->printer_default.devmode_cont.size=0;
923 q_u->printer_default.devmode_cont.devmode_ptr=0;
924 q_u->printer_default.devmode_cont.devmode=NULL;
925 q_u->printer_default.access_required=access_required;
927 q_u->user_ctr.level=1;
929 q_u->user_ctr.user1.size=strlen(clientname)+strlen(user_name)+10;
930 q_u->user_ctr.user1.client_name_ptr = (clientname!=NULL)?1:0;
931 q_u->user_ctr.user1.user_name_ptr = (user_name!=NULL)?1:0;
932 q_u->user_ctr.user1.build=1381;
933 q_u->user_ctr.user1.major=2;
934 q_u->user_ctr.user1.minor=0;
935 q_u->user_ctr.user1.processor=0;
936 init_unistr2(&q_u->user_ctr.user1.client_name, clientname, strlen(clientname)+1);
937 init_unistr2(&q_u->user_ctr.user1.user_name, user_name, strlen(user_name)+1);
942 /*******************************************************************
944 ********************************************************************/
946 BOOL make_spoolss_q_addprinterex(
948 SPOOL_Q_ADDPRINTEREX *q_u,
949 const char *srv_name,
950 const char* clientname,
951 const char* user_name,
953 PRINTER_INFO_CTR *ctr)
955 DEBUG(5,("make_spoolss_q_addprinterex\n"));
957 if (!ctr) return False;
961 q_u->server_name_ptr = (srv_name!=NULL)?1:0;
962 init_unistr2(&q_u->server_name, srv_name, strlen(srv_name));
966 q_u->info.level = level;
967 q_u->info.info_ptr = (ctr->printers_2!=NULL)?1:0;
970 /* init q_u->info.info2 from *info */
971 if (!make_spoolss_printer_info_2(mem_ctx, &q_u->info.info_2, ctr->printers_2)) {
972 DEBUG(0,("make_spoolss_q_addprinterex: Unable to fill SPOOL_Q_ADDPRINTEREX struct!\n"));
982 q_u->user_ctr.level=1;
984 q_u->user_ctr.user1.client_name_ptr = (clientname!=NULL)?1:0;
985 q_u->user_ctr.user1.user_name_ptr = (user_name!=NULL)?1:0;
986 q_u->user_ctr.user1.build=1381;
987 q_u->user_ctr.user1.major=2;
988 q_u->user_ctr.user1.minor=0;
989 q_u->user_ctr.user1.processor=0;
990 init_unistr2(&q_u->user_ctr.user1.client_name, clientname, strlen(clientname)+1);
991 init_unistr2(&q_u->user_ctr.user1.user_name, user_name, strlen(user_name)+1);
992 q_u->user_ctr.user1.size=q_u->user_ctr.user1.user_name.uni_str_len +
993 q_u->user_ctr.user1.client_name.uni_str_len + 2;
998 /*******************************************************************
999 create a SPOOL_PRINTER_INFO_2 stuct from a PRINTER_INFO_2 struct
1000 *******************************************************************/
1002 BOOL make_spoolss_printer_info_2(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_2 **spool_info2,
1003 PRINTER_INFO_2 *info)
1006 SPOOL_PRINTER_INFO_LEVEL_2 *inf;
1008 /* allocate the necessary memory */
1009 if (!(inf=(SPOOL_PRINTER_INFO_LEVEL_2*)talloc(mem_ctx, sizeof(SPOOL_PRINTER_INFO_LEVEL_2)))) {
1010 DEBUG(0,("make_spoolss_printer_info_2: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_2 sruct!\n"));
1014 inf->servername_ptr = (info->servername.buffer!=NULL)?1:0;
1015 inf->printername_ptr = (info->printername.buffer!=NULL)?1:0;
1016 inf->sharename_ptr = (info->sharename.buffer!=NULL)?1:0;
1017 inf->portname_ptr = (info->portname.buffer!=NULL)?1:0;
1018 inf->drivername_ptr = (info->drivername.buffer!=NULL)?1:0;
1019 inf->comment_ptr = (info->comment.buffer!=NULL)?1:0;
1020 inf->location_ptr = (info->location.buffer!=NULL)?1:0;
1021 inf->devmode_ptr = (info->devmode!=NULL)?1:0;
1022 inf->sepfile_ptr = (info->sepfile.buffer!=NULL)?1:0;
1023 inf->printprocessor_ptr = (info->printprocessor.buffer!=NULL)?1:0;
1024 inf->datatype_ptr = (info->datatype.buffer!=NULL)?1:0;
1025 inf->parameters_ptr = (info->parameters.buffer!=NULL)?1:0;
1026 inf->secdesc_ptr = (info->secdesc!=NULL)?1:0;
1027 inf->attributes = info->attributes;
1028 inf->priority = info->priority;
1029 inf->default_priority = info->defaultpriority;
1030 inf->starttime = info->starttime;
1031 inf->untiltime = info->untiltime;
1032 inf->cjobs = info->cjobs;
1033 inf->averageppm = info->averageppm;
1034 init_unistr2_from_unistr(&inf->servername, &info->servername);
1035 init_unistr2_from_unistr(&inf->printername, &info->printername);
1036 init_unistr2_from_unistr(&inf->sharename, &info->sharename);
1037 init_unistr2_from_unistr(&inf->portname, &info->portname);
1038 init_unistr2_from_unistr(&inf->drivername, &info->drivername);
1039 init_unistr2_from_unistr(&inf->comment, &info->comment);
1040 init_unistr2_from_unistr(&inf->location, &info->location);
1041 init_unistr2_from_unistr(&inf->sepfile, &info->sepfile);
1042 init_unistr2_from_unistr(&inf->printprocessor, &info->printprocessor);
1043 init_unistr2_from_unistr(&inf->datatype, &info->datatype);
1044 init_unistr2_from_unistr(&inf->parameters, &info->parameters);
1045 init_unistr2_from_unistr(&inf->datatype, &info->datatype);
1053 /*******************************************************************
1055 * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1056 ********************************************************************/
1058 BOOL spoolss_io_q_open_printer(char *desc, SPOOL_Q_OPEN_PRINTER *q_u, prs_struct *ps, int depth)
1063 prs_debug(ps, depth, desc, "spoolss_io_q_open_printer");
1069 if (!prs_uint32("printername_ptr", ps, depth, &q_u->printername_ptr))
1071 if (!smb_io_unistr2("", &q_u->printername, q_u->printername_ptr, ps,depth))
1077 if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth))
1083 /*******************************************************************
1084 * write a structure.
1085 * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1086 * called from spoolss_open_printer_ex (cli_spoolss.c)
1087 ********************************************************************/
1089 BOOL spoolss_io_r_open_printer(char *desc, SPOOL_R_OPEN_PRINTER *r_u, prs_struct *ps, int depth)
1091 if (r_u == NULL) return False;
1093 prs_debug(ps, depth, desc, "spoolss_io_r_open_printer");
1099 if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
1102 if (!prs_werror("status code", ps, depth, &(r_u->status)))
1109 /*******************************************************************
1111 * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1112 ********************************************************************/
1114 BOOL spoolss_io_q_open_printer_ex(char *desc, SPOOL_Q_OPEN_PRINTER_EX *q_u, prs_struct *ps, int depth)
1119 prs_debug(ps, depth, desc, "spoolss_io_q_open_printer_ex");
1125 if (!prs_uint32("printername_ptr", ps, depth, &q_u->printername_ptr))
1127 if (!smb_io_unistr2("", &q_u->printername, q_u->printername_ptr, ps,depth))
1133 if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth))
1136 if (!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
1138 if (!spool_io_user_level("", &q_u->user_ctr, ps, depth))
1144 /*******************************************************************
1145 * write a structure.
1146 * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1147 * called from spoolss_open_printer_ex (cli_spoolss.c)
1148 ********************************************************************/
1150 BOOL spoolss_io_r_open_printer_ex(char *desc, SPOOL_R_OPEN_PRINTER_EX *r_u, prs_struct *ps, int depth)
1152 if (r_u == NULL) return False;
1154 prs_debug(ps, depth, desc, "spoolss_io_r_open_printer_ex");
1160 if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
1163 if (!prs_werror("status code", ps, depth, &(r_u->status)))
1169 /*******************************************************************
1171 ********************************************************************/
1172 BOOL make_spoolss_q_deleteprinterdriver(
1173 TALLOC_CTX *mem_ctx,
1174 SPOOL_Q_DELETEPRINTERDRIVER *q_u,
1180 DEBUG(5,("make_spoolss_q_deleteprinterdriver\n"));
1182 q_u->server_ptr = (server!=NULL)?1:0;
1184 /* these must be NULL terminated or else NT4 will
1185 complain about invalid parameters --jerry */
1186 init_unistr2(&q_u->server, server, strlen(server)+1);
1187 init_unistr2(&q_u->arch, arch, strlen(arch)+1);
1188 init_unistr2(&q_u->driver, driver, strlen(driver)+1);
1195 /*******************************************************************
1197 ********************************************************************/
1199 BOOL make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u,
1200 const POLICY_HND *handle,
1201 char *valuename, uint32 size)
1203 if (q_u == NULL) return False;
1205 DEBUG(5,("make_spoolss_q_getprinterdata\n"));
1207 q_u->handle = *handle;
1208 init_unistr2(&q_u->valuename, valuename, strlen(valuename) + 1);
1214 /*******************************************************************
1216 ********************************************************************/
1218 BOOL make_spoolss_q_getprinterdataex(SPOOL_Q_GETPRINTERDATAEX *q_u,
1219 const POLICY_HND *handle,
1220 char *keyname, char *valuename, uint32 size)
1222 if (q_u == NULL) return False;
1224 DEBUG(5,("make_spoolss_q_getprinterdataex\n"));
1226 q_u->handle = *handle;
1227 init_unistr2(&q_u->valuename, valuename, strlen(valuename) + 1);
1228 init_unistr2(&q_u->keyname, keyname, strlen(keyname) + 1);
1234 /*******************************************************************
1236 * called from spoolss_q_getprinterdata (srv_spoolss.c)
1237 ********************************************************************/
1239 BOOL spoolss_io_q_getprinterdata(char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_struct *ps, int depth)
1244 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdata");
1249 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1253 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1257 if (!prs_uint32("size", ps, depth, &q_u->size))
1263 /*******************************************************************
1265 * called from spoolss_q_deleteprinterdata (srv_spoolss.c)
1266 ********************************************************************/
1268 BOOL spoolss_io_q_deleteprinterdata(char *desc, SPOOL_Q_DELETEPRINTERDATA *q_u, prs_struct *ps, int depth)
1273 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdata");
1278 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1282 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1288 /*******************************************************************
1289 * write a structure.
1290 * called from spoolss_r_deleteprinterdata (srv_spoolss.c)
1291 ********************************************************************/
1293 BOOL spoolss_io_r_deleteprinterdata(char *desc, SPOOL_R_DELETEPRINTERDATA *r_u, prs_struct *ps, int depth)
1295 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdata");
1297 if(!prs_werror("status", ps, depth, &r_u->status))
1303 /*******************************************************************
1305 * called from spoolss_q_deleteprinterdataex (srv_spoolss.c)
1306 ********************************************************************/
1308 BOOL spoolss_io_q_deleteprinterdataex(char *desc, SPOOL_Q_DELETEPRINTERDATAEX *q_u, prs_struct *ps, int depth)
1313 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdataex");
1318 if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1321 if (!smb_io_unistr2("keyname ", &q_u->keyname, True, ps, depth))
1323 if (!smb_io_unistr2("valuename", &q_u->valuename, True, ps, depth))
1329 /*******************************************************************
1330 * write a structure.
1331 * called from spoolss_r_deleteprinterdataex (srv_spoolss.c)
1332 ********************************************************************/
1334 BOOL spoolss_io_r_deleteprinterdataex(char *desc, SPOOL_R_DELETEPRINTERDATAEX *r_u, prs_struct *ps, int depth)
1336 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdataex");
1339 if(!prs_werror("status", ps, depth, &r_u->status))
1345 /*******************************************************************
1346 * write a structure.
1347 * called from spoolss_r_getprinterdata (srv_spoolss.c)
1348 ********************************************************************/
1350 BOOL spoolss_io_r_getprinterdata(char *desc, SPOOL_R_GETPRINTERDATA *r_u, prs_struct *ps, int depth)
1355 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdata");
1360 if (!prs_uint32("type", ps, depth, &r_u->type))
1362 if (!prs_uint32("size", ps, depth, &r_u->size))
1365 if (UNMARSHALLING(ps) && r_u->size) {
1366 r_u->data = prs_alloc_mem(ps, r_u->size);
1371 if (!prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size))
1377 if (!prs_uint32("needed", ps, depth, &r_u->needed))
1379 if (!prs_werror("status", ps, depth, &r_u->status))
1385 /*******************************************************************
1387 ********************************************************************/
1389 BOOL make_spoolss_q_closeprinter(SPOOL_Q_CLOSEPRINTER *q_u, POLICY_HND *hnd)
1391 if (q_u == NULL) return False;
1393 DEBUG(5,("make_spoolss_q_closeprinter\n"));
1395 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
1400 /*******************************************************************
1402 * called from static spoolss_q_abortprinter (srv_spoolss.c)
1403 * called from spoolss_abortprinter (cli_spoolss.c)
1404 ********************************************************************/
1406 BOOL spoolss_io_q_abortprinter(char *desc, SPOOL_Q_ABORTPRINTER *q_u, prs_struct *ps, int depth)
1408 if (q_u == NULL) return False;
1410 prs_debug(ps, depth, desc, "spoolss_io_q_abortprinter");
1416 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1422 /*******************************************************************
1423 * write a structure.
1424 * called from spoolss_r_abortprinter (srv_spoolss.c)
1425 ********************************************************************/
1427 BOOL spoolss_io_r_abortprinter(char *desc, SPOOL_R_ABORTPRINTER *r_u, prs_struct *ps, int depth)
1429 prs_debug(ps, depth, desc, "spoolss_io_r_abortprinter");
1431 if(!prs_werror("status", ps, depth, &r_u->status))
1437 /*******************************************************************
1439 * called from static spoolss_q_deleteprinter (srv_spoolss.c)
1440 * called from spoolss_deleteprinter (cli_spoolss.c)
1441 ********************************************************************/
1443 BOOL spoolss_io_q_deleteprinter(char *desc, SPOOL_Q_DELETEPRINTER *q_u, prs_struct *ps, int depth)
1445 if (q_u == NULL) return False;
1447 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinter");
1453 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1459 /*******************************************************************
1460 * write a structure.
1461 * called from static spoolss_r_deleteprinter (srv_spoolss.c)
1462 * called from spoolss_deleteprinter (cli_spoolss.c)
1463 ********************************************************************/
1465 BOOL spoolss_io_r_deleteprinter(char *desc, SPOOL_R_DELETEPRINTER *r_u, prs_struct *ps, int depth)
1467 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinter");
1473 if (!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
1475 if (!prs_werror("status", ps, depth, &r_u->status))
1482 /*******************************************************************
1484 * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1485 * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1486 ********************************************************************/
1488 BOOL spoolss_io_q_deleteprinterdriver(char *desc, SPOOL_Q_DELETEPRINTERDRIVER *q_u, prs_struct *ps, int depth)
1490 if (q_u == NULL) return False;
1492 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriver");
1498 if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
1500 if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
1502 if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
1504 if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
1512 /*******************************************************************
1513 * write a structure.
1514 ********************************************************************/
1515 BOOL spoolss_io_r_deleteprinterdriver(char *desc, SPOOL_R_DELETEPRINTERDRIVER *r_u, prs_struct *ps, int depth)
1517 if (r_u == NULL) return False;
1519 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriver");
1525 if (!prs_werror("status", ps, depth, &r_u->status))
1532 /*******************************************************************
1534 * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1535 * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1536 ********************************************************************/
1538 BOOL spoolss_io_q_deleteprinterdriverex(char *desc, SPOOL_Q_DELETEPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
1540 if (q_u == NULL) return False;
1542 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriverex");
1548 if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
1550 if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
1552 if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
1554 if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
1560 if(!prs_uint32("delete_flags ", ps, depth, &q_u->delete_flags))
1562 if(!prs_uint32("version ", ps, depth, &q_u->version))
1570 /*******************************************************************
1571 * write a structure.
1572 ********************************************************************/
1573 BOOL spoolss_io_r_deleteprinterdriverex(char *desc, SPOOL_R_DELETEPRINTERDRIVEREX *r_u, prs_struct *ps, int depth)
1575 if (r_u == NULL) return False;
1577 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriverex");
1583 if (!prs_werror("status", ps, depth, &r_u->status))
1591 /*******************************************************************
1593 * called from static spoolss_q_closeprinter (srv_spoolss.c)
1594 * called from spoolss_closeprinter (cli_spoolss.c)
1595 ********************************************************************/
1597 BOOL spoolss_io_q_closeprinter(char *desc, SPOOL_Q_CLOSEPRINTER *q_u, prs_struct *ps, int depth)
1599 if (q_u == NULL) return False;
1601 prs_debug(ps, depth, desc, "spoolss_io_q_closeprinter");
1607 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1613 /*******************************************************************
1614 * write a structure.
1615 * called from static spoolss_r_closeprinter (srv_spoolss.c)
1616 * called from spoolss_closeprinter (cli_spoolss.c)
1617 ********************************************************************/
1619 BOOL spoolss_io_r_closeprinter(char *desc, SPOOL_R_CLOSEPRINTER *r_u, prs_struct *ps, int depth)
1621 prs_debug(ps, depth, desc, "spoolss_io_r_closeprinter");
1627 if (!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
1629 if (!prs_werror("status", ps, depth, &r_u->status))
1635 /*******************************************************************
1637 * called from spoolss_q_startdocprinter (srv_spoolss.c)
1638 ********************************************************************/
1640 BOOL spoolss_io_q_startdocprinter(char *desc, SPOOL_Q_STARTDOCPRINTER *q_u, prs_struct *ps, int depth)
1642 if (q_u == NULL) return False;
1644 prs_debug(ps, depth, desc, "spoolss_io_q_startdocprinter");
1650 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1653 if(!smb_io_doc_info_container("",&q_u->doc_info_container, ps, depth))
1659 /*******************************************************************
1660 * write a structure.
1661 * called from spoolss_r_startdocprinter (srv_spoolss.c)
1662 ********************************************************************/
1664 BOOL spoolss_io_r_startdocprinter(char *desc, SPOOL_R_STARTDOCPRINTER *r_u, prs_struct *ps, int depth)
1666 prs_debug(ps, depth, desc, "spoolss_io_r_startdocprinter");
1668 if(!prs_uint32("jobid", ps, depth, &r_u->jobid))
1670 if(!prs_werror("status", ps, depth, &r_u->status))
1676 /*******************************************************************
1678 * called from spoolss_q_enddocprinter (srv_spoolss.c)
1679 ********************************************************************/
1681 BOOL spoolss_io_q_enddocprinter(char *desc, SPOOL_Q_ENDDOCPRINTER *q_u, prs_struct *ps, int depth)
1683 if (q_u == NULL) return False;
1685 prs_debug(ps, depth, desc, "spoolss_io_q_enddocprinter");
1691 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1697 /*******************************************************************
1698 * write a structure.
1699 * called from spoolss_r_enddocprinter (srv_spoolss.c)
1700 ********************************************************************/
1702 BOOL spoolss_io_r_enddocprinter(char *desc, SPOOL_R_ENDDOCPRINTER *r_u, prs_struct *ps, int depth)
1704 prs_debug(ps, depth, desc, "spoolss_io_r_enddocprinter");
1706 if(!prs_werror("status", ps, depth, &r_u->status))
1712 /*******************************************************************
1714 * called from spoolss_q_startpageprinter (srv_spoolss.c)
1715 ********************************************************************/
1717 BOOL spoolss_io_q_startpageprinter(char *desc, SPOOL_Q_STARTPAGEPRINTER *q_u, prs_struct *ps, int depth)
1719 if (q_u == NULL) return False;
1721 prs_debug(ps, depth, desc, "spoolss_io_q_startpageprinter");
1727 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1733 /*******************************************************************
1734 * write a structure.
1735 * called from spoolss_r_startpageprinter (srv_spoolss.c)
1736 ********************************************************************/
1738 BOOL spoolss_io_r_startpageprinter(char *desc, SPOOL_R_STARTPAGEPRINTER *r_u, prs_struct *ps, int depth)
1740 prs_debug(ps, depth, desc, "spoolss_io_r_startpageprinter");
1742 if(!prs_werror("status", ps, depth, &r_u->status))
1748 /*******************************************************************
1750 * called from spoolss_q_endpageprinter (srv_spoolss.c)
1751 ********************************************************************/
1753 BOOL spoolss_io_q_endpageprinter(char *desc, SPOOL_Q_ENDPAGEPRINTER *q_u, prs_struct *ps, int depth)
1755 if (q_u == NULL) return False;
1757 prs_debug(ps, depth, desc, "spoolss_io_q_endpageprinter");
1763 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1769 /*******************************************************************
1770 * write a structure.
1771 * called from spoolss_r_endpageprinter (srv_spoolss.c)
1772 ********************************************************************/
1774 BOOL spoolss_io_r_endpageprinter(char *desc, SPOOL_R_ENDPAGEPRINTER *r_u, prs_struct *ps, int depth)
1776 prs_debug(ps, depth, desc, "spoolss_io_r_endpageprinter");
1778 if(!prs_werror("status", ps, depth, &r_u->status))
1784 /*******************************************************************
1786 * called from spoolss_q_writeprinter (srv_spoolss.c)
1787 ********************************************************************/
1789 BOOL spoolss_io_q_writeprinter(char *desc, SPOOL_Q_WRITEPRINTER *q_u, prs_struct *ps, int depth)
1791 if (q_u == NULL) return False;
1793 prs_debug(ps, depth, desc, "spoolss_io_q_writeprinter");
1799 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1801 if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size))
1804 if (q_u->buffer_size!=0)
1806 if (UNMARSHALLING(ps))
1807 q_u->buffer=(uint8 *)prs_alloc_mem(ps,q_u->buffer_size*sizeof(uint8));
1808 if(q_u->buffer == NULL)
1810 if(!prs_uint8s(True, "buffer", ps, depth, q_u->buffer, q_u->buffer_size))
1815 if(!prs_uint32("buffer_size2", ps, depth, &q_u->buffer_size2))
1821 /*******************************************************************
1822 * write a structure.
1823 * called from spoolss_r_writeprinter (srv_spoolss.c)
1824 ********************************************************************/
1826 BOOL spoolss_io_r_writeprinter(char *desc, SPOOL_R_WRITEPRINTER *r_u, prs_struct *ps, int depth)
1828 prs_debug(ps, depth, desc, "spoolss_io_r_writeprinter");
1830 if(!prs_uint32("buffer_written", ps, depth, &r_u->buffer_written))
1832 if(!prs_werror("status", ps, depth, &r_u->status))
1838 /*******************************************************************
1840 * called from spoolss_q_rffpcnex (srv_spoolss.c)
1841 ********************************************************************/
1843 BOOL spoolss_io_q_rffpcnex(char *desc, SPOOL_Q_RFFPCNEX *q_u, prs_struct *ps, int depth)
1845 prs_debug(ps, depth, desc, "spoolss_io_q_rffpcnex");
1851 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1853 if(!prs_uint32("flags", ps, depth, &q_u->flags))
1855 if(!prs_uint32("options", ps, depth, &q_u->options))
1857 if(!prs_uint32("localmachine_ptr", ps, depth, &q_u->localmachine_ptr))
1859 if(!smb_io_unistr2("localmachine", &q_u->localmachine, q_u->localmachine_ptr, ps, depth))
1865 if(!prs_uint32("printerlocal", ps, depth, &q_u->printerlocal))
1868 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1871 if (q_u->option_ptr!=0) {
1873 if (UNMARSHALLING(ps))
1874 if((q_u->option=(SPOOL_NOTIFY_OPTION *)prs_alloc_mem(ps,sizeof(SPOOL_NOTIFY_OPTION))) == NULL)
1877 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1884 /*******************************************************************
1885 * write a structure.
1886 * called from spoolss_r_rffpcnex (srv_spoolss.c)
1887 ********************************************************************/
1889 BOOL spoolss_io_r_rffpcnex(char *desc, SPOOL_R_RFFPCNEX *r_u, prs_struct *ps, int depth)
1891 prs_debug(ps, depth, desc, "spoolss_io_r_rffpcnex");
1894 if(!prs_werror("status", ps, depth, &r_u->status))
1900 /*******************************************************************
1902 * called from spoolss_q_rfnpcnex (srv_spoolss.c)
1903 ********************************************************************/
1905 BOOL spoolss_io_q_rfnpcnex(char *desc, SPOOL_Q_RFNPCNEX *q_u, prs_struct *ps, int depth)
1907 prs_debug(ps, depth, desc, "spoolss_io_q_rfnpcnex");
1913 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1916 if(!prs_uint32("change", ps, depth, &q_u->change))
1919 if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1922 if (q_u->option_ptr!=0) {
1924 if (UNMARSHALLING(ps))
1925 if((q_u->option=(SPOOL_NOTIFY_OPTION *)prs_alloc_mem(ps,sizeof(SPOOL_NOTIFY_OPTION))) == NULL)
1928 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1935 /*******************************************************************
1936 * write a structure.
1937 * called from spoolss_r_rfnpcnex (srv_spoolss.c)
1938 ********************************************************************/
1940 BOOL spoolss_io_r_rfnpcnex(char *desc, SPOOL_R_RFNPCNEX *r_u, prs_struct *ps, int depth)
1942 prs_debug(ps, depth, desc, "spoolss_io_r_rfnpcnex");
1948 if (!prs_uint32("info_ptr", ps, depth, &r_u->info_ptr))
1951 if(!smb_io_notify_info("notify info", &r_u->info ,ps,depth))
1956 if(!prs_werror("status", ps, depth, &r_u->status))
1962 /*******************************************************************
1963 * return the length of a uint16 (obvious, but the code is clean)
1964 ********************************************************************/
1966 static uint32 size_of_uint16(uint16 *value)
1968 return (sizeof(*value));
1971 /*******************************************************************
1972 * return the length of a uint32 (obvious, but the code is clean)
1973 ********************************************************************/
1975 static uint32 size_of_uint32(uint32 *value)
1977 return (sizeof(*value));
1980 /*******************************************************************
1981 * return the length of a NTTIME (obvious, but the code is clean)
1982 ********************************************************************/
1984 static uint32 size_of_nttime(NTTIME *value)
1986 return (sizeof(*value));
1989 /*******************************************************************
1990 * return the length of a UNICODE string in number of char, includes:
1991 * - the leading zero
1992 * - the relative pointer size
1993 ********************************************************************/
1995 static uint32 size_of_relative_string(UNISTR *string)
1999 size=str_len_uni(string); /* the string length */
2000 size=size+1; /* add the trailing zero */
2001 size=size*2; /* convert in char */
2002 size=size+4; /* add the size of the ptr */
2006 * Do not include alignment as Win2k does not align relative
2007 * strings within a buffer --jerry
2009 /* Ensure size is 4 byte multiple (prs_align is being called...). */
2010 /* size += ((4 - (size & 3)) & 3); */
2016 /*******************************************************************
2017 * return the length of a uint32 (obvious, but the code is clean)
2018 ********************************************************************/
2020 static uint32 size_of_device_mode(DEVICEMODE *devmode)
2025 return (4+devmode->size+devmode->driverextra);
2028 /*******************************************************************
2029 * return the length of a uint32 (obvious, but the code is clean)
2030 ********************************************************************/
2032 static uint32 size_of_systemtime(SYSTEMTIME *systime)
2037 return (sizeof(SYSTEMTIME) +4);
2040 /*******************************************************************
2041 * write a UNICODE string and its relative pointer.
2042 * used by all the RPC structs passing a buffer
2044 * As I'm a nice guy, I'm forcing myself to explain this code.
2045 * MS did a good job in the overall spoolss code except in some
2046 * functions where they are passing the API buffer directly in the
2047 * RPC request/reply. That's to maintain compatiility at the API level.
2048 * They could have done it the good way the first time.
2050 * So what happen is: the strings are written at the buffer's end,
2051 * in the reverse order of the original structure. Some pointers to
2052 * the strings are also in the buffer. Those are relative to the
2055 * If you don't understand or want to change that function,
2056 * first get in touch with me: jfm@samba.org
2058 ********************************************************************/
2060 static BOOL smb_io_relstr(char *desc, NEW_BUFFER *buffer, int depth, UNISTR *string)
2062 prs_struct *ps=&buffer->prs;
2064 if (MARSHALLING(ps)) {
2065 uint32 struct_offset = prs_offset(ps);
2066 uint32 relative_offset;
2068 buffer->string_at_end -= (size_of_relative_string(string) - 4);
2069 if(!prs_set_offset(ps, buffer->string_at_end))
2073 * Win2k does not align strings in a buffer
2074 * Tested against WinNT 4.0 SP 6a & 2k SP2 --jerry
2079 buffer->string_at_end = prs_offset(ps);
2081 /* write the string */
2082 if (!smb_io_unistr(desc, string, ps, depth))
2085 if(!prs_set_offset(ps, struct_offset))
2088 relative_offset=buffer->string_at_end - buffer->struct_start;
2089 /* write its offset */
2090 if (!prs_uint32("offset", ps, depth, &relative_offset))
2096 /* read the offset */
2097 if (!prs_uint32("offset", ps, depth, &(buffer->string_at_end)))
2100 if (buffer->string_at_end == 0)
2103 old_offset = prs_offset(ps);
2104 if(!prs_set_offset(ps, buffer->string_at_end+buffer->struct_start))
2107 /* read the string */
2108 if (!smb_io_unistr(desc, string, ps, depth))
2111 if(!prs_set_offset(ps, old_offset))
2117 /*******************************************************************
2118 * write a array of UNICODE strings and its relative pointer.
2119 * used by 2 RPC structs
2120 ********************************************************************/
2122 static BOOL smb_io_relarraystr(char *desc, NEW_BUFFER *buffer, int depth, uint16 **string)
2126 prs_struct *ps=&buffer->prs;
2128 if (MARSHALLING(ps)) {
2129 uint32 struct_offset = prs_offset(ps);
2130 uint32 relative_offset;
2137 /* first write the last 0 */
2138 buffer->string_at_end -= 2;
2139 if(!prs_set_offset(ps, buffer->string_at_end))
2142 if(!prs_uint16("leading zero", ps, depth, &zero))
2145 while (p && (*p!=0)) {
2149 /* Yes this should be malloc not talloc. Don't change. */
2151 chaine.buffer = malloc((q-p+1)*sizeof(uint16));
2152 if (chaine.buffer == NULL)
2155 memcpy(chaine.buffer, p, (q-p+1)*sizeof(uint16));
2157 buffer->string_at_end -= (q-p+1)*sizeof(uint16);
2159 if(!prs_set_offset(ps, buffer->string_at_end)) {
2160 SAFE_FREE(chaine.buffer);
2164 /* write the string */
2165 if (!smb_io_unistr(desc, &chaine, ps, depth)) {
2166 SAFE_FREE(chaine.buffer);
2172 SAFE_FREE(chaine.buffer);
2175 if(!prs_set_offset(ps, struct_offset))
2178 relative_offset=buffer->string_at_end - buffer->struct_start;
2179 /* write its offset */
2180 if (!prs_uint32("offset", ps, depth, &relative_offset))
2188 uint16 *chaine2=NULL;
2191 size_t realloc_size = 0;
2195 /* read the offset */
2196 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
2199 old_offset = prs_offset(ps);
2200 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
2204 if (!smb_io_unistr(desc, &chaine, ps, depth))
2207 l_chaine=str_len_uni(&chaine);
2209 /* we're going to add two more bytes here in case this
2210 is the last string in the array and we need to add
2211 an extra NULL for termination */
2216 realloc_size = (l_chaine2+l_chaine+2)*sizeof(uint16);
2218 /* Yes this should be realloc - it's freed below. JRA */
2220 if((tc2=(uint16 *)Realloc(chaine2, realloc_size)) == NULL) {
2225 memcpy(chaine2+l_chaine2, chaine.buffer, (l_chaine+1)*sizeof(uint16));
2226 l_chaine2+=l_chaine+1;
2229 } while(l_chaine!=0);
2231 /* the end should be bould NULL terminated so add
2232 the second one here */
2235 chaine2[l_chaine2] = '\0';
2236 *string=(uint16 *)talloc_memdup(prs_get_mem_context(ps),chaine2,realloc_size);
2240 if(!prs_set_offset(ps, old_offset))
2246 /*******************************************************************
2247 Parse a DEVMODE structure and its relative pointer.
2248 ********************************************************************/
2250 static BOOL smb_io_relsecdesc(char *desc, NEW_BUFFER *buffer, int depth, SEC_DESC **secdesc)
2252 prs_struct *ps= &buffer->prs;
2254 prs_debug(ps, depth, desc, "smb_io_relsecdesc");
2257 if (MARSHALLING(ps)) {
2258 uint32 struct_offset = prs_offset(ps);
2259 uint32 relative_offset;
2262 relative_offset = 0;
2263 if (!prs_uint32("offset", ps, depth, &relative_offset))
2268 if (*secdesc != NULL) {
2269 buffer->string_at_end -= sec_desc_size(*secdesc);
2271 if(!prs_set_offset(ps, buffer->string_at_end))
2273 /* write the secdesc */
2274 if (!sec_io_desc(desc, secdesc, ps, depth))
2277 if(!prs_set_offset(ps, struct_offset))
2281 relative_offset=buffer->string_at_end - buffer->struct_start;
2282 /* write its offset */
2284 if (!prs_uint32("offset", ps, depth, &relative_offset))
2289 /* read the offset */
2290 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
2293 old_offset = prs_offset(ps);
2294 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
2298 if (!sec_io_desc(desc, secdesc, ps, depth))
2301 if(!prs_set_offset(ps, old_offset))
2307 /*******************************************************************
2308 Parse a DEVMODE structure and its relative pointer.
2309 ********************************************************************/
2311 static BOOL smb_io_reldevmode(char *desc, NEW_BUFFER *buffer, int depth, DEVICEMODE **devmode)
2313 prs_struct *ps=&buffer->prs;
2315 prs_debug(ps, depth, desc, "smb_io_reldevmode");
2318 if (MARSHALLING(ps)) {
2319 uint32 struct_offset = prs_offset(ps);
2320 uint32 relative_offset;
2322 if (*devmode == NULL) {
2324 if (!prs_uint32("offset", ps, depth, &relative_offset))
2326 DEBUG(8, ("boing, the devmode was NULL\n"));
2331 buffer->string_at_end -= ((*devmode)->size + (*devmode)->driverextra);
2333 if(!prs_set_offset(ps, buffer->string_at_end))
2336 /* write the DEVMODE */
2337 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
2340 if(!prs_set_offset(ps, struct_offset))
2343 relative_offset=buffer->string_at_end - buffer->struct_start;
2344 /* write its offset */
2345 if (!prs_uint32("offset", ps, depth, &relative_offset))
2351 /* read the offset */
2352 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
2354 if (buffer->string_at_end == 0) {
2359 old_offset = prs_offset(ps);
2360 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
2363 /* read the string */
2364 if((*devmode=(DEVICEMODE *)prs_alloc_mem(ps,sizeof(DEVICEMODE))) == NULL)
2366 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
2369 if(!prs_set_offset(ps, old_offset))
2375 /*******************************************************************
2376 Parse a PRINTER_INFO_0 structure.
2377 ********************************************************************/
2379 BOOL smb_io_printer_info_0(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_0 *info, int depth)
2381 prs_struct *ps=&buffer->prs;
2383 prs_debug(ps, depth, desc, "smb_io_printer_info_0");
2386 buffer->struct_start=prs_offset(ps);
2388 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2390 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2393 if(!prs_uint32("cjobs", ps, depth, &info->cjobs))
2395 if(!prs_uint32("total_jobs", ps, depth, &info->total_jobs))
2397 if(!prs_uint32("total_bytes", ps, depth, &info->total_bytes))
2400 if(!prs_uint16("year", ps, depth, &info->year))
2402 if(!prs_uint16("month", ps, depth, &info->month))
2404 if(!prs_uint16("dayofweek", ps, depth, &info->dayofweek))
2406 if(!prs_uint16("day", ps, depth, &info->day))
2408 if(!prs_uint16("hour", ps, depth, &info->hour))
2410 if(!prs_uint16("minute", ps, depth, &info->minute))
2412 if(!prs_uint16("second", ps, depth, &info->second))
2414 if(!prs_uint16("milliseconds", ps, depth, &info->milliseconds))
2417 if(!prs_uint32("global_counter", ps, depth, &info->global_counter))
2419 if(!prs_uint32("total_pages", ps, depth, &info->total_pages))
2422 if(!prs_uint16("major_version", ps, depth, &info->major_version))
2424 if(!prs_uint16("build_version", ps, depth, &info->build_version))
2426 if(!prs_uint32("unknown7", ps, depth, &info->unknown7))
2428 if(!prs_uint32("unknown8", ps, depth, &info->unknown8))
2430 if(!prs_uint32("unknown9", ps, depth, &info->unknown9))
2432 if(!prs_uint32("session_counter", ps, depth, &info->session_counter))
2434 if(!prs_uint32("unknown11", ps, depth, &info->unknown11))
2436 if(!prs_uint32("printer_errors", ps, depth, &info->printer_errors))
2438 if(!prs_uint32("unknown13", ps, depth, &info->unknown13))
2440 if(!prs_uint32("unknown14", ps, depth, &info->unknown14))
2442 if(!prs_uint32("unknown15", ps, depth, &info->unknown15))
2444 if(!prs_uint32("unknown16", ps, depth, &info->unknown16))
2446 if(!prs_uint32("change_id", ps, depth, &info->change_id))
2448 if(!prs_uint32("unknown18", ps, depth, &info->unknown18))
2450 if(!prs_uint32("status" , ps, depth, &info->status))
2452 if(!prs_uint32("unknown20", ps, depth, &info->unknown20))
2454 if(!prs_uint32("c_setprinter", ps, depth, &info->c_setprinter))
2456 if(!prs_uint16("unknown22", ps, depth, &info->unknown22))
2458 if(!prs_uint16("unknown23", ps, depth, &info->unknown23))
2460 if(!prs_uint16("unknown24", ps, depth, &info->unknown24))
2462 if(!prs_uint16("unknown25", ps, depth, &info->unknown25))
2464 if(!prs_uint16("unknown26", ps, depth, &info->unknown26))
2466 if(!prs_uint16("unknown27", ps, depth, &info->unknown27))
2468 if(!prs_uint16("unknown28", ps, depth, &info->unknown28))
2470 if(!prs_uint16("unknown29", ps, depth, &info->unknown29))
2476 /*******************************************************************
2477 Parse a PRINTER_INFO_1 structure.
2478 ********************************************************************/
2480 BOOL smb_io_printer_info_1(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_1 *info, int depth)
2482 prs_struct *ps=&buffer->prs;
2484 prs_debug(ps, depth, desc, "smb_io_printer_info_1");
2487 buffer->struct_start=prs_offset(ps);
2489 if (!prs_uint32("flags", ps, depth, &info->flags))
2491 if (!smb_io_relstr("description", buffer, depth, &info->description))
2493 if (!smb_io_relstr("name", buffer, depth, &info->name))
2495 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2501 /*******************************************************************
2502 Parse a PRINTER_INFO_2 structure.
2503 ********************************************************************/
2505 BOOL smb_io_printer_info_2(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_2 *info, int depth)
2507 prs_struct *ps=&buffer->prs;
2508 uint32 dm_offset, sd_offset, current_offset;
2509 uint32 dummy_value = 0, has_secdesc = 0;
2511 prs_debug(ps, depth, desc, "smb_io_printer_info_2");
2514 buffer->struct_start=prs_offset(ps);
2516 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2518 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2520 if (!smb_io_relstr("sharename", buffer, depth, &info->sharename))
2522 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2524 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2526 if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2528 if (!smb_io_relstr("location", buffer, depth, &info->location))
2531 /* save current offset and wind forwared by a uint32 */
2532 dm_offset = prs_offset(ps);
2533 if (!prs_uint32("devmode", ps, depth, &dummy_value))
2536 if (!smb_io_relstr("sepfile", buffer, depth, &info->sepfile))
2538 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2540 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2542 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2545 /* save current offset for the sec_desc */
2546 sd_offset = prs_offset(ps);
2547 if (!prs_uint32("sec_desc", ps, depth, &has_secdesc))
2551 /* save current location so we can pick back up here */
2552 current_offset = prs_offset(ps);
2554 /* parse the devmode */
2555 if (!prs_set_offset(ps, dm_offset))
2557 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2560 /* parse the sec_desc */
2562 if (!prs_set_offset(ps, sd_offset))
2564 if (!smb_io_relsecdesc("secdesc", buffer, depth, &info->secdesc))
2568 /* pick up where we left off */
2569 if (!prs_set_offset(ps, current_offset))
2572 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2574 if (!prs_uint32("priority", ps, depth, &info->priority))
2576 if (!prs_uint32("defpriority", ps, depth, &info->defaultpriority))
2578 if (!prs_uint32("starttime", ps, depth, &info->starttime))
2580 if (!prs_uint32("untiltime", ps, depth, &info->untiltime))
2582 if (!prs_uint32("status", ps, depth, &info->status))
2584 if (!prs_uint32("jobs", ps, depth, &info->cjobs))
2586 if (!prs_uint32("averageppm", ps, depth, &info->averageppm))
2592 /*******************************************************************
2593 Parse a PRINTER_INFO_3 structure.
2594 ********************************************************************/
2596 BOOL smb_io_printer_info_3(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_3 *info, int depth)
2598 prs_struct *ps=&buffer->prs;
2600 prs_debug(ps, depth, desc, "smb_io_printer_info_3");
2603 buffer->struct_start=prs_offset(ps);
2605 if (!prs_uint32("flags", ps, depth, &info->flags))
2607 if (!sec_io_desc("sec_desc", &info->secdesc, ps, depth))
2613 /*******************************************************************
2614 Parse a PRINTER_INFO_4 structure.
2615 ********************************************************************/
2617 BOOL smb_io_printer_info_4(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_4 *info, int depth)
2619 prs_struct *ps=&buffer->prs;
2621 prs_debug(ps, depth, desc, "smb_io_printer_info_4");
2624 buffer->struct_start=prs_offset(ps);
2626 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2628 if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2630 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2635 /*******************************************************************
2636 Parse a PRINTER_INFO_5 structure.
2637 ********************************************************************/
2639 BOOL smb_io_printer_info_5(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_5 *info, int depth)
2641 prs_struct *ps=&buffer->prs;
2643 prs_debug(ps, depth, desc, "smb_io_printer_info_5");
2646 buffer->struct_start=prs_offset(ps);
2648 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2650 if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2652 if (!prs_uint32("attributes", ps, depth, &info->attributes))
2654 if (!prs_uint32("device_not_selected_timeout", ps, depth, &info->device_not_selected_timeout))
2656 if (!prs_uint32("transmission_retry_timeout", ps, depth, &info->transmission_retry_timeout))
2661 /*******************************************************************
2662 Parse a PORT_INFO_1 structure.
2663 ********************************************************************/
2665 BOOL smb_io_port_info_1(char *desc, NEW_BUFFER *buffer, PORT_INFO_1 *info, int depth)
2667 prs_struct *ps=&buffer->prs;
2669 prs_debug(ps, depth, desc, "smb_io_port_info_1");
2672 buffer->struct_start=prs_offset(ps);
2674 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2680 /*******************************************************************
2681 Parse a PORT_INFO_2 structure.
2682 ********************************************************************/
2684 BOOL smb_io_port_info_2(char *desc, NEW_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2686 prs_struct *ps=&buffer->prs;
2688 prs_debug(ps, depth, desc, "smb_io_port_info_2");
2691 buffer->struct_start=prs_offset(ps);
2693 if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2695 if (!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2697 if (!smb_io_relstr("description", buffer, depth, &info->description))
2699 if (!prs_uint32("port_type", ps, depth, &info->port_type))
2701 if (!prs_uint32("reserved", ps, depth, &info->reserved))
2707 /*******************************************************************
2708 Parse a DRIVER_INFO_1 structure.
2709 ********************************************************************/
2711 BOOL smb_io_printer_driver_info_1(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_1 *info, int depth)
2713 prs_struct *ps=&buffer->prs;
2715 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_1");
2718 buffer->struct_start=prs_offset(ps);
2720 if (!smb_io_relstr("name", buffer, depth, &info->name))
2726 /*******************************************************************
2727 Parse a DRIVER_INFO_2 structure.
2728 ********************************************************************/
2730 BOOL smb_io_printer_driver_info_2(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_2 *info, int depth)
2732 prs_struct *ps=&buffer->prs;
2734 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_2");
2737 buffer->struct_start=prs_offset(ps);
2739 if (!prs_uint32("version", ps, depth, &info->version))
2741 if (!smb_io_relstr("name", buffer, depth, &info->name))
2743 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2745 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2747 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2749 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2755 /*******************************************************************
2756 Parse a DRIVER_INFO_3 structure.
2757 ********************************************************************/
2759 BOOL smb_io_printer_driver_info_3(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_3 *info, int depth)
2761 prs_struct *ps=&buffer->prs;
2763 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_3");
2766 buffer->struct_start=prs_offset(ps);
2768 if (!prs_uint32("version", ps, depth, &info->version))
2770 if (!smb_io_relstr("name", buffer, depth, &info->name))
2772 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2774 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2776 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2778 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2780 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2783 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2786 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2788 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2794 /*******************************************************************
2795 Parse a DRIVER_INFO_6 structure.
2796 ********************************************************************/
2798 BOOL smb_io_printer_driver_info_6(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_6 *info, int depth)
2800 prs_struct *ps=&buffer->prs;
2802 prs_debug(ps, depth, desc, "smb_io_printer_driver_info_6");
2805 buffer->struct_start=prs_offset(ps);
2807 if (!prs_uint32("version", ps, depth, &info->version))
2809 if (!smb_io_relstr("name", buffer, depth, &info->name))
2811 if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2813 if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2815 if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2817 if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2819 if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2822 if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2825 if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2827 if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2830 if (!smb_io_relarraystr("previousdrivernames", buffer, depth, &info->previousdrivernames))
2833 if (!prs_uint32("date.low", ps, depth, &info->driver_date.low))
2835 if (!prs_uint32("date.high", ps, depth, &info->driver_date.high))
2838 if (!prs_uint32("padding", ps, depth, &info->padding))
2841 if (!prs_uint32("driver_version_low", ps, depth, &info->driver_version_low))
2844 if (!prs_uint32("driver_version_high", ps, depth, &info->driver_version_high))
2847 if (!smb_io_relstr("mfgname", buffer, depth, &info->mfgname))
2849 if (!smb_io_relstr("oem_url", buffer, depth, &info->oem_url))
2851 if (!smb_io_relstr("hardware_id", buffer, depth, &info->hardware_id))
2853 if (!smb_io_relstr("provider", buffer, depth, &info->provider))
2859 /*******************************************************************
2860 Parse a JOB_INFO_1 structure.
2861 ********************************************************************/
2863 BOOL smb_io_job_info_1(char *desc, NEW_BUFFER *buffer, JOB_INFO_1 *info, int depth)
2865 prs_struct *ps=&buffer->prs;
2867 prs_debug(ps, depth, desc, "smb_io_job_info_1");
2870 buffer->struct_start=prs_offset(ps);
2872 if (!prs_uint32("jobid", ps, depth, &info->jobid))
2874 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2876 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2878 if (!smb_io_relstr("username", buffer, depth, &info->username))
2880 if (!smb_io_relstr("document", buffer, depth, &info->document))
2882 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2884 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2886 if (!prs_uint32("status", ps, depth, &info->status))
2888 if (!prs_uint32("priority", ps, depth, &info->priority))
2890 if (!prs_uint32("position", ps, depth, &info->position))
2892 if (!prs_uint32("totalpages", ps, depth, &info->totalpages))
2894 if (!prs_uint32("pagesprinted", ps, depth, &info->pagesprinted))
2896 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted))
2902 /*******************************************************************
2903 Parse a JOB_INFO_2 structure.
2904 ********************************************************************/
2906 BOOL smb_io_job_info_2(char *desc, NEW_BUFFER *buffer, JOB_INFO_2 *info, int depth)
2909 prs_struct *ps=&buffer->prs;
2911 prs_debug(ps, depth, desc, "smb_io_job_info_2");
2914 buffer->struct_start=prs_offset(ps);
2916 if (!prs_uint32("jobid",ps, depth, &info->jobid))
2918 if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2920 if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2922 if (!smb_io_relstr("username", buffer, depth, &info->username))
2924 if (!smb_io_relstr("document", buffer, depth, &info->document))
2926 if (!smb_io_relstr("notifyname", buffer, depth, &info->notifyname))
2928 if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2931 if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2933 if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2935 if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2937 if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2939 if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2942 /* SEC_DESC sec_desc;*/
2943 if (!prs_uint32("Hack! sec desc", ps, depth, &pipo))
2946 if (!prs_uint32("status",ps, depth, &info->status))
2948 if (!prs_uint32("priority",ps, depth, &info->priority))
2950 if (!prs_uint32("position",ps, depth, &info->position))
2952 if (!prs_uint32("starttime",ps, depth, &info->starttime))
2954 if (!prs_uint32("untiltime",ps, depth, &info->untiltime))
2956 if (!prs_uint32("totalpages",ps, depth, &info->totalpages))
2958 if (!prs_uint32("size",ps, depth, &info->size))
2960 if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted) )
2962 if (!prs_uint32("timeelapsed",ps, depth, &info->timeelapsed))
2964 if (!prs_uint32("pagesprinted",ps, depth, &info->pagesprinted))
2970 /*******************************************************************
2971 ********************************************************************/
2973 BOOL smb_io_form_1(char *desc, NEW_BUFFER *buffer, FORM_1 *info, int depth)
2975 prs_struct *ps=&buffer->prs;
2977 prs_debug(ps, depth, desc, "smb_io_form_1");
2980 buffer->struct_start=prs_offset(ps);
2982 if (!prs_uint32("flag", ps, depth, &info->flag))
2985 if (!smb_io_relstr("name", buffer, depth, &info->name))
2988 if (!prs_uint32("width", ps, depth, &info->width))
2990 if (!prs_uint32("length", ps, depth, &info->length))
2992 if (!prs_uint32("left", ps, depth, &info->left))
2994 if (!prs_uint32("top", ps, depth, &info->top))
2996 if (!prs_uint32("right", ps, depth, &info->right))
2998 if (!prs_uint32("bottom", ps, depth, &info->bottom))
3004 /*******************************************************************
3005 Read/write a BUFFER struct.
3006 ********************************************************************/
3008 static BOOL spoolss_io_buffer(char *desc, prs_struct *ps, int depth, NEW_BUFFER **pp_buffer)
3010 NEW_BUFFER *buffer = *pp_buffer;
3012 prs_debug(ps, depth, desc, "spoolss_io_buffer");
3015 if (UNMARSHALLING(ps))
3016 buffer = *pp_buffer = (NEW_BUFFER *)prs_alloc_mem(ps, sizeof(NEW_BUFFER));
3021 if (!prs_uint32("ptr", ps, depth, &buffer->ptr))
3025 if (UNMARSHALLING(ps)) {
3027 buffer->string_at_end=0;
3029 if (buffer->ptr==0) {
3031 * JRA. I'm not sure if the data in here is in big-endian format if
3032 * the client is big-endian. Leave as default (little endian) for now.
3035 if (!prs_init(&buffer->prs, 0, prs_get_mem_context(ps), UNMARSHALL))
3040 if (!prs_uint32("size", ps, depth, &buffer->size))
3044 * JRA. I'm not sure if the data in here is in big-endian format if
3045 * the client is big-endian. Leave as default (little endian) for now.
3048 if (!prs_init(&buffer->prs, buffer->size, prs_get_mem_context(ps), UNMARSHALL))
3051 if (!prs_append_some_prs_data(&buffer->prs, ps, prs_offset(ps), buffer->size))
3054 if (!prs_set_offset(&buffer->prs, 0))
3057 if (!prs_set_offset(ps, buffer->size+prs_offset(ps)))
3060 buffer->string_at_end=buffer->size;
3068 if (buffer->ptr==0) {
3069 /* We have finished with the data in buffer->prs - free it. */
3070 prs_mem_free(&buffer->prs);
3074 if (!prs_uint32("size", ps, depth, &buffer->size))
3077 if (!prs_append_some_prs_data(ps, &buffer->prs, 0, buffer->size))
3083 /* We have finished with the data in buffer->prs - free it. */
3084 prs_mem_free(&buffer->prs);
3090 /*******************************************************************
3091 move a BUFFER from the query to the reply.
3092 As the data pointers in NEW_BUFFER are malloc'ed, not talloc'ed,
3093 this is ok. This is an OPTIMIZATION and is not strictly neccessary.
3094 Clears the memory to zero also.
3095 ********************************************************************/
3097 void spoolss_move_buffer(NEW_BUFFER *src, NEW_BUFFER **dest)
3099 prs_switch_type(&src->prs, MARSHALL);
3100 if(!prs_set_offset(&src->prs, 0))
3102 prs_force_dynamic(&src->prs);
3103 prs_mem_clear(&src->prs);
3107 /*******************************************************************
3108 Get the size of a BUFFER struct.
3109 ********************************************************************/
3111 uint32 new_get_buffer_size(NEW_BUFFER *buffer)
3113 return (buffer->size);
3116 /*******************************************************************
3117 Parse a DRIVER_DIRECTORY_1 structure.
3118 ********************************************************************/
3120 BOOL smb_io_driverdir_1(char *desc, NEW_BUFFER *buffer, DRIVER_DIRECTORY_1 *info, int depth)
3122 prs_struct *ps=&buffer->prs;
3124 prs_debug(ps, depth, desc, "smb_io_driverdir_1");
3127 buffer->struct_start=prs_offset(ps);
3129 if (!smb_io_unistr(desc, &info->name, ps, depth))
3135 /*******************************************************************
3136 Parse a PORT_INFO_1 structure.
3137 ********************************************************************/
3139 BOOL smb_io_port_1(char *desc, NEW_BUFFER *buffer, PORT_INFO_1 *info, int depth)
3141 prs_struct *ps=&buffer->prs;
3143 prs_debug(ps, depth, desc, "smb_io_port_1");
3146 buffer->struct_start=prs_offset(ps);
3148 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
3154 /*******************************************************************
3155 Parse a PORT_INFO_2 structure.
3156 ********************************************************************/
3158 BOOL smb_io_port_2(char *desc, NEW_BUFFER *buffer, PORT_INFO_2 *info, int depth)
3160 prs_struct *ps=&buffer->prs;
3162 prs_debug(ps, depth, desc, "smb_io_port_2");
3165 buffer->struct_start=prs_offset(ps);
3167 if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
3169 if(!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
3171 if(!smb_io_relstr("description", buffer, depth, &info->description))
3173 if(!prs_uint32("port_type", ps, depth, &info->port_type))
3175 if(!prs_uint32("reserved", ps, depth, &info->reserved))
3181 /*******************************************************************
3182 ********************************************************************/
3184 BOOL smb_io_printprocessor_info_1(char *desc, NEW_BUFFER *buffer, PRINTPROCESSOR_1 *info, int depth)
3186 prs_struct *ps=&buffer->prs;
3188 prs_debug(ps, depth, desc, "smb_io_printprocessor_info_1");
3191 buffer->struct_start=prs_offset(ps);
3193 if (smb_io_relstr("name", buffer, depth, &info->name))
3199 /*******************************************************************
3200 ********************************************************************/
3202 BOOL smb_io_printprocdatatype_info_1(char *desc, NEW_BUFFER *buffer, PRINTPROCDATATYPE_1 *info, int depth)
3204 prs_struct *ps=&buffer->prs;
3206 prs_debug(ps, depth, desc, "smb_io_printprocdatatype_info_1");
3209 buffer->struct_start=prs_offset(ps);
3211 if (smb_io_relstr("name", buffer, depth, &info->name))
3217 /*******************************************************************
3218 ********************************************************************/
3220 BOOL smb_io_printmonitor_info_1(char *desc, NEW_BUFFER *buffer, PRINTMONITOR_1 *info, int depth)
3222 prs_struct *ps=&buffer->prs;
3224 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_1");
3227 buffer->struct_start=prs_offset(ps);
3229 if (!smb_io_relstr("name", buffer, depth, &info->name))
3235 /*******************************************************************
3236 ********************************************************************/
3238 BOOL smb_io_printmonitor_info_2(char *desc, NEW_BUFFER *buffer, PRINTMONITOR_2 *info, int depth)
3240 prs_struct *ps=&buffer->prs;
3242 prs_debug(ps, depth, desc, "smb_io_printmonitor_info_2");
3245 buffer->struct_start=prs_offset(ps);
3247 if (!smb_io_relstr("name", buffer, depth, &info->name))
3249 if (!smb_io_relstr("environment", buffer, depth, &info->environment))
3251 if (!smb_io_relstr("dll_name", buffer, depth, &info->dll_name))
3257 /*******************************************************************
3258 return the size required by a struct in the stream
3259 ********************************************************************/
3261 uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
3265 size+=size_of_relative_string( &info->printername );
3266 size+=size_of_relative_string( &info->servername );
3268 size+=size_of_uint32( &info->cjobs);
3269 size+=size_of_uint32( &info->total_jobs);
3270 size+=size_of_uint32( &info->total_bytes);
3272 size+=size_of_uint16( &info->year);
3273 size+=size_of_uint16( &info->month);
3274 size+=size_of_uint16( &info->dayofweek);
3275 size+=size_of_uint16( &info->day);
3276 size+=size_of_uint16( &info->hour);
3277 size+=size_of_uint16( &info->minute);
3278 size+=size_of_uint16( &info->second);
3279 size+=size_of_uint16( &info->milliseconds);
3281 size+=size_of_uint32( &info->global_counter);
3282 size+=size_of_uint32( &info->total_pages);
3284 size+=size_of_uint16( &info->major_version);
3285 size+=size_of_uint16( &info->build_version);
3287 size+=size_of_uint32( &info->unknown7);
3288 size+=size_of_uint32( &info->unknown8);
3289 size+=size_of_uint32( &info->unknown9);
3290 size+=size_of_uint32( &info->session_counter);
3291 size+=size_of_uint32( &info->unknown11);
3292 size+=size_of_uint32( &info->printer_errors);
3293 size+=size_of_uint32( &info->unknown13);
3294 size+=size_of_uint32( &info->unknown14);
3295 size+=size_of_uint32( &info->unknown15);
3296 size+=size_of_uint32( &info->unknown16);
3297 size+=size_of_uint32( &info->change_id);
3298 size+=size_of_uint32( &info->unknown18);
3299 size+=size_of_uint32( &info->status);
3300 size+=size_of_uint32( &info->unknown20);
3301 size+=size_of_uint32( &info->c_setprinter);
3303 size+=size_of_uint16( &info->unknown22);
3304 size+=size_of_uint16( &info->unknown23);
3305 size+=size_of_uint16( &info->unknown24);
3306 size+=size_of_uint16( &info->unknown25);
3307 size+=size_of_uint16( &info->unknown26);
3308 size+=size_of_uint16( &info->unknown27);
3309 size+=size_of_uint16( &info->unknown28);
3310 size+=size_of_uint16( &info->unknown29);
3315 /*******************************************************************
3316 return the size required by a struct in the stream
3317 ********************************************************************/
3319 uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
3323 size+=size_of_uint32( &info->flags );
3324 size+=size_of_relative_string( &info->description );
3325 size+=size_of_relative_string( &info->name );
3326 size+=size_of_relative_string( &info->comment );
3331 /*******************************************************************
3332 return the size required by a struct in the stream
3333 ********************************************************************/
3335 uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
3341 size += sec_desc_size( info->secdesc );
3343 size+=size_of_device_mode( info->devmode );
3345 size+=size_of_relative_string( &info->servername );
3346 size+=size_of_relative_string( &info->printername );
3347 size+=size_of_relative_string( &info->sharename );
3348 size+=size_of_relative_string( &info->portname );
3349 size+=size_of_relative_string( &info->drivername );
3350 size+=size_of_relative_string( &info->comment );
3351 size+=size_of_relative_string( &info->location );
3353 size+=size_of_relative_string( &info->sepfile );
3354 size+=size_of_relative_string( &info->printprocessor );
3355 size+=size_of_relative_string( &info->datatype );
3356 size+=size_of_relative_string( &info->parameters );
3358 size+=size_of_uint32( &info->attributes );
3359 size+=size_of_uint32( &info->priority );
3360 size+=size_of_uint32( &info->defaultpriority );
3361 size+=size_of_uint32( &info->starttime );
3362 size+=size_of_uint32( &info->untiltime );
3363 size+=size_of_uint32( &info->status );
3364 size+=size_of_uint32( &info->cjobs );
3365 size+=size_of_uint32( &info->averageppm );
3368 * add any adjustments for alignment. This is
3369 * not optimal since we could be calling this
3370 * function from a loop (e.g. enumprinters), but
3371 * it is easier to maintain the calculation here and
3372 * not place the burden on the caller to remember. --jerry
3374 if ((size % 4) != 0)
3375 size += 4 - (size % 4);
3380 /*******************************************************************
3381 return the size required by a struct in the stream
3382 ********************************************************************/
3384 uint32 spoolss_size_printer_info_4(PRINTER_INFO_4 *info)
3388 size+=size_of_relative_string( &info->printername );
3389 size+=size_of_relative_string( &info->servername );
3391 size+=size_of_uint32( &info->attributes );
3395 /*******************************************************************
3396 return the size required by a struct in the stream
3397 ********************************************************************/
3399 uint32 spoolss_size_printer_info_5(PRINTER_INFO_5 *info)
3403 size+=size_of_relative_string( &info->printername );
3404 size+=size_of_relative_string( &info->portname );
3406 size+=size_of_uint32( &info->attributes );
3407 size+=size_of_uint32( &info->device_not_selected_timeout );
3408 size+=size_of_uint32( &info->transmission_retry_timeout );
3413 /*******************************************************************
3414 return the size required by a struct in the stream
3415 ********************************************************************/
3417 uint32 spoolss_size_printer_info_3(PRINTER_INFO_3 *info)
3419 /* The 4 is for the self relative pointer.. */
3420 /* JRA !!!! TESTME - WHAT ABOUT prs_align.... !!! */
3421 return 4 + (uint32)sec_desc_size( info->secdesc );
3424 /*******************************************************************
3425 return the size required by a struct in the stream
3426 ********************************************************************/
3428 uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
3431 size+=size_of_relative_string( &info->name );
3436 /*******************************************************************
3437 return the size required by a struct in the stream
3438 ********************************************************************/
3440 uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
3443 size+=size_of_uint32( &info->version );
3444 size+=size_of_relative_string( &info->name );
3445 size+=size_of_relative_string( &info->architecture );
3446 size+=size_of_relative_string( &info->driverpath );
3447 size+=size_of_relative_string( &info->datafile );
3448 size+=size_of_relative_string( &info->configfile );
3453 /*******************************************************************
3454 return the size required by a string array.
3455 ********************************************************************/
3457 uint32 spoolss_size_string_array(uint16 *string)
3462 for (i=0; (string[i]!=0x0000) || (string[i+1]!=0x0000); i++);
3464 i=i+2; /* to count all chars including the leading zero */
3465 i=2*i; /* because we need the value in bytes */
3466 i=i+4; /* the offset pointer size */
3471 /*******************************************************************
3472 return the size required by a struct in the stream
3473 ********************************************************************/
3475 uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
3479 size+=size_of_uint32( &info->version );
3480 size+=size_of_relative_string( &info->name );
3481 size+=size_of_relative_string( &info->architecture );
3482 size+=size_of_relative_string( &info->driverpath );
3483 size+=size_of_relative_string( &info->datafile );
3484 size+=size_of_relative_string( &info->configfile );
3485 size+=size_of_relative_string( &info->helpfile );
3486 size+=size_of_relative_string( &info->monitorname );
3487 size+=size_of_relative_string( &info->defaultdatatype );
3489 size+=spoolss_size_string_array(info->dependentfiles);
3494 /*******************************************************************
3495 return the size required by a struct in the stream
3496 ********************************************************************/
3498 uint32 spoolss_size_printer_driver_info_6(DRIVER_INFO_6 *info)
3502 size+=size_of_uint32( &info->version );
3503 size+=size_of_relative_string( &info->name );
3504 size+=size_of_relative_string( &info->architecture );
3505 size+=size_of_relative_string( &info->driverpath );
3506 size+=size_of_relative_string( &info->datafile );
3507 size+=size_of_relative_string( &info->configfile );
3508 size+=size_of_relative_string( &info->helpfile );
3510 size+=spoolss_size_string_array(info->dependentfiles);
3512 size+=size_of_relative_string( &info->monitorname );
3513 size+=size_of_relative_string( &info->defaultdatatype );
3515 size+=spoolss_size_string_array(info->previousdrivernames);
3517 size+=size_of_nttime(&info->driver_date);
3518 size+=size_of_uint32( &info->padding );
3519 size+=size_of_uint32( &info->driver_version_low );
3520 size+=size_of_uint32( &info->driver_version_high );
3521 size+=size_of_relative_string( &info->mfgname );
3522 size+=size_of_relative_string( &info->oem_url );
3523 size+=size_of_relative_string( &info->hardware_id );
3524 size+=size_of_relative_string( &info->provider );
3529 /*******************************************************************
3530 return the size required by a struct in the stream
3531 ********************************************************************/
3533 uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
3536 size+=size_of_uint32( &info->jobid );
3537 size+=size_of_relative_string( &info->printername );
3538 size+=size_of_relative_string( &info->machinename );
3539 size+=size_of_relative_string( &info->username );
3540 size+=size_of_relative_string( &info->document );
3541 size+=size_of_relative_string( &info->datatype );
3542 size+=size_of_relative_string( &info->text_status );
3543 size+=size_of_uint32( &info->status );
3544 size+=size_of_uint32( &info->priority );
3545 size+=size_of_uint32( &info->position );
3546 size+=size_of_uint32( &info->totalpages );
3547 size+=size_of_uint32( &info->pagesprinted );
3548 size+=size_of_systemtime( &info->submitted );
3553 /*******************************************************************
3554 return the size required by a struct in the stream
3555 ********************************************************************/
3557 uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
3561 size+=4; /* size of sec desc ptr */
3563 size+=size_of_uint32( &info->jobid );
3564 size+=size_of_relative_string( &info->printername );
3565 size+=size_of_relative_string( &info->machinename );
3566 size+=size_of_relative_string( &info->username );
3567 size+=size_of_relative_string( &info->document );
3568 size+=size_of_relative_string( &info->notifyname );
3569 size+=size_of_relative_string( &info->datatype );
3570 size+=size_of_relative_string( &info->printprocessor );
3571 size+=size_of_relative_string( &info->parameters );
3572 size+=size_of_relative_string( &info->drivername );
3573 size+=size_of_device_mode( info->devmode );
3574 size+=size_of_relative_string( &info->text_status );
3575 /* SEC_DESC sec_desc;*/
3576 size+=size_of_uint32( &info->status );
3577 size+=size_of_uint32( &info->priority );
3578 size+=size_of_uint32( &info->position );
3579 size+=size_of_uint32( &info->starttime );
3580 size+=size_of_uint32( &info->untiltime );
3581 size+=size_of_uint32( &info->totalpages );
3582 size+=size_of_uint32( &info->size );
3583 size+=size_of_systemtime( &info->submitted );
3584 size+=size_of_uint32( &info->timeelapsed );
3585 size+=size_of_uint32( &info->pagesprinted );
3590 /*******************************************************************
3591 return the size required by a struct in the stream
3592 ********************************************************************/
3594 uint32 spoolss_size_form_1(FORM_1 *info)
3598 size+=size_of_uint32( &info->flag );
3599 size+=size_of_relative_string( &info->name );
3600 size+=size_of_uint32( &info->width );
3601 size+=size_of_uint32( &info->length );
3602 size+=size_of_uint32( &info->left );
3603 size+=size_of_uint32( &info->top );
3604 size+=size_of_uint32( &info->right );
3605 size+=size_of_uint32( &info->bottom );
3610 /*******************************************************************
3611 return the size required by a struct in the stream
3612 ********************************************************************/
3614 uint32 spoolss_size_port_info_1(PORT_INFO_1 *info)
3618 size+=size_of_relative_string( &info->port_name );
3623 /*******************************************************************
3624 return the size required by a struct in the stream
3625 ********************************************************************/
3627 uint32 spoolss_size_driverdir_info_1(DRIVER_DIRECTORY_1 *info)
3631 size=str_len_uni(&info->name); /* the string length */
3632 size=size+1; /* add the leading zero */
3633 size=size*2; /* convert in char */
3638 /*******************************************************************
3639 return the size required by a struct in the stream
3640 ********************************************************************/
3642 uint32 spoolss_size_printprocessordirectory_info_1(PRINTPROCESSOR_DIRECTORY_1 *info)
3646 size=str_len_uni(&info->name); /* the string length */
3647 size=size+1; /* add the leading zero */
3648 size=size*2; /* convert in char */
3653 /*******************************************************************
3654 return the size required by a struct in the stream
3655 ********************************************************************/
3657 uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
3661 size+=size_of_relative_string( &info->port_name );
3662 size+=size_of_relative_string( &info->monitor_name );
3663 size+=size_of_relative_string( &info->description );
3665 size+=size_of_uint32( &info->port_type );
3666 size+=size_of_uint32( &info->reserved );
3671 /*******************************************************************
3672 return the size required by a struct in the stream
3673 ********************************************************************/
3675 uint32 spoolss_size_printprocessor_info_1(PRINTPROCESSOR_1 *info)
3678 size+=size_of_relative_string( &info->name );
3683 /*******************************************************************
3684 return the size required by a struct in the stream
3685 ********************************************************************/
3687 uint32 spoolss_size_printprocdatatype_info_1(PRINTPROCDATATYPE_1 *info)
3690 size+=size_of_relative_string( &info->name );
3695 /*******************************************************************
3696 return the size required by a struct in the stream
3697 ********************************************************************/
3698 uint32 spoolss_size_printer_enum_values(PRINTER_ENUM_VALUES *p)
3705 /* uint32(offset) + uint32(length) + length) */
3706 size += (size_of_uint32(&p->value_len)*2) + p->value_len;
3707 size += (size_of_uint32(&p->data_len)*2) + p->data_len + (p->data_len%2) ;
3709 size += size_of_uint32(&p->type);
3714 /*******************************************************************
3715 return the size required by a struct in the stream
3716 ********************************************************************/
3718 uint32 spoolss_size_printmonitor_info_1(PRINTMONITOR_1 *info)
3721 size+=size_of_relative_string( &info->name );
3726 /*******************************************************************
3727 return the size required by a struct in the stream
3728 ********************************************************************/
3730 uint32 spoolss_size_printmonitor_info_2(PRINTMONITOR_2 *info)
3733 size+=size_of_relative_string( &info->name);
3734 size+=size_of_relative_string( &info->environment);
3735 size+=size_of_relative_string( &info->dll_name);
3740 /*******************************************************************
3742 ********************************************************************/
3744 BOOL make_spoolss_q_getprinterdriver2(SPOOL_Q_GETPRINTERDRIVER2 *q_u,
3745 const POLICY_HND *hnd,
3746 const fstring architecture,
3747 uint32 level, uint32 clientmajor, uint32 clientminor,
3748 NEW_BUFFER *buffer, uint32 offered)
3753 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3755 init_buf_unistr2(&q_u->architecture, &q_u->architecture_ptr, architecture);
3758 q_u->clientmajorversion=clientmajor;
3759 q_u->clientminorversion=clientminor;
3762 q_u->offered=offered;
3767 /*******************************************************************
3769 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3770 ********************************************************************/
3772 BOOL spoolss_io_q_getprinterdriver2(char *desc, SPOOL_Q_GETPRINTERDRIVER2 *q_u, prs_struct *ps, int depth)
3774 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriver2");
3780 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3782 if(!prs_uint32("architecture_ptr", ps, depth, &q_u->architecture_ptr))
3784 if(!smb_io_unistr2("architecture", &q_u->architecture, q_u->architecture_ptr, ps, depth))
3789 if(!prs_uint32("level", ps, depth, &q_u->level))
3792 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
3798 if(!prs_uint32("offered", ps, depth, &q_u->offered))
3801 if(!prs_uint32("clientmajorversion", ps, depth, &q_u->clientmajorversion))
3803 if(!prs_uint32("clientminorversion", ps, depth, &q_u->clientminorversion))
3809 /*******************************************************************
3811 * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3812 ********************************************************************/
3814 BOOL spoolss_io_r_getprinterdriver2(char *desc, SPOOL_R_GETPRINTERDRIVER2 *r_u, prs_struct *ps, int depth)
3816 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriver2");
3822 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
3827 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3829 if (!prs_uint32("servermajorversion", ps, depth, &r_u->servermajorversion))
3831 if (!prs_uint32("serverminorversion", ps, depth, &r_u->serverminorversion))
3833 if (!prs_werror("status", ps, depth, &r_u->status))
3839 /*******************************************************************
3841 ********************************************************************/
3843 BOOL make_spoolss_q_enumprinters(
3844 SPOOL_Q_ENUMPRINTERS *q_u,
3854 q_u->servername_ptr = (servername != NULL) ? 1 : 0;
3855 init_buf_unistr2(&q_u->servername, &q_u->servername_ptr, servername);
3859 q_u->offered=offered;
3864 /*******************************************************************
3866 ********************************************************************/
3868 BOOL make_spoolss_q_enumports(SPOOL_Q_ENUMPORTS *q_u,
3869 fstring servername, uint32 level,
3870 NEW_BUFFER *buffer, uint32 offered)
3872 q_u->name_ptr = (servername != NULL) ? 1 : 0;
3873 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
3877 q_u->offered=offered;
3882 /*******************************************************************
3884 * called from spoolss_enumprinters (srv_spoolss.c)
3885 ********************************************************************/
3887 BOOL spoolss_io_q_enumprinters(char *desc, SPOOL_Q_ENUMPRINTERS *q_u, prs_struct *ps, int depth)
3889 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinters");
3895 if (!prs_uint32("flags", ps, depth, &q_u->flags))
3897 if (!prs_uint32("servername_ptr", ps, depth, &q_u->servername_ptr))
3900 if (!smb_io_unistr2("", &q_u->servername, q_u->servername_ptr, ps, depth))
3905 if (!prs_uint32("level", ps, depth, &q_u->level))
3908 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
3913 if (!prs_uint32("offered", ps, depth, &q_u->offered))
3919 /*******************************************************************
3920 Parse a SPOOL_R_ENUMPRINTERS structure.
3921 ********************************************************************/
3923 BOOL spoolss_io_r_enumprinters(char *desc, SPOOL_R_ENUMPRINTERS *r_u, prs_struct *ps, int depth)
3925 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinters");
3931 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
3937 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3940 if (!prs_uint32("returned", ps, depth, &r_u->returned))
3943 if (!prs_werror("status", ps, depth, &r_u->status))
3949 /*******************************************************************
3950 * write a structure.
3951 * called from spoolss_r_enum_printers (srv_spoolss.c)
3953 ********************************************************************/
3955 BOOL spoolss_io_r_getprinter(char *desc, SPOOL_R_GETPRINTER *r_u, prs_struct *ps, int depth)
3957 prs_debug(ps, depth, desc, "spoolss_io_r_getprinter");
3963 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
3969 if (!prs_uint32("needed", ps, depth, &r_u->needed))
3972 if (!prs_werror("status", ps, depth, &r_u->status))
3978 /*******************************************************************
3980 * called from spoolss_getprinter (srv_spoolss.c)
3981 ********************************************************************/
3983 BOOL spoolss_io_q_getprinter(char *desc, SPOOL_Q_GETPRINTER *q_u, prs_struct *ps, int depth)
3985 prs_debug(ps, depth, desc, "spoolss_io_q_getprinter");
3991 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3993 if (!prs_uint32("level", ps, depth, &q_u->level))
3996 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
4001 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4007 /*******************************************************************
4009 ********************************************************************/
4011 BOOL make_spoolss_q_getprinter(
4012 TALLOC_CTX *mem_ctx,
4013 SPOOL_Q_GETPRINTER *q_u,
4014 const POLICY_HND *hnd,
4024 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
4028 q_u->offered=offered;
4033 /*******************************************************************
4035 ********************************************************************/
4036 BOOL make_spoolss_q_setprinter(TALLOC_CTX *mem_ctx, SPOOL_Q_SETPRINTER *q_u,
4037 const POLICY_HND *hnd, uint32 level, PRINTER_INFO_CTR *info,
4041 DEVICEMODE *devmode;
4046 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
4049 q_u->info.level = level;
4050 q_u->info.info_ptr = (info != NULL) ? 1 : 0;
4053 /* There's no such thing as a setprinter level 1 */
4056 secdesc = info->printers_2->secdesc;
4057 devmode = info->printers_2->devmode;
4059 make_spoolss_printer_info_2 (mem_ctx, &q_u->info.info_2, info->printers_2);
4060 #if 1 /* JERRY TEST */
4061 q_u->secdesc_ctr = (SEC_DESC_BUF*)malloc(sizeof(SEC_DESC_BUF));
4062 if (!q_u->secdesc_ctr)
4064 q_u->secdesc_ctr->ptr = (secdesc != NULL) ? 1: 0;
4065 q_u->secdesc_ctr->max_len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
4066 q_u->secdesc_ctr->len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
4067 q_u->secdesc_ctr->sec = secdesc;
4069 q_u->devmode_ctr.devmode_ptr = (devmode != NULL) ? 1 : 0;
4070 q_u->devmode_ctr.size = (devmode != NULL) ? sizeof(DEVICEMODE) + (3*sizeof(uint32)) : 0;
4071 q_u->devmode_ctr.devmode = devmode;
4073 q_u->secdesc_ctr = NULL;
4075 q_u->devmode_ctr.devmode_ptr = 0;
4076 q_u->devmode_ctr.size = 0;
4077 q_u->devmode_ctr.devmode = NULL;
4081 DEBUG(0,("make_spoolss_q_setprinter: Unknown info level [%d]\n", level));
4086 q_u->command = command;
4092 /*******************************************************************
4093 ********************************************************************/
4095 BOOL spoolss_io_r_setprinter(char *desc, SPOOL_R_SETPRINTER *r_u, prs_struct *ps, int depth)
4097 prs_debug(ps, depth, desc, "spoolss_io_r_setprinter");
4103 if(!prs_werror("status", ps, depth, &r_u->status))
4109 /*******************************************************************
4110 Marshall/unmarshall a SPOOL_Q_SETPRINTER struct.
4111 ********************************************************************/
4113 BOOL spoolss_io_q_setprinter(char *desc, SPOOL_Q_SETPRINTER *q_u, prs_struct *ps, int depth)
4115 uint32 ptr_sec_desc = 0;
4117 prs_debug(ps, depth, desc, "spoolss_io_q_setprinter");
4123 if(!smb_io_pol_hnd("printer handle", &q_u->handle ,ps, depth))
4125 if(!prs_uint32("level", ps, depth, &q_u->level))
4128 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
4131 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
4141 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
4146 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
4152 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
4157 /* Parse a NULL security descriptor. This should really
4158 happen inside the sec_io_desc_buf() function. */
4160 prs_debug(ps, depth, "", "sec_io_desc_buf");
4161 if (!prs_uint32("size", ps, depth + 1, &dummy))
4163 if (!prs_uint32("ptr", ps, depth + 1, &dummy)) return
4167 if(!prs_uint32("command", ps, depth, &q_u->command))
4173 /*******************************************************************
4174 ********************************************************************/
4176 BOOL spoolss_io_r_fcpn(char *desc, SPOOL_R_FCPN *r_u, prs_struct *ps, int depth)
4178 prs_debug(ps, depth, desc, "spoolss_io_r_fcpn");
4184 if(!prs_werror("status", ps, depth, &r_u->status))
4190 /*******************************************************************
4191 ********************************************************************/
4193 BOOL spoolss_io_q_fcpn(char *desc, SPOOL_Q_FCPN *q_u, prs_struct *ps, int depth)
4196 prs_debug(ps, depth, desc, "spoolss_io_q_fcpn");
4202 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4209 /*******************************************************************
4210 ********************************************************************/
4212 BOOL spoolss_io_r_addjob(char *desc, SPOOL_R_ADDJOB *r_u, prs_struct *ps, int depth)
4214 prs_debug(ps, depth, desc, "");
4220 if(!spoolss_io_buffer("", ps, depth, &r_u->buffer))
4226 if(!prs_uint32("needed", ps, depth, &r_u->needed))
4229 if(!prs_werror("status", ps, depth, &r_u->status))
4235 /*******************************************************************
4236 ********************************************************************/
4238 BOOL spoolss_io_q_addjob(char *desc, SPOOL_Q_ADDJOB *q_u, prs_struct *ps, int depth)
4240 prs_debug(ps, depth, desc, "");
4246 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
4248 if(!prs_uint32("level", ps, depth, &q_u->level))
4251 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
4257 if(!prs_uint32("offered", ps, depth, &q_u->offered))
4263 /*******************************************************************
4264 ********************************************************************/
4266 BOOL spoolss_io_r_enumjobs(char *desc, SPOOL_R_ENUMJOBS *r_u, prs_struct *ps, int depth)
4268 prs_debug(ps, depth, desc, "spoolss_io_r_enumjobs");
4274 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
4280 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4283 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4286 if (!prs_werror("status", ps, depth, &r_u->status))
4292 /*******************************************************************
4293 ********************************************************************/
4295 BOOL make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS *q_u, const POLICY_HND *hnd,
4306 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
4307 q_u->firstjob = firstjob;
4308 q_u->numofjobs = numofjobs;
4310 q_u->buffer= buffer;
4311 q_u->offered = offered;
4315 /*******************************************************************
4316 ********************************************************************/
4318 BOOL spoolss_io_q_enumjobs(char *desc, SPOOL_Q_ENUMJOBS *q_u, prs_struct *ps, int depth)
4320 prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs");
4326 if (!smb_io_pol_hnd("printer handle",&q_u->handle, ps, depth))
4329 if (!prs_uint32("firstjob", ps, depth, &q_u->firstjob))
4331 if (!prs_uint32("numofjobs", ps, depth, &q_u->numofjobs))
4333 if (!prs_uint32("level", ps, depth, &q_u->level))
4336 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
4342 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4348 /*******************************************************************
4349 ********************************************************************/
4351 BOOL spoolss_io_r_schedulejob(char *desc, SPOOL_R_SCHEDULEJOB *r_u, prs_struct *ps, int depth)
4353 prs_debug(ps, depth, desc, "spoolss_io_r_schedulejob");
4359 if(!prs_werror("status", ps, depth, &r_u->status))
4365 /*******************************************************************
4366 ********************************************************************/
4368 BOOL spoolss_io_q_schedulejob(char *desc, SPOOL_Q_SCHEDULEJOB *q_u, prs_struct *ps, int depth)
4370 prs_debug(ps, depth, desc, "spoolss_io_q_schedulejob");
4376 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4378 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
4384 /*******************************************************************
4385 ********************************************************************/
4387 BOOL spoolss_io_r_setjob(char *desc, SPOOL_R_SETJOB *r_u, prs_struct *ps, int depth)
4389 prs_debug(ps, depth, desc, "spoolss_io_r_setjob");
4395 if(!prs_werror("status", ps, depth, &r_u->status))
4401 /*******************************************************************
4402 ********************************************************************/
4404 BOOL spoolss_io_q_setjob(char *desc, SPOOL_Q_SETJOB *q_u, prs_struct *ps, int depth)
4406 prs_debug(ps, depth, desc, "spoolss_io_q_setjob");
4412 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4414 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
4417 * level is usually 0. If (level!=0) then I'm in trouble !
4418 * I will try to generate setjob command with level!=0, one day.
4420 if(!prs_uint32("level", ps, depth, &q_u->level))
4422 if(!prs_uint32("command", ps, depth, &q_u->command))
4428 /*******************************************************************
4429 Parse a SPOOL_R_ENUMPRINTERDRIVERS structure.
4430 ********************************************************************/
4432 BOOL spoolss_io_r_enumprinterdrivers(char *desc, SPOOL_R_ENUMPRINTERDRIVERS *r_u, prs_struct *ps, int depth)
4434 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdrivers");
4440 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
4446 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4449 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4452 if (!prs_werror("status", ps, depth, &r_u->status))
4458 /*******************************************************************
4460 ********************************************************************/
4462 BOOL make_spoolss_q_enumprinterdrivers(SPOOL_Q_ENUMPRINTERDRIVERS *q_u,
4464 const char *environment,
4466 NEW_BUFFER *buffer, uint32 offered)
4468 init_buf_unistr2(&q_u->name, &q_u->name_ptr, name);
4469 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, environment);
4473 q_u->offered=offered;
4478 /*******************************************************************
4479 Parse a SPOOL_Q_ENUMPRINTERDRIVERS structure.
4480 ********************************************************************/
4482 BOOL spoolss_io_q_enumprinterdrivers(char *desc, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, prs_struct *ps, int depth)
4485 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdrivers");
4491 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
4493 if (!smb_io_unistr2("", &q_u->name, q_u->name_ptr,ps, depth))
4498 if (!prs_uint32("environment_ptr", ps, depth, &q_u->environment_ptr))
4500 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
4505 if (!prs_uint32("level", ps, depth, &q_u->level))
4508 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
4514 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4520 /*******************************************************************
4521 ********************************************************************/
4523 BOOL spoolss_io_q_enumforms(char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth)
4526 prs_debug(ps, depth, desc, "spoolss_io_q_enumforms");
4531 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4533 if (!prs_uint32("level", ps, depth, &q_u->level))
4536 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
4541 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4547 /*******************************************************************
4548 ********************************************************************/
4550 BOOL spoolss_io_r_enumforms(char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth)
4552 prs_debug(ps, depth, desc, "spoolss_io_r_enumforms");
4558 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
4564 if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
4567 if (!prs_uint32("numofforms", ps, depth, &r_u->numofforms))
4570 if (!prs_werror("status", ps, depth, &r_u->status))
4576 /*******************************************************************
4577 ********************************************************************/
4579 BOOL spoolss_io_q_getform(char *desc, SPOOL_Q_GETFORM *q_u, prs_struct *ps, int depth)
4582 prs_debug(ps, depth, desc, "spoolss_io_q_getform");
4587 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4589 if (!smb_io_unistr2("", &q_u->formname,True,ps,depth))
4595 if (!prs_uint32("level", ps, depth, &q_u->level))
4598 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
4603 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4609 /*******************************************************************
4610 ********************************************************************/
4612 BOOL spoolss_io_r_getform(char *desc, SPOOL_R_GETFORM *r_u, prs_struct *ps, int depth)
4614 prs_debug(ps, depth, desc, "spoolss_io_r_getform");
4620 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
4626 if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
4629 if (!prs_werror("status", ps, depth, &r_u->status))
4635 /*******************************************************************
4636 Parse a SPOOL_R_ENUMPORTS structure.
4637 ********************************************************************/
4639 BOOL spoolss_io_r_enumports(char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
4641 prs_debug(ps, depth, desc, "spoolss_io_r_enumports");
4647 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
4653 if (!prs_uint32("needed", ps, depth, &r_u->needed))
4656 if (!prs_uint32("returned", ps, depth, &r_u->returned))
4659 if (!prs_werror("status", ps, depth, &r_u->status))
4665 /*******************************************************************
4666 ********************************************************************/
4668 BOOL spoolss_io_q_enumports(char *desc, SPOOL_Q_ENUMPORTS *q_u, prs_struct *ps, int depth)
4670 prs_debug(ps, depth, desc, "");
4676 if (!prs_uint32("", ps, depth, &q_u->name_ptr))
4678 if (!smb_io_unistr2("", &q_u->name,True,ps,depth))
4683 if (!prs_uint32("level", ps, depth, &q_u->level))
4686 if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
4691 if (!prs_uint32("offered", ps, depth, &q_u->offered))
4697 /*******************************************************************
4698 Parse a SPOOL_PRINTER_INFO_LEVEL_1 structure.
4699 ********************************************************************/
4701 BOOL spool_io_printer_info_level_1(char *desc, SPOOL_PRINTER_INFO_LEVEL_1 *il, prs_struct *ps, int depth)
4703 prs_debug(ps, depth, desc, "spool_io_printer_info_level_1");
4709 if(!prs_uint32("flags", ps, depth, &il->flags))
4711 if(!prs_uint32("description_ptr", ps, depth, &il->description_ptr))
4713 if(!prs_uint32("name_ptr", ps, depth, &il->name_ptr))
4715 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4718 if(!smb_io_unistr2("description", &il->description, il->description_ptr, ps, depth))
4720 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4722 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4728 /*******************************************************************
4729 Parse a SPOOL_PRINTER_INFO_LEVEL_3 structure.
4730 ********************************************************************/
4732 BOOL spool_io_printer_info_level_3(char *desc, SPOOL_PRINTER_INFO_LEVEL_3 *il, prs_struct *ps, int depth)
4734 prs_debug(ps, depth, desc, "spool_io_printer_info_level_3");
4740 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4746 /*******************************************************************
4747 Parse a SPOOL_PRINTER_INFO_LEVEL_2 structure.
4748 ********************************************************************/
4750 BOOL spool_io_printer_info_level_2(char *desc, SPOOL_PRINTER_INFO_LEVEL_2 *il, prs_struct *ps, int depth)
4752 prs_debug(ps, depth, desc, "spool_io_printer_info_level_2");
4758 if(!prs_uint32("servername_ptr", ps, depth, &il->servername_ptr))
4760 if(!prs_uint32("printername_ptr", ps, depth, &il->printername_ptr))
4762 if(!prs_uint32("sharename_ptr", ps, depth, &il->sharename_ptr))
4764 if(!prs_uint32("portname_ptr", ps, depth, &il->portname_ptr))
4767 if(!prs_uint32("drivername_ptr", ps, depth, &il->drivername_ptr))
4769 if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4771 if(!prs_uint32("location_ptr", ps, depth, &il->location_ptr))
4773 if(!prs_uint32("devmode_ptr", ps, depth, &il->devmode_ptr))
4775 if(!prs_uint32("sepfile_ptr", ps, depth, &il->sepfile_ptr))
4777 if(!prs_uint32("printprocessor_ptr", ps, depth, &il->printprocessor_ptr))
4779 if(!prs_uint32("datatype_ptr", ps, depth, &il->datatype_ptr))
4781 if(!prs_uint32("parameters_ptr", ps, depth, &il->parameters_ptr))
4783 if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4786 if(!prs_uint32("attributes", ps, depth, &il->attributes))
4788 if(!prs_uint32("priority", ps, depth, &il->priority))
4790 if(!prs_uint32("default_priority", ps, depth, &il->default_priority))
4792 if(!prs_uint32("starttime", ps, depth, &il->starttime))
4794 if(!prs_uint32("untiltime", ps, depth, &il->untiltime))
4796 if(!prs_uint32("status", ps, depth, &il->status))
4798 if(!prs_uint32("cjobs", ps, depth, &il->cjobs))
4800 if(!prs_uint32("averageppm", ps, depth, &il->averageppm))
4803 if(!smb_io_unistr2("servername", &il->servername, il->servername_ptr, ps, depth))
4805 if(!smb_io_unistr2("printername", &il->printername, il->printername_ptr, ps, depth))
4807 if(!smb_io_unistr2("sharename", &il->sharename, il->sharename_ptr, ps, depth))
4809 if(!smb_io_unistr2("portname", &il->portname, il->portname_ptr, ps, depth))
4811 if(!smb_io_unistr2("drivername", &il->drivername, il->drivername_ptr, ps, depth))
4813 if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4815 if(!smb_io_unistr2("location", &il->location, il->location_ptr, ps, depth))
4817 if(!smb_io_unistr2("sepfile", &il->sepfile, il->sepfile_ptr, ps, depth))
4819 if(!smb_io_unistr2("printprocessor", &il->printprocessor, il->printprocessor_ptr, ps, depth))
4821 if(!smb_io_unistr2("datatype", &il->datatype, il->datatype_ptr, ps, depth))
4823 if(!smb_io_unistr2("parameters", &il->parameters, il->parameters_ptr, ps, depth))
4829 /*******************************************************************
4830 ********************************************************************/
4832 BOOL spool_io_printer_info_level(char *desc, SPOOL_PRINTER_INFO_LEVEL *il, prs_struct *ps, int depth)
4834 prs_debug(ps, depth, desc, "spool_io_printer_info_level");
4839 if(!prs_uint32("level", ps, depth, &il->level))
4841 if(!prs_uint32("info_ptr", ps, depth, &il->info_ptr))
4844 /* if no struct inside just return */
4845 if (il->info_ptr==0) {
4846 if (UNMARSHALLING(ps)) {
4853 switch (il->level) {
4855 * level 0 is used by setprinter when managing the queue
4856 * (hold, stop, start a queue)
4860 /* DOCUMENT ME!!! What is level 1 used for? */
4863 if (UNMARSHALLING(ps)) {
4864 if ((il->info_1=(SPOOL_PRINTER_INFO_LEVEL_1 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_INFO_LEVEL_1))) == NULL)
4867 if (!spool_io_printer_info_level_1("", il->info_1, ps, depth))
4872 * level 2 is used by addprinter
4873 * and by setprinter when updating printer's info
4876 if (UNMARSHALLING(ps)) {
4877 if ((il->info_2=(SPOOL_PRINTER_INFO_LEVEL_2 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_INFO_LEVEL_2))) == NULL)
4880 if (!spool_io_printer_info_level_2("", il->info_2, ps, depth))
4883 /* DOCUMENT ME!!! What is level 3 used for? */
4886 if (UNMARSHALLING(ps)) {
4887 if ((il->info_3=(SPOOL_PRINTER_INFO_LEVEL_3 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_INFO_LEVEL_3))) == NULL)
4890 if (!spool_io_printer_info_level_3("", il->info_3, ps, depth))
4899 /*******************************************************************
4900 ********************************************************************/
4902 BOOL spoolss_io_q_addprinterex(char *desc, SPOOL_Q_ADDPRINTEREX *q_u, prs_struct *ps, int depth)
4904 uint32 ptr_sec_desc = 0;
4906 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterex");
4911 if(!prs_uint32("", ps, depth, &q_u->server_name_ptr))
4913 if(!smb_io_unistr2("", &q_u->server_name, q_u->server_name_ptr, ps, depth))
4919 if(!prs_uint32("info_level", ps, depth, &q_u->level))
4922 if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
4925 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
4931 switch (q_u->level) {
4933 ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
4936 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
4940 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
4945 /* Parse a NULL security descriptor. This should really
4946 happen inside the sec_io_desc_buf() function. */
4948 prs_debug(ps, depth, "", "sec_io_desc_buf");
4949 if (!prs_uint32("size", ps, depth + 1, &dummy))
4951 if (!prs_uint32("ptr", ps, depth + 1, &dummy))
4955 if(!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
4957 if(!spool_io_user_level("", &q_u->user_ctr, ps, depth))
4963 /*******************************************************************
4964 ********************************************************************/
4966 BOOL spoolss_io_r_addprinterex(char *desc, SPOOL_R_ADDPRINTEREX *r_u,
4967 prs_struct *ps, int depth)
4969 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterex");
4972 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
4975 if(!prs_werror("status", ps, depth, &r_u->status))
4981 /*******************************************************************
4982 ********************************************************************/
4984 BOOL spool_io_printer_driver_info_level_3(char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **q_u,
4985 prs_struct *ps, int depth)
4987 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *il;
4989 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_3");
4993 if (UNMARSHALLING(ps)) {
4994 il=(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3));
5006 if(!prs_uint32("cversion", ps, depth, &il->cversion))
5008 if(!prs_uint32("name", ps, depth, &il->name_ptr))
5010 if(!prs_uint32("environment", ps, depth, &il->environment_ptr))
5012 if(!prs_uint32("driverpath", ps, depth, &il->driverpath_ptr))
5014 if(!prs_uint32("datafile", ps, depth, &il->datafile_ptr))
5016 if(!prs_uint32("configfile", ps, depth, &il->configfile_ptr))
5018 if(!prs_uint32("helpfile", ps, depth, &il->helpfile_ptr))
5020 if(!prs_uint32("monitorname", ps, depth, &il->monitorname_ptr))
5022 if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
5024 if(!prs_uint32("dependentfilessize", ps, depth, &il->dependentfilessize))
5026 if(!prs_uint32("dependentfiles", ps, depth, &il->dependentfiles_ptr))
5032 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
5034 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
5036 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
5038 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
5040 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
5042 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
5044 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
5046 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
5052 if (il->dependentfiles_ptr)
5053 smb_io_buffer5("", &il->dependentfiles, ps, depth);
5058 /*******************************************************************
5059 parse a SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 structure
5060 ********************************************************************/
5062 BOOL spool_io_printer_driver_info_level_6(char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 **q_u,
5063 prs_struct *ps, int depth)
5065 SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *il;
5067 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_6");
5071 if (UNMARSHALLING(ps)) {
5072 il=(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6));
5085 * I know this seems weird, but I have no other explanation.
5086 * This is observed behavior on both NT4 and 2K servers.
5090 if (!prs_align_uint64(ps))
5093 /* parse the main elements the packet */
5095 if(!prs_uint32("cversion ", ps, depth, &il->version))
5097 if(!prs_uint32("name ", ps, depth, &il->name_ptr))
5099 if(!prs_uint32("environment ", ps, depth, &il->environment_ptr))
5101 if(!prs_uint32("driverpath ", ps, depth, &il->driverpath_ptr))
5103 if(!prs_uint32("datafile ", ps, depth, &il->datafile_ptr))
5105 if(!prs_uint32("configfile ", ps, depth, &il->configfile_ptr))
5107 if(!prs_uint32("helpfile ", ps, depth, &il->helpfile_ptr))
5109 if(!prs_uint32("monitorname ", ps, depth, &il->monitorname_ptr))
5111 if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
5113 if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_len))
5115 if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_ptr))
5117 if(!prs_uint32("previousnames ", ps, depth, &il->previousnames_len))
5119 if(!prs_uint32("previousnames ", ps, depth, &il->previousnames_ptr))
5121 if(!smb_io_time("driverdate ", &il->driverdate, ps, depth))
5123 if(!prs_uint32("dummy4 ", ps, depth, &il->dummy4))
5125 if(!prs_uint64("driverversion ", ps, depth, &il->driverversion))
5127 if(!prs_uint32("mfgname ", ps, depth, &il->mfgname_ptr))
5129 if(!prs_uint32("oemurl ", ps, depth, &il->oemurl_ptr))
5131 if(!prs_uint32("hardwareid ", ps, depth, &il->hardwareid_ptr))
5133 if(!prs_uint32("provider ", ps, depth, &il->provider_ptr))
5136 /* parse the structures in the packet */
5138 if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
5143 if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
5148 if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
5153 if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
5158 if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
5163 if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
5168 if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
5173 if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
5177 if (il->dependentfiles_ptr) {
5178 if(!smb_io_buffer5("dependentfiles", &il->dependentfiles, ps, depth))
5183 if (il->previousnames_ptr) {
5184 if(!smb_io_buffer5("previousnames", &il->previousnames, ps, depth))
5189 if(!smb_io_unistr2("mfgname", &il->mfgname, il->mfgname_ptr, ps, depth))
5193 if(!smb_io_unistr2("oemurl", &il->oemurl, il->oemurl_ptr, ps, depth))
5197 if(!smb_io_unistr2("hardwareid", &il->hardwareid, il->hardwareid_ptr, ps, depth))
5201 if(!smb_io_unistr2("provider", &il->provider, il->provider_ptr, ps, depth))
5207 /*******************************************************************
5208 convert a buffer of UNICODE strings null terminated
5209 the buffer is terminated by a NULL
5211 convert to an dos codepage array (null terminated)
5213 dynamically allocate memory
5215 ********************************************************************/
5216 static BOOL uniarray_2_dosarray(BUFFER5 *buf5, fstring **ar)
5225 src = (char *)buf5->buffer;
5228 while (src < ((char *)buf5->buffer) + buf5->buf_len*2) {
5229 rpcstr_pull(f, src, sizeof(f)-1, -1, STR_TERMINATE);
5230 src = skip_unibuf(src, 2*buf5->buf_len - PTR_DIFF(src,buf5->buffer));
5231 tar = (fstring *)Realloc(*ar, sizeof(fstring)*(n+2));
5236 fstrcpy((*ar)[n], f);
5239 fstrcpy((*ar)[n], "");
5247 /*******************************************************************
5248 read a UNICODE array with null terminated strings
5249 and null terminated array
5250 and size of array at beginning
5251 ********************************************************************/
5253 BOOL smb_io_unibuffer(char *desc, UNISTR2 *buffer, prs_struct *ps, int depth)
5255 if (buffer==NULL) return False;
5258 buffer->uni_str_len=buffer->uni_max_len;
5260 if(!prs_uint32("buffer_size", ps, depth, &buffer->uni_max_len))
5263 if(!prs_unistr2(True, "buffer ", ps, depth, buffer))
5269 /*******************************************************************
5270 ********************************************************************/
5272 BOOL spool_io_printer_driver_info_level(char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL *il, prs_struct *ps, int depth)
5274 prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level");
5279 if(!prs_uint32("level", ps, depth, &il->level))
5281 if(!prs_uint32("ptr", ps, depth, &il->ptr))
5287 switch (il->level) {
5289 if(!spool_io_printer_driver_info_level_3("", &il->info_3, ps, depth))
5293 if(!spool_io_printer_driver_info_level_6("", &il->info_6, ps, depth))
5303 /*******************************************************************
5304 init a SPOOL_Q_ADDPRINTERDRIVER struct
5305 ******************************************************************/
5307 BOOL make_spoolss_q_addprinterdriver(TALLOC_CTX *mem_ctx,
5308 SPOOL_Q_ADDPRINTERDRIVER *q_u, const char* srv_name,
5309 uint32 level, PRINTER_DRIVER_CTR *info)
5311 DEBUG(5,("make_spoolss_q_addprinterdriver\n"));
5313 q_u->server_name_ptr = (srv_name!=NULL)?1:0;
5314 init_unistr2(&q_u->server_name, srv_name, strlen(srv_name)+1);
5318 q_u->info.level = level;
5319 q_u->info.ptr = (info!=NULL)?1:0;
5322 /* info level 3 is supported by Windows 95/98, WinNT and Win2k */
5324 make_spoolss_driver_info_3(mem_ctx, &q_u->info.info_3, info->info3);
5328 DEBUG(0,("make_spoolss_q_addprinterdriver: Unknown info level [%d]\n", level));
5335 BOOL make_spoolss_driver_info_3(TALLOC_CTX *mem_ctx,
5336 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **spool_drv_info,
5337 DRIVER_INFO_3 *info3)
5340 uint16 *ptr = info3->dependentfiles;
5342 BOOL null_char = False;
5343 SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *inf;
5345 if (!(inf=(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3*)talloc_zero(mem_ctx, sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3))))
5348 inf->cversion = info3->version;
5349 inf->name_ptr = (info3->name.buffer!=NULL)?1:0;
5350 inf->environment_ptr = (info3->architecture.buffer!=NULL)?1:0;
5351 inf->driverpath_ptr = (info3->driverpath.buffer!=NULL)?1:0;
5352 inf->datafile_ptr = (info3->datafile.buffer!=NULL)?1:0;
5353 inf->configfile_ptr = (info3->configfile.buffer!=NULL)?1:0;
5354 inf->helpfile_ptr = (info3->helpfile.buffer!=NULL)?1:0;
5355 inf->monitorname_ptr = (info3->monitorname.buffer!=NULL)?1:0;
5356 inf->defaultdatatype_ptr = (info3->defaultdatatype.buffer!=NULL)?1:0;
5358 init_unistr2_from_unistr(&inf->name, &info3->name);
5359 init_unistr2_from_unistr(&inf->environment, &info3->architecture);
5360 init_unistr2_from_unistr(&inf->driverpath, &info3->driverpath);
5361 init_unistr2_from_unistr(&inf->datafile, &info3->datafile);
5362 init_unistr2_from_unistr(&inf->configfile, &info3->configfile);
5363 init_unistr2_from_unistr(&inf->helpfile, &info3->helpfile);
5364 init_unistr2_from_unistr(&inf->monitorname, &info3->monitorname);
5365 init_unistr2_from_unistr(&inf->defaultdatatype, &info3->defaultdatatype);
5372 /* the null_char BOOL is used to help locate
5373 two '\0's back to back */
5388 inf->dependentfiles_ptr = (info3->dependentfiles != NULL) ? 1 : 0;
5389 inf->dependentfilessize = len;
5390 if(!make_spoolss_buffer5(mem_ctx, &inf->dependentfiles, len, info3->dependentfiles))
5396 *spool_drv_info = inf;
5401 /*******************************************************************
5402 make a BUFFER5 struct from a uint16*
5403 ******************************************************************/
5404 BOOL make_spoolss_buffer5(TALLOC_CTX *mem_ctx, BUFFER5 *buf5, uint32 len, uint16 *src)
5407 buf5->buf_len = len;
5408 if((buf5->buffer=(uint16*)talloc_memdup(mem_ctx, src, sizeof(uint16)*len)) == NULL)
5410 DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
5417 /*******************************************************************
5418 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
5419 ********************************************************************/
5421 BOOL spoolss_io_q_addprinterdriver(char *desc, SPOOL_Q_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
5423 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriver");
5429 if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
5431 if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
5436 if(!prs_uint32("info_level", ps, depth, &q_u->level))
5439 if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
5445 /*******************************************************************
5446 ********************************************************************/
5448 BOOL spoolss_io_r_addprinterdriver(char *desc, SPOOL_R_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
5450 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriver");
5453 if(!prs_werror("status", ps, depth, &q_u->status))
5459 /*******************************************************************
5460 fill in the prs_struct for a ADDPRINTERDRIVER request PDU
5461 ********************************************************************/
5463 BOOL spoolss_io_q_addprinterdriverex(char *desc, SPOOL_Q_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
5465 prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriverex");
5471 if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
5473 if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
5478 if(!prs_uint32("info_level", ps, depth, &q_u->level))
5481 if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
5486 if(!prs_uint32("copy flags", ps, depth, &q_u->copy_flags))
5492 /*******************************************************************
5493 ********************************************************************/
5495 BOOL spoolss_io_r_addprinterdriverex(char *desc, SPOOL_R_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
5497 prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriverex");
5500 if(!prs_werror("status", ps, depth, &q_u->status))
5506 /*******************************************************************
5507 ********************************************************************/
5509 BOOL uni_2_asc_printer_driver_3(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *uni,
5510 NT_PRINTER_DRIVER_INFO_LEVEL_3 **asc)
5512 NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
5514 DEBUG(7,("uni_2_asc_printer_driver_3: Converting from UNICODE to ASCII\n"));
5518 *asc=(NT_PRINTER_DRIVER_INFO_LEVEL_3 *)malloc(sizeof(NT_PRINTER_DRIVER_INFO_LEVEL_3));
5526 d->cversion=uni->cversion;
5528 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name)-1);
5529 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment)-1);
5530 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath)-1);
5531 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile)-1);
5532 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile)-1);
5533 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile)-1);
5534 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname)-1);
5535 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype)-1);
5537 DEBUGADD(8,( "version: %d\n", d->cversion));
5538 DEBUGADD(8,( "name: %s\n", d->name));
5539 DEBUGADD(8,( "environment: %s\n", d->environment));
5540 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
5541 DEBUGADD(8,( "datafile: %s\n", d->datafile));
5542 DEBUGADD(8,( "configfile: %s\n", d->configfile));
5543 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
5544 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
5545 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5547 if (uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5554 /*******************************************************************
5555 ********************************************************************/
5556 BOOL uni_2_asc_printer_driver_6(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *uni,
5557 NT_PRINTER_DRIVER_INFO_LEVEL_6 **asc)
5559 NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
5561 DEBUG(7,("uni_2_asc_printer_driver_6: Converting from UNICODE to ASCII\n"));
5565 *asc=(NT_PRINTER_DRIVER_INFO_LEVEL_6 *)malloc(sizeof(NT_PRINTER_DRIVER_INFO_LEVEL_6));
5573 d->version=uni->version;
5575 unistr2_to_ascii(d->name, &uni->name, sizeof(d->name)-1);
5576 unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment)-1);
5577 unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath)-1);
5578 unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile)-1);
5579 unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile)-1);
5580 unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile)-1);
5581 unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname)-1);
5582 unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype)-1);
5584 DEBUGADD(8,( "version: %d\n", d->version));
5585 DEBUGADD(8,( "name: %s\n", d->name));
5586 DEBUGADD(8,( "environment: %s\n", d->environment));
5587 DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
5588 DEBUGADD(8,( "datafile: %s\n", d->datafile));
5589 DEBUGADD(8,( "configfile: %s\n", d->configfile));
5590 DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
5591 DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
5592 DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5594 if (!uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5596 if (!uniarray_2_dosarray(&uni->previousnames, &d->previousnames ))
5606 BOOL uni_2_asc_printer_info_2(const SPOOL_PRINTER_INFO_LEVEL_2 *uni,
5607 NT_PRINTER_INFO_LEVEL_2 **asc)
5609 NT_PRINTER_INFO_LEVEL_2 *d;
5612 DEBUG(7,("Converting from UNICODE to ASCII\n"));
5613 time_unix=time(NULL);
5616 DEBUGADD(8,("allocating memory\n"));
5618 *asc=(NT_PRINTER_INFO_LEVEL_2 *)malloc(sizeof(NT_PRINTER_INFO_LEVEL_2));
5623 /* we allocate memory iff called from
5624 * addprinter(ex) so we can do one time stuff here.
5626 (*asc)->setuptime=time_unix;
5629 DEBUGADD(8,("start converting\n"));
5633 d->attributes=uni->attributes;
5634 d->priority=uni->priority;
5635 d->default_priority=uni->default_priority;
5636 d->starttime=uni->starttime;
5637 d->untiltime=uni->untiltime;
5638 d->status=uni->status;
5639 d->cjobs=uni->cjobs;
5641 unistr2_to_ascii(d->servername, &uni->servername, sizeof(d->servername)-1);
5642 unistr2_to_ascii(d->printername, &uni->printername, sizeof(d->printername)-1);
5643 unistr2_to_ascii(d->sharename, &uni->sharename, sizeof(d->sharename)-1);
5644 unistr2_to_ascii(d->portname, &uni->portname, sizeof(d->portname)-1);
5645 unistr2_to_ascii(d->drivername, &uni->drivername, sizeof(d->drivername)-1);
5646 unistr2_to_ascii(d->comment, &uni->comment, sizeof(d->comment)-1);
5647 unistr2_to_ascii(d->location, &uni->location, sizeof(d->location)-1);
5648 unistr2_to_ascii(d->sepfile, &uni->sepfile, sizeof(d->sepfile)-1);
5649 unistr2_to_ascii(d->printprocessor, &uni->printprocessor, sizeof(d->printprocessor)-1);
5650 unistr2_to_ascii(d->datatype, &uni->datatype, sizeof(d->datatype)-1);
5651 unistr2_to_ascii(d->parameters, &uni->parameters, sizeof(d->parameters)-1);
5656 /*******************************************************************
5658 ********************************************************************/
5660 BOOL make_spoolss_q_getprinterdriverdir(SPOOL_Q_GETPRINTERDRIVERDIR *q_u,
5661 fstring servername, fstring env_name, uint32 level,
5662 NEW_BUFFER *buffer, uint32 offered)
5664 init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
5665 init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, env_name);
5669 q_u->offered=offered;
5674 /*******************************************************************
5675 Parse a SPOOL_Q_GETPRINTERDRIVERDIR structure.
5676 ********************************************************************/
5678 BOOL spoolss_io_q_getprinterdriverdir(char *desc, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, prs_struct *ps, int depth)
5680 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriverdir");
5685 if(!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5687 if(!smb_io_unistr2("", &q_u->name, q_u->name_ptr, ps, depth))
5693 if(!prs_uint32("", ps, depth, &q_u->environment_ptr))
5695 if(!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5701 if(!prs_uint32("level", ps, depth, &q_u->level))
5704 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
5710 if(!prs_uint32("offered", ps, depth, &q_u->offered))
5716 /*******************************************************************
5717 Parse a SPOOL_R_GETPRINTERDRIVERDIR structure.
5718 ********************************************************************/
5720 BOOL spoolss_io_r_getprinterdriverdir(char *desc, SPOOL_R_GETPRINTERDRIVERDIR *r_u, prs_struct *ps, int depth)
5722 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriverdir");
5728 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
5734 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5737 if (!prs_werror("status", ps, depth, &r_u->status))
5743 /*******************************************************************
5744 ********************************************************************/
5746 BOOL spoolss_io_r_enumprintprocessors(char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
5748 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
5754 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
5760 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5763 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5766 if (!prs_werror("status", ps, depth, &r_u->status))
5772 /*******************************************************************
5773 ********************************************************************/
5775 BOOL spoolss_io_q_enumprintprocessors(char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
5777 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
5783 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5785 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5791 if (!prs_uint32("", ps, depth, &q_u->environment_ptr))
5793 if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5799 if (!prs_uint32("level", ps, depth, &q_u->level))
5802 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
5808 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5814 /*******************************************************************
5815 ********************************************************************/
5817 BOOL spoolss_io_q_addprintprocessor(char *desc, SPOOL_Q_ADDPRINTPROCESSOR *q_u, prs_struct *ps, int depth)
5819 prs_debug(ps, depth, desc, "spoolss_io_q_addprintprocessor");
5825 if (!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
5827 if (!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
5832 if (!smb_io_unistr2("environment", &q_u->environment, True, ps, depth))
5837 if (!smb_io_unistr2("path", &q_u->path, True, ps, depth))
5842 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5848 /*******************************************************************
5849 ********************************************************************/
5851 BOOL spoolss_io_r_addprintprocessor(char *desc, SPOOL_R_ADDPRINTPROCESSOR *r_u, prs_struct *ps, int depth)
5853 prs_debug(ps, depth, desc, "spoolss_io_r_addprintproicessor");
5859 if (!prs_werror("status", ps, depth, &r_u->status))
5865 /*******************************************************************
5866 ********************************************************************/
5868 BOOL spoolss_io_r_enumprintprocdatatypes(char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u, prs_struct *ps, int depth)
5870 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes");
5876 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
5882 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5885 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5888 if (!prs_werror("status", ps, depth, &r_u->status))
5894 /*******************************************************************
5895 ********************************************************************/
5897 BOOL spoolss_io_q_enumprintprocdatatypes(char *desc, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, prs_struct *ps, int depth)
5899 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocdatatypes");
5905 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5907 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5913 if (!prs_uint32("processor_ptr", ps, depth, &q_u->processor_ptr))
5915 if (!smb_io_unistr2("processor", &q_u->processor, q_u->processor_ptr, ps, depth))
5921 if (!prs_uint32("level", ps, depth, &q_u->level))
5924 if(!spoolss_io_buffer("buffer", ps, depth, &q_u->buffer))
5930 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5936 /*******************************************************************
5937 Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
5938 ********************************************************************/
5940 BOOL spoolss_io_q_enumprintmonitors(char *desc, SPOOL_Q_ENUMPRINTMONITORS *q_u, prs_struct *ps, int depth)
5942 prs_debug(ps, depth, desc, "spoolss_io_q_enumprintmonitors");
5948 if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5950 if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5956 if (!prs_uint32("level", ps, depth, &q_u->level))
5959 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
5965 if (!prs_uint32("offered", ps, depth, &q_u->offered))
5971 /*******************************************************************
5972 ********************************************************************/
5974 BOOL spoolss_io_r_enumprintmonitors(char *desc, SPOOL_R_ENUMPRINTMONITORS *r_u, prs_struct *ps, int depth)
5976 prs_debug(ps, depth, desc, "spoolss_io_r_enumprintmonitors");
5982 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
5988 if (!prs_uint32("needed", ps, depth, &r_u->needed))
5991 if (!prs_uint32("returned", ps, depth, &r_u->returned))
5994 if (!prs_werror("status", ps, depth, &r_u->status))
6000 /*******************************************************************
6001 ********************************************************************/
6003 BOOL spoolss_io_r_enumprinterdata(char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth)
6005 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata");
6010 if(!prs_uint32("valuesize", ps, depth, &r_u->valuesize))
6013 if (UNMARSHALLING(ps) && r_u->valuesize) {
6014 r_u->value = (uint16 *)prs_alloc_mem(ps, r_u->valuesize * 2);
6016 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata value\n"));
6021 if(!prs_uint16uni(False, "value", ps, depth, r_u->value, r_u->valuesize ))
6027 if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
6030 if(!prs_uint32("type", ps, depth, &r_u->type))
6033 if(!prs_uint32("datasize", ps, depth, &r_u->datasize))
6036 if (UNMARSHALLING(ps) && r_u->datasize) {
6037 r_u->data = (uint8 *)prs_alloc_mem(ps, r_u->datasize);
6039 DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata data\n"));
6044 if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
6049 if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
6051 if(!prs_werror("status", ps, depth, &r_u->status))
6057 /*******************************************************************
6058 ********************************************************************/
6060 BOOL spoolss_io_q_enumprinterdata(char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
6062 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
6067 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6069 if(!prs_uint32("index", ps, depth, &q_u->index))
6071 if(!prs_uint32("valuesize", ps, depth, &q_u->valuesize))
6073 if(!prs_uint32("datasize", ps, depth, &q_u->datasize))
6079 /*******************************************************************
6080 ********************************************************************/
6082 BOOL make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u,
6083 const POLICY_HND *hnd,
6084 uint32 idx, uint32 valuelen, uint32 datalen)
6086 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6088 q_u->valuesize=valuelen;
6089 q_u->datasize=datalen;
6094 /*******************************************************************
6095 ********************************************************************/
6097 BOOL make_spoolss_q_enumprinterdataex(SPOOL_Q_ENUMPRINTERDATAEX *q_u,
6098 const POLICY_HND *hnd, char *key,
6101 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6102 init_unistr2(&q_u->key, key, strlen(key)+1);
6108 /*******************************************************************
6109 ********************************************************************/
6110 BOOL make_spoolss_q_setprinterdata(SPOOL_Q_SETPRINTERDATA *q_u, const POLICY_HND *hnd,
6111 char* value, uint32 data_type, char* data, uint32 data_size)
6113 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6114 q_u->type = data_type;
6115 init_unistr2(&q_u->value, value, strlen(value)+1);
6117 q_u->max_len = q_u->real_len = data_size;
6123 /*******************************************************************
6124 ********************************************************************/
6125 BOOL make_spoolss_q_setprinterdataex(SPOOL_Q_SETPRINTERDATAEX *q_u, const POLICY_HND *hnd,
6126 char *key, char* value, uint32 data_type, char* data,
6129 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6130 q_u->type = data_type;
6131 init_unistr2(&q_u->value, value, strlen(value)+1);
6132 init_unistr2(&q_u->key, key, strlen(key)+1);
6134 q_u->max_len = q_u->real_len = data_size;
6140 /*******************************************************************
6141 ********************************************************************/
6143 BOOL spoolss_io_q_setprinterdata(char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
6145 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
6150 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6152 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
6158 if(!prs_uint32("type", ps, depth, &q_u->type))
6161 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
6171 if (UNMARSHALLING(ps))
6172 q_u->data=(uint8 *)prs_alloc_mem(ps, q_u->max_len * sizeof(uint8));
6173 if(q_u->data == NULL)
6175 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
6183 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
6189 /*******************************************************************
6190 ********************************************************************/
6192 BOOL spoolss_io_r_setprinterdata(char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
6194 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
6199 if(!prs_werror("status", ps, depth, &r_u->status))
6205 /*******************************************************************
6206 ********************************************************************/
6207 BOOL spoolss_io_q_resetprinter(char *desc, SPOOL_Q_RESETPRINTER *q_u, prs_struct *ps, int depth)
6209 prs_debug(ps, depth, desc, "spoolss_io_q_resetprinter");
6214 if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6217 if (!prs_uint32("datatype_ptr", ps, depth, &q_u->datatype_ptr))
6220 if (q_u->datatype_ptr) {
6221 if (!smb_io_unistr2("datatype", &q_u->datatype, q_u->datatype_ptr?True:False, ps, depth))
6225 if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
6232 /*******************************************************************
6233 ********************************************************************/
6234 BOOL spoolss_io_r_resetprinter(char *desc, SPOOL_R_RESETPRINTER *r_u, prs_struct *ps, int depth)
6236 prs_debug(ps, depth, desc, "spoolss_io_r_resetprinter");
6241 if(!prs_werror("status", ps, depth, &r_u->status))
6247 /*******************************************************************
6248 ********************************************************************/
6250 static BOOL spoolss_io_addform(char *desc, FORM *f, uint32 ptr, prs_struct *ps, int depth)
6252 prs_debug(ps, depth, desc, "spoolss_io_addform");
6259 if(!prs_uint32("flags", ps, depth, &f->flags))
6261 if(!prs_uint32("name_ptr", ps, depth, &f->name_ptr))
6263 if(!prs_uint32("size_x", ps, depth, &f->size_x))
6265 if(!prs_uint32("size_y", ps, depth, &f->size_y))
6267 if(!prs_uint32("left", ps, depth, &f->left))
6269 if(!prs_uint32("top", ps, depth, &f->top))
6271 if(!prs_uint32("right", ps, depth, &f->right))
6273 if(!prs_uint32("bottom", ps, depth, &f->bottom))
6276 if(!smb_io_unistr2("", &f->name, f->name_ptr, ps, depth))
6283 /*******************************************************************
6284 ********************************************************************/
6286 BOOL spoolss_io_q_deleteform(char *desc, SPOOL_Q_DELETEFORM *q_u, prs_struct *ps, int depth)
6288 prs_debug(ps, depth, desc, "spoolss_io_q_deleteform");
6293 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6295 if(!smb_io_unistr2("form name", &q_u->name, True, ps, depth))
6301 /*******************************************************************
6302 ********************************************************************/
6304 BOOL spoolss_io_r_deleteform(char *desc, SPOOL_R_DELETEFORM *r_u, prs_struct *ps, int depth)
6306 prs_debug(ps, depth, desc, "spoolss_io_r_deleteform");
6311 if(!prs_werror("status", ps, depth, &r_u->status))
6317 /*******************************************************************
6318 ********************************************************************/
6320 BOOL spoolss_io_q_addform(char *desc, SPOOL_Q_ADDFORM *q_u, prs_struct *ps, int depth)
6322 uint32 useless_ptr=1;
6323 prs_debug(ps, depth, desc, "spoolss_io_q_addform");
6328 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6330 if(!prs_uint32("level", ps, depth, &q_u->level))
6332 if(!prs_uint32("level2", ps, depth, &q_u->level2))
6337 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
6339 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
6346 /*******************************************************************
6347 ********************************************************************/
6349 BOOL spoolss_io_r_addform(char *desc, SPOOL_R_ADDFORM *r_u, prs_struct *ps, int depth)
6351 prs_debug(ps, depth, desc, "spoolss_io_r_addform");
6356 if(!prs_werror("status", ps, depth, &r_u->status))
6362 /*******************************************************************
6363 ********************************************************************/
6365 BOOL spoolss_io_q_setform(char *desc, SPOOL_Q_SETFORM *q_u, prs_struct *ps, int depth)
6367 uint32 useless_ptr=1;
6368 prs_debug(ps, depth, desc, "spoolss_io_q_setform");
6373 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6375 if(!smb_io_unistr2("", &q_u->name, True, ps, depth))
6381 if(!prs_uint32("level", ps, depth, &q_u->level))
6383 if(!prs_uint32("level2", ps, depth, &q_u->level2))
6388 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
6390 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
6397 /*******************************************************************
6398 ********************************************************************/
6400 BOOL spoolss_io_r_setform(char *desc, SPOOL_R_SETFORM *r_u, prs_struct *ps, int depth)
6402 prs_debug(ps, depth, desc, "spoolss_io_r_setform");
6407 if(!prs_werror("status", ps, depth, &r_u->status))
6413 /*******************************************************************
6414 Parse a SPOOL_R_GETJOB structure.
6415 ********************************************************************/
6417 BOOL spoolss_io_r_getjob(char *desc, SPOOL_R_GETJOB *r_u, prs_struct *ps, int depth)
6419 prs_debug(ps, depth, desc, "spoolss_io_r_getjob");
6425 if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
6431 if (!prs_uint32("needed", ps, depth, &r_u->needed))
6434 if (!prs_werror("status", ps, depth, &r_u->status))
6440 /*******************************************************************
6441 Parse a SPOOL_Q_GETJOB structure.
6442 ********************************************************************/
6444 BOOL spoolss_io_q_getjob(char *desc, SPOOL_Q_GETJOB *q_u, prs_struct *ps, int depth)
6446 prs_debug(ps, depth, desc, "");
6452 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6454 if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
6456 if(!prs_uint32("level", ps, depth, &q_u->level))
6459 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
6465 if(!prs_uint32("offered", ps, depth, &q_u->offered))
6471 void free_devmode(DEVICEMODE *devmode)
6473 if (devmode!=NULL) {
6474 SAFE_FREE(devmode->private);
6479 void free_printer_info_1(PRINTER_INFO_1 *printer)
6484 void free_printer_info_2(PRINTER_INFO_2 *printer)
6486 if (printer!=NULL) {
6487 free_devmode(printer->devmode);
6488 printer->devmode = NULL;
6493 void free_printer_info_3(PRINTER_INFO_3 *printer)
6498 void free_printer_info_4(PRINTER_INFO_4 *printer)
6503 void free_printer_info_5(PRINTER_INFO_5 *printer)
6508 void free_job_info_2(JOB_INFO_2 *job)
6511 free_devmode(job->devmode);
6514 /*******************************************************************
6516 ********************************************************************/
6518 BOOL make_spoolss_q_replyopenprinter(SPOOL_Q_REPLYOPENPRINTER *q_u,
6519 const fstring string, uint32 printer, uint32 type)
6524 init_unistr2(&q_u->string, string, strlen(string)+1);
6526 q_u->printer=printer;
6535 /*******************************************************************
6536 Parse a SPOOL_Q_REPLYOPENPRINTER structure.
6537 ********************************************************************/
6539 BOOL spoolss_io_q_replyopenprinter(char *desc, SPOOL_Q_REPLYOPENPRINTER *q_u, prs_struct *ps, int depth)
6541 prs_debug(ps, depth, desc, "spoolss_io_q_replyopenprinter");
6547 if(!smb_io_unistr2("", &q_u->string, True, ps, depth))
6553 if(!prs_uint32("printer", ps, depth, &q_u->printer))
6555 if(!prs_uint32("type", ps, depth, &q_u->type))
6558 if(!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6560 if(!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6566 /*******************************************************************
6567 Parse a SPOOL_R_REPLYOPENPRINTER structure.
6568 ********************************************************************/
6570 BOOL spoolss_io_r_replyopenprinter(char *desc, SPOOL_R_REPLYOPENPRINTER *r_u, prs_struct *ps, int depth)
6572 prs_debug(ps, depth, desc, "spoolss_io_r_replyopenprinter");
6578 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6581 if (!prs_werror("status", ps, depth, &r_u->status))
6587 /*******************************************************************
6589 ********************************************************************/
6590 BOOL make_spoolss_q_routerreplyprinter(SPOOL_Q_ROUTERREPLYPRINTER *q_u, POLICY_HND *hnd,
6591 uint32 condition, uint32 change_id)
6594 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6596 q_u->condition = condition;
6597 q_u->change_id = change_id;
6600 q_u->unknown1 = 0x1;
6601 memset(q_u->unknown2, 0x0, 5);
6602 q_u->unknown2[0] = 0x1;
6607 /*******************************************************************
6608 Parse a SPOOL_Q_ROUTERREPLYPRINTER structure.
6609 ********************************************************************/
6610 BOOL spoolss_io_q_routerreplyprinter (char *desc, SPOOL_Q_ROUTERREPLYPRINTER *q_u, prs_struct *ps, int depth)
6613 prs_debug(ps, depth, desc, "spoolss_io_q_routerreplyprinter");
6619 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6622 if (!prs_uint32("condition", ps, depth, &q_u->condition))
6625 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6628 if (!prs_uint32("change_id", ps, depth, &q_u->change_id))
6631 if (!prs_uint8s(False, "private", ps, depth, q_u->unknown2, 5))
6637 /*******************************************************************
6638 Parse a SPOOL_R_ROUTERREPLYPRINTER structure.
6639 ********************************************************************/
6640 BOOL spoolss_io_r_routerreplyprinter (char *desc, SPOOL_R_ROUTERREPLYPRINTER *r_u, prs_struct *ps, int depth)
6642 prs_debug(ps, depth, desc, "spoolss_io_r_routerreplyprinter");
6648 if (!prs_werror("status", ps, depth, &r_u->status))
6654 /*******************************************************************
6656 ********************************************************************/
6658 BOOL make_spoolss_q_reply_closeprinter(SPOOL_Q_REPLYCLOSEPRINTER *q_u, POLICY_HND *hnd)
6663 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6668 /*******************************************************************
6669 Parse a SPOOL_Q_REPLYCLOSEPRINTER structure.
6670 ********************************************************************/
6672 BOOL spoolss_io_q_replycloseprinter(char *desc, SPOOL_Q_REPLYCLOSEPRINTER *q_u, prs_struct *ps, int depth)
6674 prs_debug(ps, depth, desc, "spoolss_io_q_replycloseprinter");
6680 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6686 /*******************************************************************
6687 Parse a SPOOL_R_REPLYCLOSEPRINTER structure.
6688 ********************************************************************/
6690 BOOL spoolss_io_r_replycloseprinter(char *desc, SPOOL_R_REPLYCLOSEPRINTER *r_u, prs_struct *ps, int depth)
6692 prs_debug(ps, depth, desc, "spoolss_io_r_replycloseprinter");
6698 if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6701 if (!prs_werror("status", ps, depth, &r_u->status))
6707 #if 0 /* JERRY - not currently used but could be :-) */
6709 /*******************************************************************
6710 Deep copy a SPOOL_NOTIFY_INFO_DATA structure
6711 ******************************************************************/
6712 static BOOL copy_spool_notify_info_data(SPOOL_NOTIFY_INFO_DATA *dst,
6713 SPOOL_NOTIFY_INFO_DATA *src, int n)
6717 memcpy(dst, src, sizeof(SPOOL_NOTIFY_INFO_DATA)*n);
6719 for (i=0; i<n; i++) {
6723 if (src->size != POINTER)
6725 len = src->notify_data.data.length;
6726 s = malloc(sizeof(uint16)*len);
6728 DEBUG(0,("copy_spool_notify_info_data: malloc() failed!\n"));
6732 memcpy(s, src->notify_data.data.string, len*2);
6733 dst->notify_data.data.string = s;
6739 /*******************************************************************
6740 Deep copy a SPOOL_NOTIFY_INFO structure
6741 ******************************************************************/
6742 static BOOL copy_spool_notify_info(SPOOL_NOTIFY_INFO *dst, SPOOL_NOTIFY_INFO *src)
6745 DEBUG(0,("copy_spool_notify_info: NULL destination pointer!\n"));
6749 dst->version = src->version;
6750 dst->flags = src->flags;
6751 dst->count = src->count;
6755 dst->data = malloc(dst->count * sizeof(SPOOL_NOTIFY_INFO_DATA));
6757 DEBUG(10,("copy_spool_notify_info: allocating space for [%d] PRINTER_NOTIFY_INFO_DATA entries\n",
6760 if (dst->data == NULL) {
6761 DEBUG(0,("copy_spool_notify_info: malloc() failed for [%d] entries!\n",
6766 return (copy_spool_notify_info_data(dst->data, src->data, src->count));
6773 /*******************************************************************
6775 ********************************************************************/
6777 BOOL make_spoolss_q_reply_rrpcn(SPOOL_Q_REPLY_RRPCN *q_u, POLICY_HND *hnd,
6778 uint32 change_low, uint32 change_high,
6779 SPOOL_NOTIFY_INFO *info)
6784 memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6786 q_u->change_low=change_low;
6787 q_u->change_high=change_high;
6792 q_u->info_ptr=0x0FF0ADDE;
6794 q_u->info.version=2;
6797 DEBUG(10,("make_spoolss_q_reply_rrpcn: [%d] PRINTER_NOTIFY_INFO_DATA\n",
6799 q_u->info.version = info->version;
6800 q_u->info.flags = info->flags;
6801 q_u->info.count = info->count;
6802 /* pointer field - be careful! */
6803 q_u->info.data = info->data;
6806 q_u->info.flags=PRINTER_NOTIFY_INFO_DISCARDED;
6813 /*******************************************************************
6814 Parse a SPOOL_Q_REPLY_RRPCN structure.
6815 ********************************************************************/
6817 BOOL spoolss_io_q_reply_rrpcn(char *desc, SPOOL_Q_REPLY_RRPCN *q_u, prs_struct *ps, int depth)
6819 prs_debug(ps, depth, desc, "spoolss_io_q_reply_rrpcn");
6825 if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6828 if (!prs_uint32("change_low", ps, depth, &q_u->change_low))
6831 if (!prs_uint32("change_high", ps, depth, &q_u->change_high))
6834 if (!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6837 if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6840 if (!prs_uint32("info_ptr", ps, depth, &q_u->info_ptr))
6843 if(q_u->info_ptr!=0)
6844 if(!smb_io_notify_info(desc, &q_u->info, ps, depth))
6850 /*******************************************************************
6851 Parse a SPOOL_R_REPLY_RRPCN structure.
6852 ********************************************************************/
6854 BOOL spoolss_io_r_reply_rrpcn(char *desc, SPOOL_R_REPLY_RRPCN *r_u, prs_struct *ps, int depth)
6856 prs_debug(ps, depth, desc, "spoolss_io_r_reply_rrpcn");
6862 if (!prs_uint32("unknown0", ps, depth, &r_u->unknown0))
6865 if (!prs_werror("status", ps, depth, &r_u->status))
6871 /*******************************************************************
6873 * called from spoolss_q_getprinterdataex (srv_spoolss.c)
6874 ********************************************************************/
6876 BOOL spoolss_io_q_getprinterdataex(char *desc, SPOOL_Q_GETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6881 prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdataex");
6886 if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6890 if (!smb_io_unistr2("keyname", &q_u->keyname,True,ps,depth))
6894 if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
6898 if (!prs_uint32("size", ps, depth, &q_u->size))
6904 /*******************************************************************
6905 * write a structure.
6906 * called from spoolss_r_getprinterdataex (srv_spoolss.c)
6907 ********************************************************************/
6909 BOOL spoolss_io_r_getprinterdataex(char *desc, SPOOL_R_GETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6914 prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdataex");
6919 if (!prs_uint32("type", ps, depth, &r_u->type))
6921 if (!prs_uint32("size", ps, depth, &r_u->size))
6924 if (UNMARSHALLING(ps) && r_u->size) {
6925 r_u->data = prs_alloc_mem(ps, r_u->size);
6930 if (!prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size))
6936 if (!prs_uint32("needed", ps, depth, &r_u->needed))
6938 if (!prs_werror("status", ps, depth, &r_u->status))
6944 /*******************************************************************
6946 ********************************************************************/
6948 BOOL spoolss_io_q_setprinterdataex(char *desc, SPOOL_Q_SETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6950 prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdataex");
6955 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6957 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6963 if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
6969 if(!prs_uint32("type", ps, depth, &q_u->type))
6972 if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
6982 if (UNMARSHALLING(ps))
6983 q_u->data=(uint8 *)prs_alloc_mem(ps, q_u->max_len * sizeof(uint8));
6984 if(q_u->data == NULL)
6986 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
6994 if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
7000 /*******************************************************************
7001 * write a structure.
7002 ********************************************************************/
7004 BOOL spoolss_io_r_setprinterdataex(char *desc, SPOOL_R_SETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
7006 prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdataex");
7011 if(!prs_werror("status", ps, depth, &r_u->status))
7018 /*******************************************************************
7020 ********************************************************************/
7022 BOOL spoolss_io_q_enumprinterkey(char *desc, SPOOL_Q_ENUMPRINTERKEY *q_u, prs_struct *ps, int depth)
7024 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterkey");
7029 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
7032 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
7038 if(!prs_uint32("size", ps, depth, &q_u->size))
7044 /*******************************************************************
7045 * write a structure.
7046 ********************************************************************/
7048 BOOL spoolss_io_r_enumprinterkey(char *desc, SPOOL_R_ENUMPRINTERKEY *r_u, prs_struct *ps, int depth)
7050 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterkey");
7056 if (!smb_io_buffer5("", &r_u->keys, ps, depth))
7062 if(!prs_uint32("needed", ps, depth, &r_u->needed))
7065 if(!prs_werror("status", ps, depth, &r_u->status))
7071 /*******************************************************************
7073 ********************************************************************/
7075 BOOL spoolss_io_q_deleteprinterkey(char *desc, SPOOL_Q_DELETEPRINTERKEY *q_u, prs_struct *ps, int depth)
7077 prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterkey");
7082 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
7085 if(!smb_io_unistr2("", &q_u->keyname, True, ps, depth))
7091 /*******************************************************************
7092 * write a structure.
7093 ********************************************************************/
7095 BOOL spoolss_io_r_deleteprinterkey(char *desc, SPOOL_R_DELETEPRINTERKEY *r_u, prs_struct *ps, int depth)
7097 prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterkey");
7103 if(!prs_werror("status", ps, depth, &r_u->status))
7110 /*******************************************************************
7112 ********************************************************************/
7114 BOOL spoolss_io_q_enumprinterdataex(char *desc, SPOOL_Q_ENUMPRINTERDATAEX *q_u, prs_struct *ps, int depth)
7116 prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdataex");
7121 if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
7124 if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
7130 if(!prs_uint32("size", ps, depth, &q_u->size))
7136 /*******************************************************************
7137 ********************************************************************/
7139 static BOOL spoolss_io_printer_enum_values_ctr(char *desc, prs_struct *ps,
7140 PRINTER_ENUM_VALUES_CTR *ctr, int depth)
7143 uint32 valuename_offset,
7146 const uint32 basic_unit = 20; /* size of static portion of enum_values */
7148 prs_debug(ps, depth, desc, "spoolss_io_printer_enum_values_ctr");
7152 * offset data begins at 20 bytes per structure * size_of_array.
7153 * Don't forget the uint32 at the beginning
7156 current_offset = basic_unit * ctr->size_of_array;
7158 /* first loop to write basic enum_value information */
7160 if (UNMARSHALLING(ps)) {
7161 ctr->values = (PRINTER_ENUM_VALUES *)prs_alloc_mem(
7162 ps, ctr->size_of_array * sizeof(PRINTER_ENUM_VALUES));
7167 for (i=0; i<ctr->size_of_array; i++) {
7168 valuename_offset = current_offset;
7169 if (!prs_uint32("valuename_offset", ps, depth, &valuename_offset))
7172 if (!prs_uint32("value_len", ps, depth, &ctr->values[i].value_len))
7175 if (!prs_uint32("type", ps, depth, &ctr->values[i].type))
7178 data_offset = ctr->values[i].value_len + valuename_offset;
7180 if (!prs_uint32("data_offset", ps, depth, &data_offset))
7183 if (!prs_uint32("data_len", ps, depth, &ctr->values[i].data_len))
7186 current_offset = data_offset + ctr->values[i].data_len - basic_unit;
7187 /* account for 2 byte alignment */
7188 current_offset += (current_offset % 2);
7192 * loop #2 for writing the dynamically size objects; pay
7193 * attention to 2-byte alignment here....
7196 for (i=0; i<ctr->size_of_array; i++) {
7198 if (!prs_unistr("valuename", ps, depth, &ctr->values[i].valuename))
7201 if (UNMARSHALLING(ps)) {
7202 ctr->values[i].data = (uint8 *)prs_alloc_mem(
7203 ps, ctr->values[i].data_len);
7204 if (!ctr->values[i].data)
7208 if (!prs_uint8s(False, "data", ps, depth, ctr->values[i].data, ctr->values[i].data_len))
7211 if ( !prs_align_uint16(ps) )
7218 /*******************************************************************
7219 * write a structure.
7220 ********************************************************************/
7222 BOOL spoolss_io_r_enumprinterdataex(char *desc, SPOOL_R_ENUMPRINTERDATAEX *r_u, prs_struct *ps, int depth)
7224 uint32 data_offset, end_offset;
7225 prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdataex");
7231 if (!prs_uint32("size", ps, depth, &r_u->ctr.size))
7234 data_offset = prs_offset(ps);
7236 if (!prs_set_offset(ps, data_offset + r_u->ctr.size))
7242 if(!prs_uint32("needed", ps, depth, &r_u->needed))
7245 if(!prs_uint32("returned", ps, depth, &r_u->returned))
7248 if(!prs_werror("status", ps, depth, &r_u->status))
7251 r_u->ctr.size_of_array = r_u->returned;
7253 end_offset = prs_offset(ps);
7255 if (!prs_set_offset(ps, data_offset))
7259 if (!spoolss_io_printer_enum_values_ctr("", ps, &r_u->ctr, depth ))
7262 if (!prs_set_offset(ps, end_offset))
7267 /*******************************************************************
7268 * write a structure.
7269 ********************************************************************/
7272 uint32 GetPrintProcessorDirectory(
7274 [in] unistr2 *environment,
7276 [in,out] NEW_BUFFER buffer,
7277 [in] uint32 offered,
7278 [out] uint32 needed,
7279 [out] uint32 returned
7284 BOOL make_spoolss_q_getprintprocessordirectory(SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, const char *name, char *environment, int level, NEW_BUFFER *buffer, uint32 offered)
7286 DEBUG(5,("make_spoolss_q_getprintprocessordirectory\n"));
7288 init_unistr2(&q_u->name, name, strlen(name)+1);
7289 init_unistr2(&q_u->environment, environment, strlen(environment)+1);
7293 q_u->buffer = buffer;
7294 q_u->offered = offered;
7299 BOOL spoolss_io_q_getprintprocessordirectory(char *desc, SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, prs_struct *ps, int depth)
7303 prs_debug(ps, depth, desc, "spoolss_io_q_getprintprocessordirectory");
7309 if (!prs_uint32("ptr", ps, depth, &ptr))
7313 if(!smb_io_unistr2("name", &q_u->name, True, ps, depth))
7320 if (!prs_uint32("ptr", ps, depth, &ptr))
7324 if(!smb_io_unistr2("environment", &q_u->environment, True,
7332 if(!prs_uint32("level", ps, depth, &q_u->level))
7335 if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
7341 if(!prs_uint32("offered", ps, depth, &q_u->offered))
7347 /*******************************************************************
7348 * write a structure.
7349 ********************************************************************/
7351 BOOL spoolss_io_r_getprintprocessordirectory(char *desc, SPOOL_R_GETPRINTPROCESSORDIRECTORY *r_u, prs_struct *ps, int depth)
7353 prs_debug(ps, depth, desc, "spoolss_io_r_getprintprocessordirectory");
7359 if(!spoolss_io_buffer("", ps, depth, &r_u->buffer))
7365 if(!prs_uint32("needed", ps, depth, &r_u->needed))
7368 if(!prs_werror("status", ps, depth, &r_u->status))
7374 BOOL smb_io_printprocessordirectory_1(char *desc, NEW_BUFFER *buffer, PRINTPROCESSOR_DIRECTORY_1 *info, int depth)
7376 prs_struct *ps=&buffer->prs;
7378 prs_debug(ps, depth, desc, "smb_io_printprocessordirectory_1");
7381 buffer->struct_start=prs_offset(ps);
7383 if (!smb_io_unistr(desc, &info->name, ps, depth))
7389 /*******************************************************************
7391 ********************************************************************/
7393 BOOL make_spoolss_q_addform(SPOOL_Q_ADDFORM *q_u, POLICY_HND *handle,
7394 int level, FORM *form)
7396 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7398 q_u->level2 = level;
7399 memcpy(&q_u->form, form, sizeof(FORM));
7404 /*******************************************************************
7406 ********************************************************************/
7408 BOOL make_spoolss_q_setform(SPOOL_Q_SETFORM *q_u, POLICY_HND *handle,
7409 int level, char *form_name, FORM *form)
7411 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7413 q_u->level2 = level;
7414 memcpy(&q_u->form, form, sizeof(FORM));
7415 init_unistr2(&q_u->name, form_name, strlen(form_name) + 1);
7420 /*******************************************************************
7422 ********************************************************************/
7424 BOOL make_spoolss_q_deleteform(SPOOL_Q_DELETEFORM *q_u, POLICY_HND *handle, char *form)
7426 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7427 init_unistr2(&q_u->name, form, strlen(form) + 1);
7431 /*******************************************************************
7433 ********************************************************************/
7435 BOOL make_spoolss_q_getform(SPOOL_Q_GETFORM *q_u, POLICY_HND *handle,
7436 char *formname, uint32 level, NEW_BUFFER *buffer,
7439 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7441 init_unistr2(&q_u->formname, formname, strlen(formname) + 1);
7443 q_u->offered=offered;
7448 /*******************************************************************
7450 ********************************************************************/
7452 BOOL make_spoolss_q_enumforms(SPOOL_Q_ENUMFORMS *q_u, POLICY_HND *handle,
7453 uint32 level, NEW_BUFFER *buffer,
7456 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7459 q_u->offered=offered;
7464 /*******************************************************************
7466 ********************************************************************/
7468 BOOL make_spoolss_q_setjob(SPOOL_Q_SETJOB *q_u, POLICY_HND *handle,
7469 uint32 jobid, uint32 level, uint32 command)
7471 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7475 /* Hmm - the SPOOL_Q_SETJOB structure has a JOB_INFO ctr in it but
7476 the server side code has it marked as unused. */
7478 q_u->command = command;
7483 /*******************************************************************
7485 ********************************************************************/
7487 BOOL make_spoolss_q_getjob(SPOOL_Q_GETJOB *q_u, POLICY_HND *handle,
7488 uint32 jobid, uint32 level, NEW_BUFFER *buffer,
7491 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7494 q_u->buffer = buffer;
7495 q_u->offered = offered;
7500 /*******************************************************************
7502 ********************************************************************/
7504 BOOL make_spoolss_q_startpageprinter(SPOOL_Q_STARTPAGEPRINTER *q_u,
7507 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7512 /*******************************************************************
7514 ********************************************************************/
7516 BOOL make_spoolss_q_endpageprinter(SPOOL_Q_ENDPAGEPRINTER *q_u,
7519 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7524 /*******************************************************************
7526 ********************************************************************/
7528 BOOL make_spoolss_q_startdocprinter(SPOOL_Q_STARTDOCPRINTER *q_u,
7529 POLICY_HND *handle, uint32 level,
7530 char *docname, char *outputfile,
7533 DOC_INFO_CONTAINER *ctr = &q_u->doc_info_container;
7535 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7541 ctr->docinfo.switch_value = level;
7543 ctr->docinfo.doc_info_1.p_docname = docname ? 1 : 0;
7544 ctr->docinfo.doc_info_1.p_outputfile = outputfile ? 1 : 0;
7545 ctr->docinfo.doc_info_1.p_datatype = datatype ? 1 : 0;
7548 init_unistr2(&ctr->docinfo.doc_info_1.docname, docname,
7549 strlen(docname) + 1);
7552 init_unistr2(&ctr->docinfo.doc_info_1.outputfile, outputfile,
7553 strlen(outputfile) + 1);
7556 init_unistr2(&ctr->docinfo.doc_info_1.datatype, datatype,
7557 strlen(datatype) + 1);
7561 /* DOC_INFO_2 is only used by Windows 9x and since it
7562 doesn't do printing over RPC we don't have to worry
7565 DEBUG(3, ("unsupported info level %d\n", level));
7572 /*******************************************************************
7574 ********************************************************************/
7576 BOOL make_spoolss_q_enddocprinter(SPOOL_Q_ENDDOCPRINTER *q_u,
7579 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7584 /*******************************************************************
7586 ********************************************************************/
7588 BOOL make_spoolss_q_writeprinter(SPOOL_Q_WRITEPRINTER *q_u,
7589 POLICY_HND *handle, uint32 data_size,
7592 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7593 q_u->buffer_size = q_u->buffer_size2 = data_size;
7598 /*******************************************************************
7600 ********************************************************************/
7602 BOOL make_spoolss_q_deleteprinterdata(SPOOL_Q_DELETEPRINTERDATA *q_u,
7603 POLICY_HND *handle, char *valuename)
7605 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7606 init_unistr2(&q_u->valuename, valuename, strlen(valuename) + 1);
7611 /*******************************************************************
7613 ********************************************************************/
7615 BOOL make_spoolss_q_deleteprinterdataex(SPOOL_Q_DELETEPRINTERDATAEX *q_u,
7616 POLICY_HND *handle, char *key,
7619 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7620 init_unistr2(&q_u->valuename, value, strlen(value) + 1);
7621 init_unistr2(&q_u->keyname, key, strlen(key) + 1);
7626 /*******************************************************************
7628 ********************************************************************/
7630 BOOL make_spoolss_q_rffpcnex(SPOOL_Q_RFFPCNEX *q_u, POLICY_HND *handle,
7631 uint32 flags, uint32 options, char *localmachine,
7632 uint32 printerlocal, SPOOL_NOTIFY_OPTION *option)
7634 memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7637 q_u->options = options;
7639 q_u->localmachine_ptr = 1;
7641 init_unistr2(&q_u->localmachine, localmachine,
7642 strlen(localmachine) + 1);
7644 q_u->printerlocal = printerlocal;
7647 q_u->option_ptr = 1;
7649 q_u->option = option;