diff options
Diffstat (limited to 'source/rpc_parse/parse_spoolss.c')
-rw-r--r-- | source/rpc_parse/parse_spoolss.c | 4423 |
1 files changed, 2017 insertions, 2406 deletions
diff --git a/source/rpc_parse/parse_spoolss.c b/source/rpc_parse/parse_spoolss.c index 0d833a7a109..d9e761da613 100644 --- a/source/rpc_parse/parse_spoolss.c +++ b/source/rpc_parse/parse_spoolss.c @@ -2,9 +2,9 @@ * Unix SMB/Netbios implementation. * Version 1.9. * RPC Pipe client / server routines - * Copyright (C) Andrew Tridgell 1992-1998, - * Copyright (C) Luke Kenneth Casson Leighton 1996-1998, - * Copyright (C) Jean François Micouleau 1998. + * Copyright (C) Andrew Tridgell 1992-2000, + * Copyright (C) Luke Kenneth Casson Leighton 1996-2000, + * Copyright (C) Jean François Micouleau 1998-2000. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -23,12 +23,19 @@ #include "includes.h" -#include "rpc_parse.h" #include "nterr.h" -extern int DEBUGLEVEL; +#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. ********************************************************************/ @@ -165,24 +172,26 @@ static BOOL smb_io_doc_info_container(char *desc, DOC_INFO_CONTAINER *cont, prs_ /******************************************************************* 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; } @@ -190,79 +199,97 @@ static BOOL smb_io_notify_option_type(char *desc, /******************************************************************* 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; - /* memory pointer to the struct */ - prs_uint32("useless ptr", ps, depth, &useless_ptr); + /* 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; + + /* 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; @@ -340,19 +367,16 @@ BOOL smb_io_notify_info_data_strings(char *desc,SPOOL_NOTIFY_INFO_DATA *data, /******************************************************************* 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)); @@ -366,75 +390,277 @@ static BOOL smb_io_notify_info(char *desc, SPOOL_NOTIFY_INFO *info, /* 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; } + /******************************************************************* - * write a structure. - * called from static spoolss_r_open_printer_ex (srv_spoolss.c) - * called from spoolss_open_printer_ex (cli_spoolss.c) - ********************************************************************/ -BOOL spoolss_io_r_open_printer_ex(char *desc, SPOOL_R_OPEN_PRINTER_EX *r_u, prs_struct *ps, int depth) +********************************************************************/ +static BOOL spool_io_user_level_1(char *desc, SPOOL_USER_1 *q_u, prs_struct *ps, int depth) { - if (r_u == NULL) return False; - - prs_debug(ps, depth, desc, "spoolss_io_r_open_printer_ex"); + prs_debug(ps, depth, desc, ""); depth++; - prs_align(ps); - smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth); + /* reading */ + if (ps->io) + ZERO_STRUCTP(q_u); + + if (!prs_align(ps)) + return False; + if (!prs_uint32("size", ps, depth, &(q_u->size))) + return False; + if (!prs_uint32("client_name_ptr", ps, depth, &(q_u->client_name_ptr))) + return False; + if (!prs_uint32("user_name_ptr", ps, depth, &(q_u->user_name_ptr))) + return False; + if (!prs_uint32("build", ps, depth, &(q_u->build))) + return False; + if (!prs_uint32("major", ps, depth, &(q_u->major))) + return False; + if (!prs_uint32("minor", ps, depth, &(q_u->minor))) + return False; + if (!prs_uint32("processor", ps, depth, &(q_u->processor))) + return False; + + if (!smb_io_unistr2("", &(q_u->client_name), q_u->client_name_ptr, ps, depth)) + return False; + if (!prs_align(ps)) + return False; + if (!smb_io_unistr2("", &(q_u->user_name), q_u->user_name_ptr, ps, depth)) + return False; + + return True; +} -/* prs_align(ps);*/ +/******************************************************************* +********************************************************************/ +static BOOL spool_io_user_level(char *desc, SPOOL_USER_CTR *q_u, prs_struct *ps, int depth) +{ + if (q_u==NULL) + return False; - prs_uint32("status code", ps, depth, &(r_u->status)); + prs_debug(ps, depth, desc, "spool_io_user_level"); + depth++; + if (!prs_align(ps)) + return False; + if (!prs_uint32("level", ps, depth, &q_u->level)) + return False; + if (!prs_uint32("ptr", ps, depth, &q_u->ptr)) + return False; + + switch (q_u->level) { + case 1: + if (!spool_io_user_level_1("", &(q_u->user1), ps, depth)) + return False; + break; + default: + return False; + } return True; } /******************************************************************* - * make a structure. + * read or write a DEVICEMODE struct. + * on reading allocate memory for the private member ********************************************************************/ -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) +static BOOL spoolss_io_devmode(char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode) { - int len_name = printername != NULL ? strlen(printername) : 0; - int len_sta = station != NULL ? strlen(station ) : 0; - int len_user = username != NULL ? strlen(username ) : 0; + prs_debug(ps, depth, desc, "spoolss_io_devmode"); + depth++; - if (q_u == NULL) return False; + if (!prs_uint16s(True,"devicename", ps, depth, devmode->devicename.buffer, 32)) + return False; + if (!prs_uint16("specversion", ps, depth, &(devmode->specversion))) + return False; + if (!prs_uint16("driverversion", ps, depth, &(devmode->driverversion))) + return False; + if (!prs_uint16("size", ps, depth, &(devmode->size))) + return False; + if (!prs_uint16("driverextra", ps, depth, &(devmode->driverextra))) + return False; + if (!prs_uint32("fields", ps, depth, &(devmode->fields))) + return False; + if (!prs_uint16("orientation", ps, depth, &(devmode->orientation))) + return False; + if (!prs_uint16("papersize", ps, depth, &(devmode->papersize))) + return False; + if (!prs_uint16("paperlength", ps, depth, &(devmode->paperlength))) + return False; + if (!prs_uint16("paperwidth", ps, depth, &(devmode->paperwidth))) + return False; + if (!prs_uint16("scale", ps, depth, &(devmode->scale))) + return False; + if (!prs_uint16("copies", ps, depth, &(devmode->copies))) + return False; + if (!prs_uint16("defaultsource", ps, depth, &(devmode->defaultsource))) + return False; + if (!prs_uint16("printquality", ps, depth, &(devmode->printquality))) + return False; + if (!prs_uint16("color", ps, depth, &(devmode->color))) + return False; + if (!prs_uint16("duplex", ps, depth, &(devmode->duplex))) + return False; + if (!prs_uint16("yresolution", ps, depth, &(devmode->yresolution))) + return False; + if (!prs_uint16("ttoption", ps, depth, &(devmode->ttoption))) + return False; + if (!prs_uint16("collate", ps, depth, &(devmode->collate))) + return False; + if (!prs_uint16s(True, "formname", ps, depth, devmode->formname.buffer, 32)) + return False; + if (!prs_uint16("logpixels", ps, depth, &(devmode->logpixels))) + return False; + if (!prs_uint32("bitsperpel", ps, depth, &(devmode->bitsperpel))) + return False; + if (!prs_uint32("pelswidth", ps, depth, &(devmode->pelswidth))) + return False; + if (!prs_uint32("pelsheight", ps, depth, &(devmode->pelsheight))) + return False; + if (!prs_uint32("displayflags", ps, depth, &(devmode->displayflags))) + return False; + if (!prs_uint32("displayfrequency", ps, depth, &(devmode->displayfrequency))) + return False; + if (!prs_uint32("icmmethod", ps, depth, &(devmode->icmmethod))) + return False; + if (!prs_uint32("icmintent", ps, depth, &(devmode->icmintent))) + return False; + if (!prs_uint32("mediatype", ps, depth, &(devmode->mediatype))) + return False; + if (!prs_uint32("dithertype", ps, depth, &(devmode->dithertype))) + return False; + if (!prs_uint32("reserved1", ps, depth, &(devmode->reserved1))) + return False; + if (!prs_uint32("reserved2", ps, depth, &(devmode->reserved2))) + return False; + if (!prs_uint32("panningwidth", ps, depth, &(devmode->panningwidth))) + return False; + if (!prs_uint32("panningheight", ps, depth, &(devmode->panningheight))) + return False; + + if (devmode->driverextra!=0) + { + if (UNMARSHALLING(ps)) { + devmode->private=(uint8 *)malloc(devmode->driverextra*sizeof(uint8)); + DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for private\n",devmode->driverextra)); + } + + DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of private\n",devmode->driverextra)); + if (!prs_uint8s(True, "private", ps, depth, devmode->private, devmode->driverextra)) + return False; + } + + return True; +} + +/******************************************************************* + Read or write a DEVICEMODE container +********************************************************************/ +static BOOL spoolss_io_devmode_cont(char *desc, DEVMODE_CTR *dm_c, prs_struct *ps, int depth) +{ + if (dm_c==NULL) + return False; + + prs_debug(ps, depth, desc, "spoolss_io_devmode_cont"); + depth++; + + if(!prs_align(ps)) + return False; + + if (!prs_uint32("size", ps, depth, &dm_c->size)) + return False; + + if (!prs_uint32("devmode_ptr", ps, depth, &dm_c->devmode_ptr)) + return False; + + if (dm_c->size==0 || dm_c->devmode_ptr==0) { + if (UNMARSHALLING(ps)) + /* if while reading there is no DEVMODE ... */ + dm_c->devmode=NULL; + return True; + } + + /* so we have a DEVICEMODE to follow */ + if (UNMARSHALLING(ps)) { + DEBUG(9,("Allocating memory for spoolss_io_devmode\n")); + dm_c->devmode=(DEVICEMODE *)malloc(sizeof(DEVICEMODE)); + ZERO_STRUCTP(dm_c->devmode); + } + + /* this is bad code, shouldn't be there */ + if (!prs_uint32("size", ps, depth, &dm_c->size)) + return False; + + if (!spoolss_io_devmode(desc, ps, depth, dm_c->devmode)) + return False; - DEBUG(5,("make_spoolss_io_q_open_printer_ex\n")); + return True; +} + +/******************************************************************* +********************************************************************/ +static BOOL spoolss_io_printer_default(char *desc, PRINTER_DEFAULT *pd, prs_struct *ps, int depth) +{ + if (pd==NULL) + return False; - q_u->ptr = 1; - make_unistr2(&(q_u->printername), printername, len_name); + prs_debug(ps, depth, desc, "spoolss_io_printer_default"); + depth++; + + if (!prs_uint32("datatype_ptr", ps, depth, &pd->datatype_ptr)) + return False; + + if (!smb_io_unistr2("datatype", &(pd->datatype), pd->datatype_ptr, ps,depth)) + return False; + + if (!prs_align(ps)) + return False; - q_u->unknown0 = 0x0; /* 0x0000 0000 */ - q_u->cbbuf = cbbuf; /* 0x0000 0000 */ - q_u->devmod = devmod; /* 0x0000 0000 */ - q_u->access_required = des_access; + if (!spoolss_io_devmode_cont("", &(pd->devmode_cont), ps, depth)) + return False; - q_u->unknown1 = 0x1; - q_u->unknown2 = 0x1; - q_u->unknown3 = 0x149f7d8; /* looks like a pointer */ - q_u->unknown4 = 0x1c; - q_u->unknown5 = 0x00b94dd0; - q_u->unknown6 = 0x0149f5cc; /* looks like _another_ pointer */ - q_u->unknown7 = 0x00000565; - q_u->unknown8 = 0x2; - q_u->unknown9 = 0x0; - q_u->unknown10 = 0x0; + if (!prs_uint32("access_required", ps, depth, &pd->access_required)) + return False; - make_unistr2(&(q_u->station), station, len_sta); - make_unistr2(&(q_u->username), username, len_user); + return True; +} +/******************************************************************* + * init a structure. + ********************************************************************/ +BOOL make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX *q_u, fstring printername, fstring datatype, + uint32 access_required, fstring client_name, fstring user_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->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(client_name)+strlen(user_name)+8; + q_u->user_ctr.user1.client_name_ptr = (client_name!=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), client_name, strlen(client_name)); + init_unistr2(&(q_u->user_ctr.user1.user_name), user_name, strlen(user_name)); + return True; } @@ -444,46 +670,58 @@ BOOL make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX *q_u, ********************************************************************/ BOOL spoolss_io_q_open_printer_ex(char *desc, SPOOL_Q_OPEN_PRINTER_EX *q_u, prs_struct *ps, int depth) { - if (q_u == NULL) return False; + if (q_u == NULL) + return False; prs_debug(ps, depth, desc, "spoolss_io_q_open_printer_ex"); depth++; - prs_align(ps); + if (!prs_align(ps)) + return False; - prs_uint32("ptr", ps, depth, &(q_u->ptr)); - smb_io_unistr2("", &(q_u->printername),True,ps,depth); + if (!prs_uint32("printername_ptr", ps, depth, &q_u->printername_ptr)) + return False; + if (!smb_io_unistr2("", &q_u->printername, q_u->printername_ptr, ps,depth)) + return False; - prs_align(ps); - - prs_uint32("unknown0", ps, depth, &(q_u->unknown0)); - prs_uint32("cbbuf", ps, depth, &(q_u->cbbuf)); - prs_uint32("devmod", ps, depth, &(q_u->devmod)); - prs_uint32("access required", ps, depth, &(q_u->access_required)); - - /* don't care to decode end of packet by now */ - /* but when acl will be implemented, it will be useful */ - - prs_uint32("unknown1", ps, depth, &(q_u->unknown1)); - prs_uint32("unknown2", ps, depth, &(q_u->unknown2)); - prs_uint32("unknown3", ps, depth, &(q_u->unknown3)); - prs_uint32("unknown4", ps, depth, &(q_u->unknown4)); - prs_uint32("unknown5", ps, depth, &(q_u->unknown5)); - prs_uint32("unknown6", ps, depth, &(q_u->unknown6)); - prs_uint32("unknown7", ps, depth, &(q_u->unknown7)); - prs_uint32("unknown8", ps, depth, &(q_u->unknown8)); - prs_uint32("unknown9", ps, depth, &(q_u->unknown9)); - prs_uint32("unknown10", ps, depth, &(q_u->unknown10)); - - smb_io_unistr2("", &(q_u->station),True,ps,depth); - prs_align(ps); - smb_io_unistr2("", &(q_u->username),True,ps,depth); - prs_align(ps); + if (!prs_align(ps)) + return False; + if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth)) + return False; + + if (!prs_uint32("user_switch", ps, depth, &q_u->user_switch)) + return False; + if (!spool_io_user_level("", &q_u->user_ctr, ps, depth)) + return False; + return True; } /******************************************************************* + * write a structure. + * called from static spoolss_r_open_printer_ex (srv_spoolss.c) + * called from spoolss_open_printer_ex (cli_spoolss.c) + ********************************************************************/ +BOOL spoolss_io_r_open_printer_ex(char *desc, SPOOL_R_OPEN_PRINTER_EX *r_u, prs_struct *ps, int depth) +{ + if (r_u == NULL) return False; + + prs_debug(ps, depth, desc, "spoolss_io_r_open_printer_ex"); + depth++; + + if (!prs_align(ps)) + return False; + + if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth)) + return False; + + if (!prs_uint32("status code", ps, depth, &(r_u->status))) + return False; + + return True; +} +/******************************************************************* * make a structure. ********************************************************************/ BOOL make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u, @@ -498,7 +736,7 @@ BOOL make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u, DEBUG(5,("make_spoolss_q_getprinterdata\n")); memcpy(&(q_u->handle), handle, sizeof(q_u->handle)); - make_unistr2(&(q_u->valuename), valuename, len_name); + init_unistr2(&(q_u->valuename), valuename, len_name); q_u->size = size; return True; @@ -515,12 +753,18 @@ BOOL spoolss_io_q_getprinterdata(char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_st prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdata"); depth++; - prs_align(ps); - smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth); - prs_align(ps); - smb_io_unistr2("", &(q_u->valuename),True,ps,depth); - prs_align(ps); - prs_uint32("size", ps, depth, &(q_u->size)); + if (!prs_align(ps)) + return False; + if (!smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth)) + return False; + if (!prs_align(ps)) + return False; + if (!smb_io_unistr2("valuename", &(q_u->valuename),True,ps,depth)) + return False; + if (!prs_align(ps)) + return False; + if (!prs_uint32("size", ps, depth, &(q_u->size))) + return False; return True; } @@ -531,22 +775,30 @@ BOOL spoolss_io_q_getprinterdata(char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_st ********************************************************************/ BOOL spoolss_io_r_getprinterdata(char *desc, SPOOL_R_GETPRINTERDATA *r_u, prs_struct *ps, int depth) { - if (r_u == NULL) return False; + if (r_u == NULL) + return False; prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdata"); depth++; - prs_align(ps); - prs_uint32("type", ps, depth, &(r_u->type)); - prs_uint32("size", ps, depth, &(r_u->size)); + if (!prs_align(ps)) + return False; + if (!prs_uint32("type", ps, depth, &(r_u->type))) + return False; + if (!prs_uint32("size", ps, depth, &(r_u->size))) + return False; - prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size); - prs_align(ps); + if (!prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size)) + return False; + + if (!prs_align(ps)) + return False; - prs_uint32("needed", ps, depth, &(r_u->needed)); - prs_uint32("status", ps, depth, &(r_u->status)); - prs_align(ps); - + if (!prs_uint32("needed", ps, depth, &(r_u->needed))) + return False; + if (!prs_uint32("status", ps, depth, &(r_u->status))) + return False; + return True; } @@ -576,9 +828,11 @@ BOOL spoolss_io_q_closeprinter(char *desc, SPOOL_Q_CLOSEPRINTER *q_u, prs_struct prs_debug(ps, depth, desc, "spoolss_io_q_closeprinter"); depth++; - prs_align(ps); + if (!prs_align(ps)) + return False; - smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth); + if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth)) + return False; return True; } @@ -592,12 +846,15 @@ BOOL spoolss_io_r_closeprinter(char *desc, SPOOL_R_CLOSEPRINTER *r_u, prs_struct { prs_debug(ps, depth, desc, "spoolss_io_r_closeprinter"); depth++; - prs_align(ps); - - smb_io_pol_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; } @@ -773,29 +1030,43 @@ BOOL spoolss_io_r_writeprinter(char *desc, SPOOL_R_WRITEPRINTER *r_u, prs_struct * 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_pol_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; } @@ -803,13 +1074,13 @@ BOOL spoolss_io_q_rffpcnex(char *desc, SPOOL_Q_RFFPCNEX *q_u, * 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; } @@ -818,20 +1089,31 @@ BOOL spoolss_io_r_rffpcnex(char *desc, SPOOL_R_RFFPCNEX *r_u, * 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_pol_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; - smb_io_notify_option("notify option",&(q_u->option),ps,depth); + 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; } @@ -840,18 +1122,24 @@ BOOL spoolss_io_q_rfnpcnex(char *desc, SPOOL_Q_RFNPCNEX *q_u, * 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; } @@ -862,8 +1150,6 @@ BOOL spoolss_io_r_rfnpcnex(char *desc, static uint32 size_of_uint32(uint32 *value) { return (sizeof(*value)); - - return True; } /******************************************************************* @@ -879,9 +1165,8 @@ static uint32 size_of_relative_string(UNISTR *string) 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; } /******************************************************************* @@ -893,8 +1178,6 @@ static uint32 size_of_device_mode(DEVICEMODE *devmode) return (4); else return (0xDC+4); - - return True; } /******************************************************************* @@ -906,21 +1189,21 @@ static uint32 size_of_systemtime(SYSTEMTIME *systime) 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; + if (uni == NULL) + return False; prs_debug(ps, depth, desc, "spoolss_smb_io_unistr"); depth++; - prs_unistr("unistr", ps, depth, uni); + if (!prs_unistr("unistr", ps, depth, uni)) + return False; return True; } @@ -929,39 +1212,59 @@ static BOOL spoolss_smb_io_unistr(char *desc, UNISTR *uni, prs_struct *ps, int /******************************************************************* * write a UNICODE string and its relative pointer. * used by all the RPC structs passing a buffer + * + * As I'm a nice guy, I'm forcing myself to explain this code. + * MS did a good job in the overall spoolss code except in some + * functions where they are passing the API buffer directly in the + * RPC request/reply. That's to maintain compatiility at the API level. + * They could have done it the good way the first time. + * + * So what happen is: the strings are written at the buffer's end, + * in the reverse order of the original structure. Some pointers to + * the strings are also in the buffer. Those are relative to the + * buffer's start. + * + * If you don't understand or want to change that function, + * first get in touch with me: jfm@samba.org + * ********************************************************************/ -static BOOL smb_io_relstr(char *desc, prs_struct *ps, int depth, UNISTR *buffer, - uint32 *start_offset, uint32 *end_offset) +static BOOL new_smb_io_relstr(char *desc, NEW_BUFFER *buffer, int depth, UNISTR *string) { - if (!ps->io) - { - uint32 struct_offset = ps->offset; + prs_struct *ps=&(buffer->prs); + + if (MARSHALLING(ps)) { + uint32 struct_offset = prs_offset(ps); uint32 relative_offset; - /* writing */ - *end_offset -= 2*(str_len_uni(buffer)+1); - ps->offset=*end_offset; - spoolss_smb_io_unistr(desc, buffer, ps, depth); - - ps->offset=struct_offset; - relative_offset=*end_offset-*start_offset; + buffer->string_at_end -= 2*(str_len_uni(string)+1); + prs_set_offset(ps, buffer->string_at_end); + + /* write the string */ + if (!spoolss_smb_io_unistr(desc, string, ps, depth)) + return False; - prs_uint32("offset", ps, depth, &(relative_offset)); + 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 - { + else { uint32 old_offset; - uint32 relative_offset; - - prs_uint32("offset", ps, depth, &(relative_offset)); + + /* read the offset */ + if (!prs_uint32("offset", ps, depth, &(buffer->string_at_end))) + return False; - old_offset = ps->offset; - ps->offset = (*start_offset) + relative_offset; + old_offset = prs_offset(ps); + prs_set_offset(ps, buffer->string_at_end+buffer->struct_start); - spoolss_smb_io_unistr(desc, buffer, ps, depth); + /* read the string */ + if (!spoolss_smb_io_unistr(desc, string, ps, depth)) + return False; - *end_offset = ps->offset; - ps->offset = old_offset; + prs_set_offset(ps, old_offset); } return True; } @@ -971,430 +1274,755 @@ static BOOL smb_io_relstr(char *desc, prs_struct *ps, int depth, UNISTR *buffer, * 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=ps->offset; - - 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); - ps->offset=*end_offset; - spoolss_smb_io_unistr(desc, (*buffer)[i], ps, depth); - + while ( (*string)[i]!=0x0000 ) + i++; i--; - } - while (i>=0); - ps->offset=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)); + /* 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); - return True; -} + /* 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; + + /* read the offset */ + if (!prs_uint32("offset", ps, depth, &(buffer->string_at_end))) + return False; -/******************************************************************* - * write a DEVICEMODE struct. - * on reading allocate memory for the private member - ********************************************************************/ -static BOOL smb_io_devmode(char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode) -{ - prs_debug(ps, depth, desc, "smb_io_devmode"); - depth++; + old_offset = prs_offset(ps); + prs_set_offset(ps, buffer->string_at_end); - prs_uint16s(True,"devicename", ps, depth, devmode->devicename.buffer, 32); - prs_uint16("specversion", ps, depth, &(devmode->specversion)); - prs_uint16("driverversion", ps, depth, &(devmode->driverversion)); - prs_uint16("size", ps, depth, &(devmode->size)); - prs_uint16("driverextra", ps, depth, &(devmode->driverextra)); - prs_uint32("fields", ps, depth, &(devmode->fields)); - prs_uint16("orientation", ps, depth, &(devmode->orientation)); - prs_uint16("papersize", ps, depth, &(devmode->papersize)); - prs_uint16("paperlength", ps, depth, &(devmode->paperlength)); - prs_uint16("paperwidth", ps, depth, &(devmode->paperwidth)); - prs_uint16("scale", ps, depth, &(devmode->scale)); - prs_uint16("copies", ps, depth, &(devmode->copies)); - prs_uint16("defaultsource", ps, depth, &(devmode->defaultsource)); - prs_uint16("printquality", ps, depth, &(devmode->printquality)); - prs_uint16("color", ps, depth, &(devmode->color)); - prs_uint16("duplex", ps, depth, &(devmode->duplex)); - prs_uint16("yresolution", ps, depth, &(devmode->yresolution)); - prs_uint16("ttoption", ps, depth, &(devmode->ttoption)); - prs_uint16("collate", ps, depth, &(devmode->collate)); - prs_uint16s(True, "formname", ps, depth, devmode->formname.buffer, 32); - prs_uint16("logpixels", ps, depth, &(devmode->logpixels)); - prs_uint32("bitsperpel", ps, depth, &(devmode->bitsperpel)); - prs_uint32("pelswidth", ps, depth, &(devmode->pelswidth)); - prs_uint32("pelsheight", ps, depth, &(devmode->pelsheight)); - prs_uint32("displayflags", ps, depth, &(devmode->displayflags)); - prs_uint32("displayfrequency", ps, depth, &(devmode->displayfrequency)); - prs_uint32("icmmethod", ps, depth, &(devmode->icmmethod)); - prs_uint32("icmintent", ps, depth, &(devmode->icmintent)); - prs_uint32("mediatype", ps, depth, &(devmode->mediatype)); - prs_uint32("dithertype", ps, depth, &(devmode->dithertype)); - prs_uint32("reserved1", ps, depth, &(devmode->reserved1)); - prs_uint32("reserved2", ps, depth, &(devmode->reserved2)); - prs_uint32("panningwidth", ps, depth, &(devmode->panningwidth)); - prs_uint32("panningheight", ps, depth, &(devmode->panningheight)); + /* read the string */ - if (devmode->driverextra!=0) - { - if (ps->io) - { - devmode->private=(uint8 *)malloc(devmode->driverextra*sizeof(uint8)); - DEBUG(7,("smb_io_devmode: allocated memory [%d] for private\n",devmode->driverextra)); - } - DEBUG(7,("smb_io_devmode: parsing [%d] bytes of private\n",devmode->driverextra)); + /* jfm: FIXME: alloc memory and read all the strings until the string is NULL */ - prs_uint8s(True, "private", ps, depth, devmode->private, devmode->driverextra); - DEBUG(8,("smb_io_devmode: parsed\n")); +/* + if (!spoolss_smb_io_unistr(desc, string, ps, depth)) + return False; +*/ + prs_set_offset(ps, old_offset); } - return True; } + /******************************************************************* - * write a DEVMODE struct and its relative pointer. - * used by all the RPC structs passing a buffer - ********************************************************************/ -static BOOL smb_io_reldevmode(char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode, - uint32 *start_offset, uint32 *end_offset) + Parse a DEVMODE structure and its relative pointer. +********************************************************************/ +static BOOL new_smb_io_reldevmode(char *desc, NEW_BUFFER *buffer, int depth, DEVICEMODE **devmode) { - uint32 struct_offset; - uint32 relative_offset; - - prs_debug(ps, depth, desc, "smb_io_reldevmode"); + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "new_smb_io_reldevmode"); depth++; + + if (MARSHALLING(ps)) { + uint32 struct_offset = prs_offset(ps); + uint32 relative_offset; - struct_offset=ps->offset; - *end_offset-= (devmode->size+devmode->driverextra); - ps->offset=*end_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; - smb_io_devmode(desc, ps, depth, devmode); + 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; - ps->offset=struct_offset; - relative_offset=*end_offset-*start_offset; + old_offset = prs_offset(ps); + prs_set_offset(ps, buffer->string_at_end + buffer->struct_start); - prs_uint32("offset", ps, depth, &(relative_offset)); + /* 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. ********************************************************************/ -static BOOL smb_io_printer_info_0(char *desc, PRINTER_INFO_0 *info, prs_struct *ps, int depth, - uint32 *start_offset, uint32 *end_offset) +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=ps->offset; - 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)); + 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; + + if(!prs_uint32("cjobs", ps, depth, &info->cjobs)) + return False; + if(!prs_uint32("attributes", ps, depth, &info->attributes)) + return False; + + if(!prs_uint32("unknown0", ps, depth, &info->unknown0)) + return False; + if(!prs_uint32("unknown1", ps, depth, &info->unknown1)) + return False; + if(!prs_uint32("unknown2", ps, depth, &info->unknown2)) + return False; + if(!prs_uint32("unknown3", ps, depth, &info->unknown3)) + return False; + if(!prs_uint32("unknown4", ps, depth, &info->unknown4)) + return False; + if(!prs_uint32("unknown5", ps, depth, &info->unknown5)) + return False; + if(!prs_uint32("unknown6", ps, depth, &info->unknown6)) + return False; + if(!prs_uint16("majorversion", ps, depth, &info->majorversion)) + return False; + if(!prs_uint16("buildversion", ps, depth, &info->buildversion)) + 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("unknown10", ps, depth, &info->unknown10)) + return False; + if(!prs_uint32("unknown11", ps, depth, &info->unknown11)) + return False; + if(!prs_uint32("unknown12", ps, depth, &info->unknown12)) + 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("unknown17", ps, depth, &info->unknown17)) + 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("unknown21", ps, depth, &info->unknown21)) + return False; + if(!prs_uint16("unknown22", ps, depth, &info->unknown22)) + return False; + if(!prs_uint32("unknown23", ps, depth, &info->unknown23)) + return False; return True; } /******************************************************************* + Parse a PRINTER_INFO_1 structure. ********************************************************************/ -static BOOL smb_io_printer_info_1(char *desc, PRINTER_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_info_1"); + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "new_smb_io_printer_info_1"); depth++; - *start_offset=ps->offset; - 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); + buffer->struct_start=prs_offset(ps); + + 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_info_2(char *desc, PRINTER_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) { + /* hack for the SEC DESC */ uint32 pipo=0; - uint32 devmode_offset; - uint32 backup_offset; - prs_debug(ps, depth, desc, "smb_io_printer_info_2"); + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "new_smb_io_printer_info_2"); depth++; - *start_offset=ps->offset; - 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=ps->offset; - ps->offset=ps->offset+4; + 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; - 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 (!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; - /* - I'm not sure if putting the devmode at the end the struct is worth it - but NT does it - */ - backup_offset=ps->offset; - ps->offset=devmode_offset; - smb_io_reldevmode("devmode", ps, depth, info->devmode, start_offset, end_offset); - ps->offset=backup_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_1(char *desc, DRIVER_INFO_1 *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_debug(ps, depth, desc, "smb_io_printer_driver_info_1"); + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "new_smb_io_printer_driver_info_1"); depth++; - *start_offset=ps->offset; + + buffer->struct_start=prs_offset(ps); - smb_io_relstr("name", ps, depth, &(info->name), start_offset, end_offset); + if (!new_smb_io_relstr("name", buffer, depth, &info->name)) + return False; return True; } + /******************************************************************* -********************************************************************/ -static BOOL smb_io_printer_driver_info_2(char *desc, DRIVER_INFO_2 *info,prs_struct *ps, int depth, - uint32 *start_offset, uint32 *end_offset) + 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_debug(ps, depth, desc, "smb_io_printer_xxx"); + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "new_smb_io_printer_driver_info_2"); depth++; - *start_offset=ps->offset; + + 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); + 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; } + /******************************************************************* -********************************************************************/ -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_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=ps->offset; + + 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=ps->offset; - 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=ps->offset; + + 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; +} + +/******************************************************************* +********************************************************************/ +BOOL new_smb_io_form_1(char *desc, NEW_BUFFER *buffer, FORM_1 *info, int depth) +{ + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "new_smb_io_form_1"); + depth++; + + buffer->struct_start=prs_offset(ps); + + if (!prs_uint32("flag", ps, depth, &(info->flag))) + return False; + + if (!new_smb_io_relstr("name", buffer, depth, &(info->name))) + return False; + + if (!prs_uint32("width", ps, depth, &(info->width))) + return False; + if (!prs_uint32("length", ps, depth, &(info->length))) + return False; + if (!prs_uint32("left", ps, depth, &(info->left))) + return False; + if (!prs_uint32("top", ps, depth, &(info->top))) + return False; + if (!prs_uint32("right", ps, depth, &(info->right))) + return False; + if (!prs_uint32("bottom", ps, depth, &(info->bottom))) + return False; + + return True; +} + +/******************************************************************* + Read/write a BUFFER struct. +********************************************************************/ +static BOOL new_spoolss_io_buffer(char *desc, prs_struct *ps, int depth, NEW_BUFFER *buffer) +{ + if (buffer == NULL) + return False; + + prs_debug(ps, depth, desc, "new_spoolss_io_buffer"); + depth++; + + if (!prs_uint32("ptr", ps, depth, &(buffer->ptr))) + return False; + + /* reading */ + if (UNMARSHALLING(ps)) { + buffer->size=0; + buffer->string_at_end=0; + + if (buffer->ptr==0) { + if (!prs_init(&(buffer->prs), 0, 4, UNMARSHALL)) + return False; + return True; + } + + if (!prs_uint32("size", ps, depth, &buffer->size)) + return False; + + if (!prs_init(&(buffer->prs), buffer->size, 4, UNMARSHALL)) + return False; + + if (!prs_append_some_prs_data(&(buffer->prs), ps, prs_offset(ps), buffer->size)) + return False; + + if (!prs_set_offset(&buffer->prs, 0)) + return False; + + if (!prs_set_offset(ps, buffer->size+prs_offset(ps))) + return False; + + buffer->string_at_end=buffer->size; + + return True; + } + else { + /* writing */ + if (buffer->ptr==0) + return True; + + if (!prs_uint32("size", ps, depth, &(buffer->size))) + return False; + if (!prs_append_some_prs_data(ps, &(buffer->prs), 0, buffer->size)) + return False; + + return True; + } +} + +/******************************************************************* + move a BUFFER from the query to the reply. +********************************************************************/ +void new_spoolss_move_buffer(NEW_BUFFER *src, NEW_BUFFER **dest) +{ + prs_switch_type(&(src->prs), MARSHALL); + prs_set_offset(&(src->prs), 0); + prs_force_dynamic(&(src->prs)); + + *dest=src; +} + +/******************************************************************* + create a BUFFER struct. +********************************************************************/ +void new_spoolss_allocate_buffer(NEW_BUFFER **buffer) +{ + if (buffer==NULL) + return; + + *buffer=(NEW_BUFFER *)malloc(sizeof(NEW_BUFFER)); + + (*buffer)->ptr=0x0; + (*buffer)->size=0; + (*buffer)->string_at_end=0; +} + +/******************************************************************* + Destroy a BUFFER struct. +********************************************************************/ +void new_spoolss_free_buffer(NEW_BUFFER *buffer) +{ + if (buffer==NULL) + return; + + prs_mem_free(&(buffer->prs)); + buffer->ptr=0x0; + buffer->size=0; + buffer->string_at_end=0; + + free(buffer); +} + +/******************************************************************* + Get the size of a BUFFER struct. +********************************************************************/ +uint32 new_get_buffer_size(NEW_BUFFER *buffer) +{ + return (buffer->size); +} + + +/******************************************************************* + Parse a DRIVER_DIRECTORY_1 structure. +********************************************************************/ +BOOL new_smb_io_driverdir_1(char *desc, NEW_BUFFER *buffer, DRIVER_DIRECTORY_1 *info, int depth) +{ + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "new_smb_io_driverdir_1"); + depth++; + + buffer->struct_start=prs_offset(ps); + + if(!new_smb_io_relstr("name", buffer, depth, &info->name)) + return False; + + return True; +} + +/******************************************************************* + Parse a PORT_INFO_1 structure. +********************************************************************/ +BOOL new_smb_io_port_1(char *desc, NEW_BUFFER *buffer, PORT_INFO_1 *info, int depth) +{ + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "new_smb_io_port_1"); + depth++; + + 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. +********************************************************************/ +BOOL new_smb_io_port_2(char *desc, NEW_BUFFER *buffer, PORT_INFO_2 *info, int depth) +{ + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "new_smb_io_port_2"); + depth++; + + buffer->struct_start=prs_offset(ps); + + 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_form_1(char *desc, FORM_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_form_1"); + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "smb_io_printprocessor_info_1"); depth++; - *start_offset=ps->offset; - 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)); + buffer->struct_start=prs_offset(ps); + + if (new_smb_io_relstr("name", buffer, depth, &info->name)) + return False; return True; } /******************************************************************* ********************************************************************/ -static BOOL smb_io_port_2(char *desc, PORT_INFO_2 *info, prs_struct *ps, int depth, - uint32 *start_offset, uint32 *end_offset) +BOOL smb_io_printprocdatatype_info_1(char *desc, NEW_BUFFER *buffer, PRINTPROCDATATYPE_1 *info, int depth) { - prs_debug(ps, depth, desc, "smb_io_form_1"); + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "smb_io_printprocdatatype_info_1"); depth++; - *start_offset=ps->offset; - 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("name", buffer, depth, &info->name)) + return False; return True; } /******************************************************************* ********************************************************************/ -static BOOL smb_io_processor_info_1(char *desc, PRINTPROCESSOR_1 *info, prs_struct *ps, int depth, - uint32 *start_offset, uint32 *end_offset) +BOOL smb_io_printmonitor_info_1(char *desc, NEW_BUFFER *buffer, PRINTMONITOR_1 *info, int depth) { - prs_debug(ps, depth, desc, "smb_io_processor_info_1"); + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "smb_io_printmonitor_info_1"); depth++; - *start_offset=ps->offset; - smb_io_relstr("name",ps, depth, &(info->name), start_offset, end_offset); + buffer->struct_start=prs_offset(ps); + + if (!new_smb_io_relstr("name", buffer, depth, &info->name)) + 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_printmonitor_info_2(char *desc, NEW_BUFFER *buffer, PRINTMONITOR_2 *info, int depth) { - prs_debug(ps, depth, desc, "smb_io_monitor_info_1"); + prs_struct *ps=&(buffer->prs); + + prs_debug(ps, depth, desc, "smb_io_printmonitor_info_2"); depth++; - *start_offset=ps->offset; - smb_io_relstr("name",ps, depth, &(info->name), start_offset, end_offset); + 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; } @@ -1402,22 +2030,24 @@ static BOOL smb_io_monitor_info_1(char *desc, PRINTMONITOR_1 *info, prs_struct * /******************************************************************* return the size required by a struct in the stream ********************************************************************/ -static uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info) +uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info) { int size=0; - + + size+=24*4; + size+=6; + size+=size_of_uint32( &(info->attributes) ); size+=size_of_relative_string( &(info->printername) ); size+=size_of_relative_string( &(info->servername) ); - return (size); - return True; + return 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; @@ -1425,15 +2055,14 @@ static uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info) 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; @@ -1462,33 +2091,26 @@ static uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info) 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) ); @@ -1496,22 +2118,18 @@ static uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info) 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) ); @@ -1531,16 +2149,13 @@ static uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info) } 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) ); @@ -1556,15 +2171,14 @@ static uint32 spoolss_size_job_info_1(JOB_INFO_1 *info) 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; @@ -1593,15 +2207,14 @@ static uint32 spoolss_size_job_info_2(JOB_INFO_2 *info) size+=size_of_systemtime( &(info->submitted) ); size+=size_of_uint32( &(info->timeelapsed) ); size+=size_of_uint32( &(info->pagesprinted) ); - return (size); - return True; + return size; } /******************************************************************* return the size required by a struct in the stream -********************************************************************/ -static uint32 spoolss_size_form_1(FORM_1 *info) +********************************************************************/ +uint32 spoolss_size_form_1(FORM_1 *info) { int size=0; @@ -1614,171 +2227,131 @@ static uint32 spoolss_size_form_1(FORM_1 *info) 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+=size_of_relative_string( &info->name ); - 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_pol_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("unknown", ps, depth, &q_u->unknown)) + return False; return True; } @@ -1787,185 +2360,46 @@ BOOL spoolss_io_q_getprinterdriver2(char *desc, * 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=ps->offset; - start_offset=ps->offset; - 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; - } - - } - - ps->offset=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("unknown0", ps, depth, &r_u->unknown0)) + return False; + if (!prs_uint32("unknown1", ps, depth, &r_u->unknown1)) + 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; - - make_unistr2(&q_u->servername, servername, len_name); + q_u->flags=flags; + + q_u->servername_ptr = (servername != NULL) ? 1 : 0; + init_unistr2(&(q_u->servername), servername, strlen(servername)); - 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; } @@ -1974,197 +2408,65 @@ BOOL make_spoolss_q_enumprinters(SPOOL_Q_ENUMPRINTERS *q_u, * 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 = ps->offset; - start_offset = ps->offset; - end_offset = start_offset + r_u->offered; + if (!prs_align(ps)) + return False; - if (ps->io) - { - /* reading */ - ps->offset = beginning + r_u->offered; - - prs_align(ps); - prs_uint32("buffer size", ps, depth, &(bufsize_required)); - prs_uint32("count", ps, depth, &(r_u->returned)); - - ps->offset = 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; - } - } - } - - ps->offset = 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; } /******************************************************************* @@ -2172,229 +2474,55 @@ BOOL spoolss_io_r_enumprinters(char *desc, * 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=ps->offset; - start_offset=ps->offset; - 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; - ps->offset=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_pol_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; } /******************************************************************* @@ -2413,61 +2541,30 @@ BOOL spoolss_io_r_setprinter(char *desc, SPOOL_R_SETPRINTER *r_u, prs_struct *ps /******************************************************************* ********************************************************************/ -static BOOL spoolss_io_devmode(char *desc, prs_struct *ps, int depth, DEVICEMODE **devmode) -{ - uint32 devmode_size=0x0; - uint32 useless_ptr=0x0; - - prs_debug(ps, depth, desc, "spoolss_io_devmode"); - depth++; - - prs_uint32("devmode_size", ps, depth, &(devmode_size)); - prs_uint32("useless_ptr", ps, depth, &(useless_ptr)); - - if (devmode_size!=0 && useless_ptr!=0) - { - /* so we have a DEVICEMODE to follow */ - if (ps->io) - { - DEBUG(9,("Allocating memory for spoolss_io_devmode\n")); - *devmode=(DEVICEMODE *)malloc(sizeof(DEVICEMODE)); - ZERO_STRUCTP(*devmode); - } - - /* this is bad code, shouldn't be there */ - prs_uint32("devmode_size", ps, depth, &(devmode_size)); - - smb_io_devmode(desc, ps, depth, *devmode); - } - - return True; -} - -/******************************************************************* -********************************************************************/ BOOL spoolss_io_q_setprinter(char *desc, SPOOL_Q_SETPRINTER *q_u, prs_struct *ps, int depth) { prs_debug(ps, depth, desc, "spoolss_io_q_setprinter"); depth++; - prs_align(ps); - - smb_io_pol_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; } @@ -2509,9 +2606,11 @@ BOOL spoolss_io_r_addjob(char *desc, SPOOL_R_ADDJOB *r_u, prs_struct *ps, int de 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; } @@ -2520,216 +2619,66 @@ BOOL spoolss_io_r_addjob(char *desc, SPOOL_R_ADDJOB *r_u, prs_struct *ps, int de ********************************************************************/ 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_pol_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=ps->offset; - start_offset=ps->offset; - end_offset=start_offset+r_u->offered; + if (!prs_align(ps)) + return False; - tmp_ct = 0; - - if (ps->io) - { - /* reading */ - ps->offset = 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; - ps->offset = 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; - } - ps->offset=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) { @@ -2739,13 +2688,8 @@ BOOL make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS *q_u, const POLICY_HND *hnd, 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; } @@ -2756,16 +2700,24 @@ BOOL spoolss_io_q_enumjobs(char *desc, SPOOL_Q_ENUMJOBS *q_u, prs_struct *ps, in prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs"); depth++; - prs_align(ps); + if (!prs_align(ps)) + return False; - smb_io_pol_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; - prs_uint32("buf_size", ps, depth, &(q_u->buf_size)); + if (!new_spoolss_io_buffer("", ps, depth, q_u->buffer)) + return False; + + if (!prs_uint32("offered", ps, depth, &q_u->offered)) + return False; return True; } @@ -2835,506 +2787,268 @@ BOOL spoolss_io_q_setjob(char *desc, SPOOL_Q_SETJOB *q_u, prs_struct *ps, int de } /******************************************************************* + 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=ps->offset; - start_offset=ps->offset; - 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; - } - } - ps->offset=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; } /******************************************************************* ********************************************************************/ -BOOL spoolss_io_r_enumforms(char *desc, SPOOL_R_ENUMFORMS *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_enumforms"); +BOOL spoolss_io_q_enumforms(char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth) +{ + + prs_debug(ps, depth, desc, "spoolss_io_q_enumforms"); depth++; - prs_align(ps); - prs_uint32("pointer", ps, depth, &useless_ptr); - switch (r_u->level) - { - case 1: - { - FORM_1 *forms_1; - forms_1=r_u->forms_1; - - for (i=0; i<r_u->numofforms; i++) - { - bufsize_required += spoolss_size_form_1(&(forms_1[i])); - } - break; - } - } + if (!prs_align(ps)) + return False; + 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; - DEBUG(4,("spoolss_io_r_enumforms, size needed: %d\n",bufsize_required)); - DEBUG(4,("spoolss_io_r_enumforms, 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_enumforms, buffer too small\n")); + if (!new_spoolss_io_buffer("", ps, depth, q_u->buffer)) + return False; - prs_uint32("size of buffer", ps, depth, &(r_u->offered)); - } - else - { - DEBUG(4,("spoolss_io_r_enumforms, buffer large enough\n")); - - prs_uint32("size of buffer", ps, depth, &(r_u->offered)); - - if (r_u->offered!=0) - { - beginning=ps->offset; - start_offset=ps->offset; - end_offset=start_offset+r_u->offered; - - switch (r_u->level) - { - case 1: - { - FORM_1 *info; - for (i=0; i<r_u->numofforms; i++) - { - info = &(r_u->forms_1[i]); - smb_io_form_1(desc, info, ps, depth, &start_offset, &end_offset); - } - break; - } - } - ps->offset=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("numofforms", ps, depth, &(r_u->numofforms)); - prs_uint32("status", ps, depth, &(r_u->status)); + if (!prs_align(ps)) + return False; + if (!prs_uint32("offered", ps, depth, &(q_u->offered))) + return False; return True; } /******************************************************************* ********************************************************************/ -void spoolss_free_r_enumforms(SPOOL_R_ENUMFORMS *r_u) -{ - switch (r_u->level) - { - case 1: - { - free(r_u->forms_1); - break; - } - } -} - -/******************************************************************* -********************************************************************/ -BOOL spoolss_io_q_enumforms(char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth) +BOOL new_spoolss_io_r_enumforms(char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth) { - - prs_debug(ps, depth, desc, ""); + prs_debug(ps, depth, desc, "new_spoolss_io_r_enumforms"); depth++; - prs_align(ps); - smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth); - prs_uint32("level", ps, depth, &(q_u->level)); - spoolss_io_read_buffer("", ps, depth, &(q_u->buffer)); - prs_align(ps); - prs_uint32("buf_size", ps, depth, &(q_u->buf_size)); + if (!prs_align(ps)) + return False; + + if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer)) + return False; + + if (!prs_align(ps)) + return False; + + if (!prs_uint32("size of buffer needed", ps, depth, &(r_u->needed))) + return False; + + if (!prs_uint32("numofforms", ps, depth, &(r_u->numofforms))) + return False; + + if (!prs_uint32("status", ps, depth, &(r_u->status))) + return False; return True; + } /******************************************************************* + 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=ps->offset; - start_offset=ps->offset; - 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; - } - } - ps->offset=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; } @@ -3343,17 +3057,24 @@ BOOL spool_io_printer_info_level_2(char *desc, SPOOL_PRINTER_INFO_LEVEL_2 **q_u, ********************************************************************/ 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) @@ -3365,71 +3086,13 @@ BOOL spool_io_printer_info_level(char *desc, SPOOL_PRINTER_INFO_LEVEL *il, prs_s * 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 spool_io_user_level_1(char *desc, SPOOL_USER_LEVEL_1 **q_u, prs_struct *ps, int depth) -{ - SPOOL_USER_LEVEL_1 *il; - prs_debug(ps, depth, desc, ""); - depth++; - - /* reading */ - if (ps->io) - { - il=(SPOOL_USER_LEVEL_1 *)malloc(sizeof(SPOOL_USER_LEVEL_1)); - ZERO_STRUCTP(il); - *q_u=il; - } - else - { - il=*q_u; - } - - prs_align(ps); - prs_uint32("size", ps, depth, &(il->size)); - prs_uint32("client_name_ptr", ps, depth, &(il->client_name_ptr)); - prs_uint32("user_name_ptr", ps, depth, &(il->user_name_ptr)); - prs_uint32("build", ps, depth, &(il->build)); - prs_uint32("major", ps, depth, &(il->major)); - prs_uint32("minor", ps, depth, &(il->minor)); - prs_uint32("processor", ps, depth, &(il->processor)); - - smb_io_unistr2("", &(il->client_name), il->client_name_ptr, ps, depth); - prs_align(ps); - smb_io_unistr2("", &(il->user_name), il->user_name_ptr, ps, depth); - - return True; -} - -/******************************************************************* -********************************************************************/ -BOOL spool_io_user_level(char *desc, SPOOL_USER_LEVEL *q_u, prs_struct *ps, int depth) -{ - uint32 useless; - uint32 level; - prs_debug(ps, depth, desc, "spool_io_user_level"); - depth++; - - prs_align(ps); - prs_uint32("info_level", ps, depth, &level); - prs_uint32("useless", ps, depth, &useless); - - switch (level) - { - case 1: - spool_io_user_level_1("", &(q_u->user_level_1), ps, depth); - break; - - } - return True; } @@ -3437,7 +3100,6 @@ BOOL spool_io_user_level(char *desc, SPOOL_USER_LEVEL *q_u, prs_struct *ps, int ********************************************************************/ 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++; @@ -3447,32 +3109,44 @@ BOOL spoolss_io_q_addprinterex(char *desc, SPOOL_Q_ADDPRINTEREX *q_u, prs_struct * 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; } @@ -3499,52 +3173,71 @@ BOOL spool_io_printer_driver_info_level_3(char *desc, SPOOL_PRINTER_DRIVER_INFO_ { 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; } @@ -3630,23 +3323,25 @@ BOOL smb_io_unibuffer(char *desc, UNISTR2 *buffer, prs_struct *ps, int depth) ********************************************************************/ 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; } @@ -3654,17 +3349,24 @@ BOOL spool_io_printer_driver_info_level(char *desc, SPOOL_PRINTER_DRIVER_INFO_LE ********************************************************************/ 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; } @@ -3673,10 +3375,11 @@ BOOL spoolss_io_q_addprinterdriver(char *desc, SPOOL_Q_ADDPRINTERDRIVER *q_u, pr ********************************************************************/ 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; } @@ -3767,331 +3470,299 @@ BOOL uni_2_asc_printer_info_2(const SPOOL_PRINTER_INFO_LEVEL_2 *uni, } /******************************************************************* + Parse a SPOOL_Q_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"); +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++; - prs_align(ps); - - prs_uint32("pointer", ps, depth, &useless_ptr); - - switch (r_u->level) - { - case 1: - { - DRIVER_DIRECTORY_1 *driver_info_1; - driver_info_1=&(r_u->ctr.driver.info_1); - - bufsize_required = size_of_relative_string(&(driver_info_1->name)); - break; - } - } - - DEBUG(4,("spoolss_io_r_getprinterdriverdir, size needed: %d\n",bufsize_required)); - DEBUG(4,("spoolss_io_r_getprinterdriverdir, size offered: %d\n",r_u->offered)); - - /* check if the buffer is big enough for the datas */ - - if (r_u->offered<bufsize_required) - { + 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; - /* 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(!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; - 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=ps->offset; - start_offset=ps->offset; - end_offset=start_offset+r_u->offered; + if(!prs_uint32("level", ps, depth, &q_u->level)) + 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; - } - } - ps->offset=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)); + 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_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_getprinterdriverdir(char *desc, SPOOL_R_GETPRINTERDRIVERDIR *r_u, prs_struct *ps, int depth) +{ + prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriverdir"); 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("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"); 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")); + 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=ps->offset; - start_offset=ps->offset; - end_offset=start_offset+r_u->offered; + if (!prs_align(ps)) + 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; - } - } - ps->offset=beginning+r_u->offered; - prs_align(ps); - } - - /* - * if the buffer was too small, send the minimum required size - * if it was too large, send the real needed size - */ - - prs_uint32("size of buffer needed", ps, depth, &(bufsize_required)); - prs_uint32("numofprintprocessors", ps, depth, &(r_u->numofprintprocessors)); - prs_uint32("status", ps, depth, &(r_u->status)); + 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; } /******************************************************************* ********************************************************************/ BOOL spoolss_io_q_enumprintprocessors(char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth) { - uint32 useless; prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors"); depth++; - prs_align(ps); - prs_uint32("useless", ps, depth, &useless); - smb_io_unistr2("", &(q_u->name),True,ps,depth); - prs_align(ps); - prs_uint32("useless", ps, depth, &useless); - smb_io_unistr2("", &(q_u->environment),True,ps,depth); - prs_align(ps); - prs_uint32("level", ps, depth, &(q_u->level)); - spoolss_io_read_buffer("", ps, depth, &(q_u->buffer)); - prs_align(ps); - prs_uint32("buf_size", ps, depth, &(q_u->buf_size)); + 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 (!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) +BOOL spoolss_io_r_enumprintprocdatatypes(char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *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"); + prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes"); 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) - { + if (!prs_align(ps)) + return False; + + if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer)) + return False; - /* 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; + + if (!prs_uint32("needed", ps, depth, &r_u->needed)) + return False; + + if (!prs_uint32("returned", ps, depth, &r_u->returned)) + return False; - DEBUG(4,("buffer too small\n")); + if (!prs_uint32("status", ps, depth, &r_u->status)) + 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=ps->offset; - start_offset=ps->offset; - end_offset=start_offset+r_u->offered; + return True; +} + +/******************************************************************* +********************************************************************/ +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++; + + 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; - } - } - ps->offset=beginning+r_u->offered; - prs_align(ps); - } + 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("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("numofprintmonitors", ps, depth, &(r_u->numofprintmonitors)); - 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_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_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) +{ + prs_debug(ps, depth, desc, "spoolss_io_r_enumprintmonitors"); + depth++; + + if (!prs_align(ps)) + return False; + + if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer)) + return False; + + if (!prs_align(ps)) + return False; + + if (!prs_uint32("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_enumprinterdata(char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth) { prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata"); depth++; - prs_align(ps); - prs_uint32("valuesize", ps, depth, &(r_u->valuesize)); - prs_unistr("value", ps, depth, &(r_u->value)); - prs_uint32("realvaluesize", ps, depth, &(r_u->realvaluesize)); + 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; } @@ -4103,11 +3774,28 @@ BOOL spoolss_io_q_enumprinterdata(char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_ prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata"); depth++; - prs_align(ps); - smb_io_pol_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 index, uint32 valuelen, uint32 datalen) +{ + memcpy(&(q_u->handle), hnd, sizeof(q_u->handle)); + q_u->index=index; + q_u->valuesize=valuelen; + q_u->datasize=datalen; return True; } @@ -4193,23 +3881,23 @@ BOOL convert_specific_param(NT_PRINTER_PARAM **param, const UNISTR2 *value, ********************************************************************/ 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; } @@ -4218,20 +3906,20 @@ static BOOL spoolss_io_addform(char *desc, FORM *f, uint32 ptr, prs_struct *ps, ********************************************************************/ 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_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)); + 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; } @@ -4240,11 +3928,11 @@ BOOL spoolss_io_q_addform(char *desc, SPOOL_Q_ADDFORM *q_u, prs_struct *ps, int ********************************************************************/ 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; } @@ -4289,134 +3977,57 @@ BOOL spoolss_io_r_setform(char *desc, SPOOL_R_SETFORM *r_u, prs_struct *ps, int } /******************************************************************* + 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=ps->offset; - start_offset=ps->offset; - 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; - } - ps->offset=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_pol_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; } |