* Copyright (C) Andrew Tridgell 1992-2000,
* Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
* Copyright (C) Jean François Micouleau 1998-2000.
+ * Copyright (C) Gerald Carter 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
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-
#include "includes.h"
-#include "nterr.h"
-
-#ifdef TNG
- #define prs_uint16 _prs_uint16
- #define prs_uint32 _prs_uint32
- #define prs_uint8s _prs_uint8s
- #define prs_uint16s _prs_uint16s
- #define prs_unistr _prs_unistr
- #define init_unistr2 make_unistr2
-#endif
-
extern int DEBUGLEVEL;
+
/*******************************************************************
return the length of a UNISTR string.
********************************************************************/
+
static uint32 str_len_uni(UNISTR *source)
{
uint32 i=0;
-
- while (source->buffer[i]!=0x0000)
- {
- i++;
- }
+
+ if (!source->buffer)
+ return 0;
+
+ while (source->buffer[i])
+ i++;
+
return i;
}
/*******************************************************************
This should be moved in a more generic lib.
********************************************************************/
+
static BOOL spoolss_io_system_time(char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
{
if(!prs_uint16("year", ps, depth, &(systime->year)))
/*******************************************************************
********************************************************************/
+
BOOL make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
{
systime->year=unixtime->tm_year+1900;
/*******************************************************************
reads or writes an DOC_INFO structure.
********************************************************************/
+
static BOOL smb_io_doc_info_1(char *desc, DOC_INFO_1 *info_1, prs_struct *ps, int depth)
{
if (info_1 == NULL) return False;
if(!prs_align(ps))
return False;
- if(!prs_uint32("p_docname", ps, depth, &(info_1->p_docname)))
+ if(!prs_uint32("p_docname", ps, depth, &info_1->p_docname))
return False;
- if(!prs_uint32("p_outputfile", ps, depth, &(info_1->p_outputfile)))
+ if(!prs_uint32("p_outputfile", ps, depth, &info_1->p_outputfile))
return False;
- if(!prs_uint32("p_datatype", ps, depth, &(info_1->p_datatype)))
+ if(!prs_uint32("p_datatype", ps, depth, &info_1->p_datatype))
return False;
- if(!smb_io_unistr2("", &(info_1->docname), info_1->p_docname, ps, depth))
+ if(!smb_io_unistr2("", &info_1->docname, info_1->p_docname, ps, depth))
return False;
- if(!smb_io_unistr2("", &(info_1->outputfile), info_1->p_outputfile, ps, depth))
+ if(!smb_io_unistr2("", &info_1->outputfile, info_1->p_outputfile, ps, depth))
return False;
- if(!smb_io_unistr2("", &(info_1->datatype), info_1->p_datatype, ps, depth))
+ if(!smb_io_unistr2("", &info_1->datatype, info_1->p_datatype, ps, depth))
return False;
return True;
/*******************************************************************
reads or writes an DOC_INFO structure.
********************************************************************/
+
static BOOL smb_io_doc_info(char *desc, DOC_INFO *info, prs_struct *ps, int depth)
{
uint32 useless_ptr=0;
if(!prs_align(ps))
return False;
- if(!prs_uint32("switch_value", ps, depth, &(info->switch_value)))
+ if(!prs_uint32("switch_value", ps, depth, &info->switch_value))
return False;
- if(!prs_uint32("doc_info_X ptr", ps, depth, &(useless_ptr)))
+ if(!prs_uint32("doc_info_X ptr", ps, depth, &useless_ptr))
return False;
switch (info->switch_value)
{
case 1:
- if(!smb_io_doc_info_1("",&(info->doc_info_1), ps, depth))
+ if(!smb_io_doc_info_1("",&info->doc_info_1, ps, depth))
return False;
break;
case 2:
Maybe one day with Windows for dishwasher 2037 ...
*/
- /* smb_io_doc_info_2("",&(info->doc_info_2), ps, depth); */
+ /* smb_io_doc_info_2("",&info->doc_info_2, ps, depth); */
break;
default:
DEBUG(0,("Something is obviously wrong somewhere !\n"));
/*******************************************************************
reads or writes an DOC_INFO_CONTAINER structure.
********************************************************************/
+
static BOOL smb_io_doc_info_container(char *desc, DOC_INFO_CONTAINER *cont, prs_struct *ps, int depth)
{
if (cont == NULL) return False;
if(!prs_align(ps))
return False;
- if(!prs_uint32("level", ps, depth, &(cont->level)))
+ if(!prs_uint32("level", ps, depth, &cont->level))
return False;
- if(!smb_io_doc_info("",&(cont->docinfo), ps, depth))
+ if(!smb_io_doc_info("",&cont->docinfo, ps, depth))
return False;
return True;
/*******************************************************************
reads or writes an NOTIFY OPTION TYPE structure.
********************************************************************/
+
static BOOL smb_io_notify_option_type(char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "smb_io_notify_option_type");
/*******************************************************************
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)
{
int i;
/* parse the option type data */
for(i=0;i<type->count2;i++)
- if(!prs_uint16("fields",ps,depth,&(type->fields[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_type_ctr(char *desc, SPOOL_NOTIFY_OPTION_TYPE_CTR *ctr , prs_struct *ps, int depth)
{
int i;
/* reading */
if (UNMARSHALLING(ps))
- ctr->type=(SPOOL_NOTIFY_OPTION_TYPE *)malloc(ctr->count*sizeof(SPOOL_NOTIFY_OPTION_TYPE));
+ if((ctr->type=(SPOOL_NOTIFY_OPTION_TYPE *)prs_alloc_mem(ps,ctr->count*sizeof(SPOOL_NOTIFY_OPTION_TYPE))) == NULL)
+ return False;
/* the option type struct */
for(i=0;i<ctr->count;i++)
- if(!smb_io_notify_option_type("", &(ctr->type[i]) , ps, depth))
+ 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))
+ if(!smb_io_notify_option_type_data("", &ctr->type[i] , ps, depth))
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)
{
prs_debug(ps, depth, desc, "smb_io_notify_option");
/*******************************************************************
reads or writes an NOTIFY INFO DATA structure.
********************************************************************/
+
static BOOL smb_io_notify_info_data(char *desc,SPOOL_NOTIFY_INFO_DATA *data, prs_struct *ps, int depth)
{
uint32 useless_ptr=0xADDE0FF0;
prs_debug(ps, depth, desc, "smb_io_notify_info_data");
depth++;
- how_many_words=data->size;
- if (how_many_words==POINTER)
- {
+ how_many_words=data->size;
+ if (how_many_words==POINTER) {
how_many_words=TWO_VALUE;
}
if(!prs_align(ps))
return False;
- if(!prs_uint16("type", ps, depth, &(data->type)))
+ if(!prs_uint16("type", ps, depth, &data->type))
return False;
- if(!prs_uint16("field", ps, depth, &(data->field)))
+ if(!prs_uint16("field", ps, depth, &data->field))
return False;
/*prs_align(ps);*/
if(!prs_uint32("how many words", ps, depth, &how_many_words))
return False;
- if(!prs_uint32("id", ps, depth, &(data->id)))
+ if(!prs_uint32("id", ps, depth, &data->id))
return False;
if(!prs_uint32("how many words", ps, depth, &how_many_words))
return False;
+
+
/*prs_align(ps);*/
- if (isvalue==True)
- {
- if(!prs_uint32("value[0]", ps, depth, &(data->notify_data.value[0])))
+ if (isvalue==True) {
+ if(!prs_uint32("value[0]", ps, depth, &data->notify_data.value[0]))
return False;
- if(!prs_uint32("value[1]", ps, depth, &(data->notify_data.value[1])))
+ if(!prs_uint32("value[1]", ps, depth, &data->notify_data.value[1]))
return False;
/*prs_align(ps);*/
- }
- else
- {
+ } else {
/* it's a string */
/* length in ascii including \0 */
x=2*(data->notify_data.data.length+1);
/*******************************************************************
reads or writes an NOTIFY INFO DATA structure.
********************************************************************/
+
BOOL smb_io_notify_info_data_strings(char *desc,SPOOL_NOTIFY_INFO_DATA *data,
prs_struct *ps, int depth)
{
uint32 x;
BOOL isvalue;
- prs_debug(ps, depth, desc, "smb_io_notify_info_data");
+ prs_debug(ps, depth, desc, "smb_io_notify_info_data_strings");
depth++;
if(!prs_align(ps))
isvalue=data->enc_type;
- if (isvalue==False)
- {
+ if (isvalue==False) {
/* length of string in unicode include \0 */
x=data->notify_data.data.length+1;
if(!prs_uint32("string length", ps, depth, &x ))
return False;
- if(!prs_uint16s(True,"string",ps,depth,data->notify_data.data.string,x))
- return False;
+ if (MARSHALLING(ps)) {
+ /* These are already in little endian format. Don't byte swap. */
+ if (x == 1) {
+
+ /* No memory allocated for this string
+ therefore following the data.string
+ pointer is a bad idea. Use a pointer to
+ the uint32 length union member to
+ provide a source for a unicode NULL */
+
+ if(!prs_uint8s(True,"string",ps,depth, (uint8 *)&data->notify_data.data.length,x*2))
+ return False;
+ } else {
+ if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
+ return False;
+ }
+ } else {
+
+ /* Tallocate memory for string */
+
+ data->notify_data.data.string = (uint16 *)prs_alloc_mem(ps, x * 2);
+ if (!data->notify_data.data.string)
+ return False;
+
+ if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
+ return False;
+ }
}
if(!prs_align(ps))
return False;
/*******************************************************************
reads or writes an NOTIFY INFO structure.
********************************************************************/
+
static BOOL smb_io_notify_info(char *desc, SPOOL_NOTIFY_INFO *info, prs_struct *ps, int depth)
{
int i;
if(!prs_align(ps))
return False;
- if(!prs_uint32("count", ps, depth, &(info->count)))
+ if(!prs_uint32("count", ps, depth, &info->count))
return False;
- if(!prs_uint32("version", ps, depth, &(info->version)))
+ if(!prs_uint32("version", ps, depth, &info->version))
return False;
- if(!prs_uint32("flags", ps, depth, &(info->flags)))
+ if(!prs_uint32("flags", ps, depth, &info->flags))
return False;
- if(!prs_uint32("count", ps, depth, &(info->count)))
+ if(!prs_uint32("count", ps, depth, &info->count))
return False;
- for (i=0;i<info->count;i++)
- {
- if(!smb_io_notify_info_data(desc, &(info->data[i]), ps, depth))
+ for (i=0;i<info->count;i++) {
+ if(!smb_io_notify_info_data(desc, &info->data[i], ps, depth))
return False;
}
/* now do the strings at the end of the stream */
- for (i=0;i<info->count;i++)
- {
- if(!smb_io_notify_info_data_strings(desc, &(info->data[i]), ps, depth))
+ for (i=0;i<info->count;i++) {
+ if(!smb_io_notify_info_data_strings(desc, &info->data[i], ps, depth))
return False;
}
return True;
}
-
/*******************************************************************
********************************************************************/
+
static BOOL spool_io_user_level_1(char *desc, SPOOL_USER_1 *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "");
depth++;
/* reading */
- if (ps->io)
+ if (UNMARSHALLING(ps))
ZERO_STRUCTP(q_u);
if (!prs_align(ps))
return False;
- if (!prs_uint32("size", ps, depth, &(q_u->size)))
+ if (!prs_uint32("size", ps, depth, &q_u->size))
return False;
- if (!prs_uint32("client_name_ptr", ps, depth, &(q_u->client_name_ptr)))
+ 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)))
+ if (!prs_uint32("user_name_ptr", ps, depth, &q_u->user_name_ptr))
return False;
- if (!prs_uint32("build", ps, depth, &(q_u->build)))
+ if (!prs_uint32("build", ps, depth, &q_u->build))
return False;
- if (!prs_uint32("major", ps, depth, &(q_u->major)))
+ if (!prs_uint32("major", ps, depth, &q_u->major))
return False;
- if (!prs_uint32("minor", ps, depth, &(q_u->minor)))
+ if (!prs_uint32("minor", ps, depth, &q_u->minor))
return False;
- if (!prs_uint32("processor", ps, depth, &(q_u->processor)))
+ 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))
+ 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))
+ if (!smb_io_unistr2("", &q_u->user_name, q_u->user_name_ptr, ps, depth))
return False;
return True;
/*******************************************************************
********************************************************************/
+
static BOOL spool_io_user_level(char *desc, SPOOL_USER_CTR *q_u, prs_struct *ps, int depth)
{
if (q_u==NULL)
switch (q_u->level) {
case 1:
- if (!spool_io_user_level_1("", &(q_u->user1), ps, depth))
+ if (!spool_io_user_level_1("", &q_u->user1, ps, depth))
return False;
break;
default:
* read or write a DEVICEMODE struct.
* on reading allocate memory for the private member
********************************************************************/
-static BOOL spoolss_io_devmode(char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
+
+BOOL spoolss_io_devmode(char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
{
prs_debug(ps, depth, desc, "spoolss_io_devmode");
depth++;
- if (!prs_uint16s(True,"devicename", ps, depth, devmode->devicename.buffer, 32))
+ if (UNMARSHALLING(ps)) {
+ devmode->devicename.buffer = (uint16 *)prs_alloc_mem(ps, 32 * sizeof(uint16) );
+ if (devmode->devicename.buffer == NULL)
+ return False;
+ }
+
+ if (!prs_uint16uni(True,"devicename", ps, depth, devmode->devicename.buffer, 32))
return False;
- if (!prs_uint16("specversion", ps, depth, &(devmode->specversion)))
+ if (!prs_uint16("specversion", ps, depth, &devmode->specversion))
return False;
- if (!prs_uint16("driverversion", ps, depth, &(devmode->driverversion)))
+ if (!prs_uint16("driverversion", ps, depth, &devmode->driverversion))
return False;
- if (!prs_uint16("size", ps, depth, &(devmode->size)))
+ if (!prs_uint16("size", ps, depth, &devmode->size))
return False;
- if (!prs_uint16("driverextra", ps, depth, &(devmode->driverextra)))
+ if (!prs_uint16("driverextra", ps, depth, &devmode->driverextra))
return False;
- if (!prs_uint32("fields", ps, depth, &(devmode->fields)))
+ if (!prs_uint32("fields", ps, depth, &devmode->fields))
return False;
- if (!prs_uint16("orientation", ps, depth, &(devmode->orientation)))
+ if (!prs_uint16("orientation", ps, depth, &devmode->orientation))
return False;
- if (!prs_uint16("papersize", ps, depth, &(devmode->papersize)))
+ if (!prs_uint16("papersize", ps, depth, &devmode->papersize))
return False;
- if (!prs_uint16("paperlength", ps, depth, &(devmode->paperlength)))
+ if (!prs_uint16("paperlength", ps, depth, &devmode->paperlength))
return False;
- if (!prs_uint16("paperwidth", ps, depth, &(devmode->paperwidth)))
+ if (!prs_uint16("paperwidth", ps, depth, &devmode->paperwidth))
return False;
- if (!prs_uint16("scale", ps, depth, &(devmode->scale)))
+ if (!prs_uint16("scale", ps, depth, &devmode->scale))
return False;
- if (!prs_uint16("copies", ps, depth, &(devmode->copies)))
+ if (!prs_uint16("copies", ps, depth, &devmode->copies))
return False;
- if (!prs_uint16("defaultsource", ps, depth, &(devmode->defaultsource)))
+ if (!prs_uint16("defaultsource", ps, depth, &devmode->defaultsource))
return False;
- if (!prs_uint16("printquality", ps, depth, &(devmode->printquality)))
+ if (!prs_uint16("printquality", ps, depth, &devmode->printquality))
return False;
- if (!prs_uint16("color", ps, depth, &(devmode->color)))
+ if (!prs_uint16("color", ps, depth, &devmode->color))
return False;
- if (!prs_uint16("duplex", ps, depth, &(devmode->duplex)))
+ if (!prs_uint16("duplex", ps, depth, &devmode->duplex))
return False;
- if (!prs_uint16("yresolution", ps, depth, &(devmode->yresolution)))
+ if (!prs_uint16("yresolution", ps, depth, &devmode->yresolution))
return False;
- if (!prs_uint16("ttoption", ps, depth, &(devmode->ttoption)))
+ if (!prs_uint16("ttoption", ps, depth, &devmode->ttoption))
return False;
- if (!prs_uint16("collate", ps, depth, &(devmode->collate)))
+ if (!prs_uint16("collate", ps, depth, &devmode->collate))
return False;
- if (!prs_uint16s(True, "formname", ps, depth, devmode->formname.buffer, 32))
+
+ if (UNMARSHALLING(ps)) {
+ devmode->formname.buffer = (uint16 *)prs_alloc_mem(ps, 32 * sizeof(uint16) );
+ if (devmode->formname.buffer == NULL)
+ return False;
+ }
+
+ if (!prs_uint16uni(True, "formname", ps, depth, devmode->formname.buffer, 32))
return False;
- if (!prs_uint16("logpixels", ps, depth, &(devmode->logpixels)))
+ if (!prs_uint16("logpixels", ps, depth, &devmode->logpixels))
return False;
- if (!prs_uint32("bitsperpel", ps, depth, &(devmode->bitsperpel)))
+ if (!prs_uint32("bitsperpel", ps, depth, &devmode->bitsperpel))
return False;
- if (!prs_uint32("pelswidth", ps, depth, &(devmode->pelswidth)))
+ if (!prs_uint32("pelswidth", ps, depth, &devmode->pelswidth))
return False;
- if (!prs_uint32("pelsheight", ps, depth, &(devmode->pelsheight)))
+ if (!prs_uint32("pelsheight", ps, depth, &devmode->pelsheight))
return False;
- if (!prs_uint32("displayflags", ps, depth, &(devmode->displayflags)))
+ if (!prs_uint32("displayflags", ps, depth, &devmode->displayflags))
return False;
- if (!prs_uint32("displayfrequency", ps, depth, &(devmode->displayfrequency)))
+ if (!prs_uint32("displayfrequency", ps, depth, &devmode->displayfrequency))
return False;
- if (!prs_uint32("icmmethod", ps, depth, &(devmode->icmmethod)))
+ if (!prs_uint32("icmmethod", ps, depth, &devmode->icmmethod))
return False;
- if (!prs_uint32("icmintent", ps, depth, &(devmode->icmintent)))
+ if (!prs_uint32("icmintent", ps, depth, &devmode->icmintent))
return False;
- if (!prs_uint32("mediatype", ps, depth, &(devmode->mediatype)))
+ if (!prs_uint32("mediatype", ps, depth, &devmode->mediatype))
return False;
- if (!prs_uint32("dithertype", ps, depth, &(devmode->dithertype)))
+ if (!prs_uint32("dithertype", ps, depth, &devmode->dithertype))
return False;
- if (!prs_uint32("reserved1", ps, depth, &(devmode->reserved1)))
+ if (!prs_uint32("reserved1", ps, depth, &devmode->reserved1))
return False;
- if (!prs_uint32("reserved2", ps, depth, &(devmode->reserved2)))
+ if (!prs_uint32("reserved2", ps, depth, &devmode->reserved2))
return False;
- if (!prs_uint32("panningwidth", ps, depth, &(devmode->panningwidth)))
+ if (!prs_uint32("panningwidth", ps, depth, &devmode->panningwidth))
return False;
- if (!prs_uint32("panningheight", ps, depth, &(devmode->panningheight)))
+ if (!prs_uint32("panningheight", ps, depth, &devmode->panningheight))
return False;
- if (devmode->driverextra!=0)
- {
+ if (devmode->driverextra!=0) {
if (UNMARSHALLING(ps)) {
- devmode->private=(uint8 *)malloc(devmode->driverextra*sizeof(uint8));
+ devmode->private=(uint8 *)prs_alloc_mem(ps, devmode->driverextra*sizeof(uint8));
if(devmode->private == NULL)
return False;
DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for private\n",devmode->driverextra));
/*******************************************************************
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)
/* 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));
+ dm_c->devmode=(DEVICEMODE *)prs_alloc_mem(ps,sizeof(DEVICEMODE));
if(dm_c->devmode == NULL)
return False;
- ZERO_STRUCTP(dm_c->devmode);
}
/* this is bad code, shouldn't be there */
/*******************************************************************
********************************************************************/
+
static BOOL spoolss_io_printer_default(char *desc, PRINTER_DEFAULT *pd, prs_struct *ps, int depth)
{
if (pd==NULL)
if (!prs_uint32("datatype_ptr", ps, depth, &pd->datatype_ptr))
return False;
- if (!smb_io_unistr2("datatype", &(pd->datatype), pd->datatype_ptr, ps,depth))
+ if (!smb_io_unistr2("datatype", &pd->datatype, pd->datatype_ptr, ps,depth))
return False;
if (!prs_align(ps))
return False;
- if (!spoolss_io_devmode_cont("", &(pd->devmode_cont), ps, depth))
+ if (!spoolss_io_devmode_cont("", &pd->devmode_cont, ps, depth))
return False;
if (!prs_uint32("access_required", ps, depth, &pd->access_required))
/*******************************************************************
* 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 clientname, fstring user_name)
+
+BOOL make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX *q_u,
+ const fstring printername,
+ const fstring datatype,
+ uint32 access_required,
+ const fstring clientname,
+ const 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));
+ init_unistr2(&q_u->printername, printername, strlen(printername)+1);
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));
+ 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->user_switch=1;
q_u->user_ctr.level=1;
q_u->user_ctr.ptr=1;
- q_u->user_ctr.user1.size=strlen(clientname)+strlen(user_name)+8;
+ q_u->user_ctr.user1.size=strlen(clientname)+strlen(user_name)+10;
+ q_u->user_ctr.user1.client_name_ptr = (clientname!=NULL)?1:0;
+ q_u->user_ctr.user1.user_name_ptr = (user_name!=NULL)?1:0;
+ q_u->user_ctr.user1.build=1381;
+ q_u->user_ctr.user1.major=2;
+ q_u->user_ctr.user1.minor=0;
+ q_u->user_ctr.user1.processor=0;
+ init_unistr2(&q_u->user_ctr.user1.client_name, clientname, strlen(clientname)+1);
+ init_unistr2(&q_u->user_ctr.user1.user_name, user_name, strlen(user_name)+1);
+
+ return True;
+}
+
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
+BOOL make_spoolss_q_addprinterex(
+ TALLOC_CTX *mem_ctx,
+ SPOOL_Q_ADDPRINTEREX *q_u,
+ const char *srv_name,
+ const char* clientname,
+ const char* user_name,
+ uint32 level,
+ PRINTER_INFO_CTR *ctr)
+{
+ DEBUG(5,("make_spoolss_q_addprinterex\n"));
+
+ if (!ctr) return False;
+
+ q_u->server_name_ptr = (srv_name!=NULL)?1:0;
+ init_unistr2(&q_u->server_name, srv_name, strlen(srv_name));
+
+ q_u->level = level;
+
+ q_u->info.level = level;
+ q_u->info.info_ptr = (ctr->printers_2!=NULL)?1:0;
+ switch (level)
+ {
+ case 2:
+ /* init q_u->info.info2 from *info */
+ if (!make_spoolss_printer_info_2(mem_ctx, &q_u->info.info_2, ctr->printers_2))
+ {
+ DEBUG(0,("make_spoolss_q_addprinterex: Unable to fill SPOOL_Q_ADDPRINTEREX struct!\n"));
+ return False;
+ }
+ break;
+ default :
+ break;
+ }
+
+ q_u->unk0 = q_u->unk1 = q_u->unk2 = q_u->unk3 = 0;
+
+ q_u->user_switch=1;
+
+ q_u->user_ctr.level=1;
+ q_u->user_ctr.ptr=1;
q_u->user_ctr.user1.client_name_ptr = (clientname!=NULL)?1:0;
q_u->user_ctr.user1.user_name_ptr = (user_name!=NULL)?1:0;
q_u->user_ctr.user1.build=1381;
q_u->user_ctr.user1.major=2;
q_u->user_ctr.user1.minor=0;
q_u->user_ctr.user1.processor=0;
- init_unistr2(&(q_u->user_ctr.user1.client_name), clientname, strlen(clientname));
- init_unistr2(&(q_u->user_ctr.user1.user_name), user_name, strlen(user_name));
+ init_unistr2(&q_u->user_ctr.user1.client_name, clientname, strlen(clientname)+1);
+ init_unistr2(&q_u->user_ctr.user1.user_name, user_name, strlen(user_name)+1);
+ q_u->user_ctr.user1.size=q_u->user_ctr.user1.user_name.uni_str_len +
+ q_u->user_ctr.user1.client_name.uni_str_len + 2;
return True;
}
+
+/*******************************************************************
+create a SPOOL_PRINTER_INFO_2 stuct from a PRINTER_INFO_2 struct
+*******************************************************************/
+
+BOOL make_spoolss_printer_info_2(
+ TALLOC_CTX *mem_ctx,
+ SPOOL_PRINTER_INFO_LEVEL_2 **spool_info2,
+ PRINTER_INFO_2 *info
+)
+{
+
+ SPOOL_PRINTER_INFO_LEVEL_2 *inf;
+
+ /* allocate the necessary memory */
+ if (!(inf=(SPOOL_PRINTER_INFO_LEVEL_2*)talloc(mem_ctx, sizeof(SPOOL_PRINTER_INFO_LEVEL_2))))
+ {
+ DEBUG(0,("make_spoolss_printer_info_2: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_2 sruct!\n"));
+ return False;
+ }
+
+ inf->servername_ptr = (info->servername.buffer!=NULL)?1:0;
+ inf->printername_ptr = (info->printername.buffer!=NULL)?1:0;
+ inf->sharename_ptr = (info->sharename.buffer!=NULL)?1:0;
+ inf->portname_ptr = (info->portname.buffer!=NULL)?1:0;
+ inf->drivername_ptr = (info->drivername.buffer!=NULL)?1:0;
+ inf->comment_ptr = (info->comment.buffer!=NULL)?1:0;
+ inf->location_ptr = (info->location.buffer!=NULL)?1:0;
+ inf->devmode_ptr = (info->devmode!=NULL)?1:0;
+ inf->sepfile_ptr = (info->sepfile.buffer!=NULL)?1:0;
+ inf->printprocessor_ptr = (info->printprocessor.buffer!=NULL)?1:0;
+ inf->datatype_ptr = (info->datatype.buffer!=NULL)?1:0;
+ inf->parameters_ptr = (info->parameters.buffer!=NULL)?1:0;
+ inf->secdesc_ptr = (info->secdesc!=NULL)?1:0;
+ inf->attributes = info->attributes;
+ inf->priority = info->priority;
+ inf->default_priority = info->defaultpriority;
+ inf->starttime = info->starttime;
+ inf->untiltime = info->untiltime;
+ inf->cjobs = info->cjobs;
+ inf->averageppm = info->averageppm;
+ init_unistr2_from_unistr(&inf->servername, &info->servername);
+ init_unistr2_from_unistr(&inf->printername, &info->printername);
+ init_unistr2_from_unistr(&inf->sharename, &info->sharename);
+ init_unistr2_from_unistr(&inf->portname, &info->portname);
+ init_unistr2_from_unistr(&inf->drivername, &info->drivername);
+ init_unistr2_from_unistr(&inf->comment, &info->comment);
+ init_unistr2_from_unistr(&inf->location, &info->location);
+ init_unistr2_from_unistr(&inf->sepfile, &info->sepfile);
+ init_unistr2_from_unistr(&inf->printprocessor, &info->printprocessor);
+ init_unistr2_from_unistr(&inf->datatype, &info->datatype);
+ init_unistr2_from_unistr(&inf->parameters, &info->parameters);
+ init_unistr2_from_unistr(&inf->datatype, &info->datatype);
+ inf->secdesc = inf->secdesc;
+
+ *spool_info2 = inf;
+
+ return True;
+}
/*******************************************************************
* read a structure.
* called from spoolss_q_open_printer_ex (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_q_open_printer_ex(char *desc, SPOOL_Q_OPEN_PRINTER_EX *q_u, prs_struct *ps, int depth)
{
if (q_u == NULL)
return True;
}
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
+BOOL make_spoolss_q_deleteprinterdriver(
+ TALLOC_CTX *mem_ctx,
+ SPOOL_Q_DELETEPRINTERDRIVER *q_u,
+ const char *server,
+ const char* arch,
+ const char* driver
+)
+{
+ DEBUG(5,("make_spoolss_q_deleteprinterdriver\n"));
+
+ q_u->server_ptr = (server!=NULL)?1:0;
+
+ /* these must be NULL terminated or else NT4 will
+ complain about invalid parameters --jerry */
+ init_unistr2(&q_u->server, server, strlen(server)+1);
+ init_unistr2(&q_u->arch, arch, strlen(arch)+1);
+ init_unistr2(&q_u->driver, driver, strlen(driver)+1);
+
+
+ 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;
return True;
}
+
/*******************************************************************
* make a structure.
********************************************************************/
+
BOOL make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u,
- POLICY_HND *handle,
- char *valuename,
- uint32 size)
+ const POLICY_HND *handle,
+ UNISTR2 *valuename, uint32 size)
{
- int len_name = valuename != NULL ? strlen(valuename) : 0;
-
- if (q_u == NULL) return False;
+ if (q_u == NULL) return False;
- DEBUG(5,("make_spoolss_q_getprinterdata\n"));
+ DEBUG(5,("make_spoolss_q_getprinterdata\n"));
- memcpy(&(q_u->handle), handle, sizeof(q_u->handle));
- init_unistr2(&(q_u->valuename), valuename, len_name);
- q_u->size = size;
+ q_u->handle = *handle;
+ copy_unistr2(&q_u->valuename, valuename);
+ q_u->size = size;
- return True;
+ return True;
}
/*******************************************************************
* read a structure.
* called from spoolss_q_getprinterdata (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_q_getprinterdata(char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_struct *ps, int depth)
{
- if (q_u == NULL) return False;
+ if (q_u == NULL)
+ return False;
prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdata");
depth++;
if (!prs_align(ps))
return False;
- if (!smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth))
+ if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
+ return False;
+ if (!prs_align(ps))
+ return False;
+ 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;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_deleteprinterdata (srv_spoolss.c)
+ ********************************************************************/
+
+BOOL spoolss_io_q_deleteprinterdata(char *desc, SPOOL_Q_DELETEPRINTERDATA *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL)
return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdata");
+ depth++;
+
if (!prs_align(ps))
return False;
- if (!smb_io_unistr2("valuename", &(q_u->valuename),True,ps,depth))
+ if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
return False;
if (!prs_align(ps))
return False;
- if (!prs_uint32("size", ps, depth, &(q_u->size)))
+ if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_deleteprinterdata (srv_spoolss.c)
+ ********************************************************************/
+
+BOOL spoolss_io_r_deleteprinterdata(char *desc, SPOOL_R_DELETEPRINTERDATA *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdata");
+ depth++;
+ if(!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
* write a structure.
* called from spoolss_r_getprinterdata (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_r_getprinterdata(char *desc, SPOOL_R_GETPRINTERDATA *r_u, prs_struct *ps, int depth)
{
if (r_u == NULL)
if (!prs_align(ps))
return False;
- if (!prs_uint32("type", ps, depth, &(r_u->type)))
+ if (!prs_uint32("type", ps, depth, &r_u->type))
return False;
- if (!prs_uint32("size", ps, depth, &(r_u->size)))
+ if (!prs_uint32("size", ps, depth, &r_u->size))
return False;
if (!prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size))
if (!prs_align(ps))
return False;
- if (!prs_uint32("needed", ps, depth, &(r_u->needed)))
+ if (!prs_uint32("needed", ps, depth, &r_u->needed))
return False;
- if (!prs_uint32("status", ps, depth, &(r_u->status)))
+ if (!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
/*******************************************************************
* make a structure.
********************************************************************/
+
BOOL make_spoolss_q_closeprinter(SPOOL_Q_CLOSEPRINTER *q_u, POLICY_HND *hnd)
{
if (q_u == NULL) return False;
DEBUG(5,("make_spoolss_q_closeprinter\n"));
- memcpy(&(q_u->handle), hnd, sizeof(q_u->handle));
+ memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
return True;
}
/*******************************************************************
* read a structure.
- * called from static spoolss_q_closeprinter (srv_spoolss.c)
- * called from spoolss_closeprinter (cli_spoolss.c)
+ * called from static spoolss_q_abortprinter (srv_spoolss.c)
+ * called from spoolss_abortprinter (cli_spoolss.c)
********************************************************************/
-BOOL spoolss_io_q_closeprinter(char *desc, SPOOL_Q_CLOSEPRINTER *q_u, prs_struct *ps, int depth)
+
+BOOL spoolss_io_q_abortprinter(char *desc, SPOOL_Q_ABORTPRINTER *q_u, prs_struct *ps, int depth)
{
if (q_u == NULL) return False;
- prs_debug(ps, depth, desc, "spoolss_io_q_closeprinter");
+ prs_debug(ps, depth, desc, "spoolss_io_q_abortprinter");
depth++;
if (!prs_align(ps))
/*******************************************************************
* write a structure.
- * called from static spoolss_r_closeprinter (srv_spoolss.c)
- * called from spoolss_closeprinter (cli_spoolss.c)
+ * called from spoolss_r_abortprinter (srv_spoolss.c)
********************************************************************/
-BOOL spoolss_io_r_closeprinter(char *desc, SPOOL_R_CLOSEPRINTER *r_u, prs_struct *ps, int depth)
+
+BOOL spoolss_io_r_abortprinter(char *desc, SPOOL_R_ABORTPRINTER *r_u, prs_struct *ps, int depth)
{
- prs_debug(ps, depth, desc, "spoolss_io_r_closeprinter");
+ prs_debug(ps, depth, desc, "spoolss_io_r_abortprinter");
depth++;
-
- if (!prs_align(ps))
+ if(!prs_uint32("status", ps, depth, &r_u->status))
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;
}
/*******************************************************************
* read a structure.
- * called from spoolss_q_startdocprinter (srv_spoolss.c)
+ * called from static spoolss_q_deleteprinter (srv_spoolss.c)
+ * called from spoolss_deleteprinter (cli_spoolss.c)
********************************************************************/
-BOOL spoolss_io_q_startdocprinter(char *desc, SPOOL_Q_STARTDOCPRINTER *q_u, prs_struct *ps, int depth)
+
+BOOL spoolss_io_q_deleteprinter(char *desc, SPOOL_Q_DELETEPRINTER *q_u, prs_struct *ps, int depth)
{
if (q_u == NULL) return False;
- prs_debug(ps, depth, desc, "spoolss_io_q_startdocprinter");
+ prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinter");
depth++;
- if(!prs_align(ps))
+ if (!prs_align(ps))
return False;
- if(!smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth))
- return False;
-
- if(!smb_io_doc_info_container("",&(q_u->doc_info_container), ps, depth))
+ if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
return False;
return True;
/*******************************************************************
* write a structure.
- * called from spoolss_r_startdocprinter (srv_spoolss.c)
+ * called from static spoolss_r_deleteprinter (srv_spoolss.c)
+ * called from spoolss_deleteprinter (cli_spoolss.c)
********************************************************************/
-BOOL spoolss_io_r_startdocprinter(char *desc, SPOOL_R_STARTDOCPRINTER *r_u, prs_struct *ps, int depth)
+
+BOOL spoolss_io_r_deleteprinter(char *desc, SPOOL_R_DELETEPRINTER *r_u, prs_struct *ps, int depth)
{
- prs_debug(ps, depth, desc, "spoolss_io_r_startdocprinter");
+ prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinter");
depth++;
- if(!prs_uint32("jobid", ps, depth, &(r_u->jobid)))
- return False;
- if(!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;
}
+
/*******************************************************************
* read a structure.
- * called from spoolss_q_enddocprinter (srv_spoolss.c)
+ * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
+ * called from spoolss_deleteprinterdriver (cli_spoolss.c)
********************************************************************/
-BOOL spoolss_io_q_enddocprinter(char *desc, SPOOL_Q_ENDDOCPRINTER *q_u, prs_struct *ps, int depth)
+
+BOOL spoolss_io_q_deleteprinterdriver(char *desc, SPOOL_Q_DELETEPRINTERDRIVER *q_u, prs_struct *ps, int depth)
{
if (q_u == NULL) return False;
- prs_debug(ps, depth, desc, "spoolss_io_q_enddocprinter");
+ prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriver");
depth++;
- if(!prs_align(ps))
+ if (!prs_align(ps))
return False;
- if(!smb_io_pol_hnd("printer handle",&(q_u->handle),ps,depth))
+ if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
+ return False;
+ if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
+ return False;
+ if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
+ return False;
+ if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
return False;
+
return True;
}
+
/*******************************************************************
* write a structure.
- * called from spoolss_r_enddocprinter (srv_spoolss.c)
********************************************************************/
-BOOL spoolss_io_r_enddocprinter(char *desc, SPOOL_R_ENDDOCPRINTER *r_u, prs_struct *ps, int depth)
+BOOL spoolss_io_r_deleteprinterdriver(char *desc, SPOOL_R_DELETEPRINTERDRIVER *r_u, prs_struct *ps, int depth)
{
- prs_debug(ps, depth, desc, "spoolss_io_r_enddocprinter");
+ if (r_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriver");
depth++;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
}
+
+
/*******************************************************************
* read a structure.
- * called from spoolss_q_startpageprinter (srv_spoolss.c)
+ * called from static spoolss_q_closeprinter (srv_spoolss.c)
+ * called from spoolss_closeprinter (cli_spoolss.c)
********************************************************************/
-BOOL spoolss_io_q_startpageprinter(char *desc, SPOOL_Q_STARTPAGEPRINTER *q_u, prs_struct *ps, int depth)
+
+BOOL spoolss_io_q_closeprinter(char *desc, SPOOL_Q_CLOSEPRINTER *q_u, prs_struct *ps, int depth)
{
if (q_u == NULL) return False;
- prs_debug(ps, depth, desc, "spoolss_io_q_startpageprinter");
+ prs_debug(ps, depth, desc, "spoolss_io_q_closeprinter");
depth++;
- if(!prs_align(ps))
+ if (!prs_align(ps))
return False;
- if(!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;
/*******************************************************************
* write a structure.
- * called from spoolss_r_startpageprinter (srv_spoolss.c)
+ * called from static spoolss_r_closeprinter (srv_spoolss.c)
+ * called from spoolss_closeprinter (cli_spoolss.c)
********************************************************************/
-BOOL spoolss_io_r_startpageprinter(char *desc, SPOOL_R_STARTPAGEPRINTER *r_u, prs_struct *ps, int depth)
+
+BOOL spoolss_io_r_closeprinter(char *desc, SPOOL_R_CLOSEPRINTER *r_u, prs_struct *ps, int depth)
{
- prs_debug(ps, depth, desc, "spoolss_io_r_startpageprinter");
+ prs_debug(ps, depth, desc, "spoolss_io_r_closeprinter");
depth++;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+
+ if (!prs_align(ps))
return False;
- return True;
-}
-
+ 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;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_startdocprinter (srv_spoolss.c)
+ ********************************************************************/
+
+BOOL spoolss_io_q_startdocprinter(char *desc, SPOOL_Q_STARTDOCPRINTER *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_startdocprinter");
+ depth++;
+
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
+ return False;
+
+ if(!smb_io_doc_info_container("",&q_u->doc_info_container, ps, depth))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_startdocprinter (srv_spoolss.c)
+ ********************************************************************/
+
+BOOL spoolss_io_r_startdocprinter(char *desc, SPOOL_R_STARTDOCPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_startdocprinter");
+ depth++;
+ if(!prs_uint32("jobid", ps, depth, &r_u->jobid))
+ return False;
+ if(!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_enddocprinter (srv_spoolss.c)
+ ********************************************************************/
+
+BOOL spoolss_io_q_enddocprinter(char *desc, SPOOL_Q_ENDDOCPRINTER *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_enddocprinter");
+ depth++;
+
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_enddocprinter (srv_spoolss.c)
+ ********************************************************************/
+
+BOOL spoolss_io_r_enddocprinter(char *desc, SPOOL_R_ENDDOCPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_enddocprinter");
+ depth++;
+ if(!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ * read a structure.
+ * called from spoolss_q_startpageprinter (srv_spoolss.c)
+ ********************************************************************/
+
+BOOL spoolss_io_q_startpageprinter(char *desc, SPOOL_Q_STARTPAGEPRINTER *q_u, prs_struct *ps, int depth)
+{
+ if (q_u == NULL) return False;
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_startpageprinter");
+ depth++;
+
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ * write a structure.
+ * called from spoolss_r_startpageprinter (srv_spoolss.c)
+ ********************************************************************/
+
+BOOL spoolss_io_r_startpageprinter(char *desc, SPOOL_R_STARTPAGEPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_startpageprinter");
+ depth++;
+ if(!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
+
+ return True;
+}
+
/*******************************************************************
* read a structure.
* called from spoolss_q_endpageprinter (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_q_endpageprinter(char *desc, SPOOL_Q_ENDPAGEPRINTER *q_u, prs_struct *ps, int depth)
{
if (q_u == NULL) return False;
if(!prs_align(ps))
return False;
- if(!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;
* write a structure.
* called from spoolss_r_endpageprinter (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_r_endpageprinter(char *desc, SPOOL_R_ENDPAGEPRINTER *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_endpageprinter");
depth++;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+ if(!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
* read a structure.
* called from spoolss_q_writeprinter (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_q_writeprinter(char *desc, SPOOL_Q_WRITEPRINTER *q_u, prs_struct *ps, int depth)
{
if (q_u == NULL) return False;
if(!prs_align(ps))
return False;
- if(!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;
- if(!prs_uint32("buffer_size", ps, depth, &(q_u->buffer_size)))
+ if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size))
return False;
if (q_u->buffer_size!=0)
{
- q_u->buffer=(uint8 *)malloc(q_u->buffer_size*sizeof(uint8));
+ if (UNMARSHALLING(ps))
+ q_u->buffer=(uint8 *)prs_alloc_mem(ps,q_u->buffer_size*sizeof(uint8));
if(q_u->buffer == NULL)
return False;
if(!prs_uint8s(True, "buffer", ps, depth, q_u->buffer, q_u->buffer_size))
}
if(!prs_align(ps))
return False;
- if(!prs_uint32("buffer_size2", ps, depth, &(q_u->buffer_size2)))
+ if(!prs_uint32("buffer_size2", ps, depth, &q_u->buffer_size2))
return False;
return True;
* write a structure.
* called from spoolss_r_writeprinter (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_r_writeprinter(char *desc, SPOOL_R_WRITEPRINTER *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_writeprinter");
depth++;
- if(!prs_uint32("buffer_written", ps, depth, &(r_u->buffer_written)))
+ if(!prs_uint32("buffer_written", ps, depth, &r_u->buffer_written))
return False;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+ if(!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
* read a structure.
* called from spoolss_q_rffpcnex (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_q_rffpcnex(char *desc, SPOOL_Q_RFFPCNEX *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_rffpcnex");
if (q_u->option_ptr!=0) {
if (UNMARSHALLING(ps))
- q_u->option=(SPOOL_NOTIFY_OPTION *)malloc(sizeof(SPOOL_NOTIFY_OPTION));
+ if((q_u->option=(SPOOL_NOTIFY_OPTION *)prs_alloc_mem(ps,sizeof(SPOOL_NOTIFY_OPTION))) == NULL)
+ return False;
if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
return False;
* write a structure.
* called from spoolss_r_rffpcnex (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_r_rffpcnex(char *desc, SPOOL_R_RFFPCNEX *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_rffpcnex");
* read a structure.
* called from spoolss_q_rfnpcnex (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_q_rfnpcnex(char *desc, SPOOL_Q_RFNPCNEX *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_rfnpcnex");
if (q_u->option_ptr!=0) {
if (UNMARSHALLING(ps))
- q_u->option=(SPOOL_NOTIFY_OPTION *)malloc(sizeof(SPOOL_NOTIFY_OPTION));
+ if((q_u->option=(SPOOL_NOTIFY_OPTION *)prs_alloc_mem(ps,sizeof(SPOOL_NOTIFY_OPTION))) == NULL)
+ return False;
if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
return False;
* write a structure.
* called from spoolss_r_rfnpcnex (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_r_rfnpcnex(char *desc, SPOOL_R_RFNPCNEX *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_rfnpcnex");
/*******************************************************************
* return the length of a uint16 (obvious, but the code is clean)
********************************************************************/
+
static uint32 size_of_uint16(uint16 *value)
{
return (sizeof(*value));
/*******************************************************************
* return the length of a uint32 (obvious, but the code is clean)
********************************************************************/
+
static uint32 size_of_uint32(uint32 *value)
{
return (sizeof(*value));
}
+
+/*******************************************************************
+ * return the length of a NTTIME (obvious, but the code is clean)
+ ********************************************************************/
+
+static uint32 size_of_nttime(NTTIME *value)
+{
+ return (sizeof(*value));
+}
+
/*******************************************************************
* return the length of a UNICODE string in number of char, includes:
* - the leading zero
* - the relative pointer size
********************************************************************/
+
static uint32 size_of_relative_string(UNISTR *string)
{
uint32 size=0;
size=str_len_uni(string); /* the string length */
size=size+1; /* add the leading zero */
size=size*2; /* convert in char */
+ /* Ensure size is 4 byte multiple (prs_align is being called...). */
+ size += ((4 - (size & 3)) & 3);
size=size+4; /* add the size of the ptr */
return size;
/*******************************************************************
* return the length of a uint32 (obvious, but the code is clean)
********************************************************************/
+
static uint32 size_of_device_mode(DEVICEMODE *devmode)
{
if (devmode==NULL)
return (4);
else
- return (0xDC+4);
+ return (4+devmode->size+devmode->driverextra);
}
/*******************************************************************
* return the length of a uint32 (obvious, but the code is clean)
********************************************************************/
+
static uint32 size_of_systemtime(SYSTEMTIME *systime)
{
if (systime==NULL)
* write a UNICODE string.
* used by all the RPC structs passing a buffer
********************************************************************/
+
static BOOL spoolss_smb_io_unistr(char *desc, UNISTR *uni, prs_struct *ps, int depth)
{
if (uni == NULL)
prs_debug(ps, depth, desc, "spoolss_smb_io_unistr");
depth++;
+
+ /* there should be no align here as it can mess up
+ parsing a NEW_BUFFER->prs */
+#if 0 /* JERRY */
+ if (!prs_align(ps))
+ return False;
+#endif
+
if (!prs_unistr("unistr", ps, depth, uni))
return False;
return True;
}
-
/*******************************************************************
* write a UNICODE string and its relative pointer.
* used by all the RPC structs passing a buffer
* first get in touch with me: jfm@samba.org
*
********************************************************************/
-static BOOL new_smb_io_relstr(char *desc, NEW_BUFFER *buffer, int depth, UNISTR *string)
+
+static BOOL smb_io_relstr(char *desc, NEW_BUFFER *buffer, int depth, UNISTR *string)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
if (MARSHALLING(ps)) {
uint32 struct_offset = prs_offset(ps);
uint32 relative_offset;
- buffer->string_at_end -= 2*(str_len_uni(string)+1);
- prs_set_offset(ps, buffer->string_at_end);
+ buffer->string_at_end -= (size_of_relative_string(string) - 4);
+ if(!prs_set_offset(ps, buffer->string_at_end))
+ return False;
+ if (!prs_align(ps))
+ return False;
+ buffer->string_at_end = prs_offset(ps);
/* write the string */
- if (!spoolss_smb_io_unistr(desc, string, ps, depth))
+ if (!smb_io_unistr(desc, string, ps, depth))
return False;
- prs_set_offset(ps, struct_offset);
+ if(!prs_set_offset(ps, struct_offset))
+ return False;
relative_offset=buffer->string_at_end - buffer->struct_start;
/* write its offset */
return False;
old_offset = prs_offset(ps);
- prs_set_offset(ps, buffer->string_at_end+buffer->struct_start);
+ if(!prs_set_offset(ps, buffer->string_at_end+buffer->struct_start))
+ return False;
/* read the string */
if (!spoolss_smb_io_unistr(desc, string, ps, depth))
return False;
- prs_set_offset(ps, old_offset);
+ if(!prs_set_offset(ps, old_offset))
+ return False;
}
return True;
}
-
/*******************************************************************
- * write a array UNICODE strings and its relative pointer.
+ * write a array of UNICODE strings and its relative pointer.
* used by 2 RPC structs
********************************************************************/
-static BOOL new_smb_io_relarraystr(char *desc, NEW_BUFFER *buffer, int depth, UNISTR ***string)
+
+static BOOL smb_io_relarraystr(char *desc, NEW_BUFFER *buffer, int depth, uint16 **string)
{
- prs_struct *ps=&(buffer->prs);
+ UNISTR chaine;
+
+ prs_struct *ps=&buffer->prs;
if (MARSHALLING(ps)) {
uint32 struct_offset = prs_offset(ps);
uint32 relative_offset;
- int i=0;
-
- while ( (*string)[i]!=0x0000 )
- i++;
- i--;
+ uint16 *p;
+ uint16 *q;
+ uint16 zero=0;
+ p=*string;
+ q=*string;
- /* count the ending NULL of the array */
+ /* first write the last 0 */
buffer->string_at_end -= 2;
+ if(!prs_set_offset(ps, buffer->string_at_end))
+ return False;
- /* 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);
+ if(!prs_uint16("leading zero", ps, depth, &zero))
+ return False;
+
+ while (p && (*p!=0)) {
+ while (*q!=0)
+ q++;
+
+ /* Yes this should be malloc not talloc. Don't change. */
+
+ chaine.buffer = malloc((q-p+1)*sizeof(uint16));
+ if (chaine.buffer == NULL)
+ return False;
+
+ memcpy(chaine.buffer, p, (q-p+1)*sizeof(uint16));
+
+ buffer->string_at_end -= (q-p+1)*sizeof(uint16);
+
+ if(!prs_set_offset(ps, buffer->string_at_end)) {
+ free(chaine.buffer);
+ return False;
+ }
/* write the string */
- if (!spoolss_smb_io_unistr(desc, (*string)[i], ps, depth))
+ if (!spoolss_smb_io_unistr(desc, &chaine, ps, depth)) {
+ free(chaine.buffer);
return False;
-
- i--;
+ }
+ q++;
+ p=q;
+
+ free(chaine.buffer);
}
- while (i>=0);
- prs_set_offset(ps, struct_offset);
+ if(!prs_set_offset(ps, struct_offset))
+ return False;
relative_offset=buffer->string_at_end - buffer->struct_start;
/* write its offset */
if (!prs_uint32("offset", ps, depth, &relative_offset))
return False;
- }
- else {
+
+ } else {
+
+ /* UNMARSHALLING */
+
uint32 old_offset;
-
+ uint16 *chaine2=NULL;
+ int l_chaine=0;
+ int l_chaine2=0;
+ size_t realloc_size = 0;
+
+ *string=NULL;
+
/* read the offset */
- if (!prs_uint32("offset", ps, depth, &(buffer->string_at_end)))
+ if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
return False;
old_offset = prs_offset(ps);
- prs_set_offset(ps, buffer->string_at_end);
+ if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
+ return False;
+
+ do {
+ if (!spoolss_smb_io_unistr(desc, &chaine, ps, depth))
+ return False;
+
+ l_chaine=str_len_uni(&chaine);
+
+ /* we're going to add two more bytes here in case this
+ is the last string in the array and we need to add
+ an extra NULL for termination */
+ if (l_chaine > 0)
+ {
+ uint16 *tc2;
+
+ realloc_size = (l_chaine2+l_chaine+2)*sizeof(uint16);
- /* read the string */
+ /* Yes this should be realloc - it's freed below. JRA */
- /* jfm: FIXME: alloc memory and read all the strings until the string is NULL */
+ if((tc2=(uint16 *)Realloc(chaine2, realloc_size)) == NULL) {
+ if (chaine2) free(chaine2);
+ return False;
+ }
+ else chaine2 = tc2;
+ memcpy(chaine2+l_chaine2, chaine.buffer, (l_chaine+1)*sizeof(uint16));
+ l_chaine2+=l_chaine+1;
+ }
+
+ } while(l_chaine!=0);
+
+ /* the end should be bould NULL terminated so add
+ the second one here */
+ if (chaine2)
+ {
+ chaine2[l_chaine2] = '\0';
+ *string=(uint16 *)talloc_memdup(prs_get_mem_context(ps),chaine2,realloc_size);
+ free(chaine2);
+ }
-/*
- if (!spoolss_smb_io_unistr(desc, string, ps, depth))
+ if(!prs_set_offset(ps, old_offset))
return False;
-*/
- prs_set_offset(ps, old_offset);
}
return True;
}
-
/*******************************************************************
Parse a DEVMODE structure and its relative pointer.
********************************************************************/
-static BOOL new_smb_io_reldevmode(char *desc, NEW_BUFFER *buffer, int depth, DEVICEMODE **devmode)
+
+static BOOL smb_io_relsecdesc(char *desc, NEW_BUFFER *buffer, int depth, SEC_DESC **secdesc)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps= &buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_reldevmode");
+ prs_debug(ps, depth, desc, "smb_io_relsecdesc");
depth++;
if (MARSHALLING(ps)) {
uint32 struct_offset = prs_offset(ps);
uint32 relative_offset;
-
- buffer->string_at_end -= ((*devmode)->size + (*devmode)->driverextra);
-
- prs_set_offset(ps, buffer->string_at_end);
-
- /* write the DEVMODE */
- if (!spoolss_io_devmode(desc, ps, depth, *devmode))
- return False;
- prs_set_offset(ps, struct_offset);
+ if (! *secdesc) {
+ relative_offset = 0;
+ if (!prs_uint32("offset", ps, depth, &relative_offset))
+ return False;
+ return True;
+ }
+ if (*secdesc != NULL) {
+ buffer->string_at_end -= sec_desc_size(*secdesc);
+
+ if(!prs_set_offset(ps, buffer->string_at_end))
+ return False;
+ /* write the secdesc */
+ if (!sec_io_desc(desc, secdesc, ps, depth))
+ return False;
+
+ if(!prs_set_offset(ps, struct_offset))
+ return False;
+ }
+
relative_offset=buffer->string_at_end - buffer->struct_start;
/* write its offset */
+
if (!prs_uint32("offset", ps, depth, &relative_offset))
return False;
- }
- else {
+ } else {
uint32 old_offset;
/* read the offset */
- if (!prs_uint32("offset", ps, depth, &(buffer->string_at_end)))
+ if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
return False;
old_offset = prs_offset(ps);
- prs_set_offset(ps, buffer->string_at_end + buffer->struct_start);
+ if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
+ return False;
- /* read the string */
- *devmode=(DEVICEMODE *)malloc(sizeof(DEVICEMODE));
- if (!spoolss_io_devmode(desc, ps, depth, *devmode))
+ /* read the sd */
+ if (!sec_io_desc(desc, secdesc, ps, depth))
return False;
- prs_set_offset(ps, old_offset);
+ if(!prs_set_offset(ps, old_offset))
+ return False;
}
return True;
}
-
/*******************************************************************
- Parse a PRINTER_INFO_0 structure.
-********************************************************************/
-BOOL new_smb_io_printer_info_0(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_0 *info, int depth)
-{
- prs_struct *ps=&(buffer->prs);
+ Parse a DEVMODE structure and its relative pointer.
+********************************************************************/
- prs_debug(ps, depth, desc, "smb_io_printer_info_0");
- depth++;
-
- buffer->struct_start=prs_offset(ps);
+static BOOL smb_io_reldevmode(char *desc, NEW_BUFFER *buffer, int depth, DEVICEMODE **devmode)
+{
+ prs_struct *ps=&buffer->prs;
- 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("total_jobs", ps, depth, &info->total_jobs))
- return False;
- if(!prs_uint32("total_bytes", ps, depth, &info->total_bytes))
- return False;
+ prs_debug(ps, depth, desc, "smb_io_reldevmode");
+ depth++;
- if(!prs_uint16("year", ps, depth, &info->year))
+ if (MARSHALLING(ps)) {
+ uint32 struct_offset = prs_offset(ps);
+ uint32 relative_offset;
+
+ if (*devmode == NULL) {
+ relative_offset=0;
+ if (!prs_uint32("offset", ps, depth, &relative_offset))
+ return False;
+ DEBUG(8, ("boing, the devmode was NULL\n"));
+
+ return True;
+ }
+
+ buffer->string_at_end -= ((*devmode)->size + (*devmode)->driverextra);
+
+ if(!prs_set_offset(ps, buffer->string_at_end))
+ return False;
+
+ /* write the DEVMODE */
+ if (!spoolss_io_devmode(desc, ps, depth, *devmode))
+ return False;
+
+ if(!prs_set_offset(ps, struct_offset))
+ return False;
+
+ relative_offset=buffer->string_at_end - buffer->struct_start;
+ /* write its offset */
+ if (!prs_uint32("offset", ps, depth, &relative_offset))
+ return False;
+ }
+ else {
+ uint32 old_offset;
+
+ /* read the offset */
+ if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
+ return False;
+
+ old_offset = prs_offset(ps);
+ if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
+ return False;
+
+ /* read the string */
+ if((*devmode=(DEVICEMODE *)prs_alloc_mem(ps,sizeof(DEVICEMODE))) == NULL)
+ return False;
+ if (!spoolss_io_devmode(desc, ps, depth, *devmode))
+ return False;
+
+ if(!prs_set_offset(ps, old_offset))
+ return False;
+ }
+ return True;
+}
+
+/*******************************************************************
+ Parse a PRINTER_INFO_0 structure.
+********************************************************************/
+
+BOOL 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++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (!smb_io_relstr("printername", buffer, depth, &info->printername))
+ return False;
+ if (!smb_io_relstr("servername", buffer, depth, &info->servername))
+ return False;
+
+ if(!prs_uint32("cjobs", ps, depth, &info->cjobs))
+ return False;
+ if(!prs_uint32("total_jobs", ps, depth, &info->total_jobs))
+ return False;
+ if(!prs_uint32("total_bytes", ps, depth, &info->total_bytes))
+ return False;
+
+ if(!prs_uint16("year", ps, depth, &info->year))
return False;
if(!prs_uint16("month", ps, depth, &info->month))
return False;
/*******************************************************************
Parse a PRINTER_INFO_1 structure.
********************************************************************/
-BOOL new_smb_io_printer_info_1(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_1 *info, int depth)
+
+BOOL smb_io_printer_info_1(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_1 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_printer_info_1");
+ prs_debug(ps, depth, desc, "smb_io_printer_info_1");
depth++;
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))
+ if (!smb_io_relstr("description", buffer, depth, &info->description))
return False;
- if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ if (!smb_io_relstr("name", buffer, depth, &info->name))
return False;
- if (!new_smb_io_relstr("comment", buffer, depth, &info->comment))
+ if (!smb_io_relstr("comment", buffer, depth, &info->comment))
return False;
return True;
/*******************************************************************
Parse a PRINTER_INFO_2 structure.
********************************************************************/
-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;
- prs_struct *ps=&(buffer->prs);
+BOOL smb_io_printer_info_2(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_2 *info, int depth)
+{
+ prs_struct *ps=&buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_printer_info_2");
+ prs_debug(ps, depth, desc, "smb_io_printer_info_2");
depth++;
buffer->struct_start=prs_offset(ps);
- if (!new_smb_io_relstr("servername", buffer, depth, &info->servername))
+ if (!smb_io_relstr("servername", buffer, depth, &info->servername))
return False;
- if (!new_smb_io_relstr("printername", buffer, depth, &info->printername))
+ if (!smb_io_relstr("printername", buffer, depth, &info->printername))
return False;
- if (!new_smb_io_relstr("sharename", buffer, depth, &info->sharename))
+ if (!smb_io_relstr("sharename", buffer, depth, &info->sharename))
return False;
- if (!new_smb_io_relstr("portname", buffer, depth, &info->portname))
+ if (!smb_io_relstr("portname", buffer, depth, &info->portname))
return False;
- if (!new_smb_io_relstr("drivername", buffer, depth, &info->drivername))
+ if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
return False;
- if (!new_smb_io_relstr("comment", buffer, depth, &info->comment))
+ if (!smb_io_relstr("comment", buffer, depth, &info->comment))
return False;
- if (!new_smb_io_relstr("location", buffer, depth, &info->location))
+ if (!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))
+ if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
return False;
- if (!new_smb_io_relstr("sepfile", buffer, depth, &info->sepfile))
+ if (!smb_io_relstr("sepfile", buffer, depth, &info->sepfile))
return False;
- if (!new_smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
+ if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
return False;
- if (!new_smb_io_relstr("datatype", buffer, depth, &info->datatype))
+ if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
return False;
- if (!new_smb_io_relstr("parameters", buffer, depth, &info->parameters))
+ if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
return False;
- if (!prs_uint32("security descriptor", ps, depth, &pipo))
+ if (!smb_io_relsecdesc("secdesc", buffer, depth, &info->secdesc))
return False;
+
if (!prs_uint32("attributes", ps, depth, &info->attributes))
return False;
if (!prs_uint32("priority", ps, depth, &info->priority))
if (!prs_uint32("averageppm", ps, depth, &info->averageppm))
return False;
+#if 0 /* JFMTEST */
+ if (!prs_uint32_post("secdesc_ptr", ps, depth, NULL, sec_offset, info->secdesc ? prs_offset(ps)-buffer->struct_start : 0 ))
+ return False;
+
+ if (!sec_io_desc("secdesc", &info->secdesc, ps, depth))
+ return False;
+#endif
+ return True;
+}
+
+/*******************************************************************
+ Parse a PRINTER_INFO_3 structure.
+********************************************************************/
+
+BOOL smb_io_printer_info_3(char *desc, NEW_BUFFER *buffer, PRINTER_INFO_3 *info, int depth)
+{
+ prs_struct *ps=&buffer->prs;
+
+ prs_debug(ps, depth, desc, "smb_io_printer_info_3");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (!prs_uint32("flags", ps, depth, &info->flags))
+ return False;
+ if (!sec_io_desc("sec_desc", &info->secdesc, ps, depth))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ Parse a PORT_INFO_1 structure.
+********************************************************************/
+
+BOOL smb_io_port_info_1(char *desc, NEW_BUFFER *buffer, PORT_INFO_1 *info, int depth)
+{
+ prs_struct *ps=&buffer->prs;
+
+ prs_debug(ps, depth, desc, "smb_io_port_info_1");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+ Parse a PORT_INFO_2 structure.
+********************************************************************/
+
+BOOL smb_io_port_info_2(char *desc, NEW_BUFFER *buffer, PORT_INFO_2 *info, int depth)
+{
+ prs_struct *ps=&buffer->prs;
+
+ prs_debug(ps, depth, desc, "smb_io_port_info_2");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
+ return False;
+ if (!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
+ return False;
+ if (!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;
}
/*******************************************************************
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)
+
+BOOL smb_io_printer_driver_info_1(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_1 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_printer_driver_info_1");
+ prs_debug(ps, depth, desc, "smb_io_printer_driver_info_1");
depth++;
buffer->struct_start=prs_offset(ps);
- if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ if (!smb_io_relstr("name", buffer, depth, &info->name))
return False;
return True;
}
-
/*******************************************************************
Parse a DRIVER_INFO_2 structure.
********************************************************************/
-BOOL new_smb_io_printer_driver_info_2(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_2 *info, int depth)
+
+BOOL smb_io_printer_driver_info_2(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_2 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_printer_driver_info_2");
+ prs_debug(ps, depth, desc, "smb_io_printer_driver_info_2");
depth++;
buffer->struct_start=prs_offset(ps);
if (!prs_uint32("version", ps, depth, &info->version))
return False;
- if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ if (!smb_io_relstr("name", buffer, depth, &info->name))
return False;
- if (!new_smb_io_relstr("architecture", buffer, depth, &info->architecture))
+ if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
return False;
- if (!new_smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
+ if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
return False;
- if (!new_smb_io_relstr("datafile", buffer, depth, &info->datafile))
+ if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
return False;
- if (!new_smb_io_relstr("configfile", buffer, depth, &info->configfile))
+ if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
return False;
return True;
}
-
/*******************************************************************
Parse a DRIVER_INFO_3 structure.
********************************************************************/
-BOOL new_smb_io_printer_driver_info_3(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_3 *info, int depth)
+
+BOOL smb_io_printer_driver_info_3(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_3 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_printer_driver_info_3");
+ prs_debug(ps, depth, desc, "smb_io_printer_driver_info_3");
depth++;
buffer->struct_start=prs_offset(ps);
if (!prs_uint32("version", ps, depth, &info->version))
return False;
- if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ if (!smb_io_relstr("name", buffer, depth, &info->name))
return False;
- if (!new_smb_io_relstr("architecture", buffer, depth, &info->architecture))
+ if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
return False;
- if (!new_smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
+ if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
return False;
- if (!new_smb_io_relstr("datafile", buffer, depth, &info->datafile))
+ if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
return False;
- if (!new_smb_io_relstr("configfile", buffer, depth, &info->configfile))
+ if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
return False;
- if (!new_smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
+ if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
return False;
- if (!new_smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
+ if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
return False;
- if (!new_smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
+ if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
return False;
- if (!new_smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
+ if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
return False;
return True;
}
+/*******************************************************************
+ Parse a DRIVER_INFO_6 structure.
+********************************************************************/
+
+BOOL smb_io_printer_driver_info_6(char *desc, NEW_BUFFER *buffer, DRIVER_INFO_6 *info, int depth)
+{
+ prs_struct *ps=&buffer->prs;
+
+ prs_debug(ps, depth, desc, "smb_io_printer_driver_info_6");
+ depth++;
+
+ buffer->struct_start=prs_offset(ps);
+
+ if (!prs_uint32("version", ps, depth, &info->version))
+ return False;
+ if (!smb_io_relstr("name", buffer, depth, &info->name))
+ return False;
+ if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
+ return False;
+ if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
+ return False;
+ if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
+ return False;
+ if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
+ return False;
+ if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
+ return False;
+
+ if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
+ return False;
+
+ if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
+ return False;
+ if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
+ return False;
+
+ if (!smb_io_relarraystr("previousdrivernames", buffer, depth, &info->previousdrivernames))
+ return False;
+
+ if (!prs_uint32("date.low", ps, depth, &info->driver_date.low))
+ return False;
+ if (!prs_uint32("date.high", ps, depth, &info->driver_date.high))
+ return False;
+
+ if (!prs_uint32("padding", ps, depth, &info->padding))
+ return False;
+
+ if (!prs_uint32("driver_version_low", ps, depth, &info->driver_version_low))
+ return False;
+
+ if (!prs_uint32("driver_version_high", ps, depth, &info->driver_version_high))
+ return False;
+
+ if (!smb_io_relstr("mfgname", buffer, depth, &info->mfgname))
+ return False;
+ if (!smb_io_relstr("oem_url", buffer, depth, &info->oem_url))
+ return False;
+ if (!smb_io_relstr("hardware_id", buffer, depth, &info->hardware_id))
+ return False;
+ if (!smb_io_relstr("provider", buffer, depth, &info->provider))
+ return False;
+
+ return True;
+}
/*******************************************************************
Parse a JOB_INFO_1 structure.
********************************************************************/
-BOOL new_smb_io_job_info_1(char *desc, NEW_BUFFER *buffer, JOB_INFO_1 *info, int depth)
+
+BOOL smb_io_job_info_1(char *desc, NEW_BUFFER *buffer, JOB_INFO_1 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_job_info_1");
+ prs_debug(ps, depth, desc, "smb_io_job_info_1");
depth++;
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))
+ if (!smb_io_relstr("printername", buffer, depth, &info->printername))
return False;
- if (!new_smb_io_relstr("machinename", buffer, depth, &info->machinename))
+ if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
return False;
- if (!new_smb_io_relstr("username", buffer, depth, &info->username))
+ if (!smb_io_relstr("username", buffer, depth, &info->username))
return False;
- if (!new_smb_io_relstr("document", buffer, depth, &info->document))
+ if (!smb_io_relstr("document", buffer, depth, &info->document))
return False;
- if (!new_smb_io_relstr("datatype", buffer, depth, &info->datatype))
+ if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
return False;
- if (!new_smb_io_relstr("text_status", buffer, depth, &info->text_status))
+ if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
return False;
if (!prs_uint32("status", ps, depth, &info->status))
return False;
/*******************************************************************
Parse a JOB_INFO_2 structure.
********************************************************************/
-BOOL new_smb_io_job_info_2(char *desc, NEW_BUFFER *buffer, JOB_INFO_2 *info, int depth)
+
+BOOL smb_io_job_info_2(char *desc, NEW_BUFFER *buffer, JOB_INFO_2 *info, int depth)
{
- int pipo=0;
- prs_struct *ps=&(buffer->prs);
+ uint32 pipo=0;
+ prs_struct *ps=&buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_job_info_2");
+ prs_debug(ps, depth, desc, "smb_io_job_info_2");
depth++;
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))
+ if (!smb_io_relstr("printername", buffer, depth, &info->printername))
return False;
- if (!new_smb_io_relstr("machinename", buffer, depth, &info->machinename))
+ if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
return False;
- if (!new_smb_io_relstr("username", buffer, depth, &info->username))
+ if (!smb_io_relstr("username", buffer, depth, &info->username))
return False;
- if (!new_smb_io_relstr("document", buffer, depth, &info->document))
+ if (!smb_io_relstr("document", buffer, depth, &info->document))
return False;
- if (!new_smb_io_relstr("notifyname", buffer, depth, &info->notifyname))
+ if (!smb_io_relstr("notifyname", buffer, depth, &info->notifyname))
return False;
- if (!new_smb_io_relstr("datatype", buffer, depth, &info->datatype))
+ if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
return False;
- if (!new_smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
+ if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
return False;
- if (!new_smb_io_relstr("parameters", buffer, depth, &info->parameters))
+ if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
return False;
- if (!new_smb_io_relstr("drivername", buffer, depth, &info->drivername))
+ if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
return False;
- if (!new_smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
+ if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
return False;
- if (!new_smb_io_relstr("text_status", buffer, depth, &info->text_status))
+ if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
return False;
/* SEC_DESC sec_desc;*/
/*******************************************************************
********************************************************************/
-BOOL new_smb_io_form_1(char *desc, NEW_BUFFER *buffer, FORM_1 *info, int depth)
+
+BOOL smb_io_form_1(char *desc, NEW_BUFFER *buffer, FORM_1 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_form_1");
+ prs_debug(ps, depth, desc, "smb_io_form_1");
depth++;
buffer->struct_start=prs_offset(ps);
- if (!prs_uint32("flag", ps, depth, &(info->flag)))
+ if (!prs_uint32("flag", ps, depth, &info->flag))
return False;
- if (!new_smb_io_relstr("name", buffer, depth, &(info->name)))
+ if (!smb_io_relstr("name", buffer, depth, &info->name))
return False;
- if (!prs_uint32("width", ps, depth, &(info->width)))
+ if (!prs_uint32("width", ps, depth, &info->width))
return False;
- if (!prs_uint32("length", ps, depth, &(info->length)))
+ if (!prs_uint32("length", ps, depth, &info->length))
return False;
- if (!prs_uint32("left", ps, depth, &(info->left)))
+ if (!prs_uint32("left", ps, depth, &info->left))
return False;
- if (!prs_uint32("top", ps, depth, &(info->top)))
+ if (!prs_uint32("top", ps, depth, &info->top))
return False;
- if (!prs_uint32("right", ps, depth, &(info->right)))
+ if (!prs_uint32("right", ps, depth, &info->right))
return False;
- if (!prs_uint32("bottom", ps, depth, &(info->bottom)))
+ 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)
+
+static BOOL spoolss_io_buffer(char *desc, prs_struct *ps, int depth, NEW_BUFFER **pp_buffer)
{
- if (buffer == NULL)
- return False;
+ NEW_BUFFER *buffer = *pp_buffer;
- prs_debug(ps, depth, desc, "new_spoolss_io_buffer");
+ prs_debug(ps, depth, desc, "spoolss_io_buffer");
depth++;
- if (!prs_uint32("ptr", ps, depth, &(buffer->ptr)))
+ if (UNMARSHALLING(ps))
+ buffer = *pp_buffer = (NEW_BUFFER *)prs_alloc_mem(ps, sizeof(NEW_BUFFER));
+
+ if (buffer == NULL)
+ return False;
+
+ if (!prs_uint32("ptr", ps, depth, &buffer->ptr))
return False;
/* reading */
buffer->string_at_end=0;
if (buffer->ptr==0) {
- if (!prs_init(&(buffer->prs), 0, 4, UNMARSHALL))
+ /*
+ * JRA. I'm not sure if the data in here is in big-endian format if
+ * the client is big-endian. Leave as default (little endian) for now.
+ */
+
+ if (!prs_init(&buffer->prs, 0, prs_get_mem_context(ps), UNMARSHALL))
return False;
return True;
}
if (!prs_uint32("size", ps, depth, &buffer->size))
return False;
- if (!prs_init(&(buffer->prs), buffer->size, 4, UNMARSHALL))
+ /*
+ * JRA. I'm not sure if the data in here is in big-endian format if
+ * the client is big-endian. Leave as default (little endian) for now.
+ */
+
+ if (!prs_init(&buffer->prs, buffer->size, prs_get_mem_context(ps), UNMARSHALL))
return False;
- if (!prs_append_some_prs_data(&(buffer->prs), ps, prs_offset(ps), buffer->size))
+ if (!prs_append_some_prs_data(&buffer->prs, ps, prs_offset(ps), buffer->size))
return False;
if (!prs_set_offset(&buffer->prs, 0))
return True;
}
else {
+ BOOL ret = False;
+
/* writing */
- if (buffer->ptr==0)
+ if (buffer->ptr==0) {
+ /* We have finished with the data in buffer->prs - free it. */
+ prs_mem_free(&buffer->prs);
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;
+ }
+
+ if (!prs_uint32("size", ps, depth, &buffer->size))
+ goto out;
- return True;
+ if (!prs_append_some_prs_data(ps, &buffer->prs, 0, buffer->size))
+ goto out;
+
+ ret = True;
+ out:
+
+ /* We have finished with the data in buffer->prs - free it. */
+ prs_mem_free(&buffer->prs);
+
+ return ret;
}
}
/*******************************************************************
move a BUFFER from the query to the reply.
+ As the data pointers in NEW_BUFFER are malloc'ed, not talloc'ed,
+ this is ok. This is an OPTIMIZATION and is not strictly neccessary.
********************************************************************/
-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)
+void spoolss_move_buffer(NEW_BUFFER *src, NEW_BUFFER **dest)
{
- if (buffer==NULL)
+ prs_switch_type(&src->prs, MARSHALL);
+ if(!prs_set_offset(&src->prs, 0))
return;
-
- *buffer=(NEW_BUFFER *)malloc(sizeof(NEW_BUFFER));
-
- (*buffer)->ptr=0x0;
- (*buffer)->size=0;
- (*buffer)->string_at_end=0;
-}
+ prs_force_dynamic(&(src->prs));
-/*******************************************************************
- 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);
+ *dest=src;
}
/*******************************************************************
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)
+
+BOOL smb_io_driverdir_1(char *desc, NEW_BUFFER *buffer, DRIVER_DIRECTORY_1 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_driverdir_1");
+ prs_debug(ps, depth, desc, "smb_io_driverdir_1");
depth++;
buffer->struct_start=prs_offset(ps);
- if (!spoolss_smb_io_unistr(desc, &info->name, ps, depth))
+ if (!smb_io_unistr(desc, &info->name, ps, depth))
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)
+
+BOOL smb_io_port_1(char *desc, NEW_BUFFER *buffer, PORT_INFO_1 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_port_1");
+ prs_debug(ps, depth, desc, "smb_io_port_1");
depth++;
buffer->struct_start=prs_offset(ps);
- if(!new_smb_io_relstr("port_name", buffer, depth, &info->port_name))
+ if(!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)
+
+BOOL smb_io_port_2(char *desc, NEW_BUFFER *buffer, PORT_INFO_2 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
- prs_debug(ps, depth, desc, "new_smb_io_port_2");
+ prs_debug(ps, depth, desc, "smb_io_port_2");
depth++;
buffer->struct_start=prs_offset(ps);
- if(!new_smb_io_relstr("port_name", buffer, depth, &info->port_name))
+ if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
return False;
- if(!new_smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
+ if(!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
return False;
- if(!new_smb_io_relstr("description", buffer, depth, &info->description))
+ if(!smb_io_relstr("description", buffer, depth, &info->description))
return False;
if(!prs_uint32("port_type", ps, depth, &info->port_type))
return False;
return True;
}
-
/*******************************************************************
********************************************************************/
+
BOOL smb_io_printprocessor_info_1(char *desc, NEW_BUFFER *buffer, PRINTPROCESSOR_1 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
prs_debug(ps, depth, desc, "smb_io_printprocessor_info_1");
depth++;
buffer->struct_start=prs_offset(ps);
- if (new_smb_io_relstr("name", buffer, depth, &info->name))
+ if (smb_io_relstr("name", buffer, depth, &info->name))
return False;
return True;
/*******************************************************************
********************************************************************/
+
BOOL smb_io_printprocdatatype_info_1(char *desc, NEW_BUFFER *buffer, PRINTPROCDATATYPE_1 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
prs_debug(ps, depth, desc, "smb_io_printprocdatatype_info_1");
depth++;
buffer->struct_start=prs_offset(ps);
- if (new_smb_io_relstr("name", buffer, depth, &info->name))
+ if (smb_io_relstr("name", buffer, depth, &info->name))
return False;
return True;
/*******************************************************************
********************************************************************/
+
BOOL smb_io_printmonitor_info_1(char *desc, NEW_BUFFER *buffer, PRINTMONITOR_1 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
prs_debug(ps, depth, desc, "smb_io_printmonitor_info_1");
depth++;
buffer->struct_start=prs_offset(ps);
- if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ if (!smb_io_relstr("name", buffer, depth, &info->name))
return False;
return True;
/*******************************************************************
********************************************************************/
+
BOOL smb_io_printmonitor_info_2(char *desc, NEW_BUFFER *buffer, PRINTMONITOR_2 *info, int depth)
{
- prs_struct *ps=&(buffer->prs);
+ prs_struct *ps=&buffer->prs;
prs_debug(ps, depth, desc, "smb_io_printmonitor_info_2");
depth++;
buffer->struct_start=prs_offset(ps);
- if (!new_smb_io_relstr("name", buffer, depth, &info->name))
+ if (!smb_io_relstr("name", buffer, depth, &info->name))
return False;
- if (!new_smb_io_relstr("environment", buffer, depth, &info->environment))
+ if (!smb_io_relstr("environment", buffer, depth, &info->environment))
return False;
- if (!new_smb_io_relstr("dll_name", buffer, depth, &info->dll_name))
+ if (!smb_io_relstr("dll_name", buffer, depth, &info->dll_name))
return False;
return True;
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
{
int size=0;
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
{
int size=0;
- size+=size_of_uint32( &(info->flags) );
- size+=size_of_relative_string( &(info->description) );
- size+=size_of_relative_string( &(info->name) );
- size+=size_of_relative_string( &(info->comment) );
+ size+=size_of_uint32( &info->flags );
+ size+=size_of_relative_string( &info->description );
+ size+=size_of_relative_string( &info->name );
+ size+=size_of_relative_string( &info->comment );
return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
{
- int size=0;
+ uint32 size=0;
- size+=4; /* the security descriptor */
- size+=info->devmode->size+4; /* size of the devmode and the ptr */
- size+=info->devmode->driverextra; /* if a devmode->private section exists, add its size */
-
- size+=size_of_relative_string( &(info->servername) );
- size+=size_of_relative_string( &(info->printername) );
- size+=size_of_relative_string( &(info->sharename) );
- size+=size_of_relative_string( &(info->portname) );
- size+=size_of_relative_string( &(info->drivername) );
- size+=size_of_relative_string( &(info->comment) );
- size+=size_of_relative_string( &(info->location) );
-
- size+=size_of_relative_string( &(info->sepfile) );
- size+=size_of_relative_string( &(info->printprocessor) );
- size+=size_of_relative_string( &(info->datatype) );
- size+=size_of_relative_string( &(info->parameters) );
-
- size+=size_of_uint32( &(info->attributes) );
- size+=size_of_uint32( &(info->priority) );
- size+=size_of_uint32( &(info->defaultpriority) );
- size+=size_of_uint32( &(info->starttime) );
- size+=size_of_uint32( &(info->untiltime) );
- size+=size_of_uint32( &(info->status) );
- size+=size_of_uint32( &(info->cjobs) );
- size+=size_of_uint32( &(info->averageppm) );
+ size += 4;
+ /* JRA !!!! TESTME - WHAT ABOUT prs_align.... !!! */
+ size += sec_desc_size( info->secdesc );
+
+ size+=size_of_device_mode( info->devmode );
+
+ size+=size_of_relative_string( &info->servername );
+ size+=size_of_relative_string( &info->printername );
+ size+=size_of_relative_string( &info->sharename );
+ size+=size_of_relative_string( &info->portname );
+ size+=size_of_relative_string( &info->drivername );
+ size+=size_of_relative_string( &info->comment );
+ size+=size_of_relative_string( &info->location );
+
+ size+=size_of_relative_string( &info->sepfile );
+ size+=size_of_relative_string( &info->printprocessor );
+ size+=size_of_relative_string( &info->datatype );
+ size+=size_of_relative_string( &info->parameters );
+
+ size+=size_of_uint32( &info->attributes );
+ size+=size_of_uint32( &info->priority );
+ size+=size_of_uint32( &info->defaultpriority );
+ size+=size_of_uint32( &info->starttime );
+ size+=size_of_uint32( &info->untiltime );
+ size+=size_of_uint32( &info->status );
+ size+=size_of_uint32( &info->cjobs );
+ size+=size_of_uint32( &info->averageppm );
return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
-uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
-{
- int size=0;
- size+=size_of_relative_string( &(info->name) );
- return size;
+uint32 spoolss_size_printer_info_3(PRINTER_INFO_3 *info)
+{
+ /* The 4 is for the self relative pointer.. */
+ /* JRA !!!! TESTME - WHAT ABOUT prs_align.... !!! */
+ return 4 + (uint32)sec_desc_size( info->secdesc );
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
-uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
+
+uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
{
int size=0;
- size+=size_of_uint32( &(info->version) );
- size+=size_of_relative_string( &(info->name) );
- size+=size_of_relative_string( &(info->architecture) );
- size+=size_of_relative_string( &(info->driverpath) );
- size+=size_of_relative_string( &(info->datafile) );
- size+=size_of_relative_string( &(info->configfile) );
+ size+=size_of_relative_string( &info->name );
return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
-uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
+
+uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
{
int size=0;
- UNISTR **string;
- int i=0;
-
- size+=size_of_uint32( &(info->version) );
- size+=size_of_relative_string( &(info->name) );
- size+=size_of_relative_string( &(info->architecture) );
- size+=size_of_relative_string( &(info->driverpath) );
- size+=size_of_relative_string( &(info->datafile) );
- size+=size_of_relative_string( &(info->configfile) );
- size+=size_of_relative_string( &(info->helpfile) );
- size+=size_of_relative_string( &(info->monitorname) );
- size+=size_of_relative_string( &(info->defaultdatatype) );
-
- string=info->dependentfiles;
-
- while ( (string)[i]!=0x0000 )
- {
- size+=2*(1+ str_len_uni( string[i] ) );
- i++;
- }
- size+=6;
+ size+=size_of_uint32( &info->version );
+ size+=size_of_relative_string( &info->name );
+ size+=size_of_relative_string( &info->architecture );
+ size+=size_of_relative_string( &info->driverpath );
+ size+=size_of_relative_string( &info->datafile );
+ size+=size_of_relative_string( &info->configfile );
+
+ return size;
+}
+
+/*******************************************************************
+return the size required by a string array.
+********************************************************************/
+
+uint32 spoolss_size_string_array(uint16 *string)
+{
+ uint32 i = 0;
+
+ if (string) {
+ for (i=0; (string[i]!=0x0000) || (string[i+1]!=0x0000); i++);
+ }
+ i=i+2; /* to count all chars including the leading zero */
+ i=2*i; /* because we need the value in bytes */
+ i=i+4; /* the offset pointer size */
+
+ return i;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+
+uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
+{
+ int size=0;
+
+ size+=size_of_uint32( &info->version );
+ size+=size_of_relative_string( &info->name );
+ size+=size_of_relative_string( &info->architecture );
+ size+=size_of_relative_string( &info->driverpath );
+ size+=size_of_relative_string( &info->datafile );
+ size+=size_of_relative_string( &info->configfile );
+ size+=size_of_relative_string( &info->helpfile );
+ size+=size_of_relative_string( &info->monitorname );
+ size+=size_of_relative_string( &info->defaultdatatype );
+
+ size+=spoolss_size_string_array(info->dependentfiles);
+
+ return size;
+}
+
+/*******************************************************************
+return the size required by a struct in the stream
+********************************************************************/
+
+uint32 spoolss_size_printer_driver_info_6(DRIVER_INFO_6 *info)
+{
+ uint32 size=0;
+
+ size+=size_of_uint32( &info->version );
+ size+=size_of_relative_string( &info->name );
+ size+=size_of_relative_string( &info->architecture );
+ size+=size_of_relative_string( &info->driverpath );
+ size+=size_of_relative_string( &info->datafile );
+ size+=size_of_relative_string( &info->configfile );
+ size+=size_of_relative_string( &info->helpfile );
+
+ size+=spoolss_size_string_array(info->dependentfiles);
+
+ size+=size_of_relative_string( &info->monitorname );
+ size+=size_of_relative_string( &info->defaultdatatype );
+
+ size+=spoolss_size_string_array(info->previousdrivernames);
+
+ size+=size_of_nttime(&info->driver_date);
+ size+=size_of_uint32( &info->padding );
+ size+=size_of_uint32( &info->driver_version_low );
+ size+=size_of_uint32( &info->driver_version_high );
+ size+=size_of_relative_string( &info->mfgname );
+ size+=size_of_relative_string( &info->oem_url );
+ size+=size_of_relative_string( &info->hardware_id );
+ size+=size_of_relative_string( &info->provider );
return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
{
int size=0;
- size+=size_of_uint32( &(info->jobid) );
- size+=size_of_relative_string( &(info->printername) );
- size+=size_of_relative_string( &(info->machinename) );
- size+=size_of_relative_string( &(info->username) );
- size+=size_of_relative_string( &(info->document) );
- size+=size_of_relative_string( &(info->datatype) );
- size+=size_of_relative_string( &(info->text_status) );
- size+=size_of_uint32( &(info->status) );
- size+=size_of_uint32( &(info->priority) );
- size+=size_of_uint32( &(info->position) );
- size+=size_of_uint32( &(info->totalpages) );
- size+=size_of_uint32( &(info->pagesprinted) );
- size+=size_of_systemtime( &(info->submitted) );
+ size+=size_of_uint32( &info->jobid );
+ size+=size_of_relative_string( &info->printername );
+ size+=size_of_relative_string( &info->machinename );
+ size+=size_of_relative_string( &info->username );
+ size+=size_of_relative_string( &info->document );
+ size+=size_of_relative_string( &info->datatype );
+ size+=size_of_relative_string( &info->text_status );
+ size+=size_of_uint32( &info->status );
+ size+=size_of_uint32( &info->priority );
+ size+=size_of_uint32( &info->position );
+ size+=size_of_uint32( &info->totalpages );
+ size+=size_of_uint32( &info->pagesprinted );
+ size+=size_of_systemtime( &info->submitted );
return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
{
int size=0;
size+=4; /* size of sec desc ptr */
- size+=size_of_uint32( &(info->jobid) );
- size+=size_of_relative_string( &(info->printername) );
- size+=size_of_relative_string( &(info->machinename) );
- size+=size_of_relative_string( &(info->username) );
- size+=size_of_relative_string( &(info->document) );
- size+=size_of_relative_string( &(info->notifyname) );
- size+=size_of_relative_string( &(info->datatype) );
- size+=size_of_relative_string( &(info->printprocessor) );
- size+=size_of_relative_string( &(info->parameters) );
- size+=size_of_relative_string( &(info->drivername) );
+ size+=size_of_uint32( &info->jobid );
+ size+=size_of_relative_string( &info->printername );
+ size+=size_of_relative_string( &info->machinename );
+ size+=size_of_relative_string( &info->username );
+ size+=size_of_relative_string( &info->document );
+ size+=size_of_relative_string( &info->notifyname );
+ size+=size_of_relative_string( &info->datatype );
+ size+=size_of_relative_string( &info->printprocessor );
+ size+=size_of_relative_string( &info->parameters );
+ size+=size_of_relative_string( &info->drivername );
size+=size_of_device_mode( info->devmode );
- size+=size_of_relative_string( &(info->text_status) );
+ size+=size_of_relative_string( &info->text_status );
/* SEC_DESC sec_desc;*/
- size+=size_of_uint32( &(info->status) );
- size+=size_of_uint32( &(info->priority) );
- size+=size_of_uint32( &(info->position) );
- size+=size_of_uint32( &(info->starttime) );
- size+=size_of_uint32( &(info->untiltime) );
- size+=size_of_uint32( &(info->totalpages) );
- size+=size_of_uint32( &(info->size) );
- size+=size_of_systemtime( &(info->submitted) );
- size+=size_of_uint32( &(info->timeelapsed) );
- size+=size_of_uint32( &(info->pagesprinted) );
+ size+=size_of_uint32( &info->status );
+ size+=size_of_uint32( &info->priority );
+ size+=size_of_uint32( &info->position );
+ size+=size_of_uint32( &info->starttime );
+ size+=size_of_uint32( &info->untiltime );
+ size+=size_of_uint32( &info->totalpages );
+ size+=size_of_uint32( &info->size );
+ size+=size_of_systemtime( &info->submitted );
+ size+=size_of_uint32( &info->timeelapsed );
+ size+=size_of_uint32( &info->pagesprinted );
return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_form_1(FORM_1 *info)
{
int size=0;
- size+=size_of_uint32( &(info->flag) );
- size+=size_of_relative_string( &(info->name) );
- size+=size_of_uint32( &(info->width) );
- size+=size_of_uint32( &(info->length) );
- size+=size_of_uint32( &(info->left) );
- size+=size_of_uint32( &(info->top) );
- size+=size_of_uint32( &(info->right) );
- size+=size_of_uint32( &(info->bottom) );
+ size+=size_of_uint32( &info->flag );
+ size+=size_of_relative_string( &info->name );
+ size+=size_of_uint32( &info->width );
+ size+=size_of_uint32( &info->length );
+ size+=size_of_uint32( &info->left );
+ size+=size_of_uint32( &info->top );
+ size+=size_of_uint32( &info->right );
+ size+=size_of_uint32( &info->bottom );
return size;
}
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_port_info_1(PORT_INFO_1 *info)
{
int size=0;
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_driverdir_info_1(DRIVER_DIRECTORY_1 *info)
{
int size=0;
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
{
int size=0;
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_printprocessor_info_1(PRINTPROCESSOR_1 *info)
{
int size=0;
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_printprocdatatype_info_1(PRINTPROCDATATYPE_1 *info)
{
int size=0;
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_printmonitor_info_1(PRINTMONITOR_1 *info)
{
int size=0;
/*******************************************************************
return the size required by a struct in the stream
********************************************************************/
+
uint32 spoolss_size_printmonitor_info_2(PRINTMONITOR_2 *info)
{
int size=0;
return size;
}
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
+
+BOOL make_spoolss_q_getprinterdriver2(SPOOL_Q_GETPRINTERDRIVER2 *q_u,
+ const POLICY_HND *hnd,
+ const fstring architecture,
+ uint32 level, uint32 clientmajor, uint32 clientminor,
+ NEW_BUFFER *buffer, uint32 offered)
+{
+ if (q_u == NULL)
+ return False;
+
+ memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
+
+ init_buf_unistr2(&q_u->architecture, &q_u->architecture_ptr, architecture);
+
+ q_u->level=level;
+ q_u->clientmajorversion=clientmajor;
+ q_u->clientminorversion=clientminor;
+
+ q_u->buffer=buffer;
+ q_u->offered=offered;
+
+ return True;
+}
+
/*******************************************************************
* read a structure.
* called from spoolss_getprinterdriver2 (srv_spoolss.c)
********************************************************************/
+
BOOL spoolss_io_q_getprinterdriver2(char *desc, SPOOL_Q_GETPRINTERDRIVER2 *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriver2");
if(!prs_align(ps))
return False;
- if(!prs_uint32("level", ps, depth, &q_u->level))
+ if(!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if(!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
return False;
if(!prs_align(ps))
* 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)
{
prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriver2");
if (!prs_align(ps))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
return False;
if (!prs_align(ps))
/*******************************************************************
* init a structure.
********************************************************************/
-BOOL make_spoolss_q_enumprinters(SPOOL_Q_ENUMPRINTERS *q_u, uint32 flags,
- fstring servername, uint32 level,
- NEW_BUFFER *buffer, uint32 offered)
+
+BOOL make_spoolss_q_enumprinters(
+ SPOOL_Q_ENUMPRINTERS *q_u,
+ uint32 flags,
+ fstring servername,
+ uint32 level,
+ NEW_BUFFER *buffer,
+ uint32 offered
+)
{
q_u->flags=flags;
q_u->servername_ptr = (servername != NULL) ? 1 : 0;
- init_unistr2(&(q_u->servername), servername, strlen(servername));
+ init_buf_unistr2(&q_u->servername, &q_u->servername_ptr, servername);
+
+ q_u->level=level;
+ q_u->buffer=buffer;
+ q_u->offered=offered;
+
+ return True;
+}
+
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
+
+BOOL make_spoolss_q_enumports(SPOOL_Q_ENUMPORTS *q_u,
+ fstring servername, uint32 level,
+ NEW_BUFFER *buffer, uint32 offered)
+{
+ q_u->name_ptr = (servername != NULL) ? 1 : 0;
+ init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
q_u->level=level;
q_u->buffer=buffer;
* 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)
{
prs_debug(ps, depth, desc, "spoolss_io_q_enumprinters");
if (!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
return False;
if (!prs_align(ps))
/*******************************************************************
Parse a SPOOL_R_ENUMPRINTERS structure.
********************************************************************/
-BOOL new_spoolss_io_r_enumprinters(char *desc, SPOOL_R_ENUMPRINTERS *r_u, prs_struct *ps, int depth)
+
+BOOL 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");
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumprinters");
depth++;
if (!prs_align(ps))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
return False;
if (!prs_align(ps))
* 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)
{
prs_debug(ps, depth, desc, "spoolss_io_r_getprinter");
if (!prs_align(ps))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ if (!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;
* 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)
{
prs_debug(ps, depth, desc, "spoolss_io_q_getprinter");
if (!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
return False;
if (!prs_align(ps))
return True;
}
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
+
+BOOL make_spoolss_q_getprinter(
+ TALLOC_CTX *mem_ctx,
+ SPOOL_Q_GETPRINTER *q_u,
+ const POLICY_HND *hnd,
+ uint32 level,
+ NEW_BUFFER *buffer,
+ uint32 offered
+)
+{
+ if (q_u == NULL)
+ {
+ return False;
+ }
+ memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
+
+ q_u->level=level;
+ q_u->buffer=buffer;
+ q_u->offered=offered;
+
+ return True;
+}
+
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
+BOOL make_spoolss_q_setprinter(
+ TALLOC_CTX *mem_ctx,
+ SPOOL_Q_SETPRINTER *q_u,
+ const POLICY_HND *hnd,
+ uint32 level,
+ PRINTER_INFO_CTR *info,
+ uint32 command
+)
+{
+ SEC_DESC *secdesc;
+ DEVICEMODE *devmode;
+
+ if (q_u == NULL)
+ {
+ return False;
+ }
+
+ memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
+
+ q_u->level = level;
+ q_u->info.level = level;
+ q_u->info.info_ptr = (info != NULL) ? 1 : 0;
+ switch (level)
+ {
+ case 2:
+ secdesc = info->printers_2->secdesc;
+ devmode = info->printers_2->devmode;
+
+ /* FIXMEE!! HACK ALERT!!! --jerry */
+ info->printers_2->devmode = NULL;
+ info->printers_2->secdesc = NULL;
+
+ make_spoolss_printer_info_2 (mem_ctx, &q_u->info.info_2, info->printers_2);
+#if 0 /* JERRY TEST */
+ q_u->secdesc_ctr = (SEC_DESC_BUF*)malloc(sizeof(SEC_DESC_BUF));
+ if (!q_u->secdesc_ctr)
+ return False;
+ q_u->secdesc_ctr->ptr = (secdesc != NULL) ? 1: 0;
+ q_u->secdesc_ctr->max_len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
+ q_u->secdesc_ctr->len = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
+ q_u->secdesc_ctr->sec = secdesc;
+
+ q_u->devmode_ctr.devmode_ptr = (devmode != NULL) ? 1 : 0;
+ q_u->devmode_ctr.size = sizeof(DEVICEMODE) + (3*sizeof(uint32));
+ q_u->devmode_ctr.devmode = devmode;
+#else
+ q_u->secdesc_ctr = NULL;
+
+ q_u->devmode_ctr.devmode_ptr = 0;
+ q_u->devmode_ctr.size = 0;
+ q_u->devmode_ctr.devmode = NULL;
+#endif
+ break;
+ default:
+ DEBUG(0,("make_spoolss_q_setprinter: Unknown info level [%d]\n", level));
+ break;
+ }
+
+
+ q_u->command = command;
+
+ return True;
+}
+
+
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_r_setprinter(char *desc, SPOOL_R_SETPRINTER *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_setprinter");
if(!prs_align(ps))
return False;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+ if(!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
}
/*******************************************************************
+ Marshall/unmarshall a SPOOL_Q_SETPRINTER struct.
********************************************************************/
+
BOOL spoolss_io_q_setprinter(char *desc, SPOOL_Q_SETPRINTER *q_u, prs_struct *ps, int depth)
{
+ uint32 ptr_sec_desc = 0;
+
prs_debug(ps, depth, desc, "spoolss_io_q_setprinter");
depth++;
if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
return False;
- if(!prs_uint32("security.size_of_buffer", ps, depth, &q_u->security.size_of_buffer))
- return False;
- if(!prs_uint32("security.data", ps, depth, &q_u->security.data))
- return False;
+ switch (q_u->level)
+ {
+ case 2:
+ {
+ ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
+ break;
+ }
+ case 3:
+ {
+ ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
+ break;
+ }
+ }
+ if (ptr_sec_desc)
+ {
+ if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
+ return False;
+ } else {
+ uint32 dummy;
+
+ /* Parse a NULL security descriptor. This should really
+ happen inside the sec_io_desc_buf() function. */
+
+ prs_debug(ps, depth, "", "sec_io_desc_buf");
+ if (!prs_uint32("size", ps, depth + 1, &dummy)) return False;
+ if (!prs_uint32("ptr", ps, depth + 1, &dummy)) return
+ False;
+ }
if(!prs_uint32("command", ps, depth, &q_u->command))
return False;
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_r_fcpn(char *desc, SPOOL_R_FCPN *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_fcpn");
if(!prs_align(ps))
return False;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+ if(!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_q_fcpn(char *desc, SPOOL_Q_FCPN *q_u, prs_struct *ps, int depth)
{
if(!prs_align(ps))
return False;
- if(!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;
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_r_addjob(char *desc, SPOOL_R_ADDJOB *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "");
if(!prs_align(ps))
return False;
+ if(!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("status", ps, depth, &r_u->status))
return False;
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_q_addjob(char *desc, SPOOL_Q_ADDJOB *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "");
if(!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if(!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
return False;
if(!prs_align(ps))
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_r_enumjobs(char *desc, SPOOL_R_ENUMJOBS *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_enumjobs");
if (!prs_align(ps))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
return False;
if (!prs_align(ps))
return True;
}
-
/*******************************************************************
********************************************************************/
+
BOOL make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS *q_u, const POLICY_HND *hnd,
uint32 firstjob,
uint32 numofjobs,
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_q_enumjobs(char *desc, SPOOL_Q_ENUMJOBS *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs");
if (!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
return False;
if (!prs_uint32("offered", ps, depth, &q_u->offered))
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_r_schedulejob(char *desc, SPOOL_R_SCHEDULEJOB *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_schedulejob");
if(!prs_align(ps))
return False;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+ if(!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_q_schedulejob(char *desc, SPOOL_Q_SCHEDULEJOB *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_schedulejob");
if(!prs_align(ps))
return False;
- if(!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;
- if(!prs_uint32("jobid", ps, depth, &(q_u->jobid)))
+ if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
return False;
return True;
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_r_setjob(char *desc, SPOOL_R_SETJOB *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_setjob");
if(!prs_align(ps))
return False;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+ if(!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_q_setjob(char *desc, SPOOL_Q_SETJOB *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_setjob");
if(!prs_align(ps))
return False;
- if(!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;
- if(!prs_uint32("jobid", ps, depth, &(q_u->jobid)))
+ if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
return False;
/*
* level is usually 0. If (level!=0) then I'm in trouble !
* I will try to generate setjob command with level!=0, one day.
*/
- if(!prs_uint32("level", ps, depth, &(q_u->level)))
+ if(!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if(!prs_uint32("command", ps, depth, &(q_u->command)))
+ if(!prs_uint32("command", ps, depth, &q_u->command))
return False;
return True;
/*******************************************************************
Parse a SPOOL_R_ENUMPRINTERDRIVERS structure.
********************************************************************/
-BOOL new_spoolss_io_r_enumprinterdrivers(char *desc, SPOOL_R_ENUMPRINTERDRIVERS *r_u, prs_struct *ps, int depth)
+
+BOOL 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");
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdrivers");
depth++;
if (!prs_align(ps))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
return False;
if (!prs_align(ps))
return True;
}
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
+
+BOOL make_spoolss_q_enumprinterdrivers(SPOOL_Q_ENUMPRINTERDRIVERS *q_u,
+ const char *name,
+ const char *environment,
+ uint32 level,
+ NEW_BUFFER *buffer, uint32 offered)
+{
+ init_buf_unistr2(&q_u->name, &q_u->name_ptr, name);
+ init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, environment);
+
+ q_u->level=level;
+ q_u->buffer=buffer;
+ q_u->offered=offered;
+
+ return True;
+}
/*******************************************************************
Parse a SPOOL_Q_ENUMPRINTERDRIVERS structure.
********************************************************************/
+
BOOL spoolss_io_q_enumprinterdrivers(char *desc, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, prs_struct *ps, int depth)
{
if (!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
return False;
if (!prs_align(ps))
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_q_enumforms(char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth)
{
if (!prs_align(ps))
return False;
- if (!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;
- if (!prs_uint32("level", ps, depth, &(q_u->level)))
+ if (!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ if (!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)))
+ if (!prs_uint32("offered", ps, depth, &q_u->offered))
return False;
return True;
/*******************************************************************
********************************************************************/
-BOOL new_spoolss_io_r_enumforms(char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth)
+
+BOOL spoolss_io_r_enumforms(char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth)
{
- prs_debug(ps, depth, desc, "new_spoolss_io_r_enumforms");
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumforms");
depth++;
if (!prs_align(ps))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ if (!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)))
+ if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
return False;
- if (!prs_uint32("numofforms", ps, depth, &(r_u->numofforms)))
+ if (!prs_uint32("numofforms", ps, depth, &r_u->numofforms))
return False;
- if (!prs_uint32("status", ps, depth, &(r_u->status)))
+ if (!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
-
}
/*******************************************************************
- Parse a SPOOL_R_ENUMPORTS structure.
********************************************************************/
-BOOL new_spoolss_io_r_enumports(char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
+
+BOOL spoolss_io_q_getform(char *desc, SPOOL_Q_GETFORM *q_u, prs_struct *ps, int depth)
{
- prs_debug(ps, depth, desc, "new_spoolss_io_r_enumports");
+
+ prs_debug(ps, depth, desc, "spoolss_io_q_getform");
depth++;
if (!prs_align(ps))
- return False;
-
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ return False;
+ if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
+ return False;
+ if (!smb_io_unistr2("", &q_u->formname,True,ps,depth))
return False;
if (!prs_align(ps))
return False;
-
- if (!prs_uint32("needed", ps, depth, &r_u->needed))
+
+ if (!prs_uint32("level", ps, depth, &q_u->level))
+ return False;
+
+ if (!spoolss_io_buffer("", ps, depth, &q_u->buffer))
return False;
-
- if (!prs_uint32("returned", ps, depth, &r_u->returned))
+
+ if (!prs_align(ps))
return False;
-
- if (!prs_uint32("status", ps, depth, &r_u->status))
+ if (!prs_uint32("offered", ps, depth, &q_u->offered))
return False;
- return True;
+ return True;
}
/*******************************************************************
********************************************************************/
-BOOL spoolss_io_q_enumports(char *desc, SPOOL_Q_ENUMPORTS *q_u, prs_struct *ps, int depth)
+
+BOOL spoolss_io_r_getform(char *desc, SPOOL_R_GETFORM *r_u, prs_struct *ps, int depth)
{
- prs_debug(ps, depth, desc, "");
+ prs_debug(ps, depth, desc, "spoolss_io_r_getform");
depth++;
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))
+
+ if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
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))
+ if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
return False;
-
- if (!prs_align(ps))
- return False;
- if (!prs_uint32("offered", ps, depth, &q_u->offered))
+
+ if (!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
}
/*******************************************************************
- Parse a SPOOL_PRINTER_INFO_LEVEL_1 structure.
+ Parse a SPOOL_R_ENUMPORTS structure.
********************************************************************/
-BOOL spool_io_printer_info_level_1(char *desc, SPOOL_PRINTER_INFO_LEVEL_1 *il, prs_struct *ps, int depth)
-{
- prs_debug(ps, depth, desc, "spool_io_printer_info_level_1");
- depth++;
+
+BOOL spoolss_io_r_enumports(char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_enumports");
+ depth++;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!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_q_enumports(char *desc, SPOOL_Q_ENUMPORTS *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "");
+ depth++;
+
+ 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 (!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_1 structure.
+********************************************************************/
+
+BOOL spool_io_printer_info_level_1(char *desc, SPOOL_PRINTER_INFO_LEVEL_1 *il, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spool_io_printer_info_level_1");
+ depth++;
if(!prs_align(ps))
return False;
return True;
}
+/*******************************************************************
+ Parse a SPOOL_PRINTER_INFO_LEVEL_3 structure.
+********************************************************************/
+
+BOOL spool_io_printer_info_level_3(char *desc, SPOOL_PRINTER_INFO_LEVEL_3 *il, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spool_io_printer_info_level_3");
+ depth++;
+
+ if(!prs_align(ps))
+ return False;
+
+ if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
+ 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 *il, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spool_io_printer_info_level_2");
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))
/*******************************************************************
********************************************************************/
+
BOOL spool_io_printer_info_level(char *desc, SPOOL_PRINTER_INFO_LEVEL *il, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spool_io_printer_info_level");
*/
case 0:
break;
- /*
- * level 2 is used by addprinter
- * and by setprinter when updating printer's info
- */
+ /* DOCUMENT ME!!! What is level 1 used for? */
case 1:
+ {
if (UNMARSHALLING(ps)) {
- il->info_1=(SPOOL_PRINTER_INFO_LEVEL_1 *)malloc(sizeof(SPOOL_PRINTER_INFO_LEVEL_1));
- if(il->info_1 == NULL)
+ if ((il->info_1=(SPOOL_PRINTER_INFO_LEVEL_1 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_INFO_LEVEL_1))) == NULL)
return False;
}
if (!spool_io_printer_info_level_1("", il->info_1, ps, depth))
return False;
break;
+ }
+ /*
+ * level 2 is used by addprinter
+ * and by setprinter when updating printer's info
+ */
case 2:
if (UNMARSHALLING(ps)) {
- il->info_2=(SPOOL_PRINTER_INFO_LEVEL_2 *)malloc(sizeof(SPOOL_PRINTER_INFO_LEVEL_2));
- if(il->info_2 == NULL)
+ if ((il->info_2=(SPOOL_PRINTER_INFO_LEVEL_2 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_INFO_LEVEL_2))) == NULL)
return False;
}
if (!spool_io_printer_info_level_2("", il->info_2, ps, depth))
return False;
break;
+ /* DOCUMENT ME!!! What is level 3 used for? */
+ case 3:
+ {
+ if (UNMARSHALLING(ps)) {
+ if ((il->info_3=(SPOOL_PRINTER_INFO_LEVEL_3 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_INFO_LEVEL_3))) == NULL)
+ return False;
+ }
+ if (!spool_io_printer_info_level_3("", il->info_3, ps, depth))
+ return False;
+ break;
+ }
}
return True;
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_q_addprinterex(char *desc, SPOOL_Q_ADDPRINTEREX *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_addprinterex");
depth++;
- /*
- * I think that's one of the few well written functions.
- * the sub-structures are correctly parsed and analysed
- * the info level are handled in a nice way.
- */
-
if(!prs_align(ps))
return False;
if(!prs_uint32("", ps, depth, &q_u->server_name_ptr))
if(!prs_uint32("info_level", ps, depth, &q_u->level))
return False;
- if(!spool_io_printer_info_level("", &(q_u->info), ps, depth))
+ if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
return False;
/* the 4 unknown are all 0 */
* et le security descriptor.
*/
+ if(!prs_align(ps))
+ return False;
if(!prs_uint32("unk0", ps, depth, &q_u->unk0))
return False;
if(!prs_uint32("unk1", ps, depth, &q_u->unk1))
return True;
}
-
/*******************************************************************
********************************************************************/
-BOOL spoolss_io_r_addprinterex(char *desc, SPOOL_R_ADDPRINTEREX *r_u, prs_struct *ps, int depth)
+
+BOOL spoolss_io_r_addprinterex(char *desc, SPOOL_R_ADDPRINTEREX *r_u,
+ prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_addprinterex");
depth++;
- if(!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
+ if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
return False;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+ if(!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
/*******************************************************************
********************************************************************/
+
BOOL spool_io_printer_driver_info_level_3(char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **q_u,
prs_struct *ps, int depth)
{
/* reading */
if (UNMARSHALLING(ps)) {
- il=(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *)malloc(sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3));
+ il=(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3));
if(il == NULL)
return False;
- ZERO_STRUCTP(il);
*q_u=il;
}
else {
return False;
if (il->dependentfiles_ptr)
- smb_io_buffer5("", &(il->dependentfiles), ps, depth);
+ smb_io_buffer5("", &il->dependentfiles, ps, depth);
return True;
}
+/*******************************************************************
+parse a SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 structure
+********************************************************************/
+
+BOOL spool_io_printer_driver_info_level_6(char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 **q_u,
+ prs_struct *ps, int depth)
+{
+ SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *il;
+
+ prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_6");
+ depth++;
+
+ /* reading */
+ if (UNMARSHALLING(ps)) {
+ il=(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *)prs_alloc_mem(ps,sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6));
+ if(il == NULL)
+ return False;
+ *q_u=il;
+ }
+ else {
+ il=*q_u;
+ }
+
+ if(!prs_align(ps))
+ return False;
+
+
+ /* parse the main elements the packet */
+
+ if(!prs_uint32("version", ps, depth, &il->version))
+ return False;
+
+ if(!prs_uint32("name_ptr", ps, depth, &il->name_ptr))
+ return False;
+ /*
+ * If name_ptr is NULL then the next 4 bytes are the name_ptr. A driver
+ * with a NULL name just isn't a driver For example: "HP LaserJet 4si"
+ * from W2K CDROM (which uses unidriver). JohnR 010205
+ */
+ if (!il->name_ptr) {
+ DEBUG(5,("spool_io_printer_driver_info_level_6: name_ptr is NULL! Get next value\n"));
+ if(!prs_uint32("name_ptr", ps, depth, &il->name_ptr))
+ return False;
+ }
+
+ if(!prs_uint32("environment_ptr", ps, depth, &il->environment_ptr))
+ return False;
+ if(!prs_uint32("driverpath_ptr", ps, depth, &il->driverpath_ptr))
+ return False;
+ if(!prs_uint32("datafile_ptr", ps, depth, &il->datafile_ptr))
+ return False;
+ if(!prs_uint32("configfile_ptr", ps, depth, &il->configfile_ptr))
+ return False;
+ if(!prs_uint32("helpfile_ptr", ps, depth, &il->helpfile_ptr))
+ return False;
+ if(!prs_uint32("monitorname_ptr", ps, depth, &il->monitorname_ptr))
+ return False;
+ if(!prs_uint32("defaultdatatype_ptr", ps, depth, &il->defaultdatatype_ptr))
+ return False;
+ if(!prs_uint32("dependentfiles_len", ps, depth, &il->dependentfiles_len))
+ return False;
+ if(!prs_uint32("dependentfiles_ptr", ps, depth, &il->dependentfiles_ptr))
+ return False;
+ if(!prs_uint32("previousnames_len", ps, depth, &il->previousnames_len))
+ return False;
+ if(!prs_uint32("previousnames_ptr", ps, depth, &il->previousnames_ptr))
+ return False;
+ if(!smb_io_time("driverdate", &il->driverdate, ps, depth))
+ return False;
+ if(!prs_uint32("dummy4", ps, depth, &il->dummy4))
+ return False;
+ if(!prs_uint64("driverversion", ps, depth, &il->driverversion))
+ return False;
+ if(!prs_uint32("mfgname_ptr", ps, depth, &il->mfgname_ptr))
+ return False;
+ if(!prs_uint32("oemurl_ptr", ps, depth, &il->oemurl_ptr))
+ return False;
+ if(!prs_uint32("hardwareid_ptr", ps, depth, &il->hardwareid_ptr))
+ return False;
+ if(!prs_uint32("provider_ptr", ps, depth, &il->provider_ptr))
+ return False;
+
+ /* parse the structures in the packet */
+
+ if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ 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) {
+ if(!smb_io_buffer5("dependentfiles", &il->dependentfiles, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+ }
+ if (il->previousnames_ptr) {
+ if(!smb_io_buffer5("previousnames", &il->previousnames, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+ }
+ if(!smb_io_unistr2("mfgname", &il->mfgname, il->mfgname_ptr, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+ if(!smb_io_unistr2("oemurl", &il->oemurl, il->oemurl_ptr, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+ if(!smb_io_unistr2("hardwareid", &il->hardwareid, il->hardwareid_ptr, ps, depth))
+ return False;
+ if(!prs_align(ps))
+ return False;
+ if(!smb_io_unistr2("provider", &il->provider, il->provider_ptr, ps, depth))
+ return False;
+
+ return True;
+}
/*******************************************************************
convert a buffer of UNICODE strings null terminated
the buffer is terminated by a NULL
- convert to an ascii array (null terminated)
+ convert to an dos codepage array (null terminated)
dynamically allocate memory
********************************************************************/
-BOOL uniarray_2_ascarray(BUFFER5 *buf5, char ***ar)
+static BOOL uniarray_2_dosarray(BUFFER5 *buf5, fstring **ar)
{
- char **array;
- char *string;
- char *destend;
- char *dest;
- uint32 n;
- uint32 i;
-
- uint16 *src;
+ fstring f, *tar;
+ int n = 0;
+ char *src;
if (buf5==NULL) return False;
- array=NULL;
- n=0;
- i=0;
- src=buf5->buffer;
-
- string=(char *)malloc(sizeof(char)*buf5->buf_len);
- if(string == NULL)
- return False;
-
- destend = string + buf5->buf_len;
- dest=string;
+ src = (char *)buf5->buffer;
+ *ar = NULL;
- while (dest < destend)
- {
- *(dest++) = (char)*(src++);
- }
-
- /* that ugly for the first one but that's working */
- array=(char **)Realloc(array, sizeof(char *)*(i+1));
- if(array == NULL)
- return False;
- array[i++]=string;
-
- while ( n < buf5->buf_len )
- {
- if ( *(string++) == '\0' )
- {
- array=(char **)Realloc(array, sizeof(char *)*(i+1));
- if(array == NULL)
- return False;
- array[i++]=string;
- }
+ while (src < ((char *)buf5->buffer) + buf5->buf_len*2) {
+ rpcstr_pull(f, src, sizeof(f)-1, -1, 0);
+ src = skip_unibuf(src, 2*buf5->buf_len - PTR_DIFF(src,buf5->buffer));
+ tar = (fstring *)Realloc(*ar, sizeof(fstring)*(n+2));
+ if (!tar) return False;
+ else *ar = tar;
+ fstrcpy((*ar)[n], f);
n++;
- }
- *ar=array;
-
- DEBUG(10,("Number of dependent files: [%d]\n", i-1));
+ }
+ fstrcpy((*ar)[n], "");
return True;
}
and null terminated array
and size of array at beginning
********************************************************************/
+
BOOL smb_io_unibuffer(char *desc, UNISTR2 *buffer, prs_struct *ps, int depth)
{
if (buffer==NULL) return False;
buffer->undoc=0;
buffer->uni_str_len=buffer->uni_max_len;
- if(!prs_uint32("buffer_size", ps, depth, &(buffer->uni_max_len)))
+ if(!prs_uint32("buffer_size", ps, depth, &buffer->uni_max_len))
return False;
if(!prs_unistr2(True, "buffer ", ps, depth, buffer))
/*******************************************************************
********************************************************************/
+
BOOL spool_io_printer_driver_info_level(char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL *il, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level");
switch (il->level) {
case 3:
- if(!spool_io_printer_driver_info_level_3("", &(il->info_3), ps, depth))
+ if(!spool_io_printer_driver_info_level_3("", &il->info_3, ps, depth))
return False;
break;
+ case 6:
+ if(!spool_io_printer_driver_info_level_6("", &il->info_6, ps, depth))
+ return False;
+ break;
+ default:
+ return False;
}
return True;
}
/*******************************************************************
-********************************************************************/
+ init a SPOOL_Q_ADDPRINTERDRIVER struct
+ ******************************************************************/
+
+BOOL make_spoolss_q_addprinterdriver(
+ TALLOC_CTX *mem_ctx,
+ SPOOL_Q_ADDPRINTERDRIVER *q_u,
+ const char* srv_name,
+ uint32 level,
+ PRINTER_DRIVER_CTR *info)
+{
+ DEBUG(5,("make_spoolss_q_addprinterdriver\n"));
+
+ q_u->server_name_ptr = (srv_name!=NULL)?1:0;
+ init_unistr2(&q_u->server_name, srv_name, strlen(srv_name)+1);
+
+ q_u->level = level;
+
+ q_u->info.level = level;
+ q_u->info.ptr = (info!=NULL)?1:0;
+ switch (level)
+ {
+ /* info level 3 is supported by Windows 95/98, WinNT and Win2k */
+ case 3 :
+ make_spoolss_driver_info_3(mem_ctx, &q_u->info.info_3, info->info3);
+ break;
+
+ /* info level 6 is supported by WinME and Win2k */
+ case 6:
+ /* WRITEME!! will add later --jerry */
+ break;
+
+ default:
+ DEBUG(0,("make_spoolss_q_addprinterdriver: Unknown info level [%d]\n", level));
+ break;
+ }
+
+ return True;
+}
+
+BOOL make_spoolss_driver_info_3(
+ TALLOC_CTX *mem_ctx,
+ SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **spool_drv_info,
+ DRIVER_INFO_3 *info3
+)
+{
+ uint32 len = 0;
+ uint16 *ptr = info3->dependentfiles;
+ BOOL done = False;
+ BOOL null_char = False;
+ SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *inf;
+
+ if (!(inf=(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3*)talloc_zero(mem_ctx, sizeof(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3))))
+ return False;
+
+ inf->cversion = info3->version;
+ inf->name_ptr = (info3->name.buffer!=NULL)?1:0;
+ inf->environment_ptr = (info3->architecture.buffer!=NULL)?1:0;
+ inf->driverpath_ptr = (info3->driverpath.buffer!=NULL)?1:0;
+ inf->datafile_ptr = (info3->datafile.buffer!=NULL)?1:0;
+ inf->configfile_ptr = (info3->configfile.buffer!=NULL)?1:0;
+ inf->helpfile_ptr = (info3->helpfile.buffer!=NULL)?1:0;
+ inf->monitorname_ptr = (info3->monitorname.buffer!=NULL)?1:0;
+ inf->defaultdatatype_ptr = (info3->defaultdatatype.buffer!=NULL)?1:0;
+
+ init_unistr2_from_unistr(&inf->name, &info3->name);
+ init_unistr2_from_unistr(&inf->environment, &info3->architecture);
+ init_unistr2_from_unistr(&inf->driverpath, &info3->driverpath);
+ init_unistr2_from_unistr(&inf->datafile, &info3->datafile);
+ init_unistr2_from_unistr(&inf->configfile, &info3->configfile);
+ init_unistr2_from_unistr(&inf->helpfile, &info3->helpfile);
+ init_unistr2_from_unistr(&inf->monitorname, &info3->monitorname);
+ init_unistr2_from_unistr(&inf->defaultdatatype, &info3->defaultdatatype);
+
+ while (!done)
+ {
+ switch (*ptr)
+ {
+ case 0:
+ /* the null_char BOOL is used to help locate
+ two '\0's back to back */
+ if (null_char)
+ done = True;
+ else
+ null_char = True;
+ break;
+
+ default:
+ null_char = False;
+ ;;
+ break;
+ }
+ len++;
+ ptr++;
+ }
+ inf->dependentfiles_ptr = (info3->dependentfiles != NULL) ? 1 : 0;
+ inf->dependentfilessize = len;
+ if(!make_spoolss_buffer5(mem_ctx, &inf->dependentfiles, len, info3->dependentfiles))
+ {
+ safe_free (inf);
+ return False;
+ }
+
+ *spool_drv_info = inf;
+
+ return True;
+}
+
+/*******************************************************************
+ make a BUFFER5 struct from a uint16*
+ ******************************************************************/
+
+BOOL make_spoolss_buffer5(
+ TALLOC_CTX *mem_ctx,
+ BUFFER5 *buf5,
+ uint32 len,
+ uint16 *src
+)
+{
+
+ buf5->buf_len = len;
+ if((buf5->buffer=(uint16*)talloc_memdup(mem_ctx, src, sizeof(uint16)*len)) == NULL)
+ {
+ DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
+ return False;
+ }
+
+ return True;
+}
+
+/*******************************************************************
+ fill in the prs_struct for a ADDPRINTERDRIVER request PDU
+ ********************************************************************/
+
BOOL spoolss_io_q_addprinterdriver(char *desc, SPOOL_Q_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriver");
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_r_addprinterdriver(char *desc, SPOOL_R_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriver");
return True;
}
-
/*******************************************************************
********************************************************************/
+
BOOL uni_2_asc_printer_driver_3(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *uni,
NT_PRINTER_DRIVER_INFO_LEVEL_3 **asc)
{
d->cversion=uni->cversion;
- unistr2_to_ascii(d->name, &(uni->name), sizeof(d->name)-1);
- unistr2_to_ascii(d->environment, &(uni->environment), sizeof(d->environment)-1);
- unistr2_to_ascii(d->driverpath, &(uni->driverpath), sizeof(d->driverpath)-1);
- unistr2_to_ascii(d->datafile, &(uni->datafile), sizeof(d->datafile)-1);
- unistr2_to_ascii(d->configfile, &(uni->configfile), sizeof(d->configfile)-1);
- unistr2_to_ascii(d->helpfile, &(uni->helpfile), sizeof(d->helpfile)-1);
- unistr2_to_ascii(d->monitorname, &(uni->monitorname), sizeof(d->monitorname)-1);
- unistr2_to_ascii(d->defaultdatatype, &(uni->defaultdatatype), sizeof(d->defaultdatatype)-1);
+ unistr2_to_ascii(d->name, &uni->name, sizeof(d->name)-1);
+ unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment)-1);
+ unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath)-1);
+ unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile)-1);
+ unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile)-1);
+ unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile)-1);
+ unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname)-1);
+ unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype)-1);
DEBUGADD(8,( "version: %d\n", d->cversion));
DEBUGADD(8,( "name: %s\n", d->name));
DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
- uniarray_2_ascarray(&(uni->dependentfiles), &(d->dependentfiles) );
+ if (uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
+ return True;
+
+ free(*asc);
+ return False;
+}
+
+/*******************************************************************
+********************************************************************/
+BOOL uni_2_asc_printer_driver_6(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *uni,
+ NT_PRINTER_DRIVER_INFO_LEVEL_6 **asc)
+{
+ NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
+
+ DEBUG(7,("uni_2_asc_printer_driver_6: Converting from UNICODE to ASCII\n"));
+
+ if (*asc==NULL)
+ {
+ *asc=(NT_PRINTER_DRIVER_INFO_LEVEL_6 *)malloc(sizeof(NT_PRINTER_DRIVER_INFO_LEVEL_6));
+ if(*asc == NULL)
+ return False;
+ ZERO_STRUCTP(*asc);
+ }
+ d=*asc;
+
+ d->version=uni->version;
+
+ unistr2_to_ascii(d->name, &uni->name, sizeof(d->name)-1);
+ unistr2_to_ascii(d->environment, &uni->environment, sizeof(d->environment)-1);
+ unistr2_to_ascii(d->driverpath, &uni->driverpath, sizeof(d->driverpath)-1);
+ unistr2_to_ascii(d->datafile, &uni->datafile, sizeof(d->datafile)-1);
+ unistr2_to_ascii(d->configfile, &uni->configfile, sizeof(d->configfile)-1);
+ unistr2_to_ascii(d->helpfile, &uni->helpfile, sizeof(d->helpfile)-1);
+ unistr2_to_ascii(d->monitorname, &uni->monitorname, sizeof(d->monitorname)-1);
+ unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype)-1);
+
+ DEBUGADD(8,( "version: %d\n", d->version));
+ DEBUGADD(8,( "name: %s\n", d->name));
+ DEBUGADD(8,( "environment: %s\n", d->environment));
+ DEBUGADD(8,( "driverpath: %s\n", d->driverpath));
+ DEBUGADD(8,( "datafile: %s\n", d->datafile));
+ DEBUGADD(8,( "configfile: %s\n", d->configfile));
+ DEBUGADD(8,( "helpfile: %s\n", d->helpfile));
+ DEBUGADD(8,( "monitorname: %s\n", d->monitorname));
+ DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
+
+ if (!uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
+ goto error;
+ if (!uniarray_2_dosarray(&uni->previousnames, &d->previousnames ))
+ goto error;
+
return True;
+
+error:
+ free(*asc);
+ return False;
}
BOOL uni_2_asc_printer_info_2(const SPOOL_PRINTER_INFO_LEVEL_2 *uni,
NT_PRINTER_INFO_LEVEL_2 **asc)
{
NT_PRINTER_INFO_LEVEL_2 *d;
- NTTIME time_nt;
time_t time_unix;
DEBUG(7,("Converting from UNICODE to ASCII\n"));
time_unix=time(NULL);
- if (*asc==NULL)
- {
+ if (*asc==NULL) {
DEBUGADD(8,("allocating memory\n"));
*asc=(NT_PRINTER_INFO_LEVEL_2 *)malloc(sizeof(NT_PRINTER_INFO_LEVEL_2));
d->untiltime=uni->untiltime;
d->status=uni->status;
d->cjobs=uni->cjobs;
-
- unix_to_nt_time(&time_nt, time_unix);
- d->changeid=time_nt.low;
- d->c_setprinter++;
-
unistr2_to_ascii(d->servername, &uni->servername, sizeof(d->servername)-1);
unistr2_to_ascii(d->printername, &uni->printername, sizeof(d->printername)-1);
unistr2_to_ascii(d->sharename, &uni->sharename, sizeof(d->sharename)-1);
unistr2_to_ascii(d->portname, &uni->portname, sizeof(d->portname)-1);
unistr2_to_ascii(d->drivername, &uni->drivername, sizeof(d->drivername)-1);
+ unistr2_to_ascii(d->comment, &uni->comment, sizeof(d->comment)-1);
unistr2_to_ascii(d->location, &uni->location, sizeof(d->location)-1);
unistr2_to_ascii(d->sepfile, &uni->sepfile, sizeof(d->sepfile)-1);
unistr2_to_ascii(d->printprocessor, &uni->printprocessor, sizeof(d->printprocessor)-1);
return True;
}
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
+
+BOOL make_spoolss_q_getprinterdriverdir(SPOOL_Q_GETPRINTERDRIVERDIR *q_u,
+ fstring servername, fstring env_name, uint32 level,
+ NEW_BUFFER *buffer, uint32 offered)
+{
+ init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
+ init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, env_name);
+
+ q_u->level=level;
+ q_u->buffer=buffer;
+ q_u->offered=offered;
+
+ return True;
+}
+
/*******************************************************************
Parse a SPOOL_Q_GETPRINTERDRIVERDIR structure.
********************************************************************/
+
BOOL spoolss_io_q_getprinterdriverdir(char *desc, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriverdir");
if(!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if(!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
return False;
if(!prs_align(ps))
/*******************************************************************
Parse a SPOOL_R_GETPRINTERDRIVERDIR structure.
********************************************************************/
+
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");
if (!prs_align(ps))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
return False;
if (!prs_align(ps))
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_r_enumprintprocessors(char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
if (!prs_align(ps))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
return False;
if (!prs_align(ps))
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_q_enumprintprocessors(char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
if (!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if(!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
+ return False;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("offered", ps, depth, &q_u->offered))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+
+BOOL spoolss_io_q_addprintprocessor(char *desc, SPOOL_Q_ADDPRINTPROCESSOR *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_q_addprintprocessor");
+ depth++;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
+ return False;
+ if (!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
+ return False;
+
+ if (!prs_align(ps))
+ return False;
+ if (!smb_io_unistr2("environment", &q_u->environment, True, ps, depth))
+ return False;
+
+ if (!prs_align(ps))
+ return False;
+ if (!smb_io_unistr2("path", &q_u->path, True, ps, depth))
+ return False;
+
+ if (!prs_align(ps))
+ return False;
+ if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
return False;
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+
+BOOL spoolss_io_r_addprintprocessor(char *desc, SPOOL_R_ADDPRINTPROCESSOR *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_addprintproicessor");
+ depth++;
+
if (!prs_align(ps))
return False;
-
- if (!prs_uint32("offered", ps, depth, &q_u->offered))
+
+ if (!prs_uint32("status", ps, depth, &r_u->status))
return False;
- return True;
+ return True;
}
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_r_enumprintprocdatatypes(char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes");
if (!prs_align(ps))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
return False;
if (!prs_align(ps))
/*******************************************************************
********************************************************************/
+
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");
if (!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if(!new_spoolss_io_buffer("buffer", ps, depth, q_u->buffer))
+ if(!spoolss_io_buffer("buffer", ps, depth, &q_u->buffer))
return False;
if (!prs_align(ps))
/*******************************************************************
Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
********************************************************************/
+
BOOL spoolss_io_q_enumprintmonitors(char *desc, SPOOL_Q_ENUMPRINTMONITORS *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_enumprintmonitors");
if (!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if(!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
return False;
if (!prs_align(ps))
/*******************************************************************
********************************************************************/
+
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");
if (!prs_align(ps))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
return False;
if (!prs_align(ps))
/*******************************************************************
********************************************************************/
+
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");
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))
+
+ if(!prs_uint16uni(False, "value", ps, depth, r_u->value, r_u->valuesize ))
+ return False;
+
+ if(!prs_align(ps))
return False;
+
if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
return False;
return False;
if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
return False;
+ if(!prs_align(ps))
+ return False;
+
if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
return False;
if(!prs_uint32("status", ps, depth, &r_u->status))
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_q_enumprinterdata(char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
/*******************************************************************
********************************************************************/
-BOOL make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u, POLICY_HND *hnd, uint32 idx, uint32 valuelen, uint32 datalen)
+
+BOOL make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u,
+ const POLICY_HND *hnd,
+ uint32 idx, uint32 valuelen, uint32 datalen)
{
- memcpy(&(q_u->handle), hnd, sizeof(q_u->handle));
+ memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
q_u->index=idx;
q_u->valuesize=valuelen;
q_u->datasize=datalen;
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_q_setprinterdata(char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
if(!prs_align(ps))
return False;
- if(!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;
- if(!smb_io_unistr2("", &(q_u->value), True, ps, depth))
+ if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
return False;
if(!prs_align(ps))
return False;
- if(!prs_uint32("type", ps, depth, &(q_u->type)))
+ if(!prs_uint32("type", ps, depth, &q_u->type))
return False;
- if(!prs_uint32("max_len", ps, depth, &(q_u->max_len)))
+ if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
return False;
switch (q_u->type)
case 0x3:
case 0x4:
case 0x7:
- q_u->data=(uint8 *)malloc(q_u->max_len * sizeof(uint8));
- if(q_u->data == NULL)
- return False;
- if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
- return False;
+ if (q_u->max_len) {
+ if (UNMARSHALLING(ps))
+ q_u->data=(uint8 *)prs_alloc_mem(ps, q_u->max_len * sizeof(uint8));
+ if(q_u->data == NULL)
+ return False;
+ if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
+ return False;
+ }
if(!prs_align(ps))
return False;
break;
}
- if(!prs_uint32("real_len", ps, depth, &(q_u->real_len)))
+ if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
return False;
return True;
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_r_setprinterdata(char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
if(!prs_align(ps))
return False;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+ if(!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
/*******************************************************************
********************************************************************/
+
BOOL convert_specific_param(NT_PRINTER_PARAM **param, const UNISTR2 *value,
uint32 type, const uint8 *data, uint32 len)
{
*param=(NT_PRINTER_PARAM *)malloc(sizeof(NT_PRINTER_PARAM));
if(*param == NULL)
return False;
- ZERO_STRUCTP(*param);
+ memset((char *)*param, '\0', sizeof(NT_PRINTER_PARAM));
DEBUGADD(6,("Allocated a new PARAM struct\n"));
}
unistr2_to_ascii((*param)->value, value, sizeof((*param)->value)-1);
(*param)->data_len=len;
- (*param)->data=(uint8 *)malloc(len * sizeof(uint8));
- if((*param)->data == NULL)
- return False;
-
- memcpy((*param)->data, data, len);
+ if (len) {
+ (*param)->data=(uint8 *)malloc(len * sizeof(uint8));
+ if((*param)->data == NULL)
+ return False;
+ memcpy((*param)->data, data, len);
+ }
DEBUGADD(6,("\tvalue:[%s], len:[%d]\n",(*param)->value, (*param)->data_len));
+ dump_data(10, (char *)(*param)->data, (*param)->data_len);
return True;
}
/*******************************************************************
********************************************************************/
+
static BOOL spoolss_io_addform(char *desc, FORM *f, uint32 ptr, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_addform");
if (ptr!=0)
{
- if(!prs_uint32("flags", ps, depth, &(f->flags)))
+ if(!prs_uint32("flags", ps, depth, &f->flags))
return False;
- if(!prs_uint32("name_ptr", ps, depth, &(f->name_ptr)))
+ if(!prs_uint32("name_ptr", ps, depth, &f->name_ptr))
return False;
- if(!prs_uint32("size_x", ps, depth, &(f->size_x)))
+ if(!prs_uint32("size_x", ps, depth, &f->size_x))
return False;
- if(!prs_uint32("size_y", ps, depth, &(f->size_y)))
+ if(!prs_uint32("size_y", ps, depth, &f->size_y))
return False;
- if(!prs_uint32("left", ps, depth, &(f->left)))
+ if(!prs_uint32("left", ps, depth, &f->left))
return False;
- if(!prs_uint32("top", ps, depth, &(f->top)))
+ if(!prs_uint32("top", ps, depth, &f->top))
return False;
- if(!prs_uint32("right", ps, depth, &(f->right)))
+ if(!prs_uint32("right", ps, depth, &f->right))
return False;
- if(!prs_uint32("bottom", ps, depth, &(f->bottom)))
+ if(!prs_uint32("bottom", ps, depth, &f->bottom))
return False;
- if(!smb_io_unistr2("", &(f->name), f->name_ptr, ps, depth))
+ if(!smb_io_unistr2("", &f->name, f->name_ptr, ps, depth))
return False;
}
/*******************************************************************
********************************************************************/
+
+BOOL spoolss_io_q_deleteform(char *desc, SPOOL_Q_DELETEFORM *q_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_q_deleteform");
+ depth++;
+
+ if(!prs_align(ps))
+ return False;
+ if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
+ return False;
+ if(!smb_io_unistr2("form name", &q_u->name, True, ps, depth))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+
+BOOL spoolss_io_r_deleteform(char *desc, SPOOL_R_DELETEFORM *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_deleteform");
+ depth++;
+
+ if(!prs_align(ps))
+ return False;
+ if(!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
+
+ return True;
+}
+
+/*******************************************************************
+********************************************************************/
+
BOOL spoolss_io_q_addform(char *desc, SPOOL_Q_ADDFORM *q_u, prs_struct *ps, int depth)
{
uint32 useless_ptr=0;
if(!prs_align(ps))
return False;
- if(!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;
- if(!prs_uint32("level", ps, depth, &(q_u->level)))
+ if(!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if(!prs_uint32("level2", ps, depth, &(q_u->level2)))
+ if(!prs_uint32("level2", ps, depth, &q_u->level2))
return False;
if (q_u->level==1)
{
- if(!prs_uint32("useless_ptr", ps, depth, &(useless_ptr)))
+ if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
return False;
- if(!spoolss_io_addform("", &(q_u->form), useless_ptr, ps, depth))
+ if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
return False;
}
/*******************************************************************
********************************************************************/
+
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");
if(!prs_align(ps))
return False;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+ if(!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_q_setform(char *desc, SPOOL_Q_SETFORM *q_u, prs_struct *ps, int depth)
{
uint32 useless_ptr=0;
if(!prs_align(ps))
return False;
- if(!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;
- if(!smb_io_unistr2("", &(q_u->name), True, ps, depth))
+ 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)))
+ if(!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if(!prs_uint32("level2", ps, depth, &(q_u->level2)))
+ if(!prs_uint32("level2", ps, depth, &q_u->level2))
return False;
if (q_u->level==1)
{
- if(!prs_uint32("useless_ptr", ps, depth, &(useless_ptr)))
+ if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
return False;
- if(!spoolss_io_addform("", &(q_u->form), useless_ptr, ps, depth))
+ if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
return False;
}
/*******************************************************************
********************************************************************/
+
BOOL spoolss_io_r_setform(char *desc, SPOOL_R_SETFORM *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_setform");
if(!prs_align(ps))
return False;
- if(!prs_uint32("status", ps, depth, &(r_u->status)))
+ if(!prs_uint32("status", ps, depth, &r_u->status))
return False;
return True;
/*******************************************************************
Parse a SPOOL_R_GETJOB structure.
********************************************************************/
+
BOOL spoolss_io_r_getjob(char *desc, SPOOL_R_GETJOB *r_u, prs_struct *ps, int depth)
{
prs_debug(ps, depth, desc, "spoolss_io_r_getjob");
if (!prs_align(ps))
return False;
- if (!new_spoolss_io_buffer("", ps, depth, r_u->buffer))
+ if (!spoolss_io_buffer("", ps, depth, &r_u->buffer))
return False;
if (!prs_align(ps))
/*******************************************************************
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, "");
if(!prs_align(ps))
return False;
- if(!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;
if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
return False;
if(!prs_uint32("level", ps, depth, &q_u->level))
return False;
- if(!new_spoolss_io_buffer("", ps, depth, q_u->buffer))
+ if(!spoolss_io_buffer("", ps, depth, &q_u->buffer))
return False;
if(!prs_align(ps))
void free_devmode(DEVICEMODE *devmode)
{
- if (devmode!=NULL)
- {
- if (devmode->private!=NULL)
- free(devmode->private);
- free(devmode);
+ if (devmode!=NULL) {
+ safe_free(devmode->private);
+ safe_free(devmode);
}
}
+void free_printer_info_1(PRINTER_INFO_1 *printer)
+{
+ safe_free(printer);
+}
+
void free_printer_info_2(PRINTER_INFO_2 *printer)
{
- if (printer!=NULL)
- {
+ if (printer!=NULL) {
free_devmode(printer->devmode);
- free(printer);
+ printer->devmode = NULL;
+ safe_free(printer);
}
}
-static PRINTER_INFO_2 *prt2_dup(const PRINTER_INFO_2* from)
+void free_printer_info_3(PRINTER_INFO_3 *printer)
{
- PRINTER_INFO_2 *copy = (PRINTER_INFO_2 *)malloc(sizeof(PRINTER_INFO_2));
- if (copy != NULL)
- {
- if (from != NULL)
- {
- memcpy(copy, from, sizeof(*copy));
- }
- else
- {
- ZERO_STRUCTP(copy);
- }
+ if (printer!=NULL) {
+ safe_free(printer);
}
- return copy;
}
-void free_print2_array(uint32 num_entries, PRINTER_INFO_2 **entries)
+void free_job_info_2(JOB_INFO_2 *job)
{
- void(*fn)(void*) = (void(*)(void*))&free_printer_info_2;
- free_void_array(num_entries, (void**)entries, *fn);
+ if (job!=NULL)
+ free_devmode(job->devmode);
}
-PRINTER_INFO_2 *add_print2_to_array(uint32 *len, PRINTER_INFO_2 ***array,
- const PRINTER_INFO_2 *prt)
-{
- void*(*fn)(const void*) = (void*(*)(const void*))&prt2_dup;
- return (PRINTER_INFO_2*)add_copy_to_array(len,
- (void***)array, (const void*)prt, *fn, True);
-}
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
-static PRINTER_INFO_1 *prt1_dup(const PRINTER_INFO_1* from)
-{
- PRINTER_INFO_1 *copy = (PRINTER_INFO_1 *)malloc(sizeof(PRINTER_INFO_1));
- if (copy != NULL)
- {
- if (from != NULL)
- {
- memcpy(copy, from, sizeof(*copy));
- }
- else
- {
- ZERO_STRUCTP(copy);
- }
- }
- return copy;
-}
+BOOL make_spoolss_q_replyopenprinter(SPOOL_Q_REPLYOPENPRINTER *q_u,
+ const fstring string, uint32 printer, uint32 type)
+{
+ if (q_u == NULL)
+ return False;
-void free_print1_array(uint32 num_entries, PRINTER_INFO_1 **entries)
-{
- void(*fn)(void*) = (void(*)(void*))&free;
- free_void_array(num_entries, (void**)entries, *fn);
-}
+ init_unistr2(&q_u->string, string, strlen(string)+1);
-PRINTER_INFO_1 *add_print1_to_array(uint32 *len, PRINTER_INFO_1 ***array,
- const PRINTER_INFO_1 *prt)
-{
- void*(*fn)(const void*) = (void*(*)(const void*))&prt1_dup;
- return (PRINTER_INFO_1*)add_copy_to_array(len,
- (void***)array, (const void*)prt, *fn, True);
+ q_u->printer=printer;
+ q_u->type=type;
+
+ q_u->unknown0=0x0;
+ q_u->unknown1=0x0;
+
+ return True;
}
-static JOB_INFO_1 *job1_dup(const JOB_INFO_1* from)
+/*******************************************************************
+ Parse a SPOOL_Q_REPLYOPENPRINTER structure.
+********************************************************************/
+
+BOOL spoolss_io_q_replyopenprinter(char *desc, SPOOL_Q_REPLYOPENPRINTER *q_u, prs_struct *ps, int depth)
{
- JOB_INFO_1 *copy = (JOB_INFO_1 *)malloc(sizeof(JOB_INFO_1));
- if (copy != NULL)
- {
- if (from != NULL)
- {
- memcpy(copy, from, sizeof(*copy));
- }
- else
- {
- ZERO_STRUCTP(copy);
- }
- }
- return copy;
+ prs_debug(ps, depth, desc, "spoolss_io_q_replyopenprinter");
+ depth++;
+
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_unistr2("", &q_u->string, True, ps, depth))
+ return False;
+
+ if(!prs_align(ps))
+ return False;
+
+ if(!prs_uint32("printer", ps, depth, &q_u->printer))
+ return False;
+ if(!prs_uint32("type", ps, depth, &q_u->type))
+ return False;
+
+ if(!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
+ return False;
+ if(!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
+ return False;
+
+ return True;
}
-void free_job1_array(uint32 num_entries, JOB_INFO_1 **entries)
-{
- void(*fn)(void*) = (void(*)(void*))&free;
- free_void_array(num_entries, (void**)entries, *fn);
+/*******************************************************************
+ Parse a SPOOL_R_REPLYOPENPRINTER structure.
+********************************************************************/
+
+BOOL spoolss_io_r_replyopenprinter(char *desc, SPOOL_R_REPLYOPENPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_replyopenprinter");
+ 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", ps, depth, &r_u->status))
+ return False;
+
+ return True;
}
-JOB_INFO_1 *add_job1_to_array(uint32 *len, JOB_INFO_1 ***array,
- const JOB_INFO_1 *job)
-{
- void*(*fn)(const void*) = (void*(*)(const void*))&job1_dup;
- return (JOB_INFO_1*)add_copy_to_array(len,
- (void***)array, (const void*)job, *fn, True);
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
+
+BOOL make_spoolss_q_reply_closeprinter(SPOOL_Q_REPLYCLOSEPRINTER *q_u, POLICY_HND *hnd)
+{
+ if (q_u == NULL)
+ return False;
+
+ memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
+
+ return True;
}
-static JOB_INFO_2 *job2_dup(const JOB_INFO_2* from)
+/*******************************************************************
+ Parse a SPOOL_Q_REPLYCLOSEPRINTER structure.
+********************************************************************/
+
+BOOL spoolss_io_q_replycloseprinter(char *desc, SPOOL_Q_REPLYCLOSEPRINTER *q_u, prs_struct *ps, int depth)
{
- JOB_INFO_2 *copy = (JOB_INFO_2 *)malloc(sizeof(JOB_INFO_2));
- if (copy != NULL)
- {
- if (from != NULL)
- {
- memcpy(copy, from, sizeof(*copy));
- }
- else
- {
- ZERO_STRUCTP(copy);
- }
- }
- return copy;
+ prs_debug(ps, depth, desc, "spoolss_io_q_replycloseprinter");
+ depth++;
+
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
+ return False;
+
+ return True;
}
-void free_job_info_2(JOB_INFO_2 *job)
-{
- if (job!=NULL)
- {
- free_devmode(job->devmode);
- free(job);
- }
+/*******************************************************************
+ Parse a SPOOL_R_REPLYCLOSEPRINTER structure.
+********************************************************************/
+
+BOOL spoolss_io_r_replycloseprinter(char *desc, SPOOL_R_REPLYCLOSEPRINTER *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_replycloseprinter");
+ 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", ps, depth, &r_u->status))
+ return False;
+
+ return True;
}
-void free_job2_array(uint32 num_entries, JOB_INFO_2 **entries)
-{
- void(*fn)(void*) = (void(*)(void*))&free_job_info_2;
- free_void_array(num_entries, (void**)entries, *fn);
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
+
+BOOL make_spoolss_q_reply_rrpcn(SPOOL_Q_REPLY_RRPCN *q_u, POLICY_HND *hnd,
+ uint32 change_low, uint32 change_high)
+{
+ if (q_u == NULL)
+ return False;
+
+ memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
+
+ q_u->change_low=change_low;
+ q_u->change_high=change_high;
+
+ q_u->unknown0=0x0;
+ q_u->unknown1=0x0;
+
+ q_u->info_ptr=1;
+
+ q_u->info.version=2;
+ q_u->info.flags=PRINTER_NOTIFY_INFO_DISCARDED;
+ q_u->info.count=0;
+
+ return True;
}
-JOB_INFO_2 *add_job2_to_array(uint32 *len, JOB_INFO_2 ***array,
- const JOB_INFO_2 *job)
+/*******************************************************************
+ Parse a SPOOL_Q_REPLY_RRPCN structure.
+********************************************************************/
+
+BOOL spoolss_io_q_reply_rrpcn(char *desc, SPOOL_Q_REPLY_RRPCN *q_u, prs_struct *ps, int depth)
{
- void*(*fn)(const void*) = (void*(*)(const void*))&job2_dup;
- return (JOB_INFO_2*)add_copy_to_array(len,
- (void***)array, (const void*)job, *fn, True);
+ prs_debug(ps, depth, desc, "spoolss_io_q_reply_rrpcn");
+ depth++;
+
+ if(!prs_align(ps))
+ return False;
+
+ if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
+ return False;
+
+ if (!prs_uint32("change_low", ps, depth, &q_u->change_low))
+ return False;
+
+ if (!prs_uint32("change_high", ps, depth, &q_u->change_high))
+ return False;
+
+ if (!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
+ return False;
+
+ if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
+ return False;
+
+ if (!prs_uint32("info_ptr", ps, depth, &q_u->info_ptr))
+ return False;
+
+ if(q_u->info_ptr!=0)
+ if(!smb_io_notify_info(desc, &q_u->info, ps, depth))
+ return False;
+
+ return True;
}
+/*******************************************************************
+ Parse a SPOOL_R_REPLY_RRPCN structure.
+********************************************************************/
+
+BOOL spoolss_io_r_reply_rrpcn(char *desc, SPOOL_R_REPLY_RRPCN *r_u, prs_struct *ps, int depth)
+{
+ prs_debug(ps, depth, desc, "spoolss_io_r_replycloseprinter");
+ depth++;
+
+ if (!prs_align(ps))
+ return False;
+
+ if (!prs_uint32("unknown0", ps, depth, &r_u->unknown0))
+ return False;
+
+ if (!prs_uint32("status", ps, depth, &r_u->status))
+ return False;
+
+ return True;
+}