summaryrefslogtreecommitdiff
path: root/source3/rpc_parse
diff options
context:
space:
mode:
authorJean-François Micouleau <jfm@samba.org>2000-02-07 16:17:59 +0000
committerJean-François Micouleau <jfm@samba.org>2000-02-07 16:17:59 +0000
commit6a6749d81e892bb06bfdc0fefdc428e5e6599f71 (patch)
tree1422ec8d31fc4202f6b565015ac28dd6d0573158 /source3/rpc_parse
parent868c81eefa72b31023eeac32788eaa439013c0f8 (diff)
downloadsamba-6a6749d81e892bb06bfdc0fefdc428e5e6599f71.tar.gz
samba-6a6749d81e892bb06bfdc0fefdc428e5e6599f71.tar.bz2
samba-6a6749d81e892bb06bfdc0fefdc428e5e6599f71.zip
First commit of the spoolss code to the HEAD branch.
still needs a lot of cleaning/debuging. J.F. (This used to be commit bd9d4cdde9193c120c6f4e8cf72f87cd67a9387e)
Diffstat (limited to 'source3/rpc_parse')
-rw-r--r--source3/rpc_parse/parse_spoolss.c4806
1 files changed, 4806 insertions, 0 deletions
diff --git a/source3/rpc_parse/parse_spoolss.c b/source3/rpc_parse/parse_spoolss.c
new file mode 100644
index 0000000000..a6f72a3181
--- /dev/null
+++ b/source3/rpc_parse/parse_spoolss.c
@@ -0,0 +1,4806 @@
+/*
+ * Unix SMB/Netbios implementation.
+ * Version 1.9.
+ * RPC Pipe client / server routines
+ * Copyright (C) Andrew Tridgell 1992-2000,
+ * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
+ * Copyright (C) Jean François Micouleau 1998-2000.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include "includes.h"
+#include "nterr.h"
+
+extern int DEBUGLEVEL;
+/*******************************************************************
+return the length of a UNISTR string.
+********************************************************************/
+static uint32 str_len_uni(UNISTR *source)
+{
+ uint32 i=0;
+
+ while (source->buffer[i]!=0x0000)
+ {
+ i++;
+ }
+ return i;
+}
+
+/*******************************************************************
+This should be moved in a more generic lib.
+********************************************************************/
+static BOOL spoolss_io_system_time(char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
+{
+ prs_uint16("year", ps, depth, &(systime->year));
+ prs_uint16("month", ps, depth, &(systime->month));
+ prs_uint16("dayofweek", ps, depth, &(systime->dayofweek));
+ prs_uint16("day", ps, depth, &(systime->day));
+ prs_uint16("hour", ps, depth, &(systime->hour));
+ prs_uint16("minute", ps, depth, &(systime->minute));
+ prs_uint16("second", ps, depth, &(systime->second));
+ prs_uint16("milliseconds", ps, depth, &(systime->milliseconds));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
+{
+ systime->year=unixtime->tm_year+1900;
+ systime->month=unixtime->tm_mon+1;
+ systime->dayofweek=unixtime->tm_wday;
+ systime->day=unixtime->tm_mday;
+ systime->hour=unixtime->tm_hour;
+ systime->minute=unixtime->tm_min;
+ systime->second=unixtime->tm_sec;
+ systime->milliseconds=0;
+
+ return True;
+}
+
+/*******************************************************************
+reads or writes an POLICY_HND structure.
+********************************************************************/
+static BOOL smb_io_prt_hnd(char *desc, POLICY_HND *hnd, prs_struct *ps, int depth)
+{
+ if (hnd == NULL) return False;
+
+ prs_debug(ps, depth, desc, "smb_io_prt_hnd");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint8s (False, "data", ps, depth, hnd->data, POLICY_HND_SIZE);
+
+ return True;
+}
+
+/*******************************************************************
+reads or writes an DOC_INFO structure.
+********************************************************************/
+static BOOL smb_io_doc_info_1(char *desc, DOC_INFO_1 *info_1, prs_struct *ps, int depth)
+{
+ if (info_1 == NULL) return False;
+
+ prs_debug(ps, depth, desc, "smb_io_doc_info_1");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("p_docname", ps, depth, &(info_1->p_docname));
+ prs_uint32("p_outputfile", ps, depth, &(info_1->p_outputfile));
+ prs_uint32("p_datatype", ps, depth, &(info_1->p_datatype));
+
+ smb_io_unistr2("", &(info_1->docname), info_1->p_docname, ps, depth);
+ smb_io_unistr2("", &(info_1->outputfile), info_1->p_outputfile, ps, depth);
+ smb_io_unistr2("", &(info_1->datatype), info_1->p_datatype, ps, depth);
+
+ return True;
+}
+
+/*******************************************************************
+reads or writes an DOC_INFO structure.
+********************************************************************/
+static BOOL smb_io_doc_info(char *desc, DOC_INFO *info, prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0;
+
+ if (info == NULL) return False;
+
+ prs_debug(ps, depth, desc, "smb_io_doc_info");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("switch_value", ps, depth, &(info->switch_value));
+
+ prs_uint32("doc_info_X ptr", ps, depth, &(useless_ptr));
+
+ switch (info->switch_value)
+ {
+ case 1:
+ smb_io_doc_info_1("",&(info->doc_info_1), ps, depth);
+ break;
+ case 2:
+ /*
+ this is just a placeholder
+
+ MSDN July 1998 says doc_info_2 is only on
+ Windows 95, and as Win95 doesn't do RPC to print
+ this case is nearly impossible
+
+ Maybe one day with Windows for dishwasher 2037 ...
+
+ */
+ /* smb_io_doc_info_2("",&(info->doc_info_2), ps, depth); */
+ break;
+ default:
+ DEBUG(0,("Something is obviously wrong somewhere !\n"));
+ break;
+ }
+
+ return True;
+}
+
+/*******************************************************************
+reads or writes an DOC_INFO_CONTAINER structure.
+********************************************************************/
+static BOOL smb_io_doc_info_container(char *desc, DOC_INFO_CONTAINER *cont, prs_struct *ps, int depth)
+{
+ if (cont == NULL) return False;
+
+ prs_debug(ps, depth, desc, "smb_io_doc_info_container");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("level", ps, depth, &(cont->level));
+
+ smb_io_doc_info("",&(cont->docinfo), ps, depth);
+
+ return True;
+}
+
+/*******************************************************************
+reads or writes an NOTIFY OPTION TYPE structure.
+********************************************************************/
+static BOOL smb_io_notify_option_type(char *desc,
+ SPOOL_NOTIFY_OPTION_TYPE *type,
+ prs_struct *ps, int depth)
+{
+ uint32 useless_ptr;
+
+ prs_debug(ps, depth, desc, "smb_io_notify_option_type");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint16("type", ps, depth, &(type->type));
+ prs_uint16("reserved0", ps, depth, &(type->reserved0));
+ prs_uint32("reserved1", ps, depth, &(type->reserved1));
+ prs_uint32("reserved2", ps, depth, &(type->reserved2));
+ prs_uint32("count", ps, depth, &(type->count));
+ prs_uint32("useless ptr", ps, depth, &useless_ptr);
+
+
+ return True;
+}
+
+/*******************************************************************
+reads or writes an NOTIFY OPTION TYPE DATA.
+********************************************************************/
+static BOOL smb_io_notify_option_type_data(char *desc,
+ SPOOL_NOTIFY_OPTION_TYPE *type,
+ prs_struct *ps, int depth)
+{
+ uint32 count;
+ int i;
+
+ prs_debug(ps, depth, desc, "smb_io_notify_option_type_data");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("count", ps, depth, &count);
+
+ if (count != type->count)
+ {
+ DEBUG(4,("What a mess, count was %x now is %x !\n",type->count,count));
+ type->count=count;
+ }
+ for(i=0;i<count;i++)
+ {
+ /* read the option type struct */
+ prs_uint16("fields",ps,depth,&(type->fields[i]));
+ }
+
+ return True;
+}
+
+/*******************************************************************
+reads or writes an NOTIFY OPTION structure.
+********************************************************************/
+static BOOL smb_io_notify_option(char *desc, SPOOL_NOTIFY_OPTION *option,
+ prs_struct *ps, int depth)
+{
+ uint32 useless_ptr;
+ int i;
+
+ prs_debug(ps, depth, desc, "smb_io_notify_option");
+ depth++;
+
+ prs_align(ps);
+
+ /* memory pointer to the struct */
+ prs_uint32("useless ptr", ps, depth, &useless_ptr);
+
+ prs_uint32("version", ps, depth, &(option->version));
+ prs_uint32("reserved", ps, depth, &(option->reserved));
+ prs_uint32("count", ps, depth, &(option->count));
+ prs_uint32("useless ptr", ps, depth, &useless_ptr);
+ prs_uint32("count", ps, depth, &(option->count));
+
+ /* read the option type struct */
+ for(i=0;i<option->count;i++)
+ {
+ smb_io_notify_option_type("",&(option->type[i]) ,ps, depth);
+ }
+
+ /* now read the type associated with the option type struct */
+ for(i=0;i<option->count;i++)
+ {
+ smb_io_notify_option_type_data("",&(option->type[i]) ,ps, depth);
+ }
+
+
+ return True;
+}
+
+
+/*******************************************************************
+reads or writes an NOTIFY INFO DATA structure.
+********************************************************************/
+static BOOL smb_io_notify_info_data(char *desc,SPOOL_NOTIFY_INFO_DATA *data,
+ prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0xADDE0FF0;
+
+ uint32 how_many_words;
+ BOOL isvalue;
+ uint32 x;
+
+ prs_debug(ps, depth, desc, "smb_io_notify_info_data");
+ depth++;
+
+ how_many_words=data->size;
+ if (how_many_words==POINTER)
+ {
+ how_many_words=TWO_VALUE;
+ }
+
+ isvalue=data->enc_type;
+
+ prs_align(ps);
+ prs_uint16("type", ps, depth, &(data->type));
+ prs_uint16("field", ps, depth, &(data->field));
+ /*prs_align(ps);*/
+
+ prs_uint32("how many words", ps, depth, &how_many_words);
+ prs_uint32("id", ps, depth, &(data->id));
+ prs_uint32("how many words", ps, depth, &how_many_words);
+ /*prs_align(ps);*/
+
+ if (isvalue==True)
+ {
+ prs_uint32("value[0]", ps, depth, &(data->notify_data.value[0]));
+ prs_uint32("value[1]", ps, depth, &(data->notify_data.value[1]));
+ /*prs_align(ps);*/
+ }
+ else
+ {
+ /* it's a string */
+ /* length in ascii including \0 */
+ x=2*(data->notify_data.data.length+1);
+ prs_uint32("string length", ps, depth, &x );
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+ /*prs_align(ps);*/
+ }
+
+ return True;
+}
+
+/*******************************************************************
+reads or writes an NOTIFY INFO DATA structure.
+********************************************************************/
+BOOL smb_io_notify_info_data_strings(char *desc,SPOOL_NOTIFY_INFO_DATA *data,
+ prs_struct *ps, int depth)
+{
+ uint32 x;
+ BOOL isvalue;
+
+ prs_debug(ps, depth, desc, "smb_io_notify_info_data");
+ depth++;
+
+ prs_align(ps);
+ isvalue=data->enc_type;
+
+ if (isvalue==False)
+ {
+ /* length of string in unicode include \0 */
+ x=data->notify_data.data.length+1;
+ prs_uint32("string length", ps, depth, &x );
+ prs_uint16s(True,"string",ps,depth,data->notify_data.data.string,x);
+ }
+ prs_align(ps);
+
+ return True;
+}
+
+/*******************************************************************
+reads or writes an NOTIFY INFO structure.
+********************************************************************/
+static BOOL smb_io_notify_info(char *desc, SPOOL_NOTIFY_INFO *info,
+ prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0x0001;
+ int i;
+
+ info->version=0x02;
+ prs_debug(ps, depth, desc, "smb_io_notify_info");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+ prs_uint32("count", ps, depth, &(info->count));
+ prs_uint32("version", ps, depth, &(info->version));
+ prs_uint32("flags", ps, depth, &(info->flags));
+ prs_uint32("count", ps, depth, &(info->count));
+
+ for (i=0;i<info->count;i++)
+ {
+ smb_io_notify_info_data(desc, &(info->data[i]), ps, depth);
+ }
+
+ /* now do the strings at the end of the stream */
+ for (i=0;i<info->count;i++)
+ {
+ smb_io_notify_info_data_strings(desc, &(info->data[i]),
+ ps, depth);
+ }
+
+ return True;
+}
+
+
+/*******************************************************************
+********************************************************************/
+static BOOL spool_io_user_level_1(char *desc, SPOOL_USER_1 *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ /* reading */
+ if (ps->io)
+ ZERO_STRUCTP(q_u);
+
+ if (!prs_align(ps))
+ return False;
+ if (!prs_uint32("size", ps, depth, &(q_u->size)))
+ return False;
+ if (!prs_uint32("client_name_ptr", ps, depth, &(q_u->client_name_ptr)))
+ return False;
+ if (!prs_uint32("user_name_ptr", ps, depth, &(q_u->user_name_ptr)))
+ return False;
+ if (!prs_uint32("build", ps, depth, &(q_u->build)))
+ return False;
+ if (!prs_uint32("major", ps, depth, &(q_u->major)))
+ return False;
+ if (!prs_uint32("minor", ps, depth, &(q_u->minor)))
+ return False;
+ if (!prs_uint32("processor", ps, depth, &(q_u->processor)))
+ return False;
+
+ if (!smb_io_unistr2("", &(q_u->client_name), q_u->client_name_ptr, ps, depth))
+ return False;
+ if (!prs_align(ps))
+ return False;
+ if (!smb_io_unistr2("", &(q_u->user_name), q_u->user_name_ptr, ps, depth))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL spool_io_user_level(char *desc, SPOOL_USER_CTR *q_u, prs_struct *ps, int depth)
+{
+ if (q_u==NULL)
+ return False;
+
+ prs_debug(ps, depth, desc, "spool_io_user_level");
+ depth++;
+
+ if (!prs_align(ps))
+ return False;
+ if (!prs_uint32("level", ps, depth, &q_u->level))
+ return False;
+ if (!prs_uint32("ptr", ps, depth, &q_u->ptr))
+ return False;
+
+ switch (q_u->level) {
+ case 1:
+ if (!spool_io_user_level_1("", &(q_u->user1), ps, depth))
+ return False;
+ break;
+ default:
+ return False;
+ }
+
+ return True;
+}
+
+/*******************************************************************
+ * read or write a DEVICEMODE struct.
+ * on reading allocate memory for the private member
+ ********************************************************************/
+static BOOL spoolss_io_devmode(char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_devmode");
+ depth++;
+
+ if (!prs_uint16s(True,"devicename", ps, depth, devmode->devicename.buffer, 32))
+ return False;
+ if (!prs_uint16("specversion", ps, depth, &(devmode->specversion)))
+ return False;
+ if (!prs_uint16("driverversion", ps, depth, &(devmode->driverversion)))
+ return False;
+ if (!prs_uint16("size", ps, depth, &(devmode->size)))
+ return False;
+ if (!prs_uint16("driverextra", ps, depth, &(devmode->driverextra)))
+ return False;
+ if (!prs_uint32("fields", ps, depth, &(devmode->fields)))
+ return False;
+ if (!prs_uint16("orientation", ps, depth, &(devmode->orientation)))
+ return False;
+ if (!prs_uint16("papersize", ps, depth, &(devmode->papersize)))
+ return False;
+ if (!prs_uint16("paperlength", ps, depth, &(devmode->paperlength)))
+ return False;
+ if (!prs_uint16("paperwidth", ps, depth, &(devmode->paperwidth)))
+ return False;
+ if (!prs_uint16("scale", ps, depth, &(devmode->scale)))
+ return False;
+ if (!prs_uint16("copies", ps, depth, &(devmode->copies)))
+ return False;
+ if (!prs_uint16("defaultsource", ps, depth, &(devmode->defaultsource)))
+ return False;
+ if (!prs_uint16("printquality", ps, depth, &(devmode->printquality)))
+ return False;
+ if (!prs_uint16("color", ps, depth, &(devmode->color)))
+ return False;
+ if (!prs_uint16("duplex", ps, depth, &(devmode->duplex)))
+ return False;
+ if (!prs_uint16("yresolution", ps, depth, &(devmode->yresolution)))
+ return False;
+ if (!prs_uint16("ttoption", ps, depth, &(devmode->ttoption)))
+ return False;
+ if (!prs_uint16("collate", ps, depth, &(devmode->collate)))
+ return False;
+ if (!prs_uint16s(True, "formname", ps, depth, devmode->formname.buffer, 32))
+ return False;
+ if (!prs_uint16("logpixels", ps, depth, &(devmode->logpixels)))
+ return False;
+ if (!prs_uint32("bitsperpel", ps, depth, &(devmode->bitsperpel)))
+ return False;
+ if (!prs_uint32("pelswidth", ps, depth, &(devmode->pelswidth)))
+ return False;
+ if (!prs_uint32("pelsheight", ps, depth, &(devmode->pelsheight)))
+ return False;
+ if (!prs_uint32("displayflags", ps, depth, &(devmode->displayflags)))
+ return False;
+ if (!prs_uint32("displayfrequency", ps, depth, &(devmode->displayfrequency)))
+ return False;
+ if (!prs_uint32("icmmethod", ps, depth, &(devmode->icmmethod)))
+ return False;
+ if (!prs_uint32("icmintent", ps, depth, &(devmode->icmintent)))
+ return False;
+ if (!prs_uint32("mediatype", ps, depth, &(devmode->mediatype)))
+ return False;
+ if (!prs_uint32("dithertype", ps, depth, &(devmode->dithertype)))
+ return False;
+ if (!prs_uint32("reserved1", ps, depth, &(devmode->reserved1)))
+ return False;
+ if (!prs_uint32("reserved2", ps, depth, &(devmode->reserved2)))
+ return False;
+ if (!prs_uint32("panningwidth", ps, depth, &(devmode->panningwidth)))
+ return False;
+ if (!prs_uint32("panningheight", ps, depth, &(devmode->panningheight)))
+ return False;
+
+ if (devmode->driverextra!=0)
+ {
+ if (UNMARSHALLING(ps)) {
+ devmode->private=(uint8 *)malloc(devmode->driverextra*sizeof(uint8));
+ DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for private\n",devmode->driverextra));
+ }
+
+ DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of private\n",devmode->driverextra));
+ if (!prs_uint8s(True, "private", ps, depth, devmode->private, devmode->driverextra))
+ return False;
+ }
+
+ return True;
+}
+
+/*******************************************************************
+ Read or write a DEVICEMODE container
+********************************************************************/
+static BOOL spoolss_io_devmode_cont(char *desc, DEVMODE_CTR *dm_c, prs_struct *ps, int depth)
+{
+ if (dm_c==NULL)
+ return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_devmode_cont");
+ depth++;
+
+ if (!prs_uint32("size", ps, depth, &dm_c->size))
+ return False;
+
+ if (!prs_uint32("devmode_ptr", ps, depth, &dm_c->devmode_ptr))
+ return False;
+
+ if (dm_c->size==0 || dm_c->devmode_ptr==0) {
+ if (UNMARSHALLING(ps))
+ /* if while reading there is no DEVMODE ... */
+ dm_c->devmode=NULL;
+ return True;
+ }
+
+ /* so we have a DEVICEMODE to follow */
+ if (UNMARSHALLING(ps)) {
+ DEBUG(9,("Allocating memory for spoolss_io_devmode\n"));
+ dm_c->devmode=(DEVICEMODE *)malloc(sizeof(DEVICEMODE));
+ ZERO_STRUCTP(dm_c->devmode);
+ }
+
+ /* this is bad code, shouldn't be there */
+ if (!prs_uint32("size", ps, depth, &dm_c->size))
+ return False;
+
+ if (!spoolss_io_devmode(desc, ps, depth, dm_c->devmode))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL spoolss_io_printer_default(char *desc, PRINTER_DEFAULT *pd, prs_struct *ps, int depth)
+{
+ if (pd==NULL)
+ return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_printer_default");
+ depth++;
+
+ if (!prs_uint32("datatype_ptr", ps, depth, &pd->datatype_ptr))
+ return False;
+
+ if (!smb_io_unistr2("datatype", &(pd->datatype), pd->datatype_ptr, ps,depth))
+ return False;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!spoolss_io_devmode_cont("", &(pd->devmode_cont), ps, depth))
+ return False;
+
+ if (!prs_uint32("access_required", ps, depth, &pd->access_required))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ * make a structure.
+ ********************************************************************/
+BOOL make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX *q_u,
+ const char *printername,
+ uint32 cbbuf, uint32 devmod, uint32 des_access,
+ const char *station,
+ const char *username)
+{
+ int len_name = printername != NULL ? strlen(printername) : 0;
+ int len_sta = station != NULL ? strlen(station ) : 0;
+ int len_user = username != NULL ? strlen(username ) : 0;
+
+ if (q_u == NULL) return False;
+
+ DEBUG(5,("make_spoolss_io_q_open_printer_ex\n"));
+
+ q_u->printername_ptr = 1;
+ init_unistr2(&(q_u->printername), printername, len_name);
+
+/*
+ q_u->unknown0 = 0x0;
+ q_u->cbbuf = cbbuf;
+ q_u->devmod = devmod;
+ q_u->access_required = des_access;
+*/
+/* q_u->unknown1 = 0x1;
+ q_u->unknown2 = 0x1;
+ q_u->unknown3 = 0x149f7d8;
+ q_u->unknown4 = 0x1c;
+ q_u->unknown5 = 0x00b94dd0;
+ q_u->unknown6 = 0x0149f5cc;
+ q_u->unknown7 = 0x00000565;
+ q_u->unknown8 = 0x2;
+ q_u->unknown9 = 0x0;
+ q_u->unknown10 = 0x0;
+
+ init_unistr2(&(q_u->station), station, len_sta);
+ init_unistr2(&(q_u->username), username, len_user);
+*/
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_open_printer_ex (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_open_printer_ex(char *desc, SPOOL_Q_OPEN_PRINTER_EX *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL)
+ return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_open_printer_ex");
+ depth++;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("printername_ptr", ps, depth, &(q_u->printername_ptr)))
+ return False;
+ if (!smb_io_unistr2("", &(q_u->printername), q_u->printername_ptr, ps,depth))
+ return False;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!spoolss_io_printer_default("", &(q_u->printer_default), ps, depth))
+ return False;
+
+ if (!prs_uint32("user_switch", ps, depth, &(q_u->user_switch)))
+ return False;
+
+ if (!spool_io_user_level("", &(q_u->user_ctr), ps, depth))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
+ * called from spoolss_open_printer_ex (cli_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_r_open_printer_ex(char *desc, SPOOL_R_OPEN_PRINTER_EX *r_u, prs_struct *ps, int depth)
+{
+ if (r_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_open_printer_ex");
+ depth++;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!smb_io_prt_hnd("printer handle",&(r_u->handle),ps,depth))
+ return False;
+
+ if (!prs_uint32("status code", ps, depth, &(r_u->status)))
+ return False;
+
+ return True;
+}
+/*******************************************************************
+ * make a structure.
+ ********************************************************************/
+BOOL make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u,
+ POLICY_HND *handle,
+ char *valuename,
+ uint32 size)
+{
+ int len_name = valuename != NULL ? strlen(valuename) : 0;
+
+ if (q_u == NULL) return False;
+
+ DEBUG(5,("make_spoolss_q_getprinterdata\n"));
+
+ memcpy(&(q_u->handle), handle, sizeof(q_u->handle));
+ init_unistr2(&(q_u->valuename), valuename, len_name);
+ q_u->size = size;
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_getprinterdata (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_getprinterdata(char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdata");
+ depth++;
+
+ if (!prs_align(ps))
+ return False;
+ if (!smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth))
+ return False;
+ if (!prs_align(ps))
+ return False;
+ if (!smb_io_unistr2("valuename", &(q_u->valuename),True,ps,depth))
+ return False;
+ if (!prs_align(ps))
+ return False;
+ if (!prs_uint32("size", ps, depth, &(q_u->size)))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_getprinterdata (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_r_getprinterdata(char *desc, SPOOL_R_GETPRINTERDATA *r_u, prs_struct *ps, int depth)
+{
+ if (r_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdata");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("type", ps, depth, &(r_u->type));
+ prs_uint32("size", ps, depth, &(r_u->size));
+
+ prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size);
+ prs_align(ps);
+
+ prs_uint32("needed", ps, depth, &(r_u->needed));
+ prs_uint32("status", ps, depth, &(r_u->status));
+ prs_align(ps);
+
+ return True;
+}
+
+/*******************************************************************
+ * make a structure.
+ ********************************************************************/
+BOOL make_spoolss_q_closeprinter(SPOOL_Q_CLOSEPRINTER *q_u, POLICY_HND *hnd)
+{
+ if (q_u == NULL) return False;
+
+ DEBUG(5,("make_spoolss_q_closeprinter\n"));
+
+ memcpy(&(q_u->handle), hnd, sizeof(q_u->handle));
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from static spoolss_q_closeprinter (srv_spoolss.c)
+ * called from spoolss_closeprinter (cli_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_closeprinter(char *desc, SPOOL_Q_CLOSEPRINTER *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_closeprinter");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from static spoolss_r_closeprinter (srv_spoolss.c)
+ * called from spoolss_closeprinter (cli_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_r_closeprinter(char *desc, SPOOL_R_CLOSEPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_closeprinter");
+ depth++;
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(r_u->handle),ps,depth);
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_startdocprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_startdocprinter(char *desc, SPOOL_Q_STARTDOCPRINTER *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_startdocprinter");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+
+ smb_io_doc_info_container("",&(q_u->doc_info_container), ps, depth);
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_startdocprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_r_startdocprinter(char *desc, SPOOL_R_STARTDOCPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_startdocprinter");
+ depth++;
+ prs_uint32("jobid", ps, depth, &(r_u->jobid));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_enddocprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_enddocprinter(char *desc, SPOOL_Q_ENDDOCPRINTER *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_enddocprinter");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_enddocprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_r_enddocprinter(char *desc, SPOOL_R_ENDDOCPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_enddocprinter");
+ depth++;
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_startpageprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_startpageprinter(char *desc, SPOOL_Q_STARTPAGEPRINTER *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_startpageprinter");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_startpageprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_r_startpageprinter(char *desc, SPOOL_R_STARTPAGEPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_startpageprinter");
+ depth++;
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_endpageprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_endpageprinter(char *desc, SPOOL_Q_ENDPAGEPRINTER *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_endpageprinter");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_endpageprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_r_endpageprinter(char *desc, SPOOL_R_ENDPAGEPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_endpageprinter");
+ depth++;
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_writeprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_writeprinter(char *desc, SPOOL_Q_WRITEPRINTER *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_writeprinter");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ prs_uint32("buffer_size", ps, depth, &(q_u->buffer_size));
+
+ if (q_u->buffer_size!=0)
+ {
+ q_u->buffer=(uint8 *)malloc(q_u->buffer_size*sizeof(uint8));
+ prs_uint8s(True, "buffer", ps, depth, q_u->buffer, q_u->buffer_size);
+ }
+ prs_align(ps);
+ prs_uint32("buffer_size2", ps, depth, &(q_u->buffer_size2));
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_writeprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_r_writeprinter(char *desc, SPOOL_R_WRITEPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_writeprinter");
+ depth++;
+ prs_uint32("buffer_written", ps, depth, &(r_u->buffer_written));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_rffpcnex (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_rffpcnex(char *desc, SPOOL_Q_RFFPCNEX *q_u,
+ prs_struct *ps, int depth)
+{
+ uint32 useless_ptr;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_rffpcnex");
+ depth++;
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ prs_uint32("flags", ps, depth, &(q_u->flags));
+ prs_uint32("options", ps, depth, &(q_u->options));
+ prs_uint32("useless ptr", ps, depth, &useless_ptr);
+ /*prs_align(ps);*/
+
+ smb_io_unistr2("", &(q_u->localmachine), True, ps, depth);
+
+ prs_align(ps);
+ prs_uint32("printerlocal", ps, depth, &(q_u->printerlocal));
+
+ smb_io_notify_option("notify option", &(q_u->option), ps, depth);
+
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_rffpcnex (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_r_rffpcnex(char *desc, SPOOL_R_RFFPCNEX *r_u,
+ prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_rffpcnex");
+ depth++;
+
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_rfnpcnex (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_rfnpcnex(char *desc, SPOOL_Q_RFNPCNEX *q_u,
+ prs_struct *ps, int depth)
+{
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_rfnpcnex");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+
+ prs_uint32("change", ps, depth, &(q_u->change));
+
+ smb_io_notify_option("notify option",&(q_u->option),ps,depth);
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_rfnpcnex (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_r_rfnpcnex(char *desc,
+ SPOOL_R_RFNPCNEX *r_u,
+ prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_rfnpcnex");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_notify_info("notify info",&(r_u->info),ps,depth);
+ prs_align(ps);
+ prs_uint32("status", ps, depth, &r_u->status);
+
+ return True;
+}
+
+/*******************************************************************
+ * return the length of a uint32 (obvious, but the code is clean)
+ ********************************************************************/
+static uint32 size_of_uint32(uint32 *value)
+{
+ return (sizeof(*value));
+
+ return True;
+}
+
+/*******************************************************************
+ * return the length of a UNICODE string in number of char, includes:
+ * - the leading zero
+ * - the relative pointer size
+ ********************************************************************/
+static uint32 size_of_relative_string(UNISTR *string)
+{
+ uint32 size=0;
+
+ size=str_len_uni(string); /* the string length */
+ size=size+1; /* add the leading zero */
+ size=size*2; /* convert in char */
+ size=size+4; /* add the size of the ptr */
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+ * return the length of a uint32 (obvious, but the code is clean)
+ ********************************************************************/
+static uint32 size_of_device_mode(DEVICEMODE *devmode)
+{
+ if (devmode==NULL)
+ return (4);
+ else
+ return (0xDC+4);
+
+ return True;
+}
+
+/*******************************************************************
+ * return the length of a uint32 (obvious, but the code is clean)
+ ********************************************************************/
+static uint32 size_of_systemtime(SYSTEMTIME *systime)
+{
+ if (systime==NULL)
+ return (4);
+ else
+ return (sizeof(SYSTEMTIME) +4);
+
+ return True;
+}
+
+/*******************************************************************
+ * write a UNICODE string.
+ * used by all the RPC structs passing a buffer
+ ********************************************************************/
+static BOOL spoolss_smb_io_unistr(char *desc, UNISTR *uni, prs_struct *ps, int depth)
+{
+ if (uni == NULL)
+ return False;
+
+ prs_debug(ps, depth, desc, "spoolss_smb_io_unistr");
+ depth++;
+ if (!prs_unistr("unistr", ps, depth, uni))
+ return False;
+
+ return True;
+}
+
+
+/*******************************************************************
+ * write a UNICODE string and its relative pointer.
+ * used by all the RPC structs passing a buffer
+ ********************************************************************/
+static BOOL smb_io_relstr(char *desc, prs_struct *ps, int depth, UNISTR *buffer,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ if (!ps->io)
+ {
+ uint32 struct_offset = prs_offset(ps);
+ uint32 relative_offset;
+
+ /* writing */
+ *end_offset -= 2*(str_len_uni(buffer)+1);
+ prs_set_offset(ps, *end_offset);
+ spoolss_smb_io_unistr(desc, buffer, ps, depth);
+
+ prs_set_offset(ps,struct_offset);
+ relative_offset=*end_offset-*start_offset;
+
+ prs_uint32("offset", ps, depth, &(relative_offset));
+ }
+ else
+ {
+ uint32 old_offset;
+ uint32 relative_offset;
+
+ prs_uint32("offset", ps, depth, &(relative_offset));
+
+ old_offset = prs_offset(ps);
+ prs_set_offset(ps, (*start_offset) + relative_offset);
+
+ spoolss_smb_io_unistr(desc, buffer, ps, depth);
+
+ *end_offset = prs_offset(ps);
+ prs_set_offset(ps, old_offset);
+ }
+ return True;
+}
+
+/*******************************************************************
+ * write a UNICODE string and its relative pointer.
+ * used by all the RPC structs passing a buffer
+ *
+ * As I'm a nice guy, I'm forcing myself to explain this code.
+ * MS did a good job in the overall spoolss code except in some
+ * functions where they are passing the API buffer directly in the
+ * RPC request/reply. That's to maintain compatiility at the API level.
+ * They could have done it the good way the first time.
+ *
+ * So what happen is: the strings are written at the buffer's end,
+ * in the reverse order of the original structure. Some pointers to
+ * the strings are also in the buffer. Those are relative to the
+ * buffer's start.
+ *
+ * If you don't understand or want to change that function,
+ * first get in touch with me: jfm@samba.org
+ *
+ ********************************************************************/
+static BOOL new_smb_io_relstr(char *desc, NEW_BUFFER *buffer, int depth, UNISTR *string)
+{
+ prs_struct *ps=&(buffer->prs);
+
+ if (MARSHALLING(ps))
+ {
+ uint32 struct_offset = prs_offset(ps);
+ uint32 relative_offset;
+
+ buffer->string_at_end -= 2*(str_len_uni(string)+1);
+ prs_set_offset(ps, buffer->string_at_end);
+
+ /* write the string */
+ if (!spoolss_smb_io_unistr(desc, string, ps, depth))
+ return False;
+
+ prs_set_offset(ps, struct_offset);
+
+ relative_offset=buffer->string_at_end-buffer->struct_start;
+ /* write its offset */
+ if (!prs_uint32("offset", ps, depth, &relative_offset))
+ return False;
+ }
+ else
+ {
+ uint32 old_offset;
+
+ /* read the offset */
+ if (!prs_uint32("offset", ps, depth, &(buffer->string_at_end)))
+ return False;
+
+ old_offset = prs_offset(ps);
+ prs_set_offset(ps, buffer->string_at_end);
+
+ /* read the string */
+ if (!spoolss_smb_io_unistr(desc, string, ps, depth))
+ return False;
+
+ prs_set_offset(ps, old_offset);
+ }
+ return True;
+}
+
+
+/*******************************************************************
+ * write a array UNICODE strings and its relative pointer.
+ * used by 2 RPC structs
+ ********************************************************************/
+static BOOL smb_io_relarraystr(char *desc, prs_struct *ps, int depth, UNISTR ***buffer,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ int i=0;
+ uint32 struct_offset;
+ uint32 relative_offset;
+ struct_offset=prs_offset(ps);
+
+ while ( (*buffer)[i]!=0x0000 )
+ {
+ i++;
+ }
+
+ i--;
+
+ /* that's for the ending NULL */
+ *end_offset-=2;
+
+ do
+ {
+ *end_offset-= 2*(str_len_uni((*buffer)[i])+1);
+ prs_set_offset(ps, *end_offset);
+ spoolss_smb_io_unistr(desc, (*buffer)[i], ps, depth);
+
+ i--;
+ }
+ while (i>=0);
+
+ prs_set_offset(ps, struct_offset);
+ relative_offset=*end_offset-*start_offset;
+
+ prs_uint32("offset", ps, depth, &(relative_offset));
+
+ return True;
+}
+
+/*******************************************************************
+ * write a DEVMODE struct and its relative pointer.
+ * used by all the RPC structs passing a buffer
+ ********************************************************************/
+static BOOL smb_io_reldevmode(char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ uint32 struct_offset;
+ uint32 relative_offset;
+
+ prs_debug(ps, depth, desc, "smb_io_reldevmode");
+ depth++;
+
+ struct_offset=prs_offset(ps);
+ *end_offset-= (devmode->size+devmode->driverextra);
+ prs_set_offset(ps, *end_offset);
+
+ spoolss_io_devmode(desc, ps, depth, devmode);
+
+ prs_set_offset(ps, struct_offset);
+ relative_offset=*end_offset-*start_offset;
+
+ prs_uint32("offset", ps, depth, &(relative_offset));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_printer_info_0(char *desc, PRINTER_INFO_0 *info, prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ prs_debug(ps, depth, desc, "smb_io_printer_info_0");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ smb_io_relstr("printername",ps, depth, &(info->printername), start_offset, end_offset);
+ smb_io_relstr("servername",ps, depth, &(info->servername), start_offset, end_offset);
+ prs_uint32("cjobs", ps, depth, &(info->cjobs));
+ prs_uint32("attributes", ps, depth, &(info->attributes));
+
+ prs_uint32("unknown0", ps, depth, &(info->unknown0));
+ prs_uint32("unknown1", ps, depth, &(info->unknown1));
+ prs_uint32("unknown2", ps, depth, &(info->unknown2));
+ prs_uint32("unknown3", ps, depth, &(info->unknown3));
+ prs_uint32("unknown4", ps, depth, &(info->unknown4));
+ prs_uint32("unknown5", ps, depth, &(info->unknown5));
+ prs_uint32("unknown6", ps, depth, &(info->unknown6));
+ prs_uint16("majorversion", ps, depth, &(info->majorversion));
+ prs_uint16("buildversion", ps, depth, &(info->buildversion));
+ prs_uint32("unknown7", ps, depth, &(info->unknown7));
+ prs_uint32("unknown8", ps, depth, &(info->unknown8));
+ prs_uint32("unknown9", ps, depth, &(info->unknown9));
+ prs_uint32("unknown10", ps, depth, &(info->unknown10));
+ prs_uint32("unknown11", ps, depth, &(info->unknown11));
+ prs_uint32("unknown12", ps, depth, &(info->unknown12));
+ prs_uint32("unknown13", ps, depth, &(info->unknown13));
+ prs_uint32("unknown14", ps, depth, &(info->unknown14));
+ prs_uint32("unknown15", ps, depth, &(info->unknown15));
+ prs_uint32("unknown16", ps, depth, &(info->unknown16));
+ prs_uint32("unknown17", ps, depth, &(info->unknown17));
+ prs_uint32("unknown18", ps, depth, &(info->unknown18));
+ prs_uint32("status" , ps, depth, &(info->status));
+ prs_uint32("unknown20", ps, depth, &(info->unknown20));
+ prs_uint32("unknown21", ps, depth, &(info->unknown21));
+ prs_uint16("unknown22", ps, depth, &(info->unknown22));
+ prs_uint32("unknown23", ps, depth, &(info->unknown23));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_printer_info_1(char *desc, PRINTER_INFO_1 *info, prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ prs_debug(ps, depth, desc, "smb_io_printer_info_1");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ prs_uint32("flags", ps, depth, &(info->flags));
+ smb_io_relstr("description",ps, depth, &(info->description), start_offset, end_offset);
+ smb_io_relstr("name",ps, depth, &(info->name), start_offset, end_offset);
+ smb_io_relstr("comment",ps, depth, &(info->comment), start_offset, end_offset);
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_printer_info_2(char *desc, PRINTER_INFO_2 *info, prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ uint32 pipo=0;
+ uint32 devmode_offset;
+ uint32 backup_offset;
+
+ prs_debug(ps, depth, desc, "smb_io_printer_info_2");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ smb_io_relstr("servername", ps, depth, &(info->servername), start_offset, end_offset);
+ smb_io_relstr("printername", ps, depth, &(info->printername), start_offset, end_offset);
+ smb_io_relstr("sharename", ps, depth, &(info->sharename), start_offset, end_offset);
+ smb_io_relstr("portname", ps, depth, &(info->portname), start_offset, end_offset);
+ smb_io_relstr("drivername", ps, depth, &(info->drivername), start_offset, end_offset);
+ smb_io_relstr("comment", ps, depth, &(info->comment), start_offset, end_offset);
+ smb_io_relstr("location", ps, depth, &(info->location), start_offset, end_offset);
+
+ devmode_offset=prs_offset(ps);
+ prs_set_offset(ps, prs_offset(ps)+4);
+
+ smb_io_relstr("sepfile", ps, depth, &(info->sepfile), start_offset, end_offset);
+ smb_io_relstr("printprocessor",ps, depth, &(info->printprocessor), start_offset, end_offset);
+ smb_io_relstr("datatype", ps, depth, &(info->datatype), start_offset, end_offset);
+ smb_io_relstr("parameters", ps, depth, &(info->parameters), start_offset, end_offset);
+
+ prs_uint32("security descriptor", ps, depth, &(pipo));
+
+ prs_uint32("attributes", ps, depth, &(info->attributes));
+ prs_uint32("priority", ps, depth, &(info->priority));
+ prs_uint32("defpriority", ps, depth, &(info->defaultpriority));
+ prs_uint32("starttime", ps, depth, &(info->starttime));
+ prs_uint32("untiltime", ps, depth, &(info->untiltime));
+ prs_uint32("status", ps, depth, &(info->status));
+ prs_uint32("jobs", ps, depth, &(info->cjobs));
+ prs_uint32("averageppm", ps, depth, &(info->averageppm));
+
+ /*
+ I'm not sure if putting the devmode at the end the struct is worth it
+ but NT does it
+ */
+ backup_offset=prs_offset(ps);
+ prs_set_offset(ps, devmode_offset);
+ smb_io_reldevmode("devmode", ps, depth, info->devmode, start_offset, end_offset);
+ prs_set_offset(ps, backup_offset);
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_printer_driver_info_1(char *desc, DRIVER_INFO_1 *info, prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ prs_debug(ps, depth, desc, "smb_io_printer_driver_info_1");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ smb_io_relstr("name", ps, depth, &(info->name), start_offset, end_offset);
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_printer_driver_info_2(char *desc, DRIVER_INFO_2 *info,prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ prs_debug(ps, depth, desc, "smb_io_printer_xxx");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ prs_uint32("version", ps, depth, &(info->version));
+ smb_io_relstr("name", ps, depth, &(info->name), start_offset, end_offset);
+ smb_io_relstr("architecture", ps, depth, &(info->architecture), start_offset, end_offset);
+ smb_io_relstr("driverpath", ps, depth, &(info->driverpath), start_offset, end_offset);
+ smb_io_relstr("datafile", ps, depth, &(info->datafile), start_offset, end_offset);
+ smb_io_relstr("configfile", ps, depth, &(info->configfile), start_offset, end_offset);
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_printer_driver_info_3(char *desc, DRIVER_INFO_3 *info,prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ prs_debug(ps, depth, desc, "smb_io_printer_driver_info_3");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ prs_uint32("version", ps, depth, &(info->version));
+ smb_io_relstr("name", ps, depth, &(info->name), start_offset, end_offset);
+ smb_io_relstr("architecture", ps, depth, &(info->architecture), start_offset, end_offset);
+ smb_io_relstr("driverpath", ps, depth, &(info->driverpath), start_offset, end_offset);
+ smb_io_relstr("datafile", ps, depth, &(info->datafile), start_offset, end_offset);
+ smb_io_relstr("configfile", ps, depth, &(info->configfile), start_offset, end_offset);
+ smb_io_relstr("helpfile", ps, depth, &(info->helpfile), start_offset, end_offset);
+
+ smb_io_relarraystr("dependentfiles", ps, depth, &(info->dependentfiles), start_offset, end_offset);
+
+ smb_io_relstr("monitorname", ps, depth, &(info->monitorname), start_offset, end_offset);
+ smb_io_relstr("defaultdatatype", ps, depth, &(info->defaultdatatype), start_offset, end_offset);
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_job_info_1(char *desc, JOB_INFO_1 *info, prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ prs_debug(ps, depth, desc, "smb_io_job_info_1");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ prs_uint32("jobid", ps, depth, &(info->jobid));
+ smb_io_relstr("printername", ps, depth, &(info->printername), start_offset, end_offset);
+ smb_io_relstr("machinename", ps, depth, &(info->machinename), start_offset, end_offset);
+ smb_io_relstr("username", ps, depth, &(info->username), start_offset, end_offset);
+ smb_io_relstr("document", ps, depth, &(info->document), start_offset, end_offset);
+ smb_io_relstr("datatype", ps, depth, &(info->datatype), start_offset, end_offset);
+ smb_io_relstr("text_status", ps, depth, &(info->text_status), start_offset, end_offset);
+ prs_uint32("status", ps, depth, &(info->status));
+ prs_uint32("priority", ps, depth, &(info->priority));
+ prs_uint32("position", ps, depth, &(info->position));
+ prs_uint32("totalpages", ps, depth, &(info->totalpages));
+ prs_uint32("pagesprinted", ps, depth, &(info->pagesprinted));
+ spoolss_io_system_time("submitted", ps, depth, &(info->submitted) );
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_job_info_2(char *desc, JOB_INFO_2 *info, prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ int pipo=0;
+ prs_debug(ps, depth, desc, "smb_io_job_info_2");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ prs_uint32("jobid", ps, depth, &(info->jobid));
+ smb_io_relstr("printername", ps, depth, &(info->printername), start_offset, end_offset);
+ smb_io_relstr("machinename", ps, depth, &(info->machinename), start_offset, end_offset);
+ smb_io_relstr("username", ps, depth, &(info->username), start_offset, end_offset);
+ smb_io_relstr("document", ps, depth, &(info->document), start_offset, end_offset);
+ smb_io_relstr("notifyname", ps, depth, &(info->notifyname), start_offset, end_offset);
+ smb_io_relstr("datatype", ps, depth, &(info->datatype), start_offset, end_offset);
+
+ smb_io_relstr("printprocessor", ps, depth, &(info->printprocessor), start_offset, end_offset);
+ smb_io_relstr("parameters", ps, depth, &(info->parameters), start_offset, end_offset);
+ smb_io_relstr("drivername", ps, depth, &(info->drivername), start_offset, end_offset);
+ smb_io_reldevmode("devmode", ps, depth, info->devmode, start_offset, end_offset);
+ smb_io_relstr("text_status", ps, depth, &(info->text_status), start_offset, end_offset);
+
+/* SEC_DESC sec_desc;*/
+ prs_uint32("Hack! sec desc", ps, depth, &pipo);
+
+ prs_uint32("status", ps, depth, &(info->status));
+ prs_uint32("priority", ps, depth, &(info->priority));
+ prs_uint32("position", ps, depth, &(info->position));
+ prs_uint32("starttime", ps, depth, &(info->starttime));
+ prs_uint32("untiltime", ps, depth, &(info->untiltime));
+ prs_uint32("totalpages", ps, depth, &(info->totalpages));
+ prs_uint32("size", ps, depth, &(info->size));
+ spoolss_io_system_time("submitted", ps, depth, &(info->submitted) );
+ prs_uint32("timeelapsed", ps, depth, &(info->timeelapsed));
+ prs_uint32("pagesprinted", ps, depth, &(info->pagesprinted));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL new_smb_io_form_1(char *desc, NEW_BUFFER *buffer, FORM_1 *info, int depth)
+{
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "new_smb_io_form_1");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (!prs_uint32("flag", ps, depth, &(info->flag)))
+ return False;
+
+ if (!new_smb_io_relstr("name", buffer, depth, &(info->name)))
+ return False;
+
+ if (!prs_uint32("width", ps, depth, &(info->width)))
+ return False;
+ if (!prs_uint32("length", ps, depth, &(info->length)))
+ return False;
+ if (!prs_uint32("left", ps, depth, &(info->left)))
+ return False;
+ if (!prs_uint32("top", ps, depth, &(info->top)))
+ return False;
+ if (!prs_uint32("right", ps, depth, &(info->right)))
+ return False;
+ if (!prs_uint32("bottom", ps, depth, &(info->bottom)))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ Read/write a BUFFER struct.
+********************************************************************/
+static BOOL new_spoolss_io_buffer(char *desc, prs_struct *ps, int depth, NEW_BUFFER *buffer)
+{
+ if (buffer == NULL)
+ return False;
+
+ prs_debug(ps, depth, desc, "new_spoolss_io_buffer");
+ depth++;
+
+ if (!prs_uint32("ptr", ps, depth, &(buffer->ptr)))
+ return False;
+
+ /* reading */
+ if (UNMARSHALLING(ps)) {
+ buffer->size=0;
+ buffer->string_at_end=0;
+
+ if (buffer->ptr==0) {
+ if (!prs_init(&(buffer->prs), 0, 4, UNMARSHALL))
+ return False;
+ return True;
+ }
+
+ if (!prs_uint32("size", ps, depth, &(buffer->size)))
+ return False;
+
+ if (!prs_init(&(buffer->prs), buffer->size, 4, UNMARSHALL))
+ return False;
+
+ if (!prs_append_some_prs_data(&(buffer->prs), ps, buffer->size))
+ return False;
+
+ prs_set_offset(&(buffer->prs),0);
+
+ prs_set_offset(ps, buffer->size+prs_offset(ps));
+
+ buffer->string_at_end=buffer->size;
+
+ return True;
+ }
+ else {
+ /* writing */
+ if (buffer->ptr==0)
+ return True;
+
+ if (!prs_uint32("size", ps, depth, &(buffer->size)))
+ return False;
+
+ if (!prs_append_some_prs_data(ps, &(buffer->prs), buffer->size))
+ return False;
+ }
+
+ return True;
+}
+
+/*******************************************************************
+ move a BUFFER from the query to the reply.
+********************************************************************/
+void new_spoolss_move_buffer(NEW_BUFFER *src, NEW_BUFFER **dest)
+{
+ prs_switch_type(&(src->prs), MARSHALL);
+ prs_set_offset(&(src->prs), 0);
+ prs_force_dynamic(&(src->prs));
+
+ *dest=src;
+}
+
+/*******************************************************************
+ create a BUFFER struct.
+********************************************************************/
+void new_spoolss_allocate_buffer(NEW_BUFFER **buffer)
+{
+ if (buffer==NULL)
+ return;
+
+ *buffer=(NEW_BUFFER *)malloc(sizeof(NEW_BUFFER));
+
+ (*buffer)->ptr=0x0;
+ (*buffer)->size=0;
+ (*buffer)->string_at_end=0;
+}
+
+/*******************************************************************
+ Destroy a BUFFER struct.
+********************************************************************/
+void new_spoolss_free_buffer(NEW_BUFFER *buffer)
+{
+ if (buffer==NULL)
+ return;
+
+ prs_mem_free(&(buffer->prs));
+ buffer->ptr=0x0;
+ buffer->size=0;
+ buffer->string_at_end=0;
+
+ free(buffer);
+}
+
+/*******************************************************************
+ Get the size of a BUFFER struct.
+********************************************************************/
+uint32 new_get_buffer_size(NEW_BUFFER *buffer)
+{
+ return (buffer->size);
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_form_1(char *desc, FORM_1 *info, prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ prs_debug(ps, depth, desc, "smb_io_form_1");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ prs_uint32("flag", ps, depth, &(info->flag));
+ smb_io_relstr("name",ps, depth, &(info->name), start_offset, end_offset);
+ prs_uint32("width", ps, depth, &(info->width));
+ prs_uint32("length", ps, depth, &(info->length));
+ prs_uint32("left", ps, depth, &(info->left));
+ prs_uint32("top", ps, depth, &(info->top));
+ prs_uint32("right", ps, depth, &(info->right));
+ prs_uint32("bottom", ps, depth, &(info->bottom));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_port_2(char *desc, PORT_INFO_2 *info, prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ prs_debug(ps, depth, desc, "smb_io_port_2");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ smb_io_relstr("port_name",ps, depth, &(info->port_name), start_offset, end_offset);
+ smb_io_relstr("monitor_name",ps, depth, &(info->monitor_name), start_offset, end_offset);
+ smb_io_relstr("description",ps, depth, &(info->description), start_offset, end_offset);
+ prs_uint32("port_type", ps, depth, &(info->port_type));
+ prs_uint32("reserved", ps, depth, &(info->reserved));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_processor_info_1(char *desc, PRINTPROCESSOR_1 *info, prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ prs_debug(ps, depth, desc, "smb_io_processor_info_1");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ smb_io_relstr("name",ps, depth, &(info->name), start_offset, end_offset);
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL smb_io_monitor_info_1(char *desc, PRINTMONITOR_1 *info, prs_struct *ps, int depth,
+ uint32 *start_offset, uint32 *end_offset)
+{
+ prs_debug(ps, depth, desc, "smb_io_monitor_info_1");
+ depth++;
+ *start_offset=prs_offset(ps);
+
+ smb_io_relstr("name",ps, depth, &(info->name), start_offset, end_offset);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+static uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
+{
+ int size=0;
+
+ size+=size_of_uint32( &(info->attributes) );
+ size+=size_of_relative_string( &(info->printername) );
+ size+=size_of_relative_string( &(info->servername) );
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+static uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
+{
+ int size=0;
+
+ size+=size_of_uint32( &(info->flags) );
+ size+=size_of_relative_string( &(info->description) );
+ size+=size_of_relative_string( &(info->name) );
+ size+=size_of_relative_string( &(info->comment) );
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+static uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
+{
+ int size=0;
+
+ size+=4; /* the security descriptor */
+ size+=info->devmode->size+4; /* size of the devmode and the ptr */
+ size+=info->devmode->driverextra; /* if a devmode->private section exists, add its size */
+
+ size+=size_of_relative_string( &(info->servername) );
+ size+=size_of_relative_string( &(info->printername) );
+ size+=size_of_relative_string( &(info->sharename) );
+ size+=size_of_relative_string( &(info->portname) );
+ size+=size_of_relative_string( &(info->drivername) );
+ size+=size_of_relative_string( &(info->comment) );
+ size+=size_of_relative_string( &(info->location) );
+
+ size+=size_of_relative_string( &(info->sepfile) );
+ size+=size_of_relative_string( &(info->printprocessor) );
+ size+=size_of_relative_string( &(info->datatype) );
+ size+=size_of_relative_string( &(info->parameters) );
+
+ size+=size_of_uint32( &(info->attributes) );
+ size+=size_of_uint32( &(info->priority) );
+ size+=size_of_uint32( &(info->defaultpriority) );
+ size+=size_of_uint32( &(info->starttime) );
+ size+=size_of_uint32( &(info->untiltime) );
+ size+=size_of_uint32( &(info->status) );
+ size+=size_of_uint32( &(info->cjobs) );
+ size+=size_of_uint32( &(info->averageppm) );
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+static uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
+{
+ int size=0;
+ DEBUG(9,("Sizing driver info_1\n"));
+ size+=size_of_relative_string( &(info->name) );
+
+ DEBUGADD(9,("size: [%d]\n", size));
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+static uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
+{
+ int size=0;
+ DEBUG(9,("Sizing driver info_2\n"));
+ size+=size_of_uint32( &(info->version) );
+ size+=size_of_relative_string( &(info->name) );
+ size+=size_of_relative_string( &(info->architecture) );
+ size+=size_of_relative_string( &(info->driverpath) );
+ size+=size_of_relative_string( &(info->datafile) );
+ size+=size_of_relative_string( &(info->configfile) );
+
+ DEBUGADD(9,("size: [%d]\n", size));
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+static uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
+{
+ int size=0;
+ UNISTR **string;
+ int i=0;
+
+ DEBUG(9,("Sizing driver info_3\n"));
+ size+=size_of_uint32( &(info->version) );
+ size+=size_of_relative_string( &(info->name) );
+ size+=size_of_relative_string( &(info->architecture) );
+ size+=size_of_relative_string( &(info->driverpath) );
+ size+=size_of_relative_string( &(info->datafile) );
+ size+=size_of_relative_string( &(info->configfile) );
+ size+=size_of_relative_string( &(info->helpfile) );
+ size+=size_of_relative_string( &(info->monitorname) );
+ size+=size_of_relative_string( &(info->defaultdatatype) );
+
+ string=info->dependentfiles;
+
+ while ( (string)[i]!=0x0000 )
+ {
+ size+=2*(1+ str_len_uni( string[i] ) );
+ i++;
+ }
+ size+=6;
+
+ DEBUGADD(9,("size: [%d]\n", size));
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+static uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
+{
+ int size=0;
+ size+=size_of_uint32( &(info->jobid) );
+ size+=size_of_relative_string( &(info->printername) );
+ size+=size_of_relative_string( &(info->machinename) );
+ size+=size_of_relative_string( &(info->username) );
+ size+=size_of_relative_string( &(info->document) );
+ size+=size_of_relative_string( &(info->datatype) );
+ size+=size_of_relative_string( &(info->text_status) );
+ size+=size_of_uint32( &(info->status) );
+ size+=size_of_uint32( &(info->priority) );
+ size+=size_of_uint32( &(info->position) );
+ size+=size_of_uint32( &(info->totalpages) );
+ size+=size_of_uint32( &(info->pagesprinted) );
+ size+=size_of_systemtime( &(info->submitted) );
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+static uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
+{
+ int size=0;
+
+ size+=4; /* size of sec desc ptr */
+
+ size+=size_of_uint32( &(info->jobid) );
+ size+=size_of_relative_string( &(info->printername) );
+ size+=size_of_relative_string( &(info->machinename) );
+ size+=size_of_relative_string( &(info->username) );
+ size+=size_of_relative_string( &(info->document) );
+ size+=size_of_relative_string( &(info->notifyname) );
+ size+=size_of_relative_string( &(info->datatype) );
+ size+=size_of_relative_string( &(info->printprocessor) );
+ size+=size_of_relative_string( &(info->parameters) );
+ size+=size_of_relative_string( &(info->drivername) );
+ size+=size_of_device_mode( info->devmode );
+ size+=size_of_relative_string( &(info->text_status) );
+/* SEC_DESC sec_desc;*/
+ size+=size_of_uint32( &(info->status) );
+ size+=size_of_uint32( &(info->priority) );
+ size+=size_of_uint32( &(info->position) );
+ size+=size_of_uint32( &(info->starttime) );
+ size+=size_of_uint32( &(info->untiltime) );
+ size+=size_of_uint32( &(info->totalpages) );
+ size+=size_of_uint32( &(info->size) );
+ size+=size_of_systemtime( &(info->submitted) );
+ size+=size_of_uint32( &(info->timeelapsed) );
+ size+=size_of_uint32( &(info->pagesprinted) );
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+uint32 spoolss_size_form_1(FORM_1 *info)
+{
+ int size=0;
+
+ size+=size_of_uint32( &(info->flag) );
+ size+=size_of_relative_string( &(info->name) );
+ size+=size_of_uint32( &(info->width) );
+ size+=size_of_uint32( &(info->length) );
+ size+=size_of_uint32( &(info->left) );
+ size+=size_of_uint32( &(info->top) );
+ size+=size_of_uint32( &(info->right) );
+ size+=size_of_uint32( &(info->bottom) );
+
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+static uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
+{
+ int size=0;
+
+ size+=size_of_relative_string( &(info->port_name) );
+ size+=size_of_relative_string( &(info->monitor_name) );
+ size+=size_of_relative_string( &(info->description) );
+
+ size+=size_of_uint32( &(info->port_type) );
+ size+=size_of_uint32( &(info->reserved) );
+
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+static uint32 spoolss_size_processor_info_1(PRINTPROCESSOR_1 *info)
+{
+ int size=0;
+ size+=size_of_relative_string( &(info->name) );
+
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+static uint32 spoolss_size_monitor_info_1(PRINTMONITOR_1 *info)
+{
+ int size=0;
+ size+=size_of_relative_string( &(info->name) );
+
+ return (size);
+
+ return True;
+}
+
+/*******************************************************************
+ * make a structure.
+ ********************************************************************/
+static BOOL make_spoolss_buffer(BUFFER* buffer, uint32 size)
+{
+ buffer->ptr = (size != 0) ? 1 : 0;
+ buffer->size = size;
+ buffer->data = (uint8 *)Realloc( NULL, (buffer->size) * sizeof(uint8) );
+
+ return (buffer->data != NULL || size == 0);
+}
+
+/*******************************************************************
+ * read a uint8 buffer of size *size.
+ * allocate memory for it
+ * return a pointer to the allocated memory and the size
+ * return NULL and a size of 0 if the buffer is empty
+ *
+ * jfmxxxx: fix it to also write a buffer
+ ********************************************************************/
+static BOOL spoolss_io_read_buffer(char *desc, prs_struct *ps, int depth, BUFFER *buffer)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_read_buffer");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("pointer", ps, depth, &(buffer->ptr));
+
+ if (buffer->ptr != 0x0000)
+ {
+ prs_uint32("size", ps, depth, &(buffer->size));
+ if (ps->io)
+ {
+ /* reading */
+ buffer->data=(uint8 *)Realloc(NULL, buffer->size * sizeof(uint8) );
+ }
+ if (buffer->data == NULL)
+ {
+ return False;
+ }
+ prs_uint8s(True, "buffer", ps, depth, buffer->data, buffer->size);
+ prs_align(ps);
+
+ }
+ else
+ {
+ if (ps->io)
+ {
+ /* reading */
+ buffer->data=0x0000;
+ buffer->size=0x0000;
+ }
+ }
+
+ if (!ps->io)
+ {
+ /* writing */
+ if (buffer->data != NULL)
+ {
+ free(buffer->data);
+ }
+ buffer->data = NULL;
+ }
+ return True;
+}
+
+/*******************************************************************
+ * read a uint8 buffer of size *size.
+ * allocate memory for it
+ * return a pointer to the allocated memory and the size
+ * return NULL and a size of 0 if the buffer is empty
+ *
+ * jfmxxxx: fix it to also write a buffer
+ ********************************************************************/
+BOOL spoolss_io_free_buffer(BUFFER *buffer)
+{
+ DEBUG(8,("spoolss_io_free_buffer\n"));
+
+ if (buffer->ptr != 0x0000)
+ {
+ free(buffer->data);
+ }
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_getprinterdriver2 (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_getprinterdriver2(char *desc,
+ SPOOL_Q_GETPRINTERDRIVER2 *q_u,
+ prs_struct *ps, int depth)
+{
+ uint32 useless_ptr;
+ prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriver2");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+ smb_io_unistr2("architecture", &(q_u->architecture),True,ps,depth);
+
+ prs_align(ps);
+
+ prs_uint32("level", ps, depth, &(q_u->level));
+ spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+
+ prs_align(ps);
+
+ prs_uint32("buffer size", ps, depth, &(q_u->buf_size));
+ DEBUG(0,("spoolss_io_q_getprinterdriver2: renamed status - unknown\n"));
+ prs_uint32("unknown", ps, depth, &(q_u->unknown));
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_getprinterdriver2 (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_r_getprinterdriver2(char *desc, SPOOL_R_GETPRINTERDRIVER2 *r_u,
+ prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0xADDE0FF0;
+ uint32 start_offset, end_offset, beginning;
+ uint32 bufsize_required=0;
+ uint32 pipo=0;
+ DRIVER_INFO_1 *info1;
+ DRIVER_INFO_2 *info2;
+ DRIVER_INFO_3 *info3;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriver2");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+
+ info1 = r_u->ctr.driver.info1;
+ info2 = r_u->ctr.driver.info2;
+ info3 = r_u->ctr.driver.info3;
+
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ bufsize_required += spoolss_size_printer_driver_info_1(info1);
+ break;
+ }
+ case 2:
+ {
+ bufsize_required += spoolss_size_printer_driver_info_2(info2);
+ break;
+ }
+ case 3:
+ {
+ bufsize_required += spoolss_size_printer_driver_info_3(info3);
+ break;
+ }
+ }
+
+ if (ps->io)
+ {
+ /* reading */
+ r_u->offered = bufsize_required;
+ }
+
+ DEBUG(4,("spoolss_io_r_getprinterdriver2, size needed: %d\n",bufsize_required));
+ DEBUG(4,("spoolss_io_r_getprinterdriver2, size offered: %d\n",r_u->offered));
+
+ /* check if the buffer is big enough for the datas */
+ if (r_u->offered < bufsize_required)
+ {
+ /* it's too small */
+ r_u->status=ERROR_INSUFFICIENT_BUFFER; /* say so */
+ r_u->offered=0; /* don't send back the buffer */
+
+ DEBUG(4,("spoolss_io_r_getprinterdriver2, buffer too small\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ }
+ else
+ {
+ DEBUG(4,("spoolss_io_r_getprinterdriver2, buffer large enough\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+
+ beginning=prs_offset(ps);
+ start_offset=prs_offset(ps);
+ end_offset=start_offset+r_u->offered;
+
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ smb_io_printer_driver_info_1(desc,
+ info1,
+ ps,
+ depth,
+ &start_offset,
+ &end_offset);
+ break;
+ }
+ case 2:
+ {
+ smb_io_printer_driver_info_2(desc,
+ info2,
+ ps,
+ depth,
+ &start_offset,
+ &end_offset);
+ break;
+ }
+ case 3:
+ {
+ smb_io_printer_driver_info_3(desc,
+ info3,
+ ps,
+ depth,
+ &start_offset,
+ &end_offset);
+ break;
+ }
+
+ }
+
+ prs_set_offset(ps, beginning+r_u->offered);
+ prs_align(ps);
+ }
+
+ if (!ps->io)
+ {
+ /* writing */
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ safe_free(info1);
+ break;
+ }
+ case 2:
+ {
+ safe_free(info2);
+ break;
+ }
+ case 3:
+ {
+ if (info3!=NULL)
+ {
+ UNISTR **dependentfiles;
+ int j=0;
+ dependentfiles=info3->dependentfiles;
+ while ( dependentfiles[j] != NULL )
+ {
+ free(dependentfiles[j]);
+ j++;
+ }
+ free(dependentfiles);
+
+ free(info3);
+ }
+ break;
+ }
+
+ }
+ }
+
+ /*
+ * if the buffer was too small, send the minimum required size
+ * if it was too large, send the real needed size
+ */
+
+ prs_uint32("size of buffer needed", ps, depth, &(bufsize_required));
+ prs_uint32("pipo", ps, depth, &pipo);
+ prs_uint32("pipo", ps, depth, &pipo);
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+ * make a structure.
+ ********************************************************************/
+BOOL make_spoolss_q_enumprinters(SPOOL_Q_ENUMPRINTERS *q_u,
+ uint32 flags,
+ const char* servername,
+ uint32 level,
+ uint32 size)
+{
+ size_t len_name = servername != NULL ? strlen(servername) : 0;
+
+ DEBUG(5,("make_spoolss_q_enumprinters. size: %d\n", size));
+
+ q_u->flags = flags;
+
+ init_unistr2(&q_u->servername, servername, len_name);
+
+ q_u->level = level;
+ make_spoolss_buffer(&q_u->buffer, size);
+ q_u->buf_size = size;
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_enumprinters (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_enumprinters(char *desc, SPOOL_Q_ENUMPRINTERS *q_u,
+ prs_struct *ps, int depth)
+{
+ uint32 useless_ptr = 0x01;
+ prs_debug(ps, depth, desc, "spoolss_io_q_enumprinters");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("flags", ps, depth, &(q_u->flags));
+ prs_uint32("useless ptr", ps, depth, &useless_ptr);
+
+ smb_io_unistr2("", &q_u->servername,True,ps,depth);
+ prs_align(ps);
+
+ prs_uint32("level", ps, depth, &(q_u->level));
+
+ spoolss_io_read_buffer("buffer", ps, depth, &(q_u->buffer));
+
+ prs_uint32("buf_size", ps, depth, &q_u->buf_size);
+
+ return True;
+}
+
+/****************************************************************************
+****************************************************************************/
+void free_r_enumprinters(SPOOL_R_ENUMPRINTERS *r_u)
+{
+ DEBUG(4,("free_enum_printers_info: [%d] structs to free at level [%d]\n", r_u->returned, r_u->level));
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ free_print1_array(r_u->returned, r_u->ctr.printer.printers_1);
+ break;
+ }
+ case 2:
+ {
+ free_print2_array(r_u->returned, r_u->ctr.printer.printers_2);
+ break;
+ }
+ }
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_enum_printers (srv_spoolss.c)
+ *
+ ********************************************************************/
+BOOL spoolss_io_r_enumprinters(char *desc,
+ SPOOL_R_ENUMPRINTERS *r_u,
+ prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0xADDE0FF0;
+ int i;
+ uint32 start_offset, end_offset, beginning;
+ uint32 bufsize_required=0;
+ uint32 tmp_ct = 0;
+
+ PRINTER_INFO_1 *info1;
+ PRINTER_INFO_2 *info2;
+ fstring tmp;
+
+ slprintf(tmp, sizeof(tmp)-1, "spoolss_io_r_enumprinters %d", r_u->level);
+
+ prs_debug(ps, depth, desc, tmp);
+ depth++;
+ prs_align(ps);
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+
+ if (!ps->io)
+ {
+ /* writing */
+ for(i=0;i<r_u->returned;i++)
+ {
+ switch (r_u->level)
+ {
+ case 1:
+ info1 = r_u->ctr.printer.printers_1[i];
+ bufsize_required += spoolss_size_printer_info_1(info1);
+ break;
+ case 2:
+ info2 = r_u->ctr.printer.printers_2[i];
+ bufsize_required += spoolss_size_printer_info_2(info2);
+ break;
+ }
+ }
+
+ DEBUG(4,("spoolss_io_r_enumprinters, size needed: %d\n",bufsize_required));
+ DEBUG(4,("spoolss_io_r_enumprinters, size offered: %d\n",r_u->offered));
+
+ if (r_u->offered<bufsize_required)
+ {
+ /*
+ * so the buffer is too small to handle datas
+ * reply the minimum size required in the status
+ * make the buffer equal 0
+ * and reply no printers in buffer
+ */
+ r_u->status=ERROR_INSUFFICIENT_BUFFER;
+ r_u->offered=0;
+ /*r_u->returned=0;*/
+
+ DEBUG(4,("spoolss_io_r_enumprinters, buffer too small\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ prs_uint32("size of buffer needed", ps, depth, &(bufsize_required));
+ prs_uint32("count", ps, depth, &(r_u->returned));
+ prs_uint32("status", ps, depth, &(r_u->status));
+ return False;
+ }
+
+ DEBUG(4,("spoolss_io_r_enumprinters, buffer large enough\n"));
+ }
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+
+ /* have to skip to end of buffer when reading, and have to record
+ * size of buffer when writing. *shudder*.
+ */
+
+ beginning = prs_offset(ps);
+ start_offset = prs_offset(ps);
+ end_offset = start_offset + r_u->offered;
+
+ if (ps->io)
+ {
+ /* reading */
+ prs_set_offset(ps, beginning + r_u->offered);
+
+ prs_align(ps);
+ prs_uint32("buffer size", ps, depth, &(bufsize_required));
+ prs_uint32("count", ps, depth, &(r_u->returned));
+
+ prs_set_offset(ps, beginning);
+ }
+
+ for(i=0;i<r_u->returned;i++)
+ {
+
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ if (ps->io)
+ {
+ /* reading */
+/* r_u->ctr.printer.printers_1[i] = add_print1_to_array(&tmp_ct, &r_u->ctr.printer.printers_1, NULL);*/
+ }
+ info1 = r_u->ctr.printer.printers_1[i];
+ if (info1 == NULL)
+ {
+ return False;
+ }
+ smb_io_printer_info_1(desc, info1, ps, depth,
+ &start_offset, &end_offset);
+ break;
+ }
+ case 2:
+ {
+ if (ps->io)
+ {
+ /* reading */
+/*
+ r_u->ctr.printer.printers_2[i] = add_print2_to_array(&tmp_ct, &r_u->ctr.printer.printers_2, NULL);
+*/ }
+ info2 = r_u->ctr.printer.printers_2[i];
+ if (info2 == NULL)
+ {
+ return False;
+ }
+ smb_io_printer_info_2(desc, info2, ps, depth,
+ &start_offset, &end_offset);
+ break;
+ }
+ }
+ }
+
+ prs_set_offset(ps, beginning + r_u->offered);
+ prs_align(ps);
+
+ prs_uint32("buffer size", ps, depth, &(bufsize_required));
+ prs_uint32("count", ps, depth, &(r_u->returned));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ if (!ps->io)
+ {
+ /* writing */
+ free_r_enumprinters(r_u);
+ }
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_enum_printers (srv_spoolss.c)
+ *
+ ********************************************************************/
+BOOL spoolss_io_r_getprinter(char *desc,
+ SPOOL_R_GETPRINTER *r_u,
+ prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0xADDE0FF0;
+ uint32 start_offset, end_offset, beginning;
+ uint32 bufsize_required=0;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_getprinter");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+
+ switch (r_u->level)
+ {
+ case 0:
+ {
+ PRINTER_INFO_0 *info;
+ info = r_u->ctr.printer.info0;
+ bufsize_required += spoolss_size_printer_info_0(info);
+ break;
+ }
+ case 1:
+ {
+ PRINTER_INFO_1 *info;
+ info = r_u->ctr.printer.info1;
+ bufsize_required += spoolss_size_printer_info_1(info);
+ break;
+ }
+ case 2:
+ {
+ PRINTER_INFO_2 *info;
+ info = r_u->ctr.printer.info2;
+ bufsize_required += spoolss_size_printer_info_2(info);
+ break;
+ }
+ }
+
+ DEBUG(4,("spoolss_io_r_getprinter, size needed: %d\n",bufsize_required));
+ DEBUG(4,("spoolss_io_r_getprinter, size offered: %d\n",r_u->offered));
+
+ /* check if the buffer is big enough for the datas */
+ if (r_u->offered < bufsize_required)
+ {
+ /* it's too small */
+ r_u->status = ERROR_INSUFFICIENT_BUFFER; /* say so */
+ r_u->offered = 0; /* don't send back the buffer */
+
+ DEBUG(4,("spoolss_io_r_getprinter, buffer too small\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ }
+ else
+ {
+ DEBUG(4,("spoolss_io_r_getprinter, buffer large enough\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ }
+
+ if (ps->io)
+ {
+ /* reading */
+ r_u->ctr.printer.info = Realloc(NULL, r_u->offered);
+ }
+
+ if (bufsize_required <= r_u->offered)
+ {
+ beginning=prs_offset(ps);
+ start_offset=prs_offset(ps);
+ end_offset=start_offset+r_u->offered;
+
+ switch (r_u->level)
+ {
+ case 0:
+ {
+ PRINTER_INFO_0 *info;
+ info = r_u->ctr.printer.info0;
+ smb_io_printer_info_0(desc,
+ info,
+ ps,
+ depth,
+ &start_offset,
+ &end_offset);
+ if (!ps->io)
+ {
+ /* writing */
+ free(info);
+ }
+ break;
+ }
+ case 1:
+ {
+ PRINTER_INFO_1 *info;
+ info = r_u->ctr.printer.info1;
+ smb_io_printer_info_1(desc,
+ info,
+ ps,
+ depth,
+ &start_offset,
+ &end_offset);
+ if (!ps->io)
+ {
+ /* writing */
+ free(info);
+ }
+ break;
+ }
+ case 2:
+ {
+ PRINTER_INFO_2 *info;
+ info = r_u->ctr.printer.info2;
+ smb_io_printer_info_2(desc,
+ info,
+ ps,
+ depth,
+ &start_offset,
+ &end_offset);
+ if (!ps->io)
+ {
+ /* writing */
+ free_printer_info_2(info);
+ }
+ break;
+ }
+
+ }
+
+ prs_set_offset(ps, beginning+r_u->offered);
+ prs_align(ps);
+ }
+
+ /*
+ * if the buffer was too small, send the minimum required size
+ * if it was too large, send the real needed size
+ */
+
+ prs_uint32("size of buffer needed", ps, depth, &(bufsize_required));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+ * read a uint8 buffer of size *size.
+ * allocate memory for it
+ * return a pointer to the allocated memory and the size
+ * return NULL and a size of 0 if the buffer is empty
+ *
+ * jfmxxxx: fix it to also write a buffer
+ ********************************************************************/
+static BOOL spoolss_io_read_buffer8(char *desc, prs_struct *ps, uint8 **buffer, uint32 *size,int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_read_buffer8");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("buffer size", ps, depth, size);
+ *buffer = (uint8 *)Realloc(NULL, (*size) * sizeof(uint8) );
+ prs_uint8s(True,"buffer",ps,depth,*buffer,*size);
+ prs_align(ps);
+
+ return True;
+}
+
+/*******************************************************************
+ * make a structure.
+ * called from spoolss_getprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL make_spoolss_q_getprinter(SPOOL_Q_GETPRINTER *q_u,
+ POLICY_HND *hnd,
+ uint32 level,
+ uint32 buf_size)
+{
+ if (q_u == NULL) return False;
+
+ memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
+
+ q_u->level = level;
+ q_u->buffer = (uint8 *)Realloc(NULL, (buf_size) * sizeof(uint8) );
+ q_u->offered = buf_size;
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_getprinter (srv_spoolss.c)
+ ********************************************************************/
+BOOL spoolss_io_q_getprinter(char *desc, SPOOL_Q_GETPRINTER *q_u,
+ prs_struct *ps, int depth)
+{
+ uint32 count = 0;
+ uint32 buf_ptr = q_u->buffer != NULL ? 1 : 0;
+ prs_debug(ps, depth, desc, "spoolss_io_q_getprinter");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+
+ prs_uint32("level", ps, depth, &(q_u->level));
+
+ if (!ps->io)
+ {
+ /* writing */
+ buf_ptr = q_u->buffer != NULL ? 1 : 0;
+ }
+ prs_uint32("buffer pointer", ps, depth, &buf_ptr);
+
+ if (buf_ptr != 0)
+ {
+ spoolss_io_read_buffer8("",ps, &q_u->buffer, &count,depth);
+ }
+ if (q_u->buffer != NULL)
+ {
+ free(q_u->buffer);
+ }
+ prs_uint32("buffer size", ps, depth, &(q_u->offered));
+
+ return count == q_u->offered;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_setprinter(char *desc, SPOOL_R_SETPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_setprinter");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_setprinter(char *desc, SPOOL_Q_SETPRINTER *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_q_setprinter");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle", &(q_u->handle),ps,depth);
+ prs_uint32("level", ps, depth, &(q_u->level));
+
+ /* again a designed mess */
+ /* sometimes I'm wondering how all of this work ! */
+
+ /* To be correct it need to be split in 3 functions */
+
+ spool_io_printer_info_level("", &(q_u->info), ps, depth);
+
+ spoolss_io_devmode(desc, ps, depth, q_u->devmode);
+
+ prs_uint32("security.size_of_buffer", ps, depth, &(q_u->security.size_of_buffer));
+ prs_uint32("security.data", ps, depth, &(q_u->security.data));
+
+ prs_uint32("command", ps, depth, &(q_u->command));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_fcpn(char *desc, SPOOL_R_FCPN *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_fcpn");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_fcpn(char *desc, SPOOL_Q_FCPN *q_u, prs_struct *ps, int depth)
+{
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_fcpn");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+
+ return True;
+}
+
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_addjob(char *desc, SPOOL_R_ADDJOB *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_addjob(char *desc, SPOOL_Q_ADDJOB *q_u, prs_struct *ps, int depth)
+{
+
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ prs_uint32("level", ps, depth, &(q_u->level));
+
+ spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+
+ prs_align(ps);
+
+ prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
+
+ return True;
+}
+
+/****************************************************************************
+****************************************************************************/
+void free_job_info_ctr(JOB_INFO_CTR *ctr, uint32 level, uint32 numofjobs)
+{
+ DEBUG(4,("free_enum_jobs_info: [%d] structs to free at level [%d]\n",
+ numofjobs, level));
+ switch (level)
+ {
+ case 1:
+ {
+ free_job1_array(numofjobs,
+ ctr->job.job_info_1);
+ break;
+ }
+ case 2:
+ {
+ free_job2_array(numofjobs,
+ ctr->job.job_info_2);
+ break;
+ }
+ }
+}
+
+/****************************************************************************
+****************************************************************************/
+void free_r_enumjobs(SPOOL_R_ENUMJOBS *r_u)
+{
+ free_job_info_ctr(&r_u->ctr, r_u->level, r_u->numofjobs);
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_enumjobs(char *desc, SPOOL_R_ENUMJOBS *r_u, prs_struct *ps, int depth)
+{
+ uint32 useless_ptr = 0;
+ uint32 start_offset, end_offset, beginning;
+ uint32 bufsize_required=0;
+ uint32 tmp_ct = 0;
+ int i;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumjobs");
+ depth++;
+
+ prs_align(ps);
+
+ if (!ps->io)
+ {
+ /* writing */
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ for (i=0; i<r_u->numofjobs; i++)
+ {
+ JOB_INFO_1 *info;
+ info=r_u->ctr.job.job_info_1[i];
+ bufsize_required += spoolss_size_job_info_1(&(info[i]));
+ }
+ break;
+ }
+ case 2:
+ {
+ for (i=0; i<r_u->numofjobs; i++)
+ {
+ JOB_INFO_2 *info;
+ info=r_u->ctr.job.job_info_2[i];
+
+ bufsize_required += spoolss_size_job_info_2(&(info[i]));
+ }
+ break;
+ }
+ }
+
+ DEBUG(4,("spoolss_io_r_enumjobs, size needed: %d\n",
+ bufsize_required));
+ DEBUG(4,("spoolss_io_r_enumjobs, size offered: %d\n",
+ r_u->offered));
+
+ /* check if the buffer is big enough for the datas */
+ if (r_u->offered<bufsize_required)
+ {
+ /* it's too small */
+ r_u->status = ERROR_INSUFFICIENT_BUFFER; /* say so */
+ r_u->offered = bufsize_required;
+ useless_ptr = 0;
+
+ DEBUG(4,("spoolss_io_r_enumjobs, buffer too small\n"));
+
+ }
+ else
+ {
+ useless_ptr = 1;
+ }
+ }
+
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+
+ if (useless_ptr != 0)
+ {
+ beginning=prs_offset(ps);
+ start_offset=prs_offset(ps);
+ end_offset=start_offset+r_u->offered;
+
+ tmp_ct = 0;
+
+ if (ps->io)
+ {
+ /* reading */
+ prs_set_offset(ps, beginning + r_u->offered);
+
+ prs_align(ps);
+ prs_uint32("buffer size", ps, depth, &(bufsize_required));
+ prs_uint32("numofjobs", ps, depth, &(r_u->numofjobs));
+
+ prs_set_offset(ps, beginning);
+ }
+
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ JOB_INFO_1 *info;
+ for (i=0; i<r_u->numofjobs; i++)
+ {
+ if (ps->io)
+ {
+ /* reading */
+/* r_u->ctr.job.job_info_1[i] = add_job1_to_array(&tmp_ct, &r_u->ctr.job.job_info_1, NULL);*/
+ }
+ info = r_u->ctr.job.job_info_1[i];
+ smb_io_job_info_1(desc,
+ info,
+ ps,
+ depth,
+ &start_offset,
+ &end_offset);
+ }
+ break;
+ }
+ case 2:
+ {
+ JOB_INFO_2 *info;
+ for (i=0; i<r_u->numofjobs; i++)
+ {
+ if (ps->io)
+ {
+ /* reading */
+/* r_u->ctr.job.job_info_2[i] = add_job2_to_array(&tmp_ct, &r_u->ctr.job.job_info_2, NULL);*/
+ }
+ info = r_u->ctr.job.job_info_2[i];
+ smb_io_job_info_2(desc,
+ info,
+ ps,
+ depth,
+ &start_offset,
+ &end_offset);
+ }
+ break;
+ }
+
+ }
+ prs_set_offset(ps, beginning+r_u->offered);
+ prs_align(ps);
+
+ /*
+ * if the buffer was too small, send the minimum required size
+ * if it was too large, send the real needed size
+ */
+
+ prs_uint32("buffer size", ps, depth, &(bufsize_required));
+ }
+
+ prs_uint32("numofjobs", ps, depth, &(r_u->numofjobs));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ if (!ps->io)
+ {
+ /* writing */
+ free_r_enumjobs(r_u);
+ }
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS *q_u, const POLICY_HND *hnd,
+ uint32 firstjob,
+ uint32 numofjobs,
+ uint32 level,
+ uint32 buf_size)
+{
+ if (q_u == NULL)
+ {
+ return False;
+ }
+ memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
+ q_u->firstjob = firstjob;
+ q_u->numofjobs = numofjobs;
+ q_u->level = level;
+
+ if (!make_spoolss_buffer(&q_u->buffer, buf_size))
+ {
+ return False;
+ }
+ q_u->buf_size = buf_size;
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_enumjobs(char *desc, SPOOL_Q_ENUMJOBS *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ prs_uint32("firstjob", ps, depth, &(q_u->firstjob));
+ prs_uint32("numofjobs", ps, depth, &(q_u->numofjobs));
+ prs_uint32("level", ps, depth, &(q_u->level));
+
+ spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+
+ prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_schedulejob(char *desc, SPOOL_R_SCHEDULEJOB *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_schedulejob");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_schedulejob(char *desc, SPOOL_Q_SCHEDULEJOB *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_q_schedulejob");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ prs_uint32("jobid", ps, depth, &(q_u->jobid));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_setjob(char *desc, SPOOL_R_SETJOB *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_setjob");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_setjob(char *desc, SPOOL_Q_SETJOB *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_q_setjob");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ prs_uint32("jobid", ps, depth, &(q_u->jobid));
+ /*
+ * level is usually 0. If (level!=0) then I'm in trouble !
+ * I will try to generate setjob command with level!=0, one day.
+ */
+ prs_uint32("level", ps, depth, &(q_u->level));
+ prs_uint32("command", ps, depth, &(q_u->command));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_enumdrivers(char *desc, SPOOL_R_ENUMPRINTERDRIVERS *r_u, prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0xADDE0FF0;
+ uint32 start_offset, end_offset, beginning;
+ uint32 bufsize_required=0;
+ int i;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumdrivers");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+
+ DEBUG(7,("Level [%d], number [%d]\n", r_u->level, r_u->numofdrivers));
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ DRIVER_INFO_1 *driver_info_1;
+ driver_info_1=r_u->ctr.driver.info1;
+
+ for (i=0; i<r_u->numofdrivers; i++)
+ {
+ bufsize_required += spoolss_size_printer_driver_info_1(&(driver_info_1[i]));
+ }
+ break;
+ }
+ case 2:
+ {
+ DRIVER_INFO_2 *driver_info_2;
+ driver_info_2=r_u->ctr.driver.info2;
+
+ for (i=0; i<r_u->numofdrivers; i++)
+ {
+ bufsize_required += spoolss_size_printer_driver_info_2(&(driver_info_2[i]));
+ }
+ break;
+ }
+ case 3:
+ {
+ DRIVER_INFO_3 *driver_info_3;
+ driver_info_3=r_u->ctr.driver.info3;
+
+ for (i=0; i<r_u->numofdrivers; i++)
+ {
+ bufsize_required += spoolss_size_printer_driver_info_3(&(driver_info_3[i]));
+ }
+ break;
+ }
+ }
+
+ DEBUGADD(7,("size needed: %d\n",bufsize_required));
+ DEBUGADD(7,("size offered: %d\n",r_u->offered));
+
+ /* check if the buffer is big enough for the datas */
+
+ if (r_u->offered<bufsize_required)
+ {
+
+ /* it's too small */
+ r_u->status=ERROR_INSUFFICIENT_BUFFER; /* say so */
+ r_u->offered=0; /* don't send back the buffer */
+ DEBUGADD(8,("buffer too small\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ }
+ else
+ {
+ DEBUGADD(8,("buffer large enough\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ beginning=prs_offset(ps);
+ start_offset=prs_offset(ps);
+ end_offset=start_offset+r_u->offered;
+
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ DRIVER_INFO_1 *info;
+ for (i=0; i<r_u->numofdrivers; i++)
+ {
+ info = &(r_u->ctr.driver.info1[i]);
+ smb_io_printer_driver_info_1(desc, info, ps, depth, &start_offset, &end_offset);
+ }
+ break;
+ }
+ case 2:
+ {
+ DRIVER_INFO_2 *info;
+ for (i=0; i<r_u->numofdrivers; i++)
+ {
+ info = &(r_u->ctr.driver.info2[i]);
+ smb_io_printer_driver_info_2(desc, info, ps, depth, &start_offset, &end_offset);
+ }
+ break;
+ }
+ case 3:
+ {
+ DRIVER_INFO_3 *info;
+ for (i=0; i<r_u->numofdrivers; i++)
+ {
+ info = &(r_u->ctr.driver.info3[i]);
+ smb_io_printer_driver_info_3(desc, info, ps, depth, &start_offset, &end_offset);
+ }
+ break;
+ }
+ }
+ prs_set_offset(ps, beginning+r_u->offered);
+ prs_align(ps);
+ }
+
+ /*
+ * if the buffer was too small, send the minimum required size
+ * if it was too large, send the real needed size
+ */
+
+ prs_uint32("size of buffer needed", ps, depth, &(bufsize_required));
+ prs_uint32("numofdrivers", ps, depth, &(r_u->numofdrivers));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+
+void free_spoolss_r_enumdrivers(SPOOL_R_ENUMPRINTERDRIVERS *r_u)
+{
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ DRIVER_INFO_1 *driver_info_1;
+ driver_info_1=r_u->ctr.driver.info1;
+
+ free(driver_info_1);
+ break;
+ }
+ case 2:
+ {
+ DRIVER_INFO_2 *driver_info_2;
+ driver_info_2=r_u->ctr.driver.info2;
+
+ free(driver_info_2);
+ break;
+ }
+ case 3:
+ {
+ DRIVER_INFO_3 *driver_info_3;
+
+ UNISTR **dependentfiles;
+ int i;
+
+ driver_info_3=r_u->ctr.driver.info3;
+
+ for (i=0; i<r_u->numofdrivers; i++)
+ {
+ int j=0;
+ dependentfiles=(driver_info_3[i]).dependentfiles;
+ while ( dependentfiles[j] != NULL )
+ {
+ free(dependentfiles[j]);
+ j++;
+ }
+
+ free(dependentfiles);
+ }
+ free(driver_info_3);
+ break;
+ }
+ }
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_enumprinterdrivers(char *desc, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, prs_struct *ps, int depth)
+{
+
+ uint32 useless_ptr=0xADDE0FF0;
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+ smb_io_unistr2("", &(q_u->name),True,ps,depth);
+ prs_align(ps);
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+ smb_io_unistr2("", &(q_u->environment),True,ps,depth);
+ prs_align(ps);
+ prs_uint32("level", ps, depth, &(q_u->level));
+ spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+ prs_align(ps);
+ prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_enumforms(char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth)
+{
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_enumforms");
+ depth++;
+
+ if (!prs_align(ps))
+ return False;
+ if (!smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth))
+ return False;
+ if (!prs_uint32("level", ps, depth, &(q_u->level)))
+ return False;
+
+ if (!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ return False;
+
+ if (!prs_align(ps))
+ return False;
+ if (!prs_uint32("offered", ps, depth, &(q_u->offered)))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL new_spoolss_io_r_enumforms(char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "new_spoolss_io_r_enumforms");
+ depth++;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("size of buffer needed", ps, depth, &(r_u->needed)))
+ return False;
+
+ if (!prs_uint32("numofforms", ps, depth, &(r_u->numofforms)))
+ return False;
+
+ if (!prs_uint32("status", ps, depth, &(r_u->status)))
+ return False;
+
+ return True;
+
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_enumports(char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0xADDE0FF0;
+ uint32 start_offset, end_offset, beginning;
+ uint32 bufsize_required=0;
+ int i;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumports");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+ switch (r_u->level)
+ {
+ case 2:
+ {
+ PORT_INFO_2 *port_2;
+ port_2=r_u->ctr.port.info_2;
+
+ for (i=0; i<r_u->numofports; i++)
+ {
+ bufsize_required += spoolss_size_port_info_2(&(port_2[i]));
+ }
+ break;
+ }
+ }
+
+ DEBUG(4,("size needed: %d\n",bufsize_required));
+ DEBUG(4,("size offered: %d\n",r_u->offered));
+
+ /* check if the buffer is big enough for the datas */
+ if (r_u->offered<bufsize_required)
+ {
+
+ /* it's too small */
+ r_u->status=ERROR_INSUFFICIENT_BUFFER; /* say so */
+ r_u->offered=0; /* don't send back the buffer */
+
+ DEBUG(4,("buffer too small\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ }
+ else
+ {
+ DEBUG(4,("buffer large enough\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ beginning=prs_offset(ps);
+ start_offset=prs_offset(ps);
+ end_offset=start_offset+r_u->offered;
+
+ switch (r_u->level)
+ {
+ case 2:
+ {
+ PORT_INFO_2 *info;
+ for (i=0; i<r_u->numofports; i++)
+ {
+ info = &(r_u->ctr.port.info_2[i]);
+ smb_io_port_2(desc, info, ps, depth, &start_offset, &end_offset);
+ }
+ break;
+ }
+ }
+ prs_set_offset(ps, beginning+r_u->offered);
+ prs_align(ps);
+ }
+
+ /*
+ * if the buffer was too small, send the minimum required size
+ * if it was too large, send the real needed size
+ */
+
+ prs_uint32("size of buffer needed", ps, depth, &(bufsize_required));
+ prs_uint32("numofports", ps, depth, &(r_u->numofports));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+void spoolss_free_r_enumports(SPOOL_R_ENUMPORTS *r_u)
+{
+ switch (r_u->level)
+ {
+ case 2:
+ {
+ safe_free(r_u->ctr.port.info_2);
+ break;
+ }
+ }
+}
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_enumports(char *desc, SPOOL_Q_ENUMPORTS *q_u, prs_struct *ps, int depth)
+{
+ uint32 useless;
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("useless", ps, depth, &useless);
+ smb_io_unistr2("", &(q_u->name),True,ps,depth);
+ prs_align(ps);
+ prs_uint32("level", ps, depth, &(q_u->level));
+ spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+ prs_align(ps);
+ prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
+
+ return True;
+}
+
+
+/*******************************************************************
+********************************************************************/
+BOOL spool_io_printer_info_level_2(char *desc, SPOOL_PRINTER_INFO_LEVEL_2 **q_u, prs_struct *ps, int depth)
+{
+ SPOOL_PRINTER_INFO_LEVEL_2 *il;
+
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ /* reading */
+ if (ps->io)
+ {
+ il=(SPOOL_PRINTER_INFO_LEVEL_2 *)malloc(sizeof(SPOOL_PRINTER_INFO_LEVEL_2));
+ ZERO_STRUCTP(il);
+ *q_u=il;
+ DEBUG(7,("lecture: memoire ok\n"));
+ }
+ else
+ {
+ il=*q_u;
+ }
+
+ prs_align(ps);
+
+ prs_uint32("servername_ptr", ps, depth, &(il->servername_ptr));
+ prs_uint32("printername_ptr", ps, depth, &(il->printername_ptr));
+ prs_uint32("sharename_ptr", ps, depth, &(il->sharename_ptr));
+ prs_uint32("portname_ptr", ps, depth, &(il->portname_ptr));
+ prs_uint32("drivername_ptr", ps, depth, &(il->drivername_ptr));
+ prs_uint32("comment_ptr", ps, depth, &(il->comment_ptr));
+ prs_uint32("location_ptr", ps, depth, &(il->location_ptr));
+ prs_uint32("devmode_ptr", ps, depth, &(il->devmode_ptr));
+ prs_uint32("sepfile_ptr", ps, depth, &(il->sepfile_ptr));
+ prs_uint32("printprocessor_ptr", ps, depth, &(il->printprocessor_ptr));
+ prs_uint32("datatype_ptr", ps, depth, &(il->datatype_ptr));
+ prs_uint32("parameters_ptr", ps, depth, &(il->parameters_ptr));
+ prs_uint32("secdesc_ptr", ps, depth, &(il->secdesc_ptr));
+
+ prs_uint32("attributes", ps, depth, &(il->attributes));
+ prs_uint32("priority", ps, depth, &(il->priority));
+ prs_uint32("default_priority", ps, depth, &(il->default_priority));
+ prs_uint32("starttime", ps, depth, &(il->starttime));
+ prs_uint32("untiltime", ps, depth, &(il->untiltime));
+ prs_uint32("status", ps, depth, &(il->status));
+ prs_uint32("cjobs", ps, depth, &(il->cjobs));
+ prs_uint32("averageppm", ps, depth, &(il->averageppm));
+
+ smb_io_unistr2("", &(il->servername), il->servername_ptr, ps, depth);
+ smb_io_unistr2("", &(il->printername), il->printername_ptr, ps, depth);
+ smb_io_unistr2("", &(il->sharename), il->sharename_ptr, ps, depth);
+ smb_io_unistr2("", &(il->portname), il->portname_ptr, ps, depth);
+ smb_io_unistr2("", &(il->drivername), il->drivername_ptr, ps, depth);
+ smb_io_unistr2("", &(il->comment), il->comment_ptr, ps, depth);
+ smb_io_unistr2("", &(il->location), il->location_ptr, ps, depth);
+ smb_io_unistr2("", &(il->sepfile), il->sepfile_ptr, ps, depth);
+ smb_io_unistr2("", &(il->printprocessor), il->printprocessor_ptr, ps, depth);
+ smb_io_unistr2("", &(il->datatype), il->datatype_ptr, ps, depth);
+ smb_io_unistr2("", &(il->parameters), il->parameters_ptr, ps, depth);
+
+ prs_align(ps);
+
+ /* this code as nothing to do here !!!
+
+ if (il->secdesc_ptr)
+ {
+ il->secdesc=NULL;
+ sec_io_desc_buf("", &(il->secdesc), ps, depth);
+ }
+
+ */
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spool_io_printer_info_level(char *desc, SPOOL_PRINTER_INFO_LEVEL *il, prs_struct *ps, int depth)
+{
+ uint32 useless;
+ uint32 level;
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("info level", ps, depth, &level);
+ prs_uint32("useless", ps, depth, &useless);
+
+ switch (level)
+ {
+ /*
+ * level 0 is used by setprinter when managing the queue
+ * (hold, stop, start a queue)
+ */
+ case 0:
+ break;
+ /*
+ * level 2 is used by addprinter
+ * and by setprinter when updating printer's info
+ */
+ case 2:
+ spool_io_printer_info_level_2("", &(il->info_2), ps, depth);
+ break;
+ }
+
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_addprinterex(char *desc, SPOOL_Q_ADDPRINTEREX *q_u, prs_struct *ps, int depth)
+{
+ uint32 useless;
+ prs_debug(ps, depth, desc, "spoolss_io_q_addprinterex");
+ depth++;
+
+ /*
+ * I think that's one of the few well written functions.
+ * the sub-structures are correctly parsed and analysed
+ * the info level are handled in a nice way.
+ */
+
+ prs_align(ps);
+ prs_uint32("useless", ps, depth, &useless);
+ smb_io_unistr2("", &(q_u->server_name),True,ps,depth);
+ prs_align(ps);
+
+ prs_uint32("info_level", ps, depth, &(q_u->level));
+
+ spool_io_printer_info_level("", &(q_u->info), ps, depth);
+
+ /* the 4 unknown are all 0 */
+
+ /*
+ * en fait ils sont pas inconnu
+ * par recoupement avec rpcSetPrinter
+ * c'est le devicemode
+ * et le security descriptor.
+ */
+
+ prs_uint32("unk0", ps, depth, &(q_u->unk0));
+ prs_uint32("unk1", ps, depth, &(q_u->unk1));
+ prs_uint32("unk2", ps, depth, &(q_u->unk2));
+ prs_uint32("unk3", ps, depth, &(q_u->unk3));
+
+ prs_uint32("info_level", ps, depth, &(q_u->user_level));
+
+ spool_io_user_level("", &(q_u->user), ps, depth);
+
+ return True;
+}
+
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_addprinterex(char *desc, SPOOL_R_ADDPRINTEREX *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_addprinterex");
+ depth++;
+
+ smb_io_prt_hnd("printer handle",&(r_u->handle),ps,depth);
+
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spool_io_printer_driver_info_level_3(char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **q_u,
+ prs_struct *ps, int depth)
+{
+ SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *il;
+
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ /* reading */
+ if (ps->io)
+ {
+ il=(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *)malloc(sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3));
+ ZERO_STRUCTP(il);
+ *q_u=il;
+ DEBUG(1,("lecture: memoire ok\n"));
+ }
+ else
+ {
+ il=*q_u;
+ }
+
+ prs_align(ps);
+
+ prs_uint32("cversion", ps, depth, &(il->cversion));
+ prs_uint32("name", ps, depth, &(il->name_ptr));
+ prs_uint32("environment", ps, depth, &(il->environment_ptr));
+ prs_uint32("driverpath", ps, depth, &(il->driverpath_ptr));
+ prs_uint32("datafile", ps, depth, &(il->datafile_ptr));
+ prs_uint32("configfile", ps, depth, &(il->configfile_ptr));
+ prs_uint32("helpfile", ps, depth, &(il->helpfile_ptr));
+ prs_uint32("monitorname", ps, depth, &(il->monitorname_ptr));
+ prs_uint32("defaultdatatype", ps, depth, &(il->defaultdatatype_ptr));
+ prs_uint32("dependentfilessize", ps, depth, &(il->dependentfilessize));
+ prs_uint32("dependentfiles", ps, depth, &(il->dependentfiles_ptr));
+
+ prs_align(ps);
+
+ smb_io_unistr2("", &(il->name), il->name_ptr, ps, depth);
+ smb_io_unistr2("", &(il->environment), il->environment_ptr, ps, depth);
+ smb_io_unistr2("", &(il->driverpath), il->driverpath_ptr, ps, depth);
+ smb_io_unistr2("", &(il->datafile), il->datafile_ptr, ps, depth);
+ smb_io_unistr2("", &(il->configfile), il->configfile_ptr, ps, depth);
+ smb_io_unistr2("", &(il->helpfile), il->helpfile_ptr, ps, depth);
+ smb_io_unistr2("", &(il->monitorname), il->monitorname_ptr, ps, depth);
+ smb_io_unistr2("", &(il->defaultdatatype), il->defaultdatatype_ptr, ps, depth);
+
+ prs_align(ps);
+ if (il->dependentfiles_ptr)
+ smb_io_buffer5("", &(il->dependentfiles), ps, depth);
+
+
+ return True;
+}
+
+
+/*******************************************************************
+ convert a buffer of UNICODE strings null terminated
+ the buffer is terminated by a NULL
+
+ convert to an ascii array (null terminated)
+
+ dynamically allocate memory
+
+********************************************************************/
+BOOL uniarray_2_ascarray(BUFFER5 *buf5, char ***ar)
+{
+ char **array;
+ char *string;
+ char *destend;
+ char *dest;
+ uint32 n;
+ uint32 i;
+
+ uint16 *src;
+
+ if (buf5==NULL) return False;
+
+ array=NULL;
+ n=0;
+ i=0;
+ src=buf5->buffer;
+
+ string=(char *)malloc(sizeof(char)*buf5->buf_len);
+
+ destend = string + buf5->buf_len;
+ dest=string;
+
+ while (dest < destend)
+ {
+ *(dest++) = (char)*(src++);
+ }
+
+ /* that ugly for the first one but that's working */
+ array=(char **)Realloc(array, sizeof(char *)*(i+1));
+ array[i++]=string;
+
+ while ( n < buf5->buf_len )
+ {
+ if ( *(string++) == '\0' )
+ {
+ array=(char **)Realloc(array, sizeof(char *)*(i+1));
+ array[i++]=string;
+ }
+ n++;
+ }
+ *ar=array;
+
+ DEBUG(10,("Number of dependent files: [%d]\n", i-1));
+
+ return True;
+}
+
+/*******************************************************************
+ read a UNICODE array with null terminated strings
+ and null terminated array
+ and size of array at beginning
+********************************************************************/
+BOOL smb_io_unibuffer(char *desc, UNISTR2 *buffer, prs_struct *ps, int depth)
+{
+ if (buffer==NULL) return False;
+
+ buffer->undoc=0;
+ buffer->uni_str_len=buffer->uni_max_len;
+
+ prs_uint32("buffer_size", ps, depth, &(buffer->uni_max_len));
+
+ prs_unistr2(True, "buffer ", ps, depth, buffer);
+
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spool_io_printer_driver_info_level(char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL *il, prs_struct *ps, int depth)
+{
+ uint32 useless;
+ uint32 level;
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("info level", ps, depth, &level);
+ prs_uint32("useless", ps, depth, &useless);
+
+ switch (level)
+ {
+ case 3:
+ spool_io_printer_driver_info_level_3("", &(il->info_3), ps, depth);
+ break;
+ }
+
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_addprinterdriver(char *desc, SPOOL_Q_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
+{
+ uint32 useless;
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("useless", ps, depth, &useless);
+ smb_io_unistr2("", &(q_u->server_name),True,ps,depth);
+ prs_align(ps);
+ prs_uint32("info_level", ps, depth, &(q_u->level));
+
+ spool_io_printer_driver_info_level("", &(q_u->info), ps, depth);
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_addprinterdriver(char *desc, SPOOL_R_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ prs_uint32("status", ps, depth, &(q_u->status));
+
+ return True;
+}
+
+
+/*******************************************************************
+********************************************************************/
+BOOL uni_2_asc_printer_driver_3(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *uni,
+ NT_PRINTER_DRIVER_INFO_LEVEL_3 **asc)
+{
+ NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
+
+ DEBUG(7,("uni_2_asc_printer_driver_3: Converting from UNICODE to ASCII\n"));
+
+ if (*asc==NULL)
+ {
+ *asc=(NT_PRINTER_DRIVER_INFO_LEVEL_3 *)malloc(sizeof(NT_PRINTER_DRIVER_INFO_LEVEL_3));
+ ZERO_STRUCTP(*asc);
+ }
+
+ d=*asc;
+
+ d->cversion=uni->cversion;
+
+ unistr2_to_ascii(d->name, &(uni->name), sizeof(d->name)-1);
+ unistr2_to_ascii(d->environment, &(uni->environment), sizeof(d->environment)-1);
+ unistr2_to_ascii(d->driverpath, &(uni->driverpath), sizeof(d->driverpath)-1);
+ unistr2_to_ascii(d->datafile, &(uni->datafile), sizeof(d->datafile)-1);
+ unistr2_to_ascii(d->configfile, &(uni->configfile), sizeof(d->configfile)-1);
+ unistr2_to_ascii(d->helpfile, &(uni->helpfile), sizeof(d->helpfile)-1);
+ unistr2_to_ascii(d->monitorname, &(uni->monitorname), sizeof(d->monitorname)-1);
+ unistr2_to_ascii(d->defaultdatatype, &(uni->defaultdatatype), sizeof(d->defaultdatatype)-1);
+
+ DEBUGADD(8,( "version: %d\n", d->cversion));
+ DEBUGADD(8,( "name: %s\n", d->name));
+ DEBUGADD(8,( "environment: %s\n", d->environment));
+ DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
+ DEBUGADD(8,( "datafile: %s\n", d->datafile));
+ DEBUGADD(8,( "configfile: %s\n", d->configfile));
+ DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
+ DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
+ DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
+
+ uniarray_2_ascarray(&(uni->dependentfiles), &(d->dependentfiles) );
+
+ return True;
+}
+
+BOOL uni_2_asc_printer_info_2(const SPOOL_PRINTER_INFO_LEVEL_2 *uni,
+ NT_PRINTER_INFO_LEVEL_2 **asc)
+{
+ NT_PRINTER_INFO_LEVEL_2 *d;
+
+ DEBUG(7,("Converting from UNICODE to ASCII\n"));
+
+ if (*asc==NULL)
+ {
+ DEBUGADD(8,("allocating memory\n"));
+
+ *asc=(NT_PRINTER_INFO_LEVEL_2 *)malloc(sizeof(NT_PRINTER_INFO_LEVEL_2));
+ ZERO_STRUCTP(*asc);
+ }
+ DEBUGADD(8,("start converting\n"));
+
+ d=*asc;
+
+ d->attributes=uni->attributes;
+ d->priority=uni->priority;
+ d->default_priority=uni->default_priority;
+ d->starttime=uni->starttime;
+ d->untiltime=uni->untiltime;
+ d->status=uni->status;
+ d->cjobs=uni->cjobs;
+
+ unistr2_to_ascii(d->servername, &(uni->servername), sizeof(d->servername)-1);
+ unistr2_to_ascii(d->printername, &(uni->printername), sizeof(d->printername)-1);
+ unistr2_to_ascii(d->sharename, &(uni->sharename), sizeof(d->sharename)-1);
+ unistr2_to_ascii(d->portname, &(uni->portname), sizeof(d->portname)-1);
+ unistr2_to_ascii(d->drivername, &(uni->drivername), sizeof(d->drivername)-1);
+ unistr2_to_ascii(d->comment, &(uni->comment), sizeof(d->comment)-1);
+ unistr2_to_ascii(d->location, &(uni->location), sizeof(d->location)-1);
+ unistr2_to_ascii(d->sepfile, &(uni->sepfile), sizeof(d->sepfile)-1);
+ unistr2_to_ascii(d->printprocessor, &(uni->printprocessor), sizeof(d->printprocessor)-1);
+ unistr2_to_ascii(d->datatype, &(uni->datatype), sizeof(d->datatype)-1);
+ unistr2_to_ascii(d->parameters, &(uni->parameters), sizeof(d->parameters)-1);
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_getprinterdriverdir(char *desc, SPOOL_R_GETPRINTERDRIVERDIR *r_u, prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0xADDE0FF0;
+ uint32 start_offset, end_offset, beginning;
+ uint32 bufsize_required=0;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriverdir");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ DRIVER_DIRECTORY_1 *driver_info_1;
+ driver_info_1=&(r_u->ctr.driver.info_1);
+
+ bufsize_required = size_of_relative_string(&(driver_info_1->name));
+ break;
+ }
+ }
+
+ DEBUG(4,("spoolss_io_r_getprinterdriverdir, size needed: %d\n",bufsize_required));
+ DEBUG(4,("spoolss_io_r_getprinterdriverdir, size offered: %d\n",r_u->offered));
+
+ /* check if the buffer is big enough for the datas */
+
+ if (r_u->offered<bufsize_required)
+ {
+
+ /* it's too small */
+ r_u->status=ERROR_INSUFFICIENT_BUFFER; /* say so */
+ r_u->offered=0; /* don't send back the buffer */
+ DEBUG(4,("spoolss_io_r_getprinterdriverdir, buffer too small\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ }
+ else
+ {
+ DEBUG(4,("spoolss_io_r_getprinterdriverdir, buffer large enough\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ beginning=prs_offset(ps);
+ start_offset=prs_offset(ps);
+ end_offset=start_offset+r_u->offered;
+
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ DRIVER_DIRECTORY_1 *info;
+ info = &(r_u->ctr.driver.info_1);
+ prs_unistr("name", ps, depth, &(info->name));
+ /*smb_io_printer_driver_dir_1(desc, info, ps, depth, &start_offset, &end_offset);*/
+ break;
+ }
+ }
+ prs_set_offset(ps, beginning+r_u->offered);
+ prs_align(ps);
+ }
+
+ /*
+ * if the buffer was too small, send the minimum required size
+ * if it was too large, send the real needed size
+ */
+
+ prs_uint32("size of buffer needed", ps, depth, &(bufsize_required));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_getprinterdriverdir(char *desc, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, prs_struct *ps, int depth)
+{
+
+ uint32 useless_ptr=0xADDE0FF0;
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+ smb_io_unistr2("", &(q_u->name),True,ps,depth);
+ prs_align(ps);
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+ smb_io_unistr2("", &(q_u->environment),True,ps,depth);
+ prs_align(ps);
+ prs_uint32("level", ps, depth, &(q_u->level));
+ spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+ prs_align(ps);
+ prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_enumprintprocessors(char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0xADDE0FF0;
+ uint32 start_offset, end_offset, beginning;
+ uint32 bufsize_required=0;
+ int i;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ PRINTPROCESSOR_1 *info_1;
+ info_1=r_u->info_1;
+
+ for (i=0; i<r_u->numofprintprocessors; i++)
+ {
+ bufsize_required += spoolss_size_processor_info_1(&(info_1[i]));
+ }
+ break;
+ }
+ }
+
+ DEBUG(4,("size needed: %d\n",bufsize_required));
+ DEBUG(4,("size offered: %d\n",r_u->offered));
+
+ /* check if the buffer is big enough for the datas */
+ if (r_u->offered<bufsize_required)
+ {
+
+ /* it's too small */
+ r_u->status=ERROR_INSUFFICIENT_BUFFER; /* say so */
+ r_u->offered=0; /* don't send back the buffer */
+
+ DEBUG(4,("buffer too small\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ }
+ else
+ {
+ DEBUG(4,("buffer large enough\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ beginning=prs_offset(ps);
+ start_offset=prs_offset(ps);
+ end_offset=start_offset+r_u->offered;
+
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ PRINTPROCESSOR_1 *info_1;
+ for (i=0; i<r_u->numofprintprocessors; i++)
+ {
+ info_1 = &(r_u->info_1[i]);
+ smb_io_processor_info_1(desc, info_1, ps, depth, &start_offset, &end_offset);
+ }
+ break;
+ }
+ }
+ prs_set_offset(ps, beginning+r_u->offered);
+ prs_align(ps);
+ }
+
+ /*
+ * if the buffer was too small, send the minimum required size
+ * if it was too large, send the real needed size
+ */
+
+ prs_uint32("size of buffer needed", ps, depth, &(bufsize_required));
+ prs_uint32("numofprintprocessors", ps, depth, &(r_u->numofprintprocessors));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_enumprintprocessors(char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
+{
+ uint32 useless;
+ prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("useless", ps, depth, &useless);
+ smb_io_unistr2("", &(q_u->name),True,ps,depth);
+ prs_align(ps);
+ prs_uint32("useless", ps, depth, &useless);
+ smb_io_unistr2("", &(q_u->environment),True,ps,depth);
+ prs_align(ps);
+ prs_uint32("level", ps, depth, &(q_u->level));
+ spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+ prs_align(ps);
+ prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_enumprintmonitors(char *desc, SPOOL_R_ENUMPRINTMONITORS *r_u, prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0xADDE0FF0;
+ uint32 start_offset, end_offset, beginning;
+ uint32 bufsize_required=0;
+ int i;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumprintmonitors");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ PRINTMONITOR_1 *info_1;
+ info_1=r_u->info_1;
+
+ for (i=0; i<r_u->numofprintmonitors; i++)
+ {
+ bufsize_required += spoolss_size_monitor_info_1(&(info_1[i]));
+ }
+ break;
+ }
+ }
+
+ DEBUG(4,("size needed: %d\n",bufsize_required));
+ DEBUG(4,("size offered: %d\n",r_u->offered));
+
+ /* check if the buffer is big enough for the datas */
+ if (r_u->offered<bufsize_required)
+ {
+
+ /* it's too small */
+ r_u->status=ERROR_INSUFFICIENT_BUFFER; /* say so */
+ r_u->offered=0; /* don't send back the buffer */
+
+ DEBUG(4,("buffer too small\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ }
+ else
+ {
+ DEBUG(4,("buffer large enough\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ beginning=prs_offset(ps);
+ start_offset=prs_offset(ps);
+ end_offset=start_offset+r_u->offered;
+
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ PRINTMONITOR_1 *info_1;
+ for (i=0; i<r_u->numofprintmonitors; i++)
+ {
+ info_1 = &(r_u->info_1[i]);
+ smb_io_monitor_info_1(desc, info_1, ps, depth, &start_offset, &end_offset);
+ }
+ break;
+ }
+ }
+ prs_set_offset(ps, beginning+r_u->offered);
+ prs_align(ps);
+ }
+
+ /*
+ * if the buffer was too small, send the minimum required size
+ * if it was too large, send the real needed size
+ */
+
+ prs_uint32("size of buffer needed", ps, depth, &(bufsize_required));
+ prs_uint32("numofprintmonitors", ps, depth, &(r_u->numofprintmonitors));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_enumprintmonitors(char *desc, SPOOL_Q_ENUMPRINTMONITORS *q_u, prs_struct *ps, int depth)
+{
+ uint32 useless;
+ prs_debug(ps, depth, desc, "spoolss_io_q_enumprintmonitors");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("useless", ps, depth, &useless);
+ smb_io_unistr2("", &(q_u->name),True,ps,depth);
+ prs_align(ps);
+ prs_uint32("level", ps, depth, &(q_u->level));
+ spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+ prs_align(ps);
+ prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_enumprinterdata(char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("valuesize", ps, depth, &(r_u->valuesize));
+ prs_unistr("value", ps, depth, &(r_u->value));
+ prs_uint32("realvaluesize", ps, depth, &(r_u->realvaluesize));
+
+ prs_uint32("type", ps, depth, &(r_u->type));
+
+ prs_uint32("datasize", ps, depth, &(r_u->datasize));
+ prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize);
+ prs_uint32("realdatasize", ps, depth, &(r_u->realdatasize));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_enumprinterdata(char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
+ depth++;
+
+ prs_align(ps);
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ prs_uint32("index", ps, depth, &(q_u->index));
+ prs_uint32("valuesize", ps, depth, &(q_u->valuesize));
+ prs_uint32("datasize", ps, depth, &(q_u->datasize));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_setprinterdata(char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
+ depth++;
+
+ prs_align(ps);
+ smb_io_prt_hnd("printer handle", &(q_u->handle), ps, depth);
+ smb_io_unistr2("", &(q_u->value), True, ps, depth);
+
+ prs_align(ps);
+
+ prs_uint32("type", ps, depth, &(q_u->type));
+
+ prs_uint32("max_len", ps, depth, &(q_u->max_len));
+
+ switch (q_u->type)
+ {
+ case 0x1:
+ case 0x3:
+ case 0x4:
+ case 0x7:
+ q_u->data=(uint8 *)malloc(q_u->max_len * sizeof(uint8));
+ prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len);
+ prs_align(ps);
+ break;
+ }
+
+ prs_uint32("real_len", ps, depth, &(q_u->real_len));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_setprinterdata(char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL convert_specific_param(NT_PRINTER_PARAM **param, const UNISTR2 *value,
+ uint32 type, const uint8 *data, uint32 len)
+{
+ DEBUG(5,("converting a specific param struct\n"));
+
+ if (*param == NULL)
+ {
+ *param=(NT_PRINTER_PARAM *)malloc(sizeof(NT_PRINTER_PARAM));
+ ZERO_STRUCTP(*param);
+ DEBUGADD(6,("Allocated a new PARAM struct\n"));
+ }
+ unistr2_to_ascii((*param)->value, value, sizeof((*param)->value)-1);
+ (*param)->type = type;
+
+ /* le champ data n'est pas NULL termine */
+ /* on stocke donc la longueur */
+
+ (*param)->data_len=len;
+
+ (*param)->data=(uint8 *)malloc(len * sizeof(uint8));
+
+ memcpy((*param)->data, data, len);
+
+ DEBUGADD(6,("\tvalue:[%s], len:[%d]\n",(*param)->value, (*param)->data_len));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+static BOOL spoolss_io_addform(char *desc, FORM *f, uint32 ptr, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_addform");
+ depth++;
+ prs_align(ps);
+
+ if (ptr!=0)
+ {
+ prs_uint32("flags", ps, depth, &(f->flags));
+ prs_uint32("name_ptr", ps, depth, &(f->name_ptr));
+ prs_uint32("size_x", ps, depth, &(f->size_x));
+ prs_uint32("size_y", ps, depth, &(f->size_y));
+ prs_uint32("left", ps, depth, &(f->left));
+ prs_uint32("top", ps, depth, &(f->top));
+ prs_uint32("right", ps, depth, &(f->right));
+ prs_uint32("bottom", ps, depth, &(f->bottom));
+
+ smb_io_unistr2("", &(f->name), f->name_ptr, ps, depth);
+ }
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_addform(char *desc, SPOOL_Q_ADDFORM *q_u, prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0;
+ prs_debug(ps, depth, desc, "spoolss_io_q_addform");
+ depth++;
+
+ prs_align(ps);
+ smb_io_prt_hnd("printer handle", &(q_u->handle), ps, depth);
+ prs_uint32("level", ps, depth, &(q_u->level));
+ prs_uint32("level2", ps, depth, &(q_u->level2));
+
+ if (q_u->level==1)
+ {
+ prs_uint32("useless_ptr", ps, depth, &(useless_ptr));
+ spoolss_io_addform("", &(q_u->form), useless_ptr, ps, depth);
+ }
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_addform(char *desc, SPOOL_R_ADDFORM *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_addform");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_setform(char *desc, SPOOL_Q_SETFORM *q_u, prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0;
+ prs_debug(ps, depth, desc, "spoolss_io_q_setform");
+ depth++;
+
+ prs_align(ps);
+ smb_io_prt_hnd("printer handle", &(q_u->handle), ps, depth);
+ smb_io_unistr2("", &(q_u->name), True, ps, depth);
+
+ prs_align(ps);
+
+ prs_uint32("level", ps, depth, &(q_u->level));
+ prs_uint32("level2", ps, depth, &(q_u->level2));
+
+ if (q_u->level==1)
+ {
+ prs_uint32("useless_ptr", ps, depth, &(useless_ptr));
+ spoolss_io_addform("", &(q_u->form), useless_ptr, ps, depth);
+ }
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_setform(char *desc, SPOOL_R_SETFORM *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_setform");
+ depth++;
+
+ prs_align(ps);
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_getjob(char *desc, SPOOL_R_GETJOB *r_u, prs_struct *ps, int depth)
+{
+ uint32 useless_ptr=0xADDE0FF0;
+ uint32 start_offset, end_offset, beginning;
+ uint32 bufsize_required=0;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_getjob");
+ depth++;
+
+ prs_align(ps);
+
+ prs_uint32("pointer", ps, depth, &useless_ptr);
+
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ JOB_INFO_1 *info;
+ info=r_u->ctr.job.job_info_1;
+
+ bufsize_required += spoolss_size_job_info_1(info);
+ break;
+ }
+ case 2:
+ {
+ JOB_INFO_2 *info;
+ info=r_u->ctr.job.job_info_2;
+
+ bufsize_required += spoolss_size_job_info_2(info);
+ break;
+ }
+ }
+
+ DEBUG(4,("spoolss_io_r_getjob, size needed: %d\n",bufsize_required));
+ DEBUG(4,("spoolss_io_r_getjob, size offered: %d\n",r_u->offered));
+
+ /* check if the buffer is big enough for the datas */
+ if (r_u->offered<bufsize_required)
+ {
+ /* it's too small */
+ r_u->status=ERROR_INSUFFICIENT_BUFFER; /* say so */
+ r_u->offered=0; /* don't send back the buffer */
+
+ DEBUG(4,("spoolss_io_r_getjob, buffer too small\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ }
+ else
+ {
+ DEBUG(4,("spoolss_io_r_enumjobs, buffer large enough\n"));
+
+ prs_uint32("size of buffer", ps, depth, &(r_u->offered));
+ beginning=prs_offset(ps);
+ start_offset=prs_offset(ps);
+ end_offset=start_offset+r_u->offered;
+
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ JOB_INFO_1 *info;
+ info = r_u->ctr.job.job_info_1;
+ smb_io_job_info_1(desc, info, ps, depth, &start_offset, &end_offset);
+ break;
+ }
+ case 2:
+ {
+ JOB_INFO_2 *info;
+ info = r_u->ctr.job.job_info_2;
+ smb_io_job_info_2(desc, info, ps, depth, &start_offset, &end_offset);
+ break;
+ }
+
+ }
+ prs_set_offset(ps, beginning+r_u->offered);
+ prs_align(ps);
+ }
+
+ /*
+ * if the buffer was too small, send the minimum required size
+ * if it was too large, send the real needed size
+ */
+
+ prs_uint32("size of buffer needed", ps, depth, &(bufsize_required));
+ prs_uint32("status", ps, depth, &(r_u->status));
+
+ return True;
+}
+
+/****************************************************************************
+****************************************************************************/
+void free_spoolss_r_getjob(SPOOL_R_GETJOB *r_u)
+{
+ switch (r_u->level)
+ {
+ case 1:
+ {
+ free(r_u->ctr.job.job_info_1);
+ break;
+ }
+ case 2:
+ {
+ free_job_info_2(r_u->ctr.job.job_info_2);
+ break;
+ }
+ }
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_getjob(char *desc, SPOOL_Q_GETJOB *q_u, prs_struct *ps, int depth)
+{
+
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ prs_align(ps);
+
+ smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ prs_uint32("jobid", ps, depth, &(q_u->jobid));
+ prs_uint32("level", ps, depth, &(q_u->level));
+
+ spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+
+ prs_align(ps);
+
+ prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
+
+ return True;
+}
+
+void free_devmode(DEVICEMODE *devmode)
+{
+ if (devmode!=NULL)
+ {
+ if (devmode->private!=NULL)
+ free(devmode->private);
+ free(devmode);
+ }
+}
+
+void free_printer_info_2(PRINTER_INFO_2 *printer)
+{
+ if (printer!=NULL)
+ {
+ free_devmode(printer->devmode);
+ free(printer);
+ }
+}
+
+static PRINTER_INFO_2 *prt2_dup(const PRINTER_INFO_2* from)
+{
+ PRINTER_INFO_2 *copy = (PRINTER_INFO_2 *)malloc(sizeof(PRINTER_INFO_2));
+ if (copy != NULL)
+ {
+ if (from != NULL)
+ {
+ memcpy(copy, from, sizeof(*copy));
+ }
+ else
+ {
+ ZERO_STRUCTP(copy);
+ }
+ }
+ return copy;
+}
+
+void free_print2_array(uint32 num_entries, PRINTER_INFO_2 **entries)
+{
+ void(*fn)(void*) = (void(*)(void*))&free_printer_info_2;
+ free_void_array(num_entries, (void**)entries, *fn);
+}
+
+PRINTER_INFO_2 *add_print2_to_array(uint32 *len, PRINTER_INFO_2 ***array,
+ const PRINTER_INFO_2 *prt)
+{
+ void*(*fn)(const void*) = (void*(*)(const void*))&prt2_dup;
+ return (PRINTER_INFO_2*)add_copy_to_array(len,
+ (void***)array, (const void*)prt, *fn, True);
+}
+
+static PRINTER_INFO_1 *prt1_dup(const PRINTER_INFO_1* from)
+{
+ PRINTER_INFO_1 *copy = (PRINTER_INFO_1 *)malloc(sizeof(PRINTER_INFO_1));
+ if (copy != NULL)
+ {
+ if (from != NULL)
+ {
+ memcpy(copy, from, sizeof(*copy));
+ }
+ else
+ {
+ ZERO_STRUCTP(copy);
+ }
+ }
+ return copy;
+}
+
+void free_print1_array(uint32 num_entries, PRINTER_INFO_1 **entries)
+{
+ void(*fn)(void*) = (void(*)(void*))&free;
+ free_void_array(num_entries, (void**)entries, *fn);
+}
+
+PRINTER_INFO_1 *add_print1_to_array(uint32 *len, PRINTER_INFO_1 ***array,
+ const PRINTER_INFO_1 *prt)
+{
+ void*(*fn)(const void*) = (void*(*)(const void*))&prt1_dup;
+ return (PRINTER_INFO_1*)add_copy_to_array(len,
+ (void***)array, (const void*)prt, *fn, True);
+}
+
+static JOB_INFO_1 *job1_dup(const JOB_INFO_1* from)
+{
+ JOB_INFO_1 *copy = (JOB_INFO_1 *)malloc(sizeof(JOB_INFO_1));
+ if (copy != NULL)
+ {
+ if (from != NULL)
+ {
+ memcpy(copy, from, sizeof(*copy));
+ }
+ else
+ {
+ ZERO_STRUCTP(copy);
+ }
+ }
+ return copy;
+}
+
+void free_job1_array(uint32 num_entries, JOB_INFO_1 **entries)
+{
+ void(*fn)(void*) = (void(*)(void*))&free;
+ free_void_array(num_entries, (void**)entries, *fn);
+}
+
+JOB_INFO_1 *add_job1_to_array(uint32 *len, JOB_INFO_1 ***array,
+ const JOB_INFO_1 *job)
+{
+ void*(*fn)(const void*) = (void*(*)(const void*))&job1_dup;
+ return (JOB_INFO_1*)add_copy_to_array(len,
+ (void***)array, (const void*)job, *fn, True);
+}
+
+static JOB_INFO_2 *job2_dup(const JOB_INFO_2* from)
+{
+ JOB_INFO_2 *copy = (JOB_INFO_2 *)malloc(sizeof(JOB_INFO_2));
+ if (copy != NULL)
+ {
+ if (from != NULL)
+ {
+ memcpy(copy, from, sizeof(*copy));
+ }
+ else
+ {
+ ZERO_STRUCTP(copy);
+ }
+ }
+ return copy;
+}
+
+void free_job_info_2(JOB_INFO_2 *job)
+{
+ if (job!=NULL)
+ {
+ free_devmode(job->devmode);
+ free(job);
+ }
+}
+
+void free_job2_array(uint32 num_entries, JOB_INFO_2 **entries)
+{
+ void(*fn)(void*) = (void(*)(void*))&free_job_info_2;
+ free_void_array(num_entries, (void**)entries, *fn);
+}
+
+JOB_INFO_2 *add_job2_to_array(uint32 *len, JOB_INFO_2 ***array,
+ const JOB_INFO_2 *job)
+{
+ void*(*fn)(const void*) = (void*(*)(const void*))&job2_dup;
+ return (JOB_INFO_2*)add_copy_to_array(len,
+ (void***)array, (const void*)job, *fn, True);
+}
+