#include "includes.h"
#include "nterr.h"
+#ifdef TNG
+ #define prs_uint16 _prs_uint16
+ #define prs_uint32 _prs_uint32
+ #define prs_uint8s _prs_uint8s
+ #define prs_uint16s _prs_uint16s
+ #define prs_unistr _prs_unistr
+ #define init_unistr2 make_unistr2
+#endif
+
+
extern int DEBUGLEVEL;
/*******************************************************************
return the length of a UNISTR string.
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.
********************************************************************/
/*******************************************************************
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)
+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);
+ if (!prs_align(ps))
+ return False;
+ if(!prs_uint16("type", ps, depth, &type->type))
+ return False;
+ if(!prs_uint16("reserved0", ps, depth, &type->reserved0))
+ return False;
+ if(!prs_uint32("reserved1", ps, depth, &type->reserved1))
+ return False;
+ if(!prs_uint32("reserved2", ps, depth, &type->reserved2))
+ return False;
+ if(!prs_uint32("count", ps, depth, &type->count))
+ return False;
+ if(!prs_uint32("fields_ptr", ps, depth, &type->fields_ptr))
+ return False;
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)
+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);
+ /* if there are no fields just return */
+ if (type->fields_ptr==0)
+ return True;
+
+ if(!prs_align(ps))
+ return False;
- prs_uint32("count", ps, depth, &count);
+ if(!prs_uint32("count2", ps, depth, &type->count2))
+ return False;
- 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]));
- }
+ if (type->count2 != type->count)
+ DEBUG(4,("What a mess, count was %x now is %x !\n", type->count, type->count2));
+ /* parse the option type data */
+ for(i=0;i<type->count2;i++)
+ if(!prs_uint16("fields",ps,depth,&(type->fields[i])))
+ return False;
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;
+static BOOL smb_io_notify_option_type_ctr(char *desc, SPOOL_NOTIFY_OPTION_TYPE_CTR *ctr , prs_struct *ps, int depth)
+{
int i;
-
- prs_debug(ps, depth, desc, "smb_io_notify_option");
+
+ prs_debug(ps, depth, desc, "smb_io_notify_option_type_ctr");
depth++;
- prs_align(ps);
+ if(!prs_uint32("count", ps, depth, &ctr->count))
+ return False;
+
+ /* reading */
+ if (UNMARSHALLING(ps))
+ ctr->type=(SPOOL_NOTIFY_OPTION_TYPE *)malloc(ctr->count*sizeof(SPOOL_NOTIFY_OPTION_TYPE));
+
+ /* the option type struct */
+ for(i=0;i<ctr->count;i++)
+ if(!smb_io_notify_option_type("", &(ctr->type[i]) , ps, depth))
+ return False;
- /* memory pointer to the struct */
- prs_uint32("useless ptr", ps, depth, &useless_ptr);
+ /* the type associated with the option type struct */
+ for(i=0;i<ctr->count;i++)
+ if(!smb_io_notify_option_type_data("", &(ctr->type[i]) , ps, depth))
+ return False;
- 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);
- }
+ return True;
+}
- /* 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);
+/*******************************************************************
+reads or writes an NOTIFY OPTION structure.
+********************************************************************/
+static BOOL smb_io_notify_option(char *desc, SPOOL_NOTIFY_OPTION *option, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "smb_io_notify_option");
+ depth++;
+
+ if(!prs_uint32("version", ps, depth, &option->version))
+ return False;
+ if(!prs_uint32("flags", ps, depth, &option->flags))
+ return False;
+ if(!prs_uint32("count", ps, depth, &option->count))
+ return False;
+ if(!prs_uint32("option_type_ptr", ps, depth, &option->option_type_ptr))
+ return False;
+
+ /* marshalling or unmarshalling, that would work */
+ if (option->option_type_ptr!=0) {
+ if(!smb_io_notify_option_type_ctr("", &option->ctr ,ps, depth))
+ return False;
+ }
+ else {
+ option->ctr.type=NULL;
+ option->ctr.count=0;
}
-
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)
+static BOOL smb_io_notify_info_data(char *desc,SPOOL_NOTIFY_INFO_DATA *data, prs_struct *ps, int depth)
{
uint32 useless_ptr=0xADDE0FF0;
/*******************************************************************
reads or writes an NOTIFY INFO structure.
********************************************************************/
-static BOOL smb_io_notify_info(char *desc, SPOOL_NOTIFY_INFO *info,
- prs_struct *ps, int depth)
+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);
+ if(!prs_align(ps))
+ return False;
- 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));
/* 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);
+ smb_io_notify_info_data_strings(desc, &(info->data[i]), ps, depth);
}
return True;
prs_debug(ps, depth, desc, "spoolss_io_devmode_cont");
depth++;
+ if(!prs_align(ps))
+ return False;
+
if (!prs_uint32("size", ps, depth, &dm_c->size))
return False;
}
/*******************************************************************
- * make a structure.
+ * init 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)
+BOOL make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX *q_u, fstring printername, fstring datatype,
+ uint32 access_required, fstring clientname, fstring user_name)
{
- 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);
+ DEBUG(5,("make_spoolss_q_open_printer_ex\n"));
+ q_u->printername_ptr = (printername!=NULL)?1:0;
+ init_unistr2(&(q_u->printername), printername, strlen(printername));
+ q_u->printer_default.datatype_ptr = 0;
/*
- 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);
+ q_u->printer_default.datatype_ptr = (datatype!=NULL)?1:0;
+ init_unistr2(&(q_u->printer_default.datatype), datatype, strlen(datatype));
*/
+ q_u->printer_default.devmode_cont.size=0;
+ q_u->printer_default.devmode_cont.devmode_ptr=0;
+ q_u->printer_default.devmode_cont.devmode=NULL;
+ q_u->printer_default.access_required=access_required;
+ q_u->user_switch=1;
+ q_u->user_ctr.level=1;
+ q_u->user_ctr.ptr=1;
+ q_u->user_ctr.user1.size=strlen(clientname)+strlen(user_name)+8;
+ q_u->user_ctr.user1.client_name_ptr = (clientname!=NULL)?1:0;
+ q_u->user_ctr.user1.user_name_ptr = (user_name!=NULL)?1:0;
+ q_u->user_ctr.user1.build=1381;
+ q_u->user_ctr.user1.major=2;
+ q_u->user_ctr.user1.minor=0;
+ q_u->user_ctr.user1.processor=0;
+ init_unistr2(&(q_u->user_ctr.user1.client_name), clientname, strlen(clientname));
+ init_unistr2(&(q_u->user_ctr.user1.user_name), user_name, strlen(user_name));
+
return True;
}
if (!prs_align(ps))
return False;
- if (!prs_uint32("printername_ptr", ps, depth, &(q_u->printername_ptr)))
+ 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))
+ 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))
+ 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))
+ 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;
if (!prs_align(ps))
return False;
- if (!smb_io_prt_hnd("printer handle",&(r_u->handle),ps,depth))
+ if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
return False;
if (!prs_uint32("status code", ps, depth, &(r_u->status)))
if (!prs_align(ps))
return False;
- if (!smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth))
+ if (!smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth))
return False;
if (!prs_align(ps))
return False;
prs_debug(ps, depth, desc, "spoolss_io_q_closeprinter");
depth++;
- prs_align(ps);
+ if (!prs_align(ps))
+ return False;
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
+ return False;
return True;
}
{
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));
+ if (!prs_align(ps))
+ return False;
+ if (!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
+ return False;
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
+
return True;
}
prs_align(ps);
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth);
smb_io_doc_info_container("",&(q_u->doc_info_container), ps, depth);
prs_align(ps);
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth);
return True;
}
prs_align(ps);
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth);
return True;
}
prs_align(ps);
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth);
return True;
}
prs_align(ps);
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth);
prs_uint32("buffer_size", ps, depth, &(q_u->buffer_size));
if (q_u->buffer_size!=0)
* 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)
+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));
+ if(!prs_align(ps))
+ return False;
- smb_io_notify_option("notify option", &(q_u->option), ps, depth);
+ if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
+ return False;
+ if(!prs_uint32("flags", ps, depth, &q_u->flags))
+ return False;
+ if(!prs_uint32("options", ps, depth, &q_u->options))
+ return False;
+ if(!prs_uint32("localmachine_ptr", ps, depth, &q_u->localmachine_ptr))
+ return False;
+ if(!smb_io_unistr2("localmachine", &q_u->localmachine, q_u->localmachine_ptr, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+
+ if(!prs_uint32("printerlocal", ps, depth, &q_u->printerlocal))
+ return False;
+ if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
+ return False;
+
+ if (q_u->option_ptr!=0) {
+
+ if (UNMARSHALLING(ps))
+ q_u->option=(SPOOL_NOTIFY_OPTION *)malloc(sizeof(SPOOL_NOTIFY_OPTION));
+
+ if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
+ return False;
+ }
+
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)
+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));
+ if(!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
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)
+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);
+ if(!prs_align(ps))
+ return False;
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
+ return False;
- prs_uint32("change", ps, depth, &(q_u->change));
+ if(!prs_uint32("change", ps, depth, &q_u->change))
+ return False;
+
+ if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
+ return False;
+
+ if (q_u->option_ptr!=0) {
+
+ if (UNMARSHALLING(ps))
+ q_u->option=(SPOOL_NOTIFY_OPTION *)malloc(sizeof(SPOOL_NOTIFY_OPTION));
- smb_io_notify_option("notify option",&(q_u->option),ps,depth);
+ if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
+ return False;
+ }
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)
+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);
+ if(!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("info_ptr", ps, depth, &r_u->info_ptr))
+ return False;
- smb_io_notify_info("notify info",&(r_u->info),ps,depth);
- prs_align(ps);
- prs_uint32("status", ps, depth, &r_u->status);
+ if(!smb_io_notify_info("notify info", &r_u->info ,ps,depth))
+ return False;
+
+ if(!prs_align(ps))
+ return False;
+ if(!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
return True;
}
+/*******************************************************************
+ * return the length of a uint16 (obvious, but the code is clean)
+ ********************************************************************/
+static uint32 size_of_uint16(uint16 *value)
+{
+ return (sizeof(*value));
+}
+
/*******************************************************************
* 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
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 size;
}
/*******************************************************************
return (4);
else
return (0xDC+4);
-
- return True;
}
/*******************************************************************
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)
+static BOOL spoolss_smb_io_unistr(char *desc, UNISTR *uni, prs_struct *ps, int depth)
{
if (uni == NULL)
return False;
}
-/*******************************************************************
- * 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
{
prs_struct *ps=&(buffer->prs);
- if (MARSHALLING(ps))
- {
+ if (MARSHALLING(ps)) {
uint32 struct_offset = prs_offset(ps);
uint32 relative_offset;
prs_set_offset(ps, struct_offset);
- relative_offset=buffer->string_at_end-buffer->struct_start;
+ relative_offset=buffer->string_at_end - buffer->struct_start;
/* write its offset */
if (!prs_uint32("offset", ps, depth, &relative_offset))
return False;
}
- else
- {
+ else {
uint32 old_offset;
/* read the offset */
return False;
old_offset = prs_offset(ps);
- prs_set_offset(ps, buffer->string_at_end);
+ prs_set_offset(ps, buffer->string_at_end+buffer->struct_start);
/* read the string */
if (!spoolss_smb_io_unistr(desc, string, ps, depth))
* 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)
+static BOOL new_smb_io_relarraystr(char *desc, NEW_BUFFER *buffer, int depth, UNISTR ***string)
{
- int i=0;
- uint32 struct_offset;
- uint32 relative_offset;
- struct_offset=prs_offset(ps);
-
- while ( (*buffer)[i]!=0x0000 )
- {
- i++;
- }
-
- i--;
+ prs_struct *ps=&(buffer->prs);
- /* that's for the ending NULL */
- *end_offset-=2;
+ if (MARSHALLING(ps)) {
+ uint32 struct_offset = prs_offset(ps);
+ uint32 relative_offset;
+ int i=0;
- 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);
-
+ while ( (*string)[i]!=0x0000 )
+ i++;
i--;
- }
- while (i>=0);
- prs_set_offset(ps, struct_offset);
- relative_offset=*end_offset-*start_offset;
+ /* count the ending NULL of the array */
+ buffer->string_at_end -= 2;
- prs_uint32("offset", ps, depth, &(relative_offset));
-
- return True;
-}
+ /* jfm: FIXME: write a (uint16) 0 for the ending NULL */
+
+ do
+ {
+ buffer->string_at_end -= 2*(str_len_uni((*string)[i])+1);
+ prs_set_offset(ps, buffer->string_at_end);
-/*******************************************************************
- * 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++;
+ /* write the string */
+ if (!spoolss_smb_io_unistr(desc, (*string)[i], ps, depth))
+ return False;
+
+ i--;
+ }
+ while (i>=0);
+
+ 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;
- struct_offset=prs_offset(ps);
- *end_offset-= (devmode->size+devmode->driverextra);
- prs_set_offset(ps, *end_offset);
+ /* read the offset */
+ if (!prs_uint32("offset", ps, depth, &(buffer->string_at_end)))
+ return False;
- spoolss_io_devmode(desc, ps, depth, devmode);
+ old_offset = prs_offset(ps);
+ prs_set_offset(ps, buffer->string_at_end);
- prs_set_offset(ps, struct_offset);
- relative_offset=*end_offset-*start_offset;
+ /* read the string */
- prs_uint32("offset", ps, depth, &(relative_offset));
+ /* jfm: FIXME: alloc memory and read all the strings until the string is NULL */
+/*
+ if (!spoolss_smb_io_unistr(desc, string, ps, depth))
+ return False;
+*/
+ prs_set_offset(ps, old_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)
+ Parse a DEVMODE structure and its relative pointer.
+********************************************************************/
+static BOOL new_smb_io_reldevmode(char *desc, NEW_BUFFER *buffer, int depth, DEVICEMODE **devmode)
{
- 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;
-}
+ prs_struct *ps=&(buffer->prs);
-/*******************************************************************
-********************************************************************/
-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, "new_smb_io_reldevmode");
+ depth++;
- prs_debug(ps, depth, desc, "smb_io_printer_info_2");
+ if (MARSHALLING(ps)) {
+ uint32 struct_offset = prs_offset(ps);
+ uint32 relative_offset;
+
+ buffer->string_at_end -= ((*devmode)->size + (*devmode)->driverextra);
+
+ prs_set_offset(ps, buffer->string_at_end);
+
+ /* write the DEVMODE */
+ if (!spoolss_io_devmode(desc, ps, depth, *devmode))
+ 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 + buffer->struct_start);
+
+ /* read the string */
+ *devmode=(DEVICEMODE *)malloc(sizeof(DEVICEMODE));
+ if (!spoolss_io_devmode(desc, ps, depth, *devmode))
+ return False;
+
+ prs_set_offset(ps, old_offset);
+ }
+ return True;
+}
+
+
+/*******************************************************************
+ Parse a PRINTER_INFO_0 structure.
+********************************************************************/
+BOOL new_smb_io_printer_info_0(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_0 *info, int depth)
+{
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "smb_io_printer_info_0");
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);
+ buffer->struct_start=prs_offset(ps);
+
+ if (!new_smb_io_relstr("printername", buffer, depth, &info->printername))
+ return False;
+ if (!new_smb_io_relstr("servername", buffer, depth, &info->servername))
+ return False;
- 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));
+ if(!prs_uint32("cjobs", ps, depth, &info->cjobs))
+ return False;
+ if(!prs_uint32("total_jobs", ps, depth, &info->total_jobs))
+ return False;
+ if(!prs_uint32("total_bytes", ps, depth, &info->total_bytes))
+ return False;
- /*
- 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);
+ if(!prs_uint16("year", ps, depth, &info->year))
+ return False;
+ if(!prs_uint16("month", ps, depth, &info->month))
+ return False;
+ if(!prs_uint16("dayofweek", ps, depth, &info->dayofweek))
+ return False;
+ if(!prs_uint16("day", ps, depth, &info->day))
+ return False;
+ if(!prs_uint16("hour", ps, depth, &info->hour))
+ return False;
+ if(!prs_uint16("minute", ps, depth, &info->minute))
+ return False;
+ if(!prs_uint16("second", ps, depth, &info->second))
+ return False;
+ if(!prs_uint16("milliseconds", ps, depth, &info->milliseconds))
+ return False;
+
+ if(!prs_uint32("global_counter", ps, depth, &info->global_counter))
+ return False;
+ if(!prs_uint32("total_pages", ps, depth, &info->total_pages))
+ return False;
+
+ if(!prs_uint16("major_version", ps, depth, &info->major_version))
+ return False;
+ if(!prs_uint16("build_version", ps, depth, &info->build_version))
+ return False;
+ if(!prs_uint32("unknown7", ps, depth, &info->unknown7))
+ return False;
+ if(!prs_uint32("unknown8", ps, depth, &info->unknown8))
+ return False;
+ if(!prs_uint32("unknown9", ps, depth, &info->unknown9))
+ return False;
+ if(!prs_uint32("session_counter", ps, depth, &info->session_counter))
+ return False;
+ if(!prs_uint32("unknown11", ps, depth, &info->unknown11))
+ return False;
+ if(!prs_uint32("printer_errors", ps, depth, &info->printer_errors))
+ return False;
+ if(!prs_uint32("unknown13", ps, depth, &info->unknown13))
+ return False;
+ if(!prs_uint32("unknown14", ps, depth, &info->unknown14))
+ return False;
+ if(!prs_uint32("unknown15", ps, depth, &info->unknown15))
+ return False;
+ if(!prs_uint32("unknown16", ps, depth, &info->unknown16))
+ return False;
+ if(!prs_uint32("change_id", ps, depth, &info->change_id))
+ return False;
+ if(!prs_uint32("unknown18", ps, depth, &info->unknown18))
+ return False;
+ if(!prs_uint32("status" , ps, depth, &info->status))
+ return False;
+ if(!prs_uint32("unknown20", ps, depth, &info->unknown20))
+ return False;
+ if(!prs_uint32("c_setprinter", ps, depth, &info->c_setprinter))
+ return False;
+ if(!prs_uint16("unknown22", ps, depth, &info->unknown22))
+ return False;
+ if(!prs_uint16("unknown23", ps, depth, &info->unknown23))
+ return False;
+ if(!prs_uint16("unknown24", ps, depth, &info->unknown24))
+ return False;
+ if(!prs_uint16("unknown25", ps, depth, &info->unknown25))
+ return False;
+ if(!prs_uint16("unknown26", ps, depth, &info->unknown26))
+ return False;
+ if(!prs_uint16("unknown27", ps, depth, &info->unknown27))
+ return False;
+ if(!prs_uint16("unknown28", ps, depth, &info->unknown28))
+ return False;
+ if(!prs_uint16("unknown29", ps, depth, &info->unknown29))
+ return False;
return True;
}
/*******************************************************************
+ Parse a PRINTER_INFO_1 structure.
********************************************************************/
-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)
+BOOL new_smb_io_printer_info_1(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_1 *info, int depth)
{
- prs_debug(ps, depth, desc, "smb_io_printer_driver_info_1");
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "new_smb_io_printer_info_1");
depth++;
- *start_offset=prs_offset(ps);
+
+ buffer->struct_start=prs_offset(ps);
- smb_io_relstr("name", ps, depth, &(info->name), start_offset, end_offset);
+ if (!prs_uint32("flags", ps, depth, &info->flags))
+ return False;
+ if (!new_smb_io_relstr("description", buffer, depth, &info->description))
+ return False;
+ if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ return False;
+ if (!new_smb_io_relstr("comment", buffer, depth, &info->comment))
+ return False;
return True;
}
/*******************************************************************
+ Parse a PRINTER_INFO_2 structure.
********************************************************************/
-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)
+BOOL new_smb_io_printer_info_2(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_2 *info, int depth)
{
- prs_debug(ps, depth, desc, "smb_io_printer_xxx");
+ /* hack for the SEC DESC */
+ uint32 pipo=0;
+
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "new_smb_io_printer_info_2");
depth++;
- *start_offset=prs_offset(ps);
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (!new_smb_io_relstr("servername", buffer, depth, &info->servername))
+ return False;
+ if (!new_smb_io_relstr("printername", buffer, depth, &info->printername))
+ return False;
+ if (!new_smb_io_relstr("sharename", buffer, depth, &info->sharename))
+ return False;
+ if (!new_smb_io_relstr("portname", buffer, depth, &info->portname))
+ return False;
+ if (!new_smb_io_relstr("drivername", buffer, depth, &info->drivername))
+ return False;
+ if (!new_smb_io_relstr("comment", buffer, depth, &info->comment))
+ return False;
+ if (!new_smb_io_relstr("location", buffer, depth, &info->location))
+ return False;
+
+ /* NT parses the DEVMODE at the end of the struct */
+ if (!new_smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
+ return False;
+
+ if (!new_smb_io_relstr("sepfile", buffer, depth, &info->sepfile))
+ return False;
+ if (!new_smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
+ return False;
+ if (!new_smb_io_relstr("datatype", buffer, depth, &info->datatype))
+ return False;
+ if (!new_smb_io_relstr("parameters", buffer, depth, &info->parameters))
+ return False;
- 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);
+ if (!prs_uint32("security descriptor", ps, depth, &pipo))
+ return False;
+ if (!prs_uint32("attributes", ps, depth, &info->attributes))
+ return False;
+ if (!prs_uint32("priority", ps, depth, &info->priority))
+ return False;
+ if (!prs_uint32("defpriority", ps, depth, &info->defaultpriority))
+ return False;
+ if (!prs_uint32("starttime", ps, depth, &info->starttime))
+ return False;
+ if (!prs_uint32("untiltime", ps, depth, &info->untiltime))
+ return False;
+ if (!prs_uint32("status", ps, depth, &info->status))
+ return False;
+ if (!prs_uint32("jobs", ps, depth, &info->cjobs))
+ return False;
+ if (!prs_uint32("averageppm", ps, depth, &info->averageppm))
+ return False;
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)
+ Parse a DRIVER_INFO_1 structure.
+********************************************************************/
+BOOL new_smb_io_printer_driver_info_1(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_1 *info, int depth)
+{
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "new_smb_io_printer_driver_info_1");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ return False;
+
+ return True;
+}
+
+
+/*******************************************************************
+ Parse a DRIVER_INFO_2 structure.
+********************************************************************/
+BOOL new_smb_io_printer_driver_info_2(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_2 *info, int depth)
+{
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "new_smb_io_printer_driver_info_2");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (!prs_uint32("version", ps, depth, &info->version))
+ return False;
+ if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ return False;
+ if (!new_smb_io_relstr("architecture", buffer, depth, &info->architecture))
+ return False;
+ if (!new_smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
+ return False;
+ if (!new_smb_io_relstr("datafile", buffer, depth, &info->datafile))
+ return False;
+ if (!new_smb_io_relstr("configfile", buffer, depth, &info->configfile))
+ return False;
+
+ return True;
+}
+
+
+/*******************************************************************
+ Parse a DRIVER_INFO_3 structure.
+********************************************************************/
+BOOL new_smb_io_printer_driver_info_3(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_3 *info, int depth)
{
- prs_debug(ps, depth, desc, "smb_io_printer_driver_info_3");
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "new_smb_io_printer_driver_info_3");
depth++;
- *start_offset=prs_offset(ps);
+
+ buffer->struct_start=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);
+ if (!prs_uint32("version", ps, depth, &info->version))
+ return False;
+ if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ return False;
+ if (!new_smb_io_relstr("architecture", buffer, depth, &info->architecture))
+ return False;
+ if (!new_smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
+ return False;
+ if (!new_smb_io_relstr("datafile", buffer, depth, &info->datafile))
+ return False;
+ if (!new_smb_io_relstr("configfile", buffer, depth, &info->configfile))
+ return False;
+ if (!new_smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
+ return False;
- smb_io_relarraystr("dependentfiles", ps, depth, &(info->dependentfiles), start_offset, end_offset);
+ if (!new_smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
+ return False;
- smb_io_relstr("monitorname", ps, depth, &(info->monitorname), start_offset, end_offset);
- smb_io_relstr("defaultdatatype", ps, depth, &(info->defaultdatatype), start_offset, end_offset);
+ if (!new_smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
+ return False;
+ if (!new_smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
+ return False;
return True;
}
+
/*******************************************************************
+ Parse a JOB_INFO_1 structure.
********************************************************************/
-static BOOL smb_io_job_info_1(char *desc, JOB_INFO_1 *info, prs_struct *ps, int depth,
- uint32 *start_offset, uint32 *end_offset)
+BOOL new_smb_io_job_info_1(char *desc, NEW_BUFFER *buffer, JOB_INFO_1 *info, int depth)
{
- prs_debug(ps, depth, desc, "smb_io_job_info_1");
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "new_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) );
+ buffer->struct_start=prs_offset(ps);
+
+ if (!prs_uint32("jobid", ps, depth, &info->jobid))
+ return False;
+ if (!new_smb_io_relstr("printername", buffer, depth, &info->printername))
+ return False;
+ if (!new_smb_io_relstr("machinename", buffer, depth, &info->machinename))
+ return False;
+ if (!new_smb_io_relstr("username", buffer, depth, &info->username))
+ return False;
+ if (!new_smb_io_relstr("document", buffer, depth, &info->document))
+ return False;
+ if (!new_smb_io_relstr("datatype", buffer, depth, &info->datatype))
+ return False;
+ if (!new_smb_io_relstr("text_status", buffer, depth, &info->text_status))
+ return False;
+ if (!prs_uint32("status", ps, depth, &info->status))
+ return False;
+ if (!prs_uint32("priority", ps, depth, &info->priority))
+ return False;
+ if (!prs_uint32("position", ps, depth, &info->position))
+ return False;
+ if (!prs_uint32("totalpages", ps, depth, &info->totalpages))
+ return False;
+ if (!prs_uint32("pagesprinted", ps, depth, &info->pagesprinted))
+ return False;
+ if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted))
+ return False;
return True;
}
/*******************************************************************
+ Parse a JOB_INFO_2 structure.
********************************************************************/
-static BOOL smb_io_job_info_2(char *desc, JOB_INFO_2 *info, prs_struct *ps, int depth,
- uint32 *start_offset, uint32 *end_offset)
+BOOL new_smb_io_job_info_2(char *desc, NEW_BUFFER *buffer, JOB_INFO_2 *info, int depth)
{
int pipo=0;
- prs_debug(ps, depth, desc, "smb_io_job_info_2");
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "new_smb_io_job_info_2");
depth++;
- *start_offset=prs_offset(ps);
+
+ buffer->struct_start=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);
+ if (!prs_uint32("jobid",ps, depth, &info->jobid))
+ return False;
+ if (!new_smb_io_relstr("printername", buffer, depth, &info->printername))
+ return False;
+ if (!new_smb_io_relstr("machinename", buffer, depth, &info->machinename))
+ return False;
+ if (!new_smb_io_relstr("username", buffer, depth, &info->username))
+ return False;
+ if (!new_smb_io_relstr("document", buffer, depth, &info->document))
+ return False;
+ if (!new_smb_io_relstr("notifyname", buffer, depth, &info->notifyname))
+ return False;
+ if (!new_smb_io_relstr("datatype", buffer, depth, &info->datatype))
+ return False;
+
+ if (!new_smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
+ return False;
+ if (!new_smb_io_relstr("parameters", buffer, depth, &info->parameters))
+ return False;
+ if (!new_smb_io_relstr("drivername", buffer, depth, &info->drivername))
+ return False;
+ if (!new_smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
+ return False;
+ if (!new_smb_io_relstr("text_status", buffer, depth, &info->text_status))
+ return False;
/* 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));
+ if (!prs_uint32("Hack! sec desc", ps, depth, &pipo))
+ return False;
+
+ if (!prs_uint32("status",ps, depth, &info->status))
+ return False;
+ if (!prs_uint32("priority",ps, depth, &info->priority))
+ return False;
+ if (!prs_uint32("position",ps, depth, &info->position))
+ return False;
+ if (!prs_uint32("starttime",ps, depth, &info->starttime))
+ return False;
+ if (!prs_uint32("untiltime",ps, depth, &info->untiltime))
+ return False;
+ if (!prs_uint32("totalpages",ps, depth, &info->totalpages))
+ return False;
+ if (!prs_uint32("size",ps, depth, &info->size))
+ return False;
+ if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted) )
+ return False;
+ if (!prs_uint32("timeelapsed",ps, depth, &info->timeelapsed))
+ return False;
+ if (!prs_uint32("pagesprinted",ps, depth, &info->pagesprinted))
+ return False;
return True;
}
return True;
}
- if (!prs_uint32("size", ps, depth, &(buffer->size)))
+ 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))
+ if (!prs_append_some_prs_data(&(buffer->prs), ps, prs_offset(ps), buffer->size))
return False;
- prs_set_offset(&(buffer->prs),0);
+ if (!prs_set_offset(&buffer->prs, 0))
+ return False;
- prs_set_offset(ps, buffer->size+prs_offset(ps));
+ if (!prs_set_offset(ps, buffer->size+prs_offset(ps)))
+ return False;
buffer->string_at_end=buffer->size;
if (!prs_uint32("size", ps, depth, &(buffer->size)))
return False;
-
- if (!prs_append_some_prs_data(ps, &(buffer->prs), buffer->size))
+ if (!prs_append_some_prs_data(ps, &(buffer->prs), 0, buffer->size))
return False;
+
+ return True;
}
-
- return True;
}
/*******************************************************************
return (buffer->size);
}
+
/*******************************************************************
+ Parse a DRIVER_DIRECTORY_1 structure.
********************************************************************/
-static BOOL smb_io_form_1(char *desc, FORM_1 *info, prs_struct *ps, int depth,
- uint32 *start_offset, uint32 *end_offset)
+BOOL new_smb_io_driverdir_1(char *desc, NEW_BUFFER *buffer, DRIVER_DIRECTORY_1 *info, int depth)
{
- prs_debug(ps, depth, desc, "smb_io_form_1");
- depth++;
- *start_offset=prs_offset(ps);
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "new_smb_io_driverdir_1");
+ depth++;
+
+ buffer->struct_start=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));
+ if (!spoolss_smb_io_unistr(desc, &info->name, ps, depth))
+ return False;
return True;
}
/*******************************************************************
+ Parse a PORT_INFO_1 structure.
********************************************************************/
-static BOOL smb_io_port_2(char *desc, PORT_INFO_2 *info, prs_struct *ps, int depth,
- uint32 *start_offset, uint32 *end_offset)
+BOOL new_smb_io_port_1(char *desc, NEW_BUFFER *buffer, PORT_INFO_1 *info, int depth)
{
- prs_debug(ps, depth, desc, "smb_io_port_2");
- depth++;
- *start_offset=prs_offset(ps);
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "new_smb_io_port_1");
+ depth++;
- 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));
+ buffer->struct_start=prs_offset(ps);
+
+ if(!new_smb_io_relstr("port_name", buffer, depth, &info->port_name))
+ return False;
return True;
}
/*******************************************************************
+ Parse a PORT_INFO_2 structure.
********************************************************************/
-static BOOL smb_io_processor_info_1(char *desc, PRINTPROCESSOR_1 *info, prs_struct *ps, int depth,
- uint32 *start_offset, uint32 *end_offset)
+BOOL new_smb_io_port_2(char *desc, NEW_BUFFER *buffer, PORT_INFO_2 *info, int depth)
{
- prs_debug(ps, depth, desc, "smb_io_processor_info_1");
- depth++;
- *start_offset=prs_offset(ps);
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "new_smb_io_port_2");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
- smb_io_relstr("name",ps, depth, &(info->name), start_offset, end_offset);
+ if(!new_smb_io_relstr("port_name", buffer, depth, &info->port_name))
+ return False;
+ if(!new_smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
+ return False;
+ if(!new_smb_io_relstr("description", buffer, depth, &info->description))
+ return False;
+ if(!prs_uint32("port_type", ps, depth, &info->port_type))
+ return False;
+ if(!prs_uint32("reserved", ps, depth, &info->reserved))
+ return False;
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)
+BOOL smb_io_printprocessor_info_1(char *desc, NEW_BUFFER *buffer, PRINTPROCESSOR_1 *info, int depth)
{
- prs_debug(ps, depth, desc, "smb_io_monitor_info_1");
- depth++;
- *start_offset=prs_offset(ps);
+ prs_struct *ps=&(buffer->prs);
- smb_io_relstr("name",ps, depth, &(info->name), start_offset, end_offset);
+ prs_debug(ps, depth, desc, "smb_io_printprocessor_info_1");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (new_smb_io_relstr("name", buffer, depth, &info->name))
+ return False;
return True;
}
/*******************************************************************
-return the size required by a struct in the stream
********************************************************************/
-static uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
+BOOL smb_io_printprocdatatype_info_1(char *desc, NEW_BUFFER *buffer, PRINTPROCDATATYPE_1 *info, int depth)
{
- 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);
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "smb_io_printprocdatatype_info_1");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (new_smb_io_relstr("name", buffer, depth, &info->name))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL smb_io_printmonitor_info_1(char *desc, NEW_BUFFER *buffer, PRINTMONITOR_1 *info, int depth)
+{
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "smb_io_printmonitor_info_1");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ return False;
return True;
}
+/*******************************************************************
+********************************************************************/
+BOOL smb_io_printmonitor_info_2(char *desc, NEW_BUFFER *buffer, PRINTMONITOR_2 *info, int depth)
+{
+ prs_struct *ps=&(buffer->prs);
+
+ prs_debug(ps, depth, desc, "smb_io_printmonitor_info_2");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ return False;
+ if (!new_smb_io_relstr("environment", buffer, depth, &info->environment))
+ return False;
+ if (!new_smb_io_relstr("dll_name", buffer, depth, &info->dll_name))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
+{
+ int size=0;
+
+ size+=size_of_relative_string( &info->printername );
+ size+=size_of_relative_string( &info->servername );
+
+ size+=size_of_uint32( &info->cjobs);
+ size+=size_of_uint32( &info->total_jobs);
+ size+=size_of_uint32( &info->total_bytes);
+
+ size+=size_of_uint16( &info->year);
+ size+=size_of_uint16( &info->month);
+ size+=size_of_uint16( &info->dayofweek);
+ size+=size_of_uint16( &info->day);
+ size+=size_of_uint16( &info->hour);
+ size+=size_of_uint16( &info->minute);
+ size+=size_of_uint16( &info->second);
+ size+=size_of_uint16( &info->milliseconds);
+
+ size+=size_of_uint32( &info->global_counter);
+ size+=size_of_uint32( &info->total_pages);
+
+ size+=size_of_uint16( &info->major_version);
+ size+=size_of_uint16( &info->build_version);
+
+ size+=size_of_uint32( &info->unknown7);
+ size+=size_of_uint32( &info->unknown8);
+ size+=size_of_uint32( &info->unknown9);
+ size+=size_of_uint32( &info->session_counter);
+ size+=size_of_uint32( &info->unknown11);
+ size+=size_of_uint32( &info->printer_errors);
+ size+=size_of_uint32( &info->unknown13);
+ size+=size_of_uint32( &info->unknown14);
+ size+=size_of_uint32( &info->unknown15);
+ size+=size_of_uint32( &info->unknown16);
+ size+=size_of_uint32( &info->change_id);
+ size+=size_of_uint32( &info->unknown18);
+ size+=size_of_uint32( &info->status);
+ size+=size_of_uint32( &info->unknown20);
+ size+=size_of_uint32( &info->c_setprinter);
+
+ size+=size_of_uint16( &info->unknown22);
+ size+=size_of_uint16( &info->unknown23);
+ size+=size_of_uint16( &info->unknown24);
+ size+=size_of_uint16( &info->unknown25);
+ size+=size_of_uint16( &info->unknown26);
+ size+=size_of_uint16( &info->unknown27);
+ size+=size_of_uint16( &info->unknown28);
+ size+=size_of_uint16( &info->unknown29);
+
+ return size;
+}
+
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
-static uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
+uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
{
int size=0;
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 size;
}
/*******************************************************************
return the size required by a struct in the stream
-********************************************************************/
-static uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
+********************************************************************/
+uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
{
int size=0;
size+=size_of_uint32( &(info->status) );
size+=size_of_uint32( &(info->cjobs) );
size+=size_of_uint32( &(info->averageppm) );
- return (size);
-
- return True;
+ return size;
}
/*******************************************************************
return the size required by a struct in the stream
-********************************************************************/
-static uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
+********************************************************************/
+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 size;
}
/*******************************************************************
return the size required by a struct in the stream
-********************************************************************/
-static uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
+********************************************************************/
+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->datafile) );
size+=size_of_relative_string( &(info->configfile) );
- DEBUGADD(9,("size: [%d]\n", size));
- return (size);
-
- return True;
+ return size;
}
/*******************************************************************
return the size required by a struct in the stream
-********************************************************************/
-static uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
+********************************************************************/
+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+=6;
- DEBUGADD(9,("size: [%d]\n", size));
- return (size);
-
- return True;
+ return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
-static uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
+uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
{
int size=0;
size+=size_of_uint32( &(info->jobid) );
size+=size_of_uint32( &(info->totalpages) );
size+=size_of_uint32( &(info->pagesprinted) );
size+=size_of_systemtime( &(info->submitted) );
- return (size);
- return True;
+ return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
-static uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
+uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
{
int size=0;
size+=size_of_systemtime( &(info->submitted) );
size+=size_of_uint32( &(info->timeelapsed) );
size+=size_of_uint32( &(info->pagesprinted) );
- return (size);
- return True;
+ return size;
}
/*******************************************************************
size+=size_of_uint32( &(info->right) );
size+=size_of_uint32( &(info->bottom) );
- return (size);
-
- return True;
+ return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
-static uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
+uint32 spoolss_size_port_info_1(PORT_INFO_1 *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) );
+ size+=size_of_relative_string( &info->port_name );
- return (size);
-
- return True;
+ return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
-static uint32 spoolss_size_processor_info_1(PRINTPROCESSOR_1 *info)
+uint32 spoolss_size_driverdir_info_1(DRIVER_DIRECTORY_1 *info)
{
int size=0;
- size+=size_of_relative_string( &(info->name) );
- return (size);
+ size=str_len_uni(&info->name); /* the string length */
+ size=size+1; /* add the leading zero */
+ size=size*2; /* convert in char */
- return True;
+ return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
-static uint32 spoolss_size_monitor_info_1(PRINTMONITOR_1 *info)
+uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
{
int size=0;
- size+=size_of_relative_string( &(info->name) );
- return (size);
+ size+=size_of_relative_string( &info->port_name );
+ size+=size_of_relative_string( &info->monitor_name );
+ size+=size_of_relative_string( &info->description );
- return True;
+ size+=size_of_uint32( &info->port_type );
+ size+=size_of_uint32( &info->reserved );
+
+ return size;
}
/*******************************************************************
- * make a structure.
- ********************************************************************/
-static BOOL make_spoolss_buffer(BUFFER* buffer, uint32 size)
+return the size required by a struct in the stream
+********************************************************************/
+uint32 spoolss_size_printprocessor_info_1(PRINTPROCESSOR_1 *info)
{
- buffer->ptr = (size != 0) ? 1 : 0;
- buffer->size = size;
- buffer->data = (uint8 *)Realloc( NULL, (buffer->size) * sizeof(uint8) );
+ int size=0;
+ size+=size_of_relative_string( &info->name );
- return (buffer->data != NULL || size == 0);
+ return size;
}
/*******************************************************************
- * 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)
+return the size required by a struct in the stream
+********************************************************************/
+uint32 spoolss_size_printprocdatatype_info_1(PRINTPROCDATATYPE_1 *info)
{
- prs_debug(ps, depth, desc, "spoolss_io_read_buffer");
- depth++;
-
- prs_align(ps);
+ int size=0;
+ size+=size_of_relative_string( &info->name );
- 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);
+ return size;
+}
- }
- else
- {
- if (ps->io)
- {
- /* reading */
- buffer->data=0x0000;
- buffer->size=0x0000;
- }
- }
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+uint32 spoolss_size_printmonitor_info_1(PRINTMONITOR_1 *info)
+{
+ int size=0;
+ size+=size_of_relative_string( &info->name );
- if (!ps->io)
- {
- /* writing */
- if (buffer->data != NULL)
- {
- free(buffer->data);
- }
- buffer->data = NULL;
- }
- return True;
+ return size;
}
/*******************************************************************
- * 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)
+return the size required by a struct in the stream
+********************************************************************/
+uint32 spoolss_size_printmonitor_info_2(PRINTMONITOR_2 *info)
{
- DEBUG(8,("spoolss_io_free_buffer\n"));
-
- if (buffer->ptr != 0x0000)
- {
- free(buffer->data);
- }
+ int size=0;
+ size+=size_of_relative_string( &info->name);
+ size+=size_of_relative_string( &info->environment);
+ size+=size_of_relative_string( &info->dll_name);
- return True;
+ return size;
}
/*******************************************************************
* 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)
+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);
+ if(!prs_align(ps))
+ return False;
- prs_align(ps);
+ if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
+ return False;
+ if(!prs_uint32("architecture_ptr", ps, depth, &q_u->architecture_ptr))
+ return False;
+ if(!smb_io_unistr2("architecture", &q_u->architecture, q_u->architecture_ptr, ps, depth))
+ return False;
- prs_uint32("level", ps, depth, &(q_u->level));
- spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+ if(!prs_align(ps))
+ 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;
- prs_align(ps);
+ if(!prs_align(ps))
+ return False;
- 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));
+ if(!prs_uint32("offered", ps, depth, &q_u->offered))
+ return False;
+
+ if(!prs_uint32("clientmajorversion", ps, depth, &q_u->clientmajorversion))
+ return False;
+ if(!prs_uint32("clientminorversion", ps, depth, &q_u->clientminorversion))
+ return False;
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)
+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 (!prs_align(ps))
+ return False;
- }
- }
+ if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
- /*
- * 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));
+ if (!prs_align(ps))
+ return False;
+ if (!prs_uint32("needed", ps, depth, &r_u->needed))
+ return False;
+ if (!prs_uint32("servermajorversion", ps, depth, &r_u->servermajorversion))
+ return False;
+ if (!prs_uint32("serverminorversion", ps, depth, &r_u->serverminorversion))
+ return False;
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
- return True;
+ return True;
}
/*******************************************************************
- * make a structure.
+ * init a structure.
********************************************************************/
-BOOL make_spoolss_q_enumprinters(SPOOL_Q_ENUMPRINTERS *q_u,
- uint32 flags,
- const char* servername,
- uint32 level,
- uint32 size)
+BOOL make_spoolss_q_enumprinters(SPOOL_Q_ENUMPRINTERS *q_u, uint32 flags,
+ fstring servername, uint32 level,
+ NEW_BUFFER *buffer, uint32 offered)
{
- size_t len_name = servername != NULL ? strlen(servername) : 0;
-
- DEBUG(5,("make_spoolss_q_enumprinters. size: %d\n", size));
-
- q_u->flags = flags;
+ q_u->flags=flags;
+
+ q_u->servername_ptr = (servername != NULL) ? 1 : 0;
+ init_unistr2(&(q_u->servername), servername, strlen(servername));
- init_unistr2(&q_u->servername, servername, len_name);
-
- q_u->level = level;
- make_spoolss_buffer(&q_u->buffer, size);
- q_u->buf_size = size;
+ q_u->level=level;
+ q_u->buffer=buffer;
+ q_u->offered=offered;
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)
+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);
+ if (!prs_align(ps))
+ return False;
- smb_io_unistr2("", &q_u->servername,True,ps,depth);
- prs_align(ps);
+ if (!prs_uint32("flags", ps, depth, &q_u->flags))
+ return False;
+ if (!prs_uint32("servername_ptr", ps, depth, &q_u->servername_ptr))
+ return False;
- prs_uint32("level", ps, depth, &(q_u->level));
+ if (!smb_io_unistr2("", &q_u->servername, q_u->servername_ptr, ps, depth))
+ return False;
+
+ if (!prs_align(ps))
+ return False;
+ if (!prs_uint32("level", ps, depth, &q_u->level))
+ return False;
- spoolss_io_read_buffer("buffer", ps, depth, &(q_u->buffer));
+ if (!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ return False;
- prs_uint32("buf_size", ps, depth, &q_u->buf_size);
+ if (!prs_align(ps))
+ return False;
+ if (!prs_uint32("offered", ps, depth, &q_u->offered))
+ return False;
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)
- *
+ Parse a SPOOL_R_ENUMPRINTERS structure.
********************************************************************/
-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);
+BOOL new_spoolss_io_r_enumprinters(char *desc, SPOOL_R_ENUMPRINTERS *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "new_spoolss_io_r_enumprinters");
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;
- }
+ if (!prs_align(ps))
+ 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*.
- */
+ if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
- beginning = prs_offset(ps);
- start_offset = prs_offset(ps);
- end_offset = start_offset + r_u->offered;
+ if (!prs_align(ps))
+ return False;
- 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);
- }
+ if (!prs_uint32("needed", ps, depth, &r_u->needed))
+ return False;
+
+ if (!prs_uint32("returned", ps, depth, &r_u->returned))
+ return False;
+
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
- return True;
+ return True;
}
/*******************************************************************
* 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)
+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 */
+ if (!prs_align(ps))
+ return False;
- 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 (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
- 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;
- }
+ if (!prs_align(ps))
+ return False;
- }
+ if (!prs_uint32("needed", ps, depth, &r_u->needed))
+ return False;
- 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;
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
- return True;
+ 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)
+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);
+ if (!prs_align(ps))
+ return False;
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
-
- prs_uint32("level", ps, depth, &(q_u->level));
+ if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
+ return False;
+ if (!prs_uint32("level", ps, depth, &q_u->level))
+ return False;
- if (!ps->io)
- {
- /* writing */
- buf_ptr = q_u->buffer != NULL ? 1 : 0;
- }
- prs_uint32("buffer pointer", ps, depth, &buf_ptr);
+ if (!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ return False;
- 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));
+ if (!prs_align(ps))
+ return False;
+ if (!prs_uint32("offered", ps, depth, &q_u->offered))
+ return False;
- return count == q_u->offered;
+ return True;
}
/*******************************************************************
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 ! */
+ if(!prs_align(ps))
+ return False;
- /* To be correct it need to be split in 3 functions */
+ if(!smb_io_pol_hnd("printer handle", &q_u->handle ,ps, depth))
+ return False;
+ if(!prs_uint32("level", ps, depth, &q_u->level))
+ return False;
- spool_io_printer_info_level("", &(q_u->info), ps, depth);
+ if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
+ return False;
- spoolss_io_devmode(desc, ps, depth, q_u->devmode);
+ if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
+ return False;
- 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("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));
+ if(!prs_uint32("command", ps, depth, &q_u->command))
+ return False;
return True;
}
prs_align(ps);
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth);
return True;
}
prs_debug(ps, depth, desc, "");
depth++;
- prs_align(ps);
+ if(!prs_align(ps))
+ return False;
- prs_uint32("status", ps, depth, &(r_u->status));
+ if(!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
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);
+ if(!prs_align(ps))
+ return False;
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
- prs_uint32("level", ps, depth, &(q_u->level));
+ if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
+ return False;
+ if(!prs_uint32("level", ps, depth, &q_u->level))
+ return False;
- spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+ if(!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ return False;
- prs_align(ps);
+ if(!prs_align(ps))
+ return False;
- prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
+ if(!prs_uint32("offered", ps, depth, &q_u->offered))
+ return False;
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;
+ if (!prs_align(ps))
+ return False;
- 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));
+ if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
- prs_set_offset(ps, beginning);
- }
+ if (!prs_align(ps))
+ return False;
- 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;
- }
+ if (!prs_uint32("needed", ps, depth, &r_u->needed))
+ return False;
- }
- prs_set_offset(ps, beginning+r_u->offered);
- prs_align(ps);
+ if (!prs_uint32("returned", ps, depth, &r_u->returned))
+ return False;
- /*
- * 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);
- }
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
- return True;
+ 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)
+ NEW_BUFFER *buffer,
+ uint32 offered)
{
if (q_u == NULL)
{
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;
-
+ q_u->buffer= buffer;
+ q_u->offered = offered;
return True;
}
prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs");
depth++;
- prs_align(ps);
+ if (!prs_align(ps))
+ return False;
- 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));
+ if (!smb_io_pol_hnd("printer handle",&q_u->handle, ps, depth))
+ return False;
+
+ if (!prs_uint32("firstjob", ps, depth, &q_u->firstjob))
+ return False;
+ if (!prs_uint32("numofjobs", ps, depth, &q_u->numofjobs))
+ 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;
- prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
+ if (!prs_uint32("offered", ps, depth, &q_u->offered))
+ return False;
return True;
}
prs_align(ps);
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth);
prs_uint32("jobid", ps, depth, &(q_u->jobid));
return True;
prs_align(ps);
- smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth);
+ smb_io_pol_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 !
}
/*******************************************************************
+ Parse a SPOOL_R_ENUMPRINTERDRIVERS structure.
********************************************************************/
-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");
+BOOL new_spoolss_io_r_enumprinterdrivers(char *desc, SPOOL_R_ENUMPRINTERDRIVERS *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "new_spoolss_io_r_enumprinterdrivers");
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"));
+ if (!prs_align(ps))
+ return False;
+
+ if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
- 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;
+ if (!prs_align(ps))
+ return False;
- 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));
+ if (!prs_uint32("needed", ps, depth, &r_u->needed))
+ return False;
+
+ if (!prs_uint32("returned", ps, depth, &r_u->returned))
+ return False;
+
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
- return True;
+ 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;
- }
- }
-}
-
/*******************************************************************
+ Parse a SPOOL_Q_ENUMPRINTERDRIVERS structure.
********************************************************************/
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, "");
+ prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdrivers");
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));
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
+ return False;
+ if (!smb_io_unistr2("", &q_u->name, q_u->name_ptr,ps, depth))
+ return False;
+
+ if (!prs_align(ps))
+ return False;
+ if (!prs_uint32("environment_ptr", ps, depth, &q_u->environment_ptr))
+ return False;
+ if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
+ return False;
+
+ if (!prs_align(ps))
+ 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;
}
if (!prs_align(ps))
return False;
- if (!smb_io_prt_hnd("printer handle",&(q_u->handle),ps,depth))
+ if (!smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth))
return False;
if (!prs_uint32("level", ps, depth, &(q_u->level)))
return False;
}
/*******************************************************************
+ Parse a SPOOL_R_ENUMPORTS structure.
********************************************************************/
-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");
+BOOL new_spoolss_io_r_enumports(char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "new_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 */
+ if (!prs_align(ps))
+ return False;
- DEBUG(4,("buffer too small\n"));
+ if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
- 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;
+ if (!prs_align(ps))
+ return False;
- 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));
+ if (!prs_uint32("needed", ps, depth, &r_u->needed))
+ return False;
+
+ if (!prs_uint32("returned", ps, depth, &r_u->returned))
+ return False;
+
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
- return True;
+ 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));
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("", ps, depth, &q_u->name_ptr))
+ return False;
+ if (!smb_io_unistr2("", &q_u->name,True,ps,depth))
+ return False;
+
+ if (!prs_align(ps))
+ 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;
}
-
/*******************************************************************
+ Parse a SPOOL_PRINTER_INFO_LEVEL_2 structure.
********************************************************************/
-BOOL spool_io_printer_info_level_2(char *desc, SPOOL_PRINTER_INFO_LEVEL_2 **q_u, prs_struct *ps, int depth)
+BOOL spool_io_printer_info_level_2(char *desc, SPOOL_PRINTER_INFO_LEVEL_2 *il, prs_struct *ps, int depth)
{
- SPOOL_PRINTER_INFO_LEVEL_2 *il;
-
- prs_debug(ps, depth, desc, "");
+ prs_debug(ps, depth, desc, "spool_io_printer_info_level_2");
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);
+ if(!prs_align(ps))
+ return False;
- prs_align(ps);
+ if(!prs_uint32("servername_ptr", ps, depth, &il->servername_ptr))
+ return False;
+ if(!prs_uint32("printername_ptr", ps, depth, &il->printername_ptr))
+ return False;
+ if(!prs_uint32("sharename_ptr", ps, depth, &il->sharename_ptr))
+ return False;
+ if(!prs_uint32("portname_ptr", ps, depth, &il->portname_ptr))
+ return False;
+ if(!prs_uint32("drivername_ptr", ps, depth, &il->drivername_ptr))
+ return False;
+ if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
+ return False;
+ if(!prs_uint32("location_ptr", ps, depth, &il->location_ptr))
+ return False;
+ if(!prs_uint32("devmode_ptr", ps, depth, &il->devmode_ptr))
+ return False;
+ if(!prs_uint32("sepfile_ptr", ps, depth, &il->sepfile_ptr))
+ return False;
+ if(!prs_uint32("printprocessor_ptr", ps, depth, &il->printprocessor_ptr))
+ return False;
+ if(!prs_uint32("datatype_ptr", ps, depth, &il->datatype_ptr))
+ return False;
+ if(!prs_uint32("parameters_ptr", ps, depth, &il->parameters_ptr))
+ return False;
+ if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
+ return False;
- /* this code as nothing to do here !!!
-
- if (il->secdesc_ptr)
- {
- il->secdesc=NULL;
- sec_io_desc_buf("", &(il->secdesc), ps, depth);
- }
-
- */
+ if(!prs_uint32("attributes", ps, depth, &il->attributes))
+ return False;
+ if(!prs_uint32("priority", ps, depth, &il->priority))
+ return False;
+ if(!prs_uint32("default_priority", ps, depth, &il->default_priority))
+ return False;
+ if(!prs_uint32("starttime", ps, depth, &il->starttime))
+ return False;
+ if(!prs_uint32("untiltime", ps, depth, &il->untiltime))
+ return False;
+ if(!prs_uint32("status", ps, depth, &il->status))
+ return False;
+ if(!prs_uint32("cjobs", ps, depth, &il->cjobs))
+ return False;
+ if(!prs_uint32("averageppm", ps, depth, &il->averageppm))
+ return False;
+
+ if(!smb_io_unistr2("servername", &il->servername, il->servername_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("printername", &il->printername, il->printername_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("sharename", &il->sharename, il->sharename_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("portname", &il->portname, il->portname_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("drivername", &il->drivername, il->drivername_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("location", &il->location, il->location_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("sepfile", &il->sepfile, il->sepfile_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("printprocessor", &il->printprocessor, il->printprocessor_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("datatype", &il->datatype, il->datatype_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("parameters", &il->parameters, il->parameters_ptr, ps, depth))
+ return False;
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, "");
+ prs_debug(ps, depth, desc, "spool_io_printer_info_level");
depth++;
- prs_align(ps);
- prs_uint32("info level", ps, depth, &level);
- prs_uint32("useless", ps, depth, &useless);
-
- switch (level)
- {
+ if(!prs_align(ps))
+ return False;
+ if(!prs_uint32("level", ps, depth, &il->level))
+ return False;
+ if(!prs_uint32("info_ptr", ps, depth, &il->info_ptr))
+ return False;
+
+ /* if no struct inside just return */
+ if (il->info_ptr==0) {
+ if (UNMARSHALLING(ps))
+ il->info_2=NULL;
+ return True;
+ }
+
+ switch (il->level) {
/*
* level 0 is used by setprinter when managing the queue
* (hold, stop, start a queue)
* and by setprinter when updating printer's info
*/
case 2:
- spool_io_printer_info_level_2("", &(il->info_2), ps, depth);
+ if (UNMARSHALLING(ps))
+ il->info_2=(SPOOL_PRINTER_INFO_LEVEL_2 *)malloc(sizeof(SPOOL_PRINTER_INFO_LEVEL_2));
+ if (!spool_io_printer_info_level_2("", il->info_2, ps, depth))
+ return False;
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++;
* 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);
+ if(!prs_align(ps))
+ return False;
+ if(!prs_uint32("", ps, depth, &q_u->server_name_ptr))
+ return False;
+ if(!smb_io_unistr2("", &q_u->server_name, q_u->server_name_ptr, ps, depth))
+ return False;
+
+ if(!prs_align(ps))
+ return False;
+
+ if(!prs_uint32("info_level", ps, depth, &q_u->level))
+ return False;
- 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 */
+ if(!spool_io_printer_info_level("", &(q_u->info), ps, depth))
+ return False;
+ /* 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);
+ if(!prs_uint32("unk0", ps, depth, &q_u->unk0))
+ return False;
+ if(!prs_uint32("unk1", ps, depth, &q_u->unk1))
+ return False;
+ if(!prs_uint32("unk2", ps, depth, &q_u->unk2))
+ return False;
+ if(!prs_uint32("unk3", ps, depth, &q_u->unk3))
+ 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;
}
prs_debug(ps, depth, desc, "spoolss_io_r_addprinterex");
depth++;
- smb_io_prt_hnd("printer handle",&(r_u->handle),ps,depth);
+ smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth);
prs_uint32("status", ps, depth, &(r_u->status));
{
SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *il;
- prs_debug(ps, depth, desc, "");
+ prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_3");
depth++;
/* reading */
- if (ps->io)
- {
+ if (UNMARSHALLING(ps)) {
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
- {
+ 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);
+ if(!prs_align(ps))
+ return False;
+
+ if(!prs_uint32("cversion", ps, depth, &il->cversion))
+ return False;
+ if(!prs_uint32("name", ps, depth, &il->name_ptr))
+ return False;
+ if(!prs_uint32("environment", ps, depth, &il->environment_ptr))
+ return False;
+ if(!prs_uint32("driverpath", ps, depth, &il->driverpath_ptr))
+ return False;
+ if(!prs_uint32("datafile", ps, depth, &il->datafile_ptr))
+ return False;
+ if(!prs_uint32("configfile", ps, depth, &il->configfile_ptr))
+ return False;
+ if(!prs_uint32("helpfile", ps, depth, &il->helpfile_ptr))
+ return False;
+ if(!prs_uint32("monitorname", ps, depth, &il->monitorname_ptr))
+ return False;
+ if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
+ return False;
+ if(!prs_uint32("dependentfilessize", ps, depth, &il->dependentfilessize))
+ return False;
+ if(!prs_uint32("dependentfiles", ps, depth, &il->dependentfiles_ptr))
+ return False;
+
+ if(!prs_align(ps))
+ return False;
- 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(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
+ return False;
+
+ if(!prs_align(ps))
+ return False;
+
if (il->dependentfiles_ptr)
smb_io_buffer5("", &(il->dependentfiles), ps, depth);
-
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, "");
+ prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level");
depth++;
- prs_align(ps);
- prs_uint32("info level", ps, depth, &level);
- prs_uint32("useless", ps, depth, &useless);
+ if(!prs_align(ps))
+ return False;
+ if(!prs_uint32("level", ps, depth, &il->level))
+ return False;
+ if(!prs_uint32("ptr", ps, depth, &il->ptr))
+ return False;
+
+ if (il->ptr==0)
+ return True;
- switch (level)
- {
+ switch (il->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, "");
+ prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriver");
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));
+ if(!prs_align(ps))
+ return False;
+
+ if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
+ return False;
+ if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
+ return False;
+
+ if(!prs_align(ps))
+ return False;
+ if(!prs_uint32("info_level", ps, depth, &q_u->level))
+ return False;
- spool_io_printer_driver_info_level("", &(q_u->info), ps, depth);
+ if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
+ return False;
return True;
}
********************************************************************/
BOOL spoolss_io_r_addprinterdriver(char *desc, SPOOL_R_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
{
- prs_debug(ps, depth, desc, "");
+ prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriver");
depth++;
- prs_uint32("status", ps, depth, &(q_u->status));
+ if(!prs_uint32("status", ps, depth, &q_u->status))
+ return False;
return True;
}
NT_PRINTER_INFO_LEVEL_2 **asc)
{
NT_PRINTER_INFO_LEVEL_2 *d;
+ NTTIME time_nt;
+ time_t time_unix;
DEBUG(7,("Converting from UNICODE to ASCII\n"));
+ time_unix=time(NULL);
if (*asc==NULL)
{
*asc=(NT_PRINTER_INFO_LEVEL_2 *)malloc(sizeof(NT_PRINTER_INFO_LEVEL_2));
ZERO_STRUCTP(*asc);
+
+ /* we allocate memory iff called from
+ * addprinter(ex) so we can do one time stuff here.
+ */
+ (*asc)->setuptime=time_unix;
+
}
DEBUGADD(8,("start converting\n"));
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);
+ unix_to_nt_time(&time_nt, time_unix);
+ d->changeid=time_nt.low;
+
+ d->c_setprinter++;
+
+ 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->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;
+}
+
+/*******************************************************************
+ Parse a SPOOL_Q_GETPRINTERDRIVERDIR structure.
+********************************************************************/
+BOOL spoolss_io_q_getprinterdriverdir(char *desc, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriverdir");
+ depth++;
+
+ if(!prs_align(ps))
+ return False;
+ if(!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
+ return False;
+ if(!smb_io_unistr2("", &q_u->name, q_u->name_ptr, ps, depth))
+ return False;
+
+ if(!prs_align(ps))
+ return False;
+
+ if(!prs_uint32("", ps, depth, &q_u->environment_ptr))
+ return False;
+ if(!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
+ return False;
+
+ if(!prs_align(ps))
+ 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;
}
/*******************************************************************
+ Parse a SPOOL_R_GETPRINTERDRIVERDIR structure.
********************************************************************/
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);
+ if (!prs_align(ps))
+ return False;
+
+ if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
- 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));
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("needed", ps, depth, &r_u->needed))
+ return False;
+
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
- /* check if the buffer is big enough for the datas */
+ return True;
+}
- if (r_u->offered<bufsize_required)
- {
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_r_enumprintprocessors(char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
+ depth++;
- /* 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"));
+ if (!prs_align(ps))
+ return False;
+
+ if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
- 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;
+ if (!prs_align(ps))
+ return False;
- 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 (!prs_uint32("needed", ps, depth, &r_u->needed))
+ return False;
+
+ if (!prs_uint32("returned", ps, depth, &r_u->returned))
+ return False;
+
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL spoolss_io_q_enumprintprocessors(char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
+ depth++;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
+ return False;
+ if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
+ return False;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("", ps, depth, &q_u->environment_ptr))
+ return False;
+ if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
+ return False;
- /*
- * 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));
+ if (!prs_align(ps))
+ 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 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, "");
+BOOL spoolss_io_r_enumprintprocdatatypes(char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes");
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));
+ if (!prs_align(ps))
+ return False;
+
+ if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
- return True;
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("needed", ps, depth, &r_u->needed))
+ return False;
+
+ if (!prs_uint32("returned", ps, depth, &r_u->returned))
+ return False;
+
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
+
+ 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");
+BOOL spoolss_io_q_enumprintprocdatatypes(char *desc, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocdatatypes");
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 */
+ if (!prs_align(ps))
+ return False;
- 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;
+ if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
+ return False;
+ if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
+ return False;
- 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 (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("processor_ptr", ps, depth, &q_u->processor_ptr))
+ return False;
+ if (!smb_io_unistr2("processor", &q_u->processor, q_u->processor_ptr, ps, depth))
+ return False;
- /*
- * 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));
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("level", ps, depth, &q_u->level))
+ return False;
+
+ if(!new_spoolss_io_buffer("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;
}
/*******************************************************************
+ Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
********************************************************************/
-BOOL spoolss_io_q_enumprintprocessors(char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
+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_enumprintprocessors");
+ 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("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));
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
+ return False;
+ if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
+ return False;
+
+ if (!prs_align(ps))
+ 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 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 */
+ if (!prs_align(ps))
+ return False;
- DEBUG(4,("buffer too small\n"));
+ if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
- 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;
+ if (!prs_align(ps))
+ return False;
- 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));
+ if (!prs_uint32("needed", ps, depth, &r_u->needed))
+ return False;
+
+ if (!prs_uint32("returned", ps, depth, &r_u->returned))
+ return False;
+
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
- return True;
+ return True;
}
/*******************************************************************
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));
+ if(!prs_align(ps))
+ return False;
+ if(!prs_uint32("valuesize", ps, depth, &r_u->valuesize))
+ return False;
+ if(!prs_uint16s(False, "value", ps, depth, r_u->value, r_u->valuesize))
+ return False;
+ if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
+ return False;
- prs_uint32("type", ps, depth, &(r_u->type));
+ if(!prs_uint32("type", ps, depth, &r_u->type))
+ return False;
- 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));
+ if(!prs_uint32("datasize", ps, depth, &r_u->datasize))
+ return False;
+ if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
+ return False;
+ if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
+ return False;
+ if(!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
return True;
}
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));
+ if(!prs_align(ps))
+ return False;
+ if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
+ return False;
+ if(!prs_uint32("index", ps, depth, &q_u->index))
+ return False;
+ if(!prs_uint32("valuesize", ps, depth, &q_u->valuesize))
+ return False;
+ if(!prs_uint32("datasize", ps, depth, &q_u->datasize))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u, POLICY_HND *hnd, uint32 idx, uint32 valuelen, uint32 datalen)
+{
+ memcpy(&(q_u->handle), hnd, sizeof(q_u->handle));
+ q_u->index=idx;
+ q_u->valuesize=valuelen;
+ q_u->datasize=datalen;
return True;
}
depth++;
prs_align(ps);
- smb_io_prt_hnd("printer handle", &(q_u->handle), ps, depth);
+ smb_io_pol_hnd("printer handle", &(q_u->handle), ps, depth);
smb_io_unistr2("", &(q_u->value), True, ps, depth);
prs_align(ps);
********************************************************************/
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));
+ prs_debug(ps, depth, desc, "spoolss_io_addform");
+ depth++;
+ prs_align(ps);
- smb_io_unistr2("", &(f->name), f->name_ptr, ps, depth);
- }
+ 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++;
+ 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));
+ prs_align(ps);
+ smb_io_pol_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);
- }
+ 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_debug(ps, depth, desc, "spoolss_io_r_addform");
+ depth++;
- prs_align(ps);
- prs_uint32("status", ps, depth, &(r_u->status));
+ prs_align(ps);
+ prs_uint32("status", ps, depth, &(r_u->status));
return True;
}
depth++;
prs_align(ps);
- smb_io_prt_hnd("printer handle", &(q_u->handle), ps, depth);
+ smb_io_pol_hnd("printer handle", &(q_u->handle), ps, depth);
smb_io_unistr2("", &(q_u->name), True, ps, depth);
prs_align(ps);
}
/*******************************************************************
+ Parse a SPOOL_R_GETJOB structure.
********************************************************************/
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 */
+ if (!prs_align(ps))
+ return False;
- DEBUG(4,("spoolss_io_r_getjob, buffer too small\n"));
+ if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
- 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;
+ if (!prs_align(ps))
+ return False;
- 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;
- }
+ if (!prs_uint32("needed", ps, depth, &r_u->needed))
+ return False;
- }
- 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;
-}
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
-/****************************************************************************
-****************************************************************************/
-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;
- }
- }
+ return True;
}
/*******************************************************************
+ Parse a SPOOL_Q_GETJOB structure.
********************************************************************/
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);
+ if(!prs_align(ps))
+ return False;
- 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));
+ if(!smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth))
+ return False;
+ if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
+ return False;
+ if(!prs_uint32("level", ps, depth, &q_u->level))
+ return False;
- spoolss_io_read_buffer("", ps, depth, &(q_u->buffer));
+ if(!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ return False;
- prs_align(ps);
+ if(!prs_align(ps))
+ return False;
- prs_uint32("buf_size", ps, depth, &(q_u->buf_size));
+ if(!prs_uint32("offered", ps, depth, &q_u->offered))
+ return False;
return True;
}