source3/rpc_parse/parse_spoolss.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-2000,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   6  *  Copyright (C) Jean François Micouleau      1998-2000,
   7  *  Copyright (C) Gerald Carter                2000-2002,
   8  *  Copyright (C) Tim Potter                   2001-2002.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 3 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 #include "includes.h"
  25
  26 #undef DBGC_CLASS
  27 #define DBGC_CLASS DBGC_RPC_PARSE
  28
  29
  30 /*******************************************************************
  31 This should be moved in a more generic lib.
  32 ********************************************************************/
  33
  34 bool spoolss_io_system_time(const char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime)
  35 {
  36         if(!prs_uint16("year", ps, depth, &systime->year))
  37                 return False;
  38         if(!prs_uint16("month", ps, depth, &systime->month))
  39                 return False;
  40         if(!prs_uint16("dayofweek", ps, depth, &systime->dayofweek))
  41                 return False;
  42         if(!prs_uint16("day", ps, depth, &systime->day))
  43                 return False;
  44         if(!prs_uint16("hour", ps, depth, &systime->hour))
  45                 return False;
  46         if(!prs_uint16("minute", ps, depth, &systime->minute))
  47                 return False;
  48         if(!prs_uint16("second", ps, depth, &systime->second))
  49                 return False;
  50         if(!prs_uint16("milliseconds", ps, depth, &systime->milliseconds))
  51                 return False;
  52
  53         return True;
  54 }
  55
  56 /*******************************************************************
  57 ********************************************************************/
  58
  59 bool make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
  60 {
  61         systime->year=unixtime->tm_year+1900;
  62         systime->month=unixtime->tm_mon+1;
  63         systime->dayofweek=unixtime->tm_wday;
  64         systime->day=unixtime->tm_mday;
  65         systime->hour=unixtime->tm_hour;
  66         systime->minute=unixtime->tm_min;
  67         systime->second=unixtime->tm_sec;
  68         systime->milliseconds=0;
  69
  70         return True;
  71 }
  72
  73 /*******************************************************************
  74  * read or write a DEVICEMODE struct.
  75  * on reading allocate memory for the private member
  76  ********************************************************************/
  77
  78 #define DM_NUM_OPTIONAL_FIELDS          8
  79
  80 bool spoolss_io_devmode(const char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
  81 {
  82         int available_space;            /* size of the device mode left to parse */
  83                                         /* only important on unmarshalling       */
  84         int i = 0;
  85         uint16 *unistr_buffer;
  86         int j;
  87
  88         struct optional_fields {
  89                 fstring         name;
  90                 uint32*         field;
  91         } opt_fields[DM_NUM_OPTIONAL_FIELDS] = {
  92                 { "icmmethod",          NULL },
  93                 { "icmintent",          NULL },
  94                 { "mediatype",          NULL },
  95                 { "dithertype",         NULL },
  96                 { "reserved1",          NULL },
  97                 { "reserved2",          NULL },
  98                 { "panningwidth",       NULL },
  99                 { "panningheight",      NULL }
 100         };
 101
 102         /* assign at run time to keep non-gcc compilers happy */
 103
 104         opt_fields[0].field = &devmode->icmmethod;
 105         opt_fields[1].field = &devmode->icmintent;
 106         opt_fields[2].field = &devmode->mediatype;
 107         opt_fields[3].field = &devmode->dithertype;
 108         opt_fields[4].field = &devmode->reserved1;
 109         opt_fields[5].field = &devmode->reserved2;
 110         opt_fields[6].field = &devmode->panningwidth;
 111         opt_fields[7].field = &devmode->panningheight;
 112
 113
 114         prs_debug(ps, depth, desc, "spoolss_io_devmode");
 115         depth++;
 116
 117         if (UNMARSHALLING(ps)) {
 118                 devmode->devicename.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
 119                 if (devmode->devicename.buffer == NULL)
 120                         return False;
 121                 unistr_buffer = devmode->devicename.buffer;
 122         }
 123         else {
 124                 /* devicename is a static sized string but the buffer we set is not */
 125                 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
 126                 memset( unistr_buffer, 0x0, MAXDEVICENAME );
 127                 for ( j=0; devmode->devicename.buffer[j]; j++ )
 128                         unistr_buffer[j] = devmode->devicename.buffer[j];
 129         }
 130
 131         if (!prs_uint16uni(True,"devicename", ps, depth, unistr_buffer, MAXDEVICENAME))
 132                 return False;
 133
 134         if (!prs_uint16("specversion",      ps, depth, &devmode->specversion))
 135                 return False;
 136
 137         if (!prs_uint16("driverversion",    ps, depth, &devmode->driverversion))
 138                 return False;
 139         if (!prs_uint16("size",             ps, depth, &devmode->size))
 140                 return False;
 141         if (!prs_uint16("driverextra",      ps, depth, &devmode->driverextra))
 142                 return False;
 143         if (!prs_uint32("fields",           ps, depth, &devmode->fields))
 144                 return False;
 145         if (!prs_uint16("orientation",      ps, depth, &devmode->orientation))
 146                 return False;
 147         if (!prs_uint16("papersize",        ps, depth, &devmode->papersize))
 148                 return False;
 149         if (!prs_uint16("paperlength",      ps, depth, &devmode->paperlength))
 150                 return False;
 151         if (!prs_uint16("paperwidth",       ps, depth, &devmode->paperwidth))
 152                 return False;
 153         if (!prs_uint16("scale",            ps, depth, &devmode->scale))
 154                 return False;
 155         if (!prs_uint16("copies",           ps, depth, &devmode->copies))
 156                 return False;
 157         if (!prs_uint16("defaultsource",    ps, depth, &devmode->defaultsource))
 158                 return False;
 159         if (!prs_uint16("printquality",     ps, depth, &devmode->printquality))
 160                 return False;
 161         if (!prs_uint16("color",            ps, depth, &devmode->color))
 162                 return False;
 163         if (!prs_uint16("duplex",           ps, depth, &devmode->duplex))
 164                 return False;
 165         if (!prs_uint16("yresolution",      ps, depth, &devmode->yresolution))
 166                 return False;
 167         if (!prs_uint16("ttoption",         ps, depth, &devmode->ttoption))
 168                 return False;
 169         if (!prs_uint16("collate",          ps, depth, &devmode->collate))
 170                 return False;
 171
 172         if (UNMARSHALLING(ps)) {
 173                 devmode->formname.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
 174                 if (devmode->formname.buffer == NULL)
 175                         return False;
 176                 unistr_buffer = devmode->formname.buffer;
 177         }
 178         else {
 179                 /* devicename is a static sized string but the buffer we set is not */
 180                 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
 181                 memset( unistr_buffer, 0x0, MAXDEVICENAME );
 182                 for ( j=0; devmode->formname.buffer[j]; j++ )
 183                         unistr_buffer[j] = devmode->formname.buffer[j];
 184         }
 185
 186         if (!prs_uint16uni(True, "formname",  ps, depth, unistr_buffer, MAXDEVICENAME))
 187                 return False;
 188         if (!prs_uint16("logpixels",        ps, depth, &devmode->logpixels))
 189                 return False;
 190         if (!prs_uint32("bitsperpel",       ps, depth, &devmode->bitsperpel))
 191                 return False;
 192         if (!prs_uint32("pelswidth",        ps, depth, &devmode->pelswidth))
 193                 return False;
 194         if (!prs_uint32("pelsheight",       ps, depth, &devmode->pelsheight))
 195                 return False;
 196         if (!prs_uint32("displayflags",     ps, depth, &devmode->displayflags))
 197                 return False;
 198         if (!prs_uint32("displayfrequency", ps, depth, &devmode->displayfrequency))
 199                 return False;
 200         /*
 201          * every device mode I've ever seen on the wire at least has up
 202          * to the displayfrequency field.   --jerry (05-09-2002)
 203          */
 204
 205         /* add uint32's + uint16's + two UNICODE strings */
 206
 207         available_space = devmode->size - (sizeof(uint32)*6 + sizeof(uint16)*18 + sizeof(uint16)*64);
 208
 209         /* Sanity check - we only have uint32's left tp parse */
 210
 211         if ( available_space && ((available_space % sizeof(uint32)) != 0) ) {
 212                 DEBUG(0,("spoolss_io_devmode: available_space [%d] no in multiple of 4 bytes (size = %d)!\n",
 213                         available_space, devmode->size));
 214                 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
 215                 return False;
 216         }
 217
 218         /*
 219          * Conditional parsing.  Assume that the DeviceMode has been
 220          * zero'd by the caller.
 221          */
 222
 223         while ((available_space > 0)  && (i < DM_NUM_OPTIONAL_FIELDS))
 224         {
 225                 DEBUG(11, ("spoolss_io_devmode: [%d] bytes left to parse in devmode\n", available_space));
 226                 if (!prs_uint32(opt_fields[i].name, ps, depth, opt_fields[i].field))
 227                         return False;
 228                 available_space -= sizeof(uint32);
 229                 i++;
 230         }
 231
 232         /* Sanity Check - we should no available space at this point unless
 233            MS changes the device mode structure */
 234
 235         if (available_space) {
 236                 DEBUG(0,("spoolss_io_devmode: I've parsed all I know and there is still stuff left|\n"));
 237                 DEBUG(0,("spoolss_io_devmode: available_space = [%d], devmode_size = [%d]!\n",
 238                         available_space, devmode->size));
 239                 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
 240                 return False;
 241         }
 242
 243
 244         if (devmode->driverextra!=0) {
 245                 if (UNMARSHALLING(ps)) {
 246                         devmode->dev_private=PRS_ALLOC_MEM(ps, uint8, devmode->driverextra);
 247                         if(devmode->dev_private == NULL)
 248                                 return False;
 249                         DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for dev_private\n",devmode->driverextra));
 250                 }
 251
 252                 DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of dev_private\n",devmode->driverextra));
 253                 if (!prs_uint8s(False, "dev_private",  ps, depth,
 254                                 devmode->dev_private, devmode->driverextra))
 255                         return False;
 256         }
 257
 258         return True;
 259 }
 260
 261 /*******************************************************************
 262  * make a structure.
 263  ********************************************************************/
 264
 265 bool make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u,
 266                                    const POLICY_HND *handle,
 267                                    const char *valuename, uint32 size)
 268 {
 269         if (q_u == NULL) return False;
 270
 271         DEBUG(5,("make_spoolss_q_getprinterdata\n"));
 272
 273         q_u->handle = *handle;
 274         init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
 275         q_u->size = size;
 276
 277         return True;
 278 }
 279
 280 /*******************************************************************
 281  * read a structure.
 282  * called from spoolss_q_getprinterdata (srv_spoolss.c)
 283  ********************************************************************/
 284
 285 bool spoolss_io_q_getprinterdata(const char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_struct *ps, int depth)
 286 {
 287         if (q_u == NULL)
 288                 return False;
 289
 290         prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdata");
 291         depth++;
 292
 293         if (!prs_align(ps))
 294                 return False;
 295         if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
 296                 return False;
 297         if (!prs_align(ps))
 298                 return False;
 299         if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
 300                 return False;
 301         if (!prs_align(ps))
 302                 return False;
 303         if (!prs_uint32("size", ps, depth, &q_u->size))
 304                 return False;
 305
 306         return True;
 307 }
 308
 309 /*******************************************************************
 310  * write a structure.
 311  * called from spoolss_r_getprinterdata (srv_spoolss.c)
 312  ********************************************************************/
 313
 314 bool spoolss_io_r_getprinterdata(const char *desc, SPOOL_R_GETPRINTERDATA *r_u, prs_struct *ps, int depth)
 315 {
 316         if (r_u == NULL)
 317                 return False;
 318
 319         prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdata");
 320         depth++;
 321
 322         if (!prs_align(ps))
 323                 return False;
 324         if (!prs_uint32("type", ps, depth, &r_u->type))
 325                 return False;
 326         if (!prs_uint32("size", ps, depth, &r_u->size))
 327                 return False;
 328
 329         if (UNMARSHALLING(ps) && r_u->size) {
 330                 r_u->data = PRS_ALLOC_MEM(ps, unsigned char, r_u->size);
 331                 if(!r_u->data)
 332                         return False;
 333         }
 334
 335         if (!prs_uint8s( False, "data", ps, depth, r_u->data, r_u->size ))
 336                 return False;
 337
 338         if (!prs_align(ps))
 339                 return False;
 340
 341         if (!prs_uint32("needed", ps, depth, &r_u->needed))
 342                 return False;
 343         if (!prs_werror("status", ps, depth, &r_u->status))
 344                 return False;
 345
 346         return True;
 347 }
 348
 349 /*******************************************************************
 350  * return the length of a uint16 (obvious, but the code is clean)
 351  ********************************************************************/
 352
 353 static uint32 size_of_uint16(uint16 *value)
 354 {
 355         return (sizeof(*value));
 356 }
 357
 358 /*******************************************************************
 359  * return the length of a uint32 (obvious, but the code is clean)
 360  ********************************************************************/
 361
 362 static uint32 size_of_uint32(uint32 *value)
 363 {
 364         return (sizeof(*value));
 365 }
 366
 367 /*******************************************************************
 368  * return the length of a NTTIME (obvious, but the code is clean)
 369  ********************************************************************/
 370
 371 static uint32 size_of_nttime(NTTIME *value)
 372 {
 373         return (sizeof(*value));
 374 }
 375
 376 /*******************************************************************
 377  * return the length of a uint32 (obvious, but the code is clean)
 378  ********************************************************************/
 379
 380 static uint32 size_of_device_mode(DEVICEMODE *devmode)
 381 {
 382         if (devmode==NULL)
 383                 return (4);
 384         else
 385                 return (4+devmode->size+devmode->driverextra);
 386 }
 387
 388 /*******************************************************************
 389  * return the length of a uint32 (obvious, but the code is clean)
 390  ********************************************************************/
 391
 392 static uint32 size_of_systemtime(SYSTEMTIME *systime)
 393 {
 394         if (systime==NULL)
 395                 return (4);
 396         else
 397                 return (sizeof(SYSTEMTIME) +4);
 398 }
 399
 400 /*******************************************************************
 401  Parse a DEVMODE structure and its relative pointer.
 402 ********************************************************************/
 403
 404 static bool smb_io_reldevmode(const char *desc, RPC_BUFFER *buffer, int depth, DEVICEMODE **devmode)
 405 {
 406         prs_struct *ps=&buffer->prs;
 407
 408         prs_debug(ps, depth, desc, "smb_io_reldevmode");
 409         depth++;
 410
 411         if (MARSHALLING(ps)) {
 412                 uint32 struct_offset = prs_offset(ps);
 413                 uint32 relative_offset;
 414
 415                 if (*devmode == NULL) {
 416                         relative_offset=0;
 417                         if (!prs_uint32("offset", ps, depth, &relative_offset))
 418                                 return False;
 419                         DEBUG(8, ("boing, the devmode was NULL\n"));
 420
 421                         return True;
 422                 }
 423
 424                 buffer->string_at_end -= ((*devmode)->size + (*devmode)->driverextra);
 425
 426                 /* mz:  we have to align the device mode for VISTA */
 427                 if (buffer->string_at_end % 4) {
 428                         buffer->string_at_end += 4 - (buffer->string_at_end % 4);
 429                 }
 430
 431                 if(!prs_set_offset(ps, buffer->string_at_end))
 432                         return False;
 433
 434                 /* write the DEVMODE */
 435                 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
 436                         return False;
 437
 438                 if(!prs_set_offset(ps, struct_offset))
 439                         return False;
 440
 441                 relative_offset=buffer->string_at_end - buffer->struct_start;
 442                 /* write its offset */
 443                 if (!prs_uint32("offset", ps, depth, &relative_offset))
 444                         return False;
 445         }
 446         else {
 447                 uint32 old_offset;
 448
 449                 /* read the offset */
 450                 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
 451                         return False;
 452                 if (buffer->string_at_end == 0) {
 453                         *devmode = NULL;
 454                         return True;
 455                 }
 456
 457                 old_offset = prs_offset(ps);
 458                 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
 459                         return False;
 460
 461                 /* read the string */
 462                 if((*devmode=PRS_ALLOC_MEM(ps,DEVICEMODE,1)) == NULL)
 463                         return False;
 464                 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
 465                         return False;
 466
 467                 if(!prs_set_offset(ps, old_offset))
 468                         return False;
 469         }
 470         return True;
 471 }
 472
 473 /*******************************************************************
 474  Parse a PRINTER_INFO_0 structure.
 475 ********************************************************************/
 476
 477 bool smb_io_printer_info_0(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_0 *info, int depth)
 478 {
 479         prs_struct *ps=&buffer->prs;
 480
 481         prs_debug(ps, depth, desc, "smb_io_printer_info_0");
 482         depth++;
 483
 484         buffer->struct_start=prs_offset(ps);
 485
 486         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
 487                 return False;
 488         if (!smb_io_relstr("servername", buffer, depth, &info->servername))
 489                 return False;
 490
 491         if(!prs_uint32("cjobs", ps, depth, &info->cjobs))
 492                 return False;
 493         if(!prs_uint32("total_jobs", ps, depth, &info->total_jobs))
 494                 return False;
 495         if(!prs_uint32("total_bytes", ps, depth, &info->total_bytes))
 496                 return False;
 497
 498         if(!prs_uint16("year", ps, depth, &info->year))
 499                 return False;
 500         if(!prs_uint16("month", ps, depth, &info->month))
 501                 return False;
 502         if(!prs_uint16("dayofweek", ps, depth, &info->dayofweek))
 503                 return False;
 504         if(!prs_uint16("day", ps, depth, &info->day))
 505                 return False;
 506         if(!prs_uint16("hour", ps, depth, &info->hour))
 507                 return False;
 508         if(!prs_uint16("minute", ps, depth, &info->minute))
 509                 return False;
 510         if(!prs_uint16("second", ps, depth, &info->second))
 511                 return False;
 512         if(!prs_uint16("milliseconds", ps, depth, &info->milliseconds))
 513                 return False;
 514
 515         if(!prs_uint32("global_counter", ps, depth, &info->global_counter))
 516                 return False;
 517         if(!prs_uint32("total_pages", ps, depth, &info->total_pages))
 518                 return False;
 519
 520         if(!prs_uint16("major_version", ps, depth, &info->major_version))
 521                 return False;
 522         if(!prs_uint16("build_version", ps, depth, &info->build_version))
 523                 return False;
 524         if(!prs_uint32("unknown7", ps, depth, &info->unknown7))
 525                 return False;
 526         if(!prs_uint32("unknown8", ps, depth, &info->unknown8))
 527                 return False;
 528         if(!prs_uint32("unknown9", ps, depth, &info->unknown9))
 529                 return False;
 530         if(!prs_uint32("session_counter", ps, depth, &info->session_counter))
 531                 return False;
 532         if(!prs_uint32("unknown11", ps, depth, &info->unknown11))
 533                 return False;
 534         if(!prs_uint32("printer_errors", ps, depth, &info->printer_errors))
 535                 return False;
 536         if(!prs_uint32("unknown13", ps, depth, &info->unknown13))
 537                 return False;
 538         if(!prs_uint32("unknown14", ps, depth, &info->unknown14))
 539                 return False;
 540         if(!prs_uint32("unknown15", ps, depth, &info->unknown15))
 541                 return False;
 542         if(!prs_uint32("unknown16", ps, depth, &info->unknown16))
 543                 return False;
 544         if(!prs_uint32("change_id", ps, depth, &info->change_id))
 545                 return False;
 546         if(!prs_uint32("unknown18", ps, depth, &info->unknown18))
 547                 return False;
 548         if(!prs_uint32("status"   , ps, depth, &info->status))
 549                 return False;
 550         if(!prs_uint32("unknown20", ps, depth, &info->unknown20))
 551                 return False;
 552         if(!prs_uint32("c_setprinter", ps, depth, &info->c_setprinter))
 553                 return False;
 554         if(!prs_uint16("unknown22", ps, depth, &info->unknown22))
 555                 return False;
 556         if(!prs_uint16("unknown23", ps, depth, &info->unknown23))
 557                 return False;
 558         if(!prs_uint16("unknown24", ps, depth, &info->unknown24))
 559                 return False;
 560         if(!prs_uint16("unknown25", ps, depth, &info->unknown25))
 561                 return False;
 562         if(!prs_uint16("unknown26", ps, depth, &info->unknown26))
 563                 return False;
 564         if(!prs_uint16("unknown27", ps, depth, &info->unknown27))
 565                 return False;
 566         if(!prs_uint16("unknown28", ps, depth, &info->unknown28))
 567                 return False;
 568         if(!prs_uint16("unknown29", ps, depth, &info->unknown29))
 569                 return False;
 570
 571         return True;
 572 }
 573
 574 /*******************************************************************
 575  Parse a PRINTER_INFO_1 structure.
 576 ********************************************************************/
 577
 578 bool smb_io_printer_info_1(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_1 *info, int depth)
 579 {
 580         prs_struct *ps=&buffer->prs;
 581
 582         prs_debug(ps, depth, desc, "smb_io_printer_info_1");
 583         depth++;
 584
 585         buffer->struct_start=prs_offset(ps);
 586
 587         if (!prs_uint32("flags", ps, depth, &info->flags))
 588                 return False;
 589         if (!smb_io_relstr("description", buffer, depth, &info->description))
 590                 return False;
 591         if (!smb_io_relstr("name", buffer, depth, &info->name))
 592                 return False;
 593         if (!smb_io_relstr("comment", buffer, depth, &info->comment))
 594                 return False;
 595
 596         return True;
 597 }
 598
 599 /*******************************************************************
 600  Parse a PRINTER_INFO_2 structure.
 601 ********************************************************************/
 602
 603 bool smb_io_printer_info_2(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_2 *info, int depth)
 604 {
 605         prs_struct *ps=&buffer->prs;
 606         uint32 dm_offset, sd_offset, current_offset;
 607         uint32 dummy_value = 0, has_secdesc = 0;
 608
 609         prs_debug(ps, depth, desc, "smb_io_printer_info_2");
 610         depth++;
 611
 612         buffer->struct_start=prs_offset(ps);
 613
 614         if (!smb_io_relstr("servername", buffer, depth, &info->servername))
 615                 return False;
 616         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
 617                 return False;
 618         if (!smb_io_relstr("sharename", buffer, depth, &info->sharename))
 619                 return False;
 620         if (!smb_io_relstr("portname", buffer, depth, &info->portname))
 621                 return False;
 622         if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
 623                 return False;
 624         if (!smb_io_relstr("comment", buffer, depth, &info->comment))
 625                 return False;
 626         if (!smb_io_relstr("location", buffer, depth, &info->location))
 627                 return False;
 628
 629         /* save current offset and wind forwared by a uint32 */
 630         dm_offset = prs_offset(ps);
 631         if (!prs_uint32("devmode", ps, depth, &dummy_value))
 632                 return False;
 633
 634         if (!smb_io_relstr("sepfile", buffer, depth, &info->sepfile))
 635                 return False;
 636         if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
 637                 return False;
 638         if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
 639                 return False;
 640         if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
 641                 return False;
 642
 643         /* save current offset for the sec_desc */
 644         sd_offset = prs_offset(ps);
 645         if (!prs_uint32("sec_desc", ps, depth, &has_secdesc))
 646                 return False;
 647
 648
 649         /* save current location so we can pick back up here */
 650         current_offset = prs_offset(ps);
 651
 652         /* parse the devmode */
 653         if (!prs_set_offset(ps, dm_offset))
 654                 return False;
 655         if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
 656                 return False;
 657
 658         /* parse the sec_desc */
 659         if (info->secdesc) {
 660                 if (!prs_set_offset(ps, sd_offset))
 661                         return False;
 662                 if (!smb_io_relsecdesc("secdesc", buffer, depth, &info->secdesc))
 663                         return False;
 664         }
 665
 666         /* pick up where we left off */
 667         if (!prs_set_offset(ps, current_offset))
 668                 return False;
 669
 670         if (!prs_uint32("attributes", ps, depth, &info->attributes))
 671                 return False;
 672         if (!prs_uint32("priority", ps, depth, &info->priority))
 673                 return False;
 674         if (!prs_uint32("defpriority", ps, depth, &info->defaultpriority))
 675                 return False;
 676         if (!prs_uint32("starttime", ps, depth, &info->starttime))
 677                 return False;
 678         if (!prs_uint32("untiltime", ps, depth, &info->untiltime))
 679                 return False;
 680         if (!prs_uint32("status", ps, depth, &info->status))
 681                 return False;
 682         if (!prs_uint32("jobs", ps, depth, &info->cjobs))
 683                 return False;
 684         if (!prs_uint32("averageppm", ps, depth, &info->averageppm))
 685                 return False;
 686
 687         return True;
 688 }
 689
 690 /*******************************************************************
 691  Parse a PRINTER_INFO_3 structure.
 692 ********************************************************************/
 693
 694 bool smb_io_printer_info_3(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_3 *info, int depth)
 695 {
 696         uint32 offset = 0;
 697         prs_struct *ps=&buffer->prs;
 698
 699         prs_debug(ps, depth, desc, "smb_io_printer_info_3");
 700         depth++;
 701
 702         buffer->struct_start=prs_offset(ps);
 703
 704         if (MARSHALLING(ps)) {
 705                 /* Ensure the SD is 8 byte aligned in the buffer. */
 706                 uint32 start = prs_offset(ps); /* Remember the start position. */
 707                 uint32 off_val = 0;
 708
 709                 /* Write a dummy value. */
 710                 if (!prs_uint32("offset", ps, depth, &off_val))
 711                         return False;
 712
 713                 /* 8 byte align. */
 714                 if (!prs_align_uint64(ps))
 715                         return False;
 716
 717                 /* Remember where we must seek back to write the SD. */
 718                 offset = prs_offset(ps);
 719
 720                 /* Calculate the real offset for the SD. */
 721
 722                 off_val = offset - start;
 723
 724                 /* Seek back to where we store the SD offset & store. */
 725                 prs_set_offset(ps, start);
 726                 if (!prs_uint32("offset", ps, depth, &off_val))
 727                         return False;
 728
 729                 /* Return to after the 8 byte align. */
 730                 prs_set_offset(ps, offset);
 731
 732         } else {
 733                 if (!prs_uint32("offset", ps, depth, &offset))
 734                         return False;
 735                 /* Seek within the buffer. */
 736                 if (!prs_set_offset(ps, offset))
 737                         return False;
 738         }
 739         if (!sec_io_desc("sec_desc", &info->secdesc, ps, depth))
 740                 return False;
 741
 742         return True;
 743 }
 744
 745 /*******************************************************************
 746  Parse a PRINTER_INFO_4 structure.
 747 ********************************************************************/
 748
 749 bool smb_io_printer_info_4(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_4 *info, int depth)
 750 {
 751         prs_struct *ps=&buffer->prs;
 752
 753         prs_debug(ps, depth, desc, "smb_io_printer_info_4");
 754         depth++;
 755
 756         buffer->struct_start=prs_offset(ps);
 757
 758         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
 759                 return False;
 760         if (!smb_io_relstr("servername", buffer, depth, &info->servername))
 761                 return False;
 762         if (!prs_uint32("attributes", ps, depth, &info->attributes))
 763                 return False;
 764         return True;
 765 }
 766
 767 /*******************************************************************
 768  Parse a PRINTER_INFO_5 structure.
 769 ********************************************************************/
 770
 771 bool smb_io_printer_info_5(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_5 *info, int depth)
 772 {
 773         prs_struct *ps=&buffer->prs;
 774
 775         prs_debug(ps, depth, desc, "smb_io_printer_info_5");
 776         depth++;
 777
 778         buffer->struct_start=prs_offset(ps);
 779
 780         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
 781                 return False;
 782         if (!smb_io_relstr("portname", buffer, depth, &info->portname))
 783                 return False;
 784         if (!prs_uint32("attributes", ps, depth, &info->attributes))
 785                 return False;
 786         if (!prs_uint32("device_not_selected_timeout", ps, depth, &info->device_not_selected_timeout))
 787                 return False;
 788         if (!prs_uint32("transmission_retry_timeout", ps, depth, &info->transmission_retry_timeout))
 789                 return False;
 790         return True;
 791 }
 792
 793 /*******************************************************************
 794  Parse a PRINTER_INFO_6 structure.
 795 ********************************************************************/
 796
 797 bool smb_io_printer_info_6(const char *desc, RPC_BUFFER *buffer,
 798                            PRINTER_INFO_6 *info, int depth)
 799 {
 800         prs_struct *ps=&buffer->prs;
 801
 802         prs_debug(ps, depth, desc, "smb_io_printer_info_6");
 803         depth++;
 804
 805         if (!prs_uint32("status", ps, depth, &info->status))
 806                 return False;
 807
 808         return True;
 809 }
 810
 811 /*******************************************************************
 812  Parse a PRINTER_INFO_7 structure.
 813 ********************************************************************/
 814
 815 bool smb_io_printer_info_7(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_7 *info, int depth)
 816 {
 817         prs_struct *ps=&buffer->prs;
 818
 819         prs_debug(ps, depth, desc, "smb_io_printer_info_7");
 820         depth++;
 821
 822         buffer->struct_start=prs_offset(ps);
 823
 824         if (!smb_io_relstr("guid", buffer, depth, &info->guid))
 825                 return False;
 826         if (!prs_uint32("action", ps, depth, &info->action))
 827                 return False;
 828         return True;
 829 }
 830
 831 /*******************************************************************
 832  Parse a PORT_INFO_1 structure.
 833 ********************************************************************/
 834
 835 bool smb_io_port_info_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
 836 {
 837         prs_struct *ps=&buffer->prs;
 838
 839         prs_debug(ps, depth, desc, "smb_io_port_info_1");
 840         depth++;
 841
 842         buffer->struct_start=prs_offset(ps);
 843
 844         if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
 845                 return False;
 846
 847         return True;
 848 }
 849
 850 /*******************************************************************
 851  Parse a PORT_INFO_2 structure.
 852 ********************************************************************/
 853
 854 bool smb_io_port_info_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
 855 {
 856         prs_struct *ps=&buffer->prs;
 857
 858         prs_debug(ps, depth, desc, "smb_io_port_info_2");
 859         depth++;
 860
 861         buffer->struct_start=prs_offset(ps);
 862
 863         if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
 864                 return False;
 865         if (!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
 866                 return False;
 867         if (!smb_io_relstr("description", buffer, depth, &info->description))
 868                 return False;
 869         if (!prs_uint32("port_type", ps, depth, &info->port_type))
 870                 return False;
 871         if (!prs_uint32("reserved", ps, depth, &info->reserved))
 872                 return False;
 873
 874         return True;
 875 }
 876
 877 /*******************************************************************
 878  Parse a DRIVER_INFO_1 structure.
 879 ********************************************************************/
 880
 881 bool smb_io_printer_driver_info_1(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_1 *info, int depth)
 882 {
 883         prs_struct *ps=&buffer->prs;
 884
 885         prs_debug(ps, depth, desc, "smb_io_printer_driver_info_1");
 886         depth++;
 887
 888         buffer->struct_start=prs_offset(ps);
 889
 890         if (!smb_io_relstr("name", buffer, depth, &info->name))
 891                 return False;
 892
 893         return True;
 894 }
 895
 896 /*******************************************************************
 897  Parse a DRIVER_INFO_2 structure.
 898 ********************************************************************/
 899
 900 bool smb_io_printer_driver_info_2(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_2 *info, int depth)
 901 {
 902         prs_struct *ps=&buffer->prs;
 903
 904         prs_debug(ps, depth, desc, "smb_io_printer_driver_info_2");
 905         depth++;
 906
 907         buffer->struct_start=prs_offset(ps);
 908
 909         if (!prs_uint32("version", ps, depth, &info->version))
 910                 return False;
 911         if (!smb_io_relstr("name", buffer, depth, &info->name))
 912                 return False;
 913         if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
 914                 return False;
 915         if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
 916                 return False;
 917         if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
 918                 return False;
 919         if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
 920                 return False;
 921
 922         return True;
 923 }
 924
 925 /*******************************************************************
 926  Parse a DRIVER_INFO_3 structure.
 927 ********************************************************************/
 928
 929 bool smb_io_printer_driver_info_3(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_3 *info, int depth)
 930 {
 931         prs_struct *ps=&buffer->prs;
 932
 933         prs_debug(ps, depth, desc, "smb_io_printer_driver_info_3");
 934         depth++;
 935
 936         buffer->struct_start=prs_offset(ps);
 937
 938         if (!prs_uint32("version", ps, depth, &info->version))
 939                 return False;
 940         if (!smb_io_relstr("name", buffer, depth, &info->name))
 941                 return False;
 942         if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
 943                 return False;
 944         if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
 945                 return False;
 946         if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
 947                 return False;
 948         if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
 949                 return False;
 950         if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
 951                 return False;
 952
 953         if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
 954                 return False;
 955
 956         if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
 957                 return False;
 958         if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
 959                 return False;
 960
 961         return True;
 962 }
 963
 964 /*******************************************************************
 965  Parse a DRIVER_INFO_6 structure.
 966 ********************************************************************/
 967
 968 bool smb_io_printer_driver_info_6(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_6 *info, int depth)
 969 {
 970         prs_struct *ps=&buffer->prs;
 971
 972         prs_debug(ps, depth, desc, "smb_io_printer_driver_info_6");
 973         depth++;
 974
 975         buffer->struct_start=prs_offset(ps);
 976
 977         if (!prs_uint32("version", ps, depth, &info->version))
 978                 return False;
 979         if (!smb_io_relstr("name", buffer, depth, &info->name))
 980                 return False;
 981         if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
 982                 return False;
 983         if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
 984                 return False;
 985         if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
 986                 return False;
 987         if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
 988                 return False;
 989         if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
 990                 return False;
 991
 992         if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
 993                 return False;
 994
 995         if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
 996                 return False;
 997         if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
 998                 return False;
 999
1000         if (!smb_io_relarraystr("previousdrivernames", buffer, depth, &info->previousdrivernames))
1001                 return False;
1002
1003         if (!prs_uint64("date", ps, depth, &info->driver_date))
1004                 return False;
1005
1006         if (!prs_uint32("padding", ps, depth, &info->padding))
1007                 return False;
1008
1009         if (!prs_uint32("driver_version_low", ps, depth, &info->driver_version_low))
1010                 return False;
1011
1012         if (!prs_uint32("driver_version_high", ps, depth, &info->driver_version_high))
1013                 return False;
1014
1015         if (!smb_io_relstr("mfgname", buffer, depth, &info->mfgname))
1016                 return False;
1017         if (!smb_io_relstr("oem_url", buffer, depth, &info->oem_url))
1018                 return False;
1019         if (!smb_io_relstr("hardware_id", buffer, depth, &info->hardware_id))
1020                 return False;
1021         if (!smb_io_relstr("provider", buffer, depth, &info->provider))
1022                 return False;
1023
1024         return True;
1025 }
1026
1027 /*******************************************************************
1028  Parse a JOB_INFO_1 structure.
1029 ********************************************************************/
1030
1031 bool smb_io_job_info_1(const char *desc, RPC_BUFFER *buffer, JOB_INFO_1 *info, int depth)
1032 {
1033         prs_struct *ps=&buffer->prs;
1034
1035         prs_debug(ps, depth, desc, "smb_io_job_info_1");
1036         depth++;
1037
1038         buffer->struct_start=prs_offset(ps);
1039
1040         if (!prs_uint32("jobid", ps, depth, &info->jobid))
1041                 return False;
1042         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
1043                 return False;
1044         if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
1045                 return False;
1046         if (!smb_io_relstr("username", buffer, depth, &info->username))
1047                 return False;
1048         if (!smb_io_relstr("document", buffer, depth, &info->document))
1049                 return False;
1050         if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
1051                 return False;
1052         if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
1053                 return False;
1054         if (!prs_uint32("status", ps, depth, &info->status))
1055                 return False;
1056         if (!prs_uint32("priority", ps, depth, &info->priority))
1057                 return False;
1058         if (!prs_uint32("position", ps, depth, &info->position))
1059                 return False;
1060         if (!prs_uint32("totalpages", ps, depth, &info->totalpages))
1061                 return False;
1062         if (!prs_uint32("pagesprinted", ps, depth, &info->pagesprinted))
1063                 return False;
1064         if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted))
1065                 return False;
1066
1067         return True;
1068 }
1069
1070 /*******************************************************************
1071  Parse a JOB_INFO_2 structure.
1072 ********************************************************************/
1073
1074 bool smb_io_job_info_2(const char *desc, RPC_BUFFER *buffer, JOB_INFO_2 *info, int depth)
1075 {
1076         uint32 pipo=0;
1077         prs_struct *ps=&buffer->prs;
1078
1079         prs_debug(ps, depth, desc, "smb_io_job_info_2");
1080         depth++;
1081
1082         buffer->struct_start=prs_offset(ps);
1083
1084         if (!prs_uint32("jobid",ps, depth, &info->jobid))
1085                 return False;
1086         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
1087                 return False;
1088         if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
1089                 return False;
1090         if (!smb_io_relstr("username", buffer, depth, &info->username))
1091                 return False;
1092         if (!smb_io_relstr("document", buffer, depth, &info->document))
1093                 return False;
1094         if (!smb_io_relstr("notifyname", buffer, depth, &info->notifyname))
1095                 return False;
1096         if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
1097                 return False;
1098
1099         if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
1100                 return False;
1101         if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
1102                 return False;
1103         if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
1104                 return False;
1105         if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
1106                 return False;
1107         if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
1108                 return False;
1109
1110 /*      SEC_DESC sec_desc;*/
1111         if (!prs_uint32("Hack! sec desc", ps, depth, &pipo))
1112                 return False;
1113
1114         if (!prs_uint32("status",ps, depth, &info->status))
1115                 return False;
1116         if (!prs_uint32("priority",ps, depth, &info->priority))
1117                 return False;
1118         if (!prs_uint32("position",ps, depth, &info->position))
1119                 return False;
1120         if (!prs_uint32("starttime",ps, depth, &info->starttime))
1121                 return False;
1122         if (!prs_uint32("untiltime",ps, depth, &info->untiltime))
1123                 return False;
1124         if (!prs_uint32("totalpages",ps, depth, &info->totalpages))
1125                 return False;
1126         if (!prs_uint32("size",ps, depth, &info->size))
1127                 return False;
1128         if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted) )
1129                 return False;
1130         if (!prs_uint32("timeelapsed",ps, depth, &info->timeelapsed))
1131                 return False;
1132         if (!prs_uint32("pagesprinted",ps, depth, &info->pagesprinted))
1133                 return False;
1134
1135         return True;
1136 }
1137
1138 /*******************************************************************
1139 ********************************************************************/
1140
1141 bool smb_io_form_1(const char *desc, RPC_BUFFER *buffer, FORM_1 *info, int depth)
1142 {
1143         prs_struct *ps=&buffer->prs;
1144
1145         prs_debug(ps, depth, desc, "smb_io_form_1");
1146         depth++;
1147
1148         buffer->struct_start=prs_offset(ps);
1149
1150         if (!prs_uint32("flag", ps, depth, &info->flag))
1151                 return False;
1152
1153         if (!smb_io_relstr("name", buffer, depth, &info->name))
1154                 return False;
1155
1156         if (!prs_uint32("width", ps, depth, &info->width))
1157                 return False;
1158         if (!prs_uint32("length", ps, depth, &info->length))
1159                 return False;
1160         if (!prs_uint32("left", ps, depth, &info->left))
1161                 return False;
1162         if (!prs_uint32("top", ps, depth, &info->top))
1163                 return False;
1164         if (!prs_uint32("right", ps, depth, &info->right))
1165                 return False;
1166         if (!prs_uint32("bottom", ps, depth, &info->bottom))
1167                 return False;
1168
1169         return True;
1170 }
1171
1172 /*******************************************************************
1173  Parse a PORT_INFO_1 structure.
1174 ********************************************************************/
1175
1176 bool smb_io_port_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
1177 {
1178         prs_struct *ps=&buffer->prs;
1179
1180         prs_debug(ps, depth, desc, "smb_io_port_1");
1181         depth++;
1182
1183         buffer->struct_start=prs_offset(ps);
1184
1185         if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
1186                 return False;
1187
1188         return True;
1189 }
1190
1191 /*******************************************************************
1192  Parse a PORT_INFO_2 structure.
1193 ********************************************************************/
1194
1195 bool smb_io_port_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
1196 {
1197         prs_struct *ps=&buffer->prs;
1198
1199         prs_debug(ps, depth, desc, "smb_io_port_2");
1200         depth++;
1201
1202         buffer->struct_start=prs_offset(ps);
1203
1204         if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
1205                 return False;
1206         if(!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
1207                 return False;
1208         if(!smb_io_relstr("description", buffer, depth, &info->description))
1209                 return False;
1210         if(!prs_uint32("port_type", ps, depth, &info->port_type))
1211                 return False;
1212         if(!prs_uint32("reserved", ps, depth, &info->reserved))
1213                 return False;
1214
1215         return True;
1216 }
1217
1218 /*******************************************************************
1219 ********************************************************************/
1220
1221 bool smb_io_printprocessor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_1 *info, int depth)
1222 {
1223         prs_struct *ps=&buffer->prs;
1224
1225         prs_debug(ps, depth, desc, "smb_io_printprocessor_info_1");
1226         depth++;
1227
1228         buffer->struct_start=prs_offset(ps);
1229
1230         if (smb_io_relstr("name", buffer, depth, &info->name))
1231                 return False;
1232
1233         return True;
1234 }
1235
1236 /*******************************************************************
1237 ********************************************************************/
1238
1239 bool smb_io_printprocdatatype_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCDATATYPE_1 *info, int depth)
1240 {
1241         prs_struct *ps=&buffer->prs;
1242
1243         prs_debug(ps, depth, desc, "smb_io_printprocdatatype_info_1");
1244         depth++;
1245
1246         buffer->struct_start=prs_offset(ps);
1247
1248         if (smb_io_relstr("name", buffer, depth, &info->name))
1249                 return False;
1250
1251         return True;
1252 }
1253
1254 /*******************************************************************
1255 ********************************************************************/
1256
1257 bool smb_io_printmonitor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_1 *info, int depth)
1258 {
1259         prs_struct *ps=&buffer->prs;
1260
1261         prs_debug(ps, depth, desc, "smb_io_printmonitor_info_1");
1262         depth++;
1263
1264         buffer->struct_start=prs_offset(ps);
1265
1266         if (!smb_io_relstr("name", buffer, depth, &info->name))
1267                 return False;
1268
1269         return True;
1270 }
1271
1272 /*******************************************************************
1273 ********************************************************************/
1274
1275 bool smb_io_printmonitor_info_2(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_2 *info, int depth)
1276 {
1277         prs_struct *ps=&buffer->prs;
1278
1279         prs_debug(ps, depth, desc, "smb_io_printmonitor_info_2");
1280         depth++;
1281
1282         buffer->struct_start=prs_offset(ps);
1283
1284         if (!smb_io_relstr("name", buffer, depth, &info->name))
1285                 return False;
1286         if (!smb_io_relstr("environment", buffer, depth, &info->environment))
1287                 return False;
1288         if (!smb_io_relstr("dll_name", buffer, depth, &info->dll_name))
1289                 return False;
1290
1291         return True;
1292 }
1293
1294 /*******************************************************************
1295 return the size required by a struct in the stream
1296 ********************************************************************/
1297
1298 uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
1299 {
1300         int size=0;
1301
1302         size+=size_of_relative_string( &info->printername );
1303         size+=size_of_relative_string( &info->servername );
1304
1305         size+=size_of_uint32( &info->cjobs);
1306         size+=size_of_uint32( &info->total_jobs);
1307         size+=size_of_uint32( &info->total_bytes);
1308
1309         size+=size_of_uint16( &info->year);
1310         size+=size_of_uint16( &info->month);
1311         size+=size_of_uint16( &info->dayofweek);
1312         size+=size_of_uint16( &info->day);
1313         size+=size_of_uint16( &info->hour);
1314         size+=size_of_uint16( &info->minute);
1315         size+=size_of_uint16( &info->second);
1316         size+=size_of_uint16( &info->milliseconds);
1317
1318         size+=size_of_uint32( &info->global_counter);
1319         size+=size_of_uint32( &info->total_pages);
1320
1321         size+=size_of_uint16( &info->major_version);
1322         size+=size_of_uint16( &info->build_version);
1323
1324         size+=size_of_uint32( &info->unknown7);
1325         size+=size_of_uint32( &info->unknown8);
1326         size+=size_of_uint32( &info->unknown9);
1327         size+=size_of_uint32( &info->session_counter);
1328         size+=size_of_uint32( &info->unknown11);
1329         size+=size_of_uint32( &info->printer_errors);
1330         size+=size_of_uint32( &info->unknown13);
1331         size+=size_of_uint32( &info->unknown14);
1332         size+=size_of_uint32( &info->unknown15);
1333         size+=size_of_uint32( &info->unknown16);
1334         size+=size_of_uint32( &info->change_id);
1335         size+=size_of_uint32( &info->unknown18);
1336         size+=size_of_uint32( &info->status);
1337         size+=size_of_uint32( &info->unknown20);
1338         size+=size_of_uint32( &info->c_setprinter);
1339
1340         size+=size_of_uint16( &info->unknown22);
1341         size+=size_of_uint16( &info->unknown23);
1342         size+=size_of_uint16( &info->unknown24);
1343         size+=size_of_uint16( &info->unknown25);
1344         size+=size_of_uint16( &info->unknown26);
1345         size+=size_of_uint16( &info->unknown27);
1346         size+=size_of_uint16( &info->unknown28);
1347         size+=size_of_uint16( &info->unknown29);
1348
1349         return size;
1350 }
1351
1352 /*******************************************************************
1353 return the size required by a struct in the stream
1354 ********************************************************************/
1355
1356 uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
1357 {
1358         int size=0;
1359
1360         size+=size_of_uint32( &info->flags );
1361         size+=size_of_relative_string( &info->description );
1362         size+=size_of_relative_string( &info->name );
1363         size+=size_of_relative_string( &info->comment );
1364
1365         return size;
1366 }
1367
1368 /*******************************************************************
1369 return the size required by a struct in the stream
1370 ********************************************************************/
1371
1372 uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
1373 {
1374         uint32 size=0;
1375
1376         size += 4;
1377
1378         size += ndr_size_security_descriptor( info->secdesc, NULL, 0 );
1379
1380         size+=size_of_device_mode( info->devmode );
1381
1382         size+=size_of_relative_string( &info->servername );
1383         size+=size_of_relative_string( &info->printername );
1384         size+=size_of_relative_string( &info->sharename );
1385         size+=size_of_relative_string( &info->portname );
1386         size+=size_of_relative_string( &info->drivername );
1387         size+=size_of_relative_string( &info->comment );
1388         size+=size_of_relative_string( &info->location );
1389
1390         size+=size_of_relative_string( &info->sepfile );
1391         size+=size_of_relative_string( &info->printprocessor );
1392         size+=size_of_relative_string( &info->datatype );
1393         size+=size_of_relative_string( &info->parameters );
1394
1395         size+=size_of_uint32( &info->attributes );
1396         size+=size_of_uint32( &info->priority );
1397         size+=size_of_uint32( &info->defaultpriority );
1398         size+=size_of_uint32( &info->starttime );
1399         size+=size_of_uint32( &info->untiltime );
1400         size+=size_of_uint32( &info->status );
1401         size+=size_of_uint32( &info->cjobs );
1402         size+=size_of_uint32( &info->averageppm );
1403
1404         /*
1405          * add any adjustments for alignment.  This is
1406          * not optimal since we could be calling this
1407          * function from a loop (e.g. enumprinters), but
1408          * it is easier to maintain the calculation here and
1409          * not place the burden on the caller to remember.   --jerry
1410          */
1411         if ((size % 4) != 0)
1412                 size += 4 - (size % 4);
1413
1414         return size;
1415 }
1416
1417 /*******************************************************************
1418 return the size required by a struct in the stream
1419 ********************************************************************/
1420
1421 uint32 spoolss_size_printer_info_4(PRINTER_INFO_4 *info)
1422 {
1423         uint32 size=0;
1424
1425         size+=size_of_relative_string( &info->printername );
1426         size+=size_of_relative_string( &info->servername );
1427
1428         size+=size_of_uint32( &info->attributes );
1429         return size;
1430 }
1431
1432 /*******************************************************************
1433 return the size required by a struct in the stream
1434 ********************************************************************/
1435
1436 uint32 spoolss_size_printer_info_5(PRINTER_INFO_5 *info)
1437 {
1438         uint32 size=0;
1439
1440         size+=size_of_relative_string( &info->printername );
1441         size+=size_of_relative_string( &info->portname );
1442
1443         size+=size_of_uint32( &info->attributes );
1444         size+=size_of_uint32( &info->device_not_selected_timeout );
1445         size+=size_of_uint32( &info->transmission_retry_timeout );
1446         return size;
1447 }
1448
1449 /*******************************************************************
1450 return the size required by a struct in the stream
1451 ********************************************************************/
1452
1453 uint32 spoolss_size_printer_info_6(PRINTER_INFO_6 *info)
1454 {
1455         return sizeof(uint32);
1456 }
1457
1458 /*******************************************************************
1459 return the size required by a struct in the stream
1460 ********************************************************************/
1461
1462 uint32 spoolss_size_printer_info_3(PRINTER_INFO_3 *info)
1463 {
1464         /* The 8 is for the self relative pointer - 8 byte aligned.. */
1465         return 8 + (uint32)ndr_size_security_descriptor( info->secdesc, NULL, 0 );
1466 }
1467
1468 /*******************************************************************
1469 return the size required by a struct in the stream
1470 ********************************************************************/
1471
1472 uint32 spoolss_size_printer_info_7(PRINTER_INFO_7 *info)
1473 {
1474         uint32 size=0;
1475
1476         size+=size_of_relative_string( &info->guid );
1477         size+=size_of_uint32( &info->action );
1478         return size;
1479 }
1480
1481 /*******************************************************************
1482 return the size required by a struct in the stream
1483 ********************************************************************/
1484
1485 uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
1486 {
1487         int size=0;
1488         size+=size_of_relative_string( &info->name );
1489
1490         return size;
1491 }
1492
1493 /*******************************************************************
1494 return the size required by a struct in the stream
1495 ********************************************************************/
1496
1497 uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
1498 {
1499         int size=0;
1500         size+=size_of_uint32( &info->version );
1501         size+=size_of_relative_string( &info->name );
1502         size+=size_of_relative_string( &info->architecture );
1503         size+=size_of_relative_string( &info->driverpath );
1504         size+=size_of_relative_string( &info->datafile );
1505         size+=size_of_relative_string( &info->configfile );
1506
1507         return size;
1508 }
1509
1510 /*******************************************************************
1511 return the size required by a string array.
1512 ********************************************************************/
1513
1514 uint32 spoolss_size_string_array(uint16 *string)
1515 {
1516         uint32 i = 0;
1517
1518         if (string) {
1519                 for (i=0; (string[i]!=0x0000) || (string[i+1]!=0x0000); i++);
1520         }
1521         i=i+2; /* to count all chars including the leading zero */
1522         i=2*i; /* because we need the value in bytes */
1523         i=i+4; /* the offset pointer size */
1524
1525         return i;
1526 }
1527
1528 /*******************************************************************
1529 return the size required by a struct in the stream
1530 ********************************************************************/
1531
1532 uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
1533 {
1534         int size=0;
1535
1536         size+=size_of_uint32( &info->version );
1537         size+=size_of_relative_string( &info->name );
1538         size+=size_of_relative_string( &info->architecture );
1539         size+=size_of_relative_string( &info->driverpath );
1540         size+=size_of_relative_string( &info->datafile );
1541         size+=size_of_relative_string( &info->configfile );
1542         size+=size_of_relative_string( &info->helpfile );
1543         size+=size_of_relative_string( &info->monitorname );
1544         size+=size_of_relative_string( &info->defaultdatatype );
1545
1546         size+=spoolss_size_string_array(info->dependentfiles);
1547
1548         return size;
1549 }
1550
1551 /*******************************************************************
1552 return the size required by a struct in the stream
1553 ********************************************************************/
1554
1555 uint32 spoolss_size_printer_driver_info_6(DRIVER_INFO_6 *info)
1556 {
1557         uint32 size=0;
1558
1559         size+=size_of_uint32( &info->version );
1560         size+=size_of_relative_string( &info->name );
1561         size+=size_of_relative_string( &info->architecture );
1562         size+=size_of_relative_string( &info->driverpath );
1563         size+=size_of_relative_string( &info->datafile );
1564         size+=size_of_relative_string( &info->configfile );
1565         size+=size_of_relative_string( &info->helpfile );
1566
1567         size+=spoolss_size_string_array(info->dependentfiles);
1568
1569         size+=size_of_relative_string( &info->monitorname );
1570         size+=size_of_relative_string( &info->defaultdatatype );
1571
1572         size+=spoolss_size_string_array(info->previousdrivernames);
1573
1574         size+=size_of_nttime(&info->driver_date);
1575         size+=size_of_uint32( &info->padding );
1576         size+=size_of_uint32( &info->driver_version_low );
1577         size+=size_of_uint32( &info->driver_version_high );
1578         size+=size_of_relative_string( &info->mfgname );
1579         size+=size_of_relative_string( &info->oem_url );
1580         size+=size_of_relative_string( &info->hardware_id );
1581         size+=size_of_relative_string( &info->provider );
1582
1583         return size;
1584 }
1585
1586 /*******************************************************************
1587 return the size required by a struct in the stream
1588 ********************************************************************/
1589
1590 uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
1591 {
1592         int size=0;
1593         size+=size_of_uint32( &info->jobid );
1594         size+=size_of_relative_string( &info->printername );
1595         size+=size_of_relative_string( &info->machinename );
1596         size+=size_of_relative_string( &info->username );
1597         size+=size_of_relative_string( &info->document );
1598         size+=size_of_relative_string( &info->datatype );
1599         size+=size_of_relative_string( &info->text_status );
1600         size+=size_of_uint32( &info->status );
1601         size+=size_of_uint32( &info->priority );
1602         size+=size_of_uint32( &info->position );
1603         size+=size_of_uint32( &info->totalpages );
1604         size+=size_of_uint32( &info->pagesprinted );
1605         size+=size_of_systemtime( &info->submitted );
1606
1607         return size;
1608 }
1609
1610 /*******************************************************************
1611 return the size required by a struct in the stream
1612 ********************************************************************/
1613
1614 uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
1615 {
1616         int size=0;
1617
1618         size+=4; /* size of sec desc ptr */
1619
1620         size+=size_of_uint32( &info->jobid );
1621         size+=size_of_relative_string( &info->printername );
1622         size+=size_of_relative_string( &info->machinename );
1623         size+=size_of_relative_string( &info->username );
1624         size+=size_of_relative_string( &info->document );
1625         size+=size_of_relative_string( &info->notifyname );
1626         size+=size_of_relative_string( &info->datatype );
1627         size+=size_of_relative_string( &info->printprocessor );
1628         size+=size_of_relative_string( &info->parameters );
1629         size+=size_of_relative_string( &info->drivername );
1630         size+=size_of_device_mode( info->devmode );
1631         size+=size_of_relative_string( &info->text_status );
1632 /*      SEC_DESC sec_desc;*/
1633         size+=size_of_uint32( &info->status );
1634         size+=size_of_uint32( &info->priority );
1635         size+=size_of_uint32( &info->position );
1636         size+=size_of_uint32( &info->starttime );
1637         size+=size_of_uint32( &info->untiltime );
1638         size+=size_of_uint32( &info->totalpages );
1639         size+=size_of_uint32( &info->size );
1640         size+=size_of_systemtime( &info->submitted );
1641         size+=size_of_uint32( &info->timeelapsed );
1642         size+=size_of_uint32( &info->pagesprinted );
1643
1644         return size;
1645 }
1646
1647 /*******************************************************************
1648 return the size required by a struct in the stream
1649 ********************************************************************/
1650
1651 uint32 spoolss_size_form_1(FORM_1 *info)
1652 {
1653         int size=0;
1654
1655         size+=size_of_uint32( &info->flag );
1656         size+=size_of_relative_string( &info->name );
1657         size+=size_of_uint32( &info->width );
1658         size+=size_of_uint32( &info->length );
1659         size+=size_of_uint32( &info->left );
1660         size+=size_of_uint32( &info->top );
1661         size+=size_of_uint32( &info->right );
1662         size+=size_of_uint32( &info->bottom );
1663
1664         return size;
1665 }
1666
1667 /*******************************************************************
1668 return the size required by a struct in the stream
1669 ********************************************************************/
1670
1671 uint32 spoolss_size_port_info_1(PORT_INFO_1 *info)
1672 {
1673         int size=0;
1674
1675         size+=size_of_relative_string( &info->port_name );
1676
1677         return size;
1678 }
1679
1680 /*******************************************************************
1681 return the size required by a struct in the stream
1682 ********************************************************************/
1683
1684 uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
1685 {
1686         int size=0;
1687
1688         size+=size_of_relative_string( &info->port_name );
1689         size+=size_of_relative_string( &info->monitor_name );
1690         size+=size_of_relative_string( &info->description );
1691
1692         size+=size_of_uint32( &info->port_type );
1693         size+=size_of_uint32( &info->reserved );
1694
1695         return size;
1696 }
1697
1698 /*******************************************************************
1699 return the size required by a struct in the stream
1700 ********************************************************************/
1701
1702 uint32 spoolss_size_printprocessor_info_1(PRINTPROCESSOR_1 *info)
1703 {
1704         int size=0;
1705         size+=size_of_relative_string( &info->name );
1706
1707         return size;
1708 }
1709
1710 /*******************************************************************
1711 return the size required by a struct in the stream
1712 ********************************************************************/
1713
1714 uint32 spoolss_size_printprocdatatype_info_1(PRINTPROCDATATYPE_1 *info)
1715 {
1716         int size=0;
1717         size+=size_of_relative_string( &info->name );
1718
1719         return size;
1720 }
1721
1722 /*******************************************************************
1723 return the size required by a struct in the stream
1724 ********************************************************************/
1725 uint32 spoolss_size_printer_enum_values(PRINTER_ENUM_VALUES *p)
1726 {
1727         uint32  size = 0;
1728
1729         if (!p)
1730                 return 0;
1731
1732         /* uint32(offset) + uint32(length) + length) */
1733         size += (size_of_uint32(&p->value_len)*2) + p->value_len;
1734         size += (size_of_uint32(&p->data_len)*2) + p->data_len + (p->data_len%2) ;
1735
1736         size += size_of_uint32(&p->type);
1737
1738         return size;
1739 }
1740
1741 /*******************************************************************
1742 return the size required by a struct in the stream
1743 ********************************************************************/
1744
1745 uint32 spoolss_size_printmonitor_info_1(PRINTMONITOR_1 *info)
1746 {
1747         int size=0;
1748         size+=size_of_relative_string( &info->name );
1749
1750         return size;
1751 }
1752
1753 /*******************************************************************
1754 return the size required by a struct in the stream
1755 ********************************************************************/
1756
1757 uint32 spoolss_size_printmonitor_info_2(PRINTMONITOR_2 *info)
1758 {
1759         int size=0;
1760         size+=size_of_relative_string( &info->name);
1761         size+=size_of_relative_string( &info->environment);
1762         size+=size_of_relative_string( &info->dll_name);
1763
1764         return size;
1765 }
1766
1767 /*******************************************************************
1768  * read a structure.
1769  * called from spoolss_getprinterdriver2 (srv_spoolss.c)
1770  ********************************************************************/
1771
1772 bool spoolss_io_q_getprinterdriver2(const char *desc, SPOOL_Q_GETPRINTERDRIVER2 *q_u, prs_struct *ps, int depth)
1773 {
1774         prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriver2");
1775         depth++;
1776
1777         if(!prs_align(ps))
1778                 return False;
1779
1780         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1781                 return False;
1782         if(!prs_uint32("architecture_ptr", ps, depth, &q_u->architecture_ptr))
1783                 return False;
1784         if(!smb_io_unistr2("architecture", &q_u->architecture, q_u->architecture_ptr, ps, depth))
1785                 return False;
1786
1787         if(!prs_align(ps))
1788                 return False;
1789         if(!prs_uint32("level", ps, depth, &q_u->level))
1790                 return False;
1791
1792         if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
1793                 return False;
1794
1795         if(!prs_align(ps))
1796                 return False;
1797
1798         if(!prs_uint32("offered", ps, depth, &q_u->offered))
1799                 return False;
1800
1801         if(!prs_uint32("clientmajorversion", ps, depth, &q_u->clientmajorversion))
1802                 return False;
1803         if(!prs_uint32("clientminorversion", ps, depth, &q_u->clientminorversion))
1804                 return False;
1805
1806         return True;
1807 }
1808
1809 /*******************************************************************
1810  * read a structure.
1811  * called from spoolss_getprinterdriver2 (srv_spoolss.c)
1812  ********************************************************************/
1813
1814 bool spoolss_io_r_getprinterdriver2(const char *desc, SPOOL_R_GETPRINTERDRIVER2 *r_u, prs_struct *ps, int depth)
1815 {
1816         prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriver2");
1817         depth++;
1818
1819         if (!prs_align(ps))
1820                 return False;
1821
1822         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
1823                 return False;
1824
1825         if (!prs_align(ps))
1826                 return False;
1827         if (!prs_uint32("needed", ps, depth, &r_u->needed))
1828                 return False;
1829         if (!prs_uint32("servermajorversion", ps, depth, &r_u->servermajorversion))
1830                 return False;
1831         if (!prs_uint32("serverminorversion", ps, depth, &r_u->serverminorversion))
1832                 return False;
1833         if (!prs_werror("status", ps, depth, &r_u->status))
1834                 return False;
1835
1836         return True;
1837 }
1838
1839 /*******************************************************************
1840  * init a structure.
1841  ********************************************************************/
1842
1843 bool make_spoolss_q_enumprinters(
1844         SPOOL_Q_ENUMPRINTERS *q_u,
1845         uint32 flags,
1846         char *servername,
1847         uint32 level,
1848         RPC_BUFFER *buffer,
1849         uint32 offered
1850 )
1851 {
1852         q_u->flags=flags;
1853
1854         q_u->servername_ptr = (servername != NULL) ? 1 : 0;
1855         init_buf_unistr2(&q_u->servername, &q_u->servername_ptr, servername);
1856
1857         q_u->level=level;
1858         q_u->buffer=buffer;
1859         q_u->offered=offered;
1860
1861         return True;
1862 }
1863
1864 /*******************************************************************
1865  * init a structure.
1866  ********************************************************************/
1867
1868 bool make_spoolss_q_enumports(SPOOL_Q_ENUMPORTS *q_u,
1869                                 fstring servername, uint32 level,
1870                                 RPC_BUFFER *buffer, uint32 offered)
1871 {
1872         q_u->name_ptr = (servername != NULL) ? 1 : 0;
1873         init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
1874
1875         q_u->level=level;
1876         q_u->buffer=buffer;
1877         q_u->offered=offered;
1878
1879         return True;
1880 }
1881
1882 /*******************************************************************
1883  * read a structure.
1884  * called from spoolss_enumprinters (srv_spoolss.c)
1885  ********************************************************************/
1886
1887 bool spoolss_io_q_enumprinters(const char *desc, SPOOL_Q_ENUMPRINTERS *q_u, prs_struct *ps, int depth)
1888 {
1889         prs_debug(ps, depth, desc, "spoolss_io_q_enumprinters");
1890         depth++;
1891
1892         if (!prs_align(ps))
1893                 return False;
1894
1895         if (!prs_uint32("flags", ps, depth, &q_u->flags))
1896                 return False;
1897         if (!prs_uint32("servername_ptr", ps, depth, &q_u->servername_ptr))
1898                 return False;
1899
1900         if (!smb_io_unistr2("", &q_u->servername, q_u->servername_ptr, ps, depth))
1901                 return False;
1902
1903         if (!prs_align(ps))
1904                 return False;
1905         if (!prs_uint32("level", ps, depth, &q_u->level))
1906                 return False;
1907
1908         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
1909                 return False;
1910
1911         if (!prs_align(ps))
1912                 return False;
1913         if (!prs_uint32("offered", ps, depth, &q_u->offered))
1914                 return False;
1915
1916         return True;
1917 }
1918
1919 /*******************************************************************
1920  Parse a SPOOL_R_ENUMPRINTERS structure.
1921  ********************************************************************/
1922
1923 bool spoolss_io_r_enumprinters(const char *desc, SPOOL_R_ENUMPRINTERS *r_u, prs_struct *ps, int depth)
1924 {
1925         prs_debug(ps, depth, desc, "spoolss_io_r_enumprinters");
1926         depth++;
1927
1928         if (!prs_align(ps))
1929                 return False;
1930
1931         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
1932                 return False;
1933
1934         if (!prs_align(ps))
1935                 return False;
1936
1937         if (!prs_uint32("needed", ps, depth, &r_u->needed))
1938                 return False;
1939
1940         if (!prs_uint32("returned", ps, depth, &r_u->returned))
1941                 return False;
1942
1943         if (!prs_werror("status", ps, depth, &r_u->status))
1944                 return False;
1945
1946         return True;
1947 }
1948
1949 /*******************************************************************
1950  * write a structure.
1951  * called from spoolss_r_enum_printers (srv_spoolss.c)
1952  *
1953  ********************************************************************/
1954
1955 bool spoolss_io_r_getprinter(const char *desc, SPOOL_R_GETPRINTER *r_u, prs_struct *ps, int depth)
1956 {
1957         prs_debug(ps, depth, desc, "spoolss_io_r_getprinter");
1958         depth++;
1959
1960         if (!prs_align(ps))
1961                 return False;
1962
1963         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
1964                 return False;
1965
1966         if (!prs_align(ps))
1967                 return False;
1968
1969         if (!prs_uint32("needed", ps, depth, &r_u->needed))
1970                 return False;
1971
1972         if (!prs_werror("status", ps, depth, &r_u->status))
1973                 return False;
1974
1975         return True;
1976 }
1977
1978 /*******************************************************************
1979  * read a structure.
1980  * called from spoolss_getprinter (srv_spoolss.c)
1981  ********************************************************************/
1982
1983 bool spoolss_io_q_getprinter(const char *desc, SPOOL_Q_GETPRINTER *q_u, prs_struct *ps, int depth)
1984 {
1985         prs_debug(ps, depth, desc, "spoolss_io_q_getprinter");
1986         depth++;
1987
1988         if (!prs_align(ps))
1989                 return False;
1990
1991         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1992                 return False;
1993         if (!prs_uint32("level", ps, depth, &q_u->level))
1994                 return False;
1995
1996         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
1997                 return False;
1998
1999         if (!prs_align(ps))
2000                 return False;
2001         if (!prs_uint32("offered", ps, depth, &q_u->offered))
2002                 return False;
2003
2004         return True;
2005 }
2006
2007 /*******************************************************************
2008 ********************************************************************/
2009
2010 bool spoolss_io_r_enumjobs(const char *desc, SPOOL_R_ENUMJOBS *r_u, prs_struct *ps, int depth)
2011 {
2012         prs_debug(ps, depth, desc, "spoolss_io_r_enumjobs");
2013         depth++;
2014
2015         if (!prs_align(ps))
2016                 return False;
2017
2018         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
2019                 return False;
2020
2021         if (!prs_align(ps))
2022                 return False;
2023
2024         if (!prs_uint32("needed", ps, depth, &r_u->needed))
2025                 return False;
2026
2027         if (!prs_uint32("returned", ps, depth, &r_u->returned))
2028                 return False;
2029
2030         if (!prs_werror("status", ps, depth, &r_u->status))
2031                 return False;
2032
2033         return True;
2034 }
2035
2036 /*******************************************************************
2037 ********************************************************************/
2038
2039 bool make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS *q_u, const POLICY_HND *hnd,
2040                                 uint32 firstjob,
2041                                 uint32 numofjobs,
2042                                 uint32 level,
2043                                 RPC_BUFFER *buffer,
2044                                 uint32 offered)
2045 {
2046         if (q_u == NULL)
2047         {
2048                 return False;
2049         }
2050         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
2051         q_u->firstjob = firstjob;
2052         q_u->numofjobs = numofjobs;
2053         q_u->level = level;
2054         q_u->buffer= buffer;
2055         q_u->offered = offered;
2056         return True;
2057 }
2058
2059 /*******************************************************************
2060 ********************************************************************/
2061
2062 bool spoolss_io_q_enumjobs(const char *desc, SPOOL_Q_ENUMJOBS *q_u, prs_struct *ps, int depth)
2063 {
2064         prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs");
2065         depth++;
2066
2067         if (!prs_align(ps))
2068                 return False;
2069
2070         if (!smb_io_pol_hnd("printer handle",&q_u->handle, ps, depth))
2071                 return False;
2072
2073         if (!prs_uint32("firstjob", ps, depth, &q_u->firstjob))
2074                 return False;
2075         if (!prs_uint32("numofjobs", ps, depth, &q_u->numofjobs))
2076                 return False;
2077         if (!prs_uint32("level", ps, depth, &q_u->level))
2078                 return False;
2079
2080         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
2081                 return False;
2082
2083         if(!prs_align(ps))
2084                 return False;
2085
2086         if (!prs_uint32("offered", ps, depth, &q_u->offered))
2087                 return False;
2088
2089         return True;
2090 }
2091
2092 /*******************************************************************
2093  Parse a SPOOL_R_ENUMPRINTERDRIVERS structure.
2094 ********************************************************************/
2095
2096 bool spoolss_io_r_enumprinterdrivers(const char *desc, SPOOL_R_ENUMPRINTERDRIVERS *r_u, prs_struct *ps, int depth)
2097 {
2098         prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdrivers");
2099         depth++;
2100
2101         if (!prs_align(ps))
2102                 return False;
2103
2104         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
2105                 return False;
2106
2107         if (!prs_align(ps))
2108                 return False;
2109
2110         if (!prs_uint32("needed", ps, depth, &r_u->needed))
2111                 return False;
2112
2113         if (!prs_uint32("returned", ps, depth, &r_u->returned))
2114                 return False;
2115
2116         if (!prs_werror("status", ps, depth, &r_u->status))
2117                 return False;
2118
2119         return True;
2120 }
2121
2122 /*******************************************************************
2123  * init a structure.
2124  ********************************************************************/
2125
2126 bool make_spoolss_q_enumprinterdrivers(SPOOL_Q_ENUMPRINTERDRIVERS *q_u,
2127                                 const char *name,
2128                                 const char *environment,
2129                                 uint32 level,
2130                                 RPC_BUFFER *buffer, uint32 offered)
2131 {
2132         init_buf_unistr2(&q_u->name, &q_u->name_ptr, name);
2133         init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, environment);
2134
2135         q_u->level=level;
2136         q_u->buffer=buffer;
2137         q_u->offered=offered;
2138
2139         return True;
2140 }
2141
2142 /*******************************************************************
2143  Parse a SPOOL_Q_ENUMPRINTERDRIVERS structure.
2144 ********************************************************************/
2145
2146 bool spoolss_io_q_enumprinterdrivers(const char *desc, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, prs_struct *ps, int depth)
2147 {
2148
2149         prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdrivers");
2150         depth++;
2151
2152         if (!prs_align(ps))
2153                 return False;
2154
2155         if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
2156                 return False;
2157         if (!smb_io_unistr2("", &q_u->name, q_u->name_ptr,ps, depth))
2158                 return False;
2159
2160         if (!prs_align(ps))
2161                 return False;
2162         if (!prs_uint32("environment_ptr", ps, depth, &q_u->environment_ptr))
2163                 return False;
2164         if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
2165                 return False;
2166
2167         if (!prs_align(ps))
2168                 return False;
2169         if (!prs_uint32("level", ps, depth, &q_u->level))
2170                 return False;
2171
2172         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
2173                 return False;
2174
2175         if (!prs_align(ps))
2176                 return False;
2177
2178         if (!prs_uint32("offered", ps, depth, &q_u->offered))
2179                 return False;
2180
2181         return True;
2182 }
2183
2184 /*******************************************************************
2185 ********************************************************************/
2186
2187 bool spoolss_io_q_enumforms(const char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth)
2188 {
2189
2190         prs_debug(ps, depth, desc, "spoolss_io_q_enumforms");
2191         depth++;
2192
2193         if (!prs_align(ps))
2194                 return False;
2195         if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
2196                 return False;
2197         if (!prs_uint32("level", ps, depth, &q_u->level))
2198                 return False;
2199
2200         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
2201                 return False;
2202
2203         if (!prs_align(ps))
2204                 return False;
2205         if (!prs_uint32("offered", ps, depth, &q_u->offered))
2206                 return False;
2207
2208         return True;
2209 }
2210
2211 /*******************************************************************
2212 ********************************************************************/
2213
2214 bool spoolss_io_r_enumforms(const char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth)
2215 {
2216         prs_debug(ps, depth, desc, "spoolss_io_r_enumforms");
2217         depth++;
2218
2219         if (!prs_align(ps))
2220                 return False;
2221
2222         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
2223                 return False;
2224
2225         if (!prs_align(ps))
2226                 return False;
2227
2228         if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
2229                 return False;
2230
2231         if (!prs_uint32("numofforms", ps, depth, &r_u->numofforms))
2232                 return False;
2233
2234         if (!prs_werror("status", ps, depth, &r_u->status))
2235                 return False;
2236
2237         return True;
2238 }
2239
2240 /*******************************************************************
2241  Parse a SPOOL_R_ENUMPORTS structure.
2242 ********************************************************************/
2243
2244 bool spoolss_io_r_enumports(const char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
2245 {
2246         prs_debug(ps, depth, desc, "spoolss_io_r_enumports");
2247         depth++;
2248
2249         if (!prs_align(ps))
2250                 return False;
2251
2252         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
2253                 return False;
2254
2255         if (!prs_align(ps))
2256                 return False;
2257
2258         if (!prs_uint32("needed", ps, depth, &r_u->needed))
2259                 return False;
2260
2261         if (!prs_uint32("returned", ps, depth, &r_u->returned))
2262                 return False;
2263
2264         if (!prs_werror("status", ps, depth, &r_u->status))
2265                 return False;
2266
2267         return True;
2268 }
2269
2270 /*******************************************************************
2271 ********************************************************************/
2272
2273 bool spoolss_io_q_enumports(const char *desc, SPOOL_Q_ENUMPORTS *q_u, prs_struct *ps, int depth)
2274 {
2275         prs_debug(ps, depth, desc, "");
2276         depth++;
2277
2278         if (!prs_align(ps))
2279                 return False;
2280
2281         if (!prs_uint32("", ps, depth, &q_u->name_ptr))
2282                 return False;
2283         if (!smb_io_unistr2("", &q_u->name,True,ps,depth))
2284                 return False;
2285
2286         if (!prs_align(ps))
2287                 return False;
2288         if (!prs_uint32("level", ps, depth, &q_u->level))
2289                 return False;
2290
2291         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
2292                 return False;
2293
2294         if (!prs_align(ps))
2295                 return False;
2296         if (!prs_uint32("offered", ps, depth, &q_u->offered))
2297                 return False;
2298
2299         return True;
2300 }
2301
2302 /*******************************************************************
2303  make a BUFFER5 struct from a uint16*
2304  ******************************************************************/
2305
2306 bool make_spoolss_buffer5(TALLOC_CTX *mem_ctx, BUFFER5 *buf5, uint32 len, uint16 *src)
2307 {
2308
2309         buf5->buf_len = len;
2310         if (src) {
2311                 if (len) {
2312                         if((buf5->buffer=(uint16*)TALLOC_MEMDUP(mem_ctx, src, sizeof(uint16)*len)) == NULL) {
2313                                 DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
2314                                 return False;
2315                         }
2316                 } else {
2317                         buf5->buffer = NULL;
2318                 }
2319         } else {
2320                 buf5->buffer=NULL;
2321         }
2322
2323         return True;
2324 }
2325
2326 /*******************************************************************
2327 ********************************************************************/
2328
2329 bool spoolss_io_r_enumprintprocessors(const char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
2330 {
2331         prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
2332         depth++;
2333
2334         if (!prs_align(ps))
2335                 return False;
2336
2337         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
2338                 return False;
2339
2340         if (!prs_align(ps))
2341                 return False;
2342
2343         if (!prs_uint32("needed", ps, depth, &r_u->needed))
2344                 return False;
2345
2346         if (!prs_uint32("returned", ps, depth, &r_u->returned))
2347                 return False;
2348
2349         if (!prs_werror("status", ps, depth, &r_u->status))
2350                 return False;
2351
2352         return True;
2353 }
2354
2355 /*******************************************************************
2356 ********************************************************************/
2357
2358 bool spoolss_io_q_enumprintprocessors(const char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
2359 {
2360         prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
2361         depth++;
2362
2363         if (!prs_align(ps))
2364                 return False;
2365
2366         if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
2367                 return False;
2368         if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
2369                 return False;
2370
2371         if (!prs_align(ps))
2372                 return False;
2373
2374         if (!prs_uint32("", ps, depth, &q_u->environment_ptr))
2375                 return False;
2376         if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
2377                 return False;
2378
2379         if (!prs_align(ps))
2380                 return False;
2381
2382         if (!prs_uint32("level", ps, depth, &q_u->level))
2383                 return False;
2384
2385         if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
2386                 return False;
2387
2388         if (!prs_align(ps))
2389                 return False;
2390
2391         if (!prs_uint32("offered", ps, depth, &q_u->offered))
2392                 return False;
2393
2394         return True;
2395 }
2396
2397 /*******************************************************************
2398 ********************************************************************/
2399
2400 bool spoolss_io_r_enumprintprocdatatypes(const char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u, prs_struct *ps, int depth)
2401 {
2402         prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes");
2403         depth++;
2404
2405         if (!prs_align(ps))
2406                 return False;
2407
2408         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
2409                 return False;
2410
2411         if (!prs_align(ps))
2412                 return False;
2413
2414         if (!prs_uint32("needed", ps, depth, &r_u->needed))
2415                 return False;
2416
2417         if (!prs_uint32("returned", ps, depth, &r_u->returned))
2418                 return False;
2419
2420         if (!prs_werror("status", ps, depth, &r_u->status))
2421                 return False;
2422
2423         return True;
2424 }
2425
2426 /*******************************************************************
2427 ********************************************************************/
2428
2429 bool spoolss_io_q_enumprintprocdatatypes(const char *desc, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, prs_struct *ps, int depth)
2430 {
2431         prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocdatatypes");
2432         depth++;
2433
2434         if (!prs_align(ps))
2435                 return False;
2436
2437         if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
2438                 return False;
2439         if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
2440                 return False;
2441
2442         if (!prs_align(ps))
2443                 return False;
2444
2445         if (!prs_uint32("processor_ptr", ps, depth, &q_u->processor_ptr))
2446                 return False;
2447         if (!smb_io_unistr2("processor", &q_u->processor, q_u->processor_ptr, ps, depth))
2448                 return False;
2449
2450         if (!prs_align(ps))
2451                 return False;
2452
2453         if (!prs_uint32("level", ps, depth, &q_u->level))
2454                 return False;
2455
2456         if(!prs_rpcbuffer_p("buffer", ps, depth, &q_u->buffer))
2457                 return False;
2458
2459         if (!prs_align(ps))
2460                 return False;
2461
2462         if (!prs_uint32("offered", ps, depth, &q_u->offered))
2463                 return False;
2464
2465         return True;
2466 }
2467
2468 /*******************************************************************
2469  Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
2470 ********************************************************************/
2471
2472 bool spoolss_io_q_enumprintmonitors(const char *desc, SPOOL_Q_ENUMPRINTMONITORS *q_u, prs_struct *ps, int depth)
2473 {
2474         prs_debug(ps, depth, desc, "spoolss_io_q_enumprintmonitors");
2475         depth++;
2476
2477         if (!prs_align(ps))
2478                 return False;
2479
2480         if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
2481                 return False;
2482         if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
2483                 return False;
2484
2485         if (!prs_align(ps))
2486                 return False;
2487
2488         if (!prs_uint32("level", ps, depth, &q_u->level))
2489                 return False;
2490
2491         if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
2492                 return False;
2493
2494         if (!prs_align(ps))
2495                 return False;
2496
2497         if (!prs_uint32("offered", ps, depth, &q_u->offered))
2498                 return False;
2499
2500         return True;
2501 }
2502
2503 /*******************************************************************
2504 ********************************************************************/
2505
2506 bool spoolss_io_r_enumprintmonitors(const char *desc, SPOOL_R_ENUMPRINTMONITORS *r_u, prs_struct *ps, int depth)
2507 {
2508         prs_debug(ps, depth, desc, "spoolss_io_r_enumprintmonitors");
2509         depth++;
2510
2511         if (!prs_align(ps))
2512                 return False;
2513
2514         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
2515                 return False;
2516
2517         if (!prs_align(ps))
2518                 return False;
2519
2520         if (!prs_uint32("needed", ps, depth, &r_u->needed))
2521                 return False;
2522
2523         if (!prs_uint32("returned", ps, depth, &r_u->returned))
2524                 return False;
2525
2526         if (!prs_werror("status", ps, depth, &r_u->status))
2527                 return False;
2528
2529         return True;
2530 }
2531
2532 /*******************************************************************
2533 ********************************************************************/
2534
2535 bool spoolss_io_r_enumprinterdata(const char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth)
2536 {
2537         prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata");
2538         depth++;
2539
2540         if(!prs_align(ps))
2541                 return False;
2542         if(!prs_uint32("valuesize", ps, depth, &r_u->valuesize))
2543                 return False;
2544
2545         if (UNMARSHALLING(ps) && r_u->valuesize) {
2546                 r_u->value = PRS_ALLOC_MEM(ps, uint16, r_u->valuesize);
2547                 if (!r_u->value) {
2548                         DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata value\n"));
2549                         return False;
2550                 }
2551         }
2552
2553         if(!prs_uint16uni(False, "value", ps, depth, r_u->value, r_u->valuesize ))
2554                 return False;
2555
2556         if(!prs_align(ps))
2557                 return False;
2558
2559         if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
2560                 return False;
2561
2562         if(!prs_uint32("type", ps, depth, &r_u->type))
2563                 return False;
2564
2565         if(!prs_uint32("datasize", ps, depth, &r_u->datasize))
2566                 return False;
2567
2568         if (UNMARSHALLING(ps) && r_u->datasize) {
2569                 r_u->data = PRS_ALLOC_MEM(ps, uint8, r_u->datasize);
2570                 if (!r_u->data) {
2571                         DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata data\n"));
2572                         return False;
2573                 }
2574         }
2575
2576         if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
2577                 return False;
2578         if(!prs_align(ps))
2579                 return False;
2580
2581         if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
2582                 return False;
2583         if(!prs_werror("status", ps, depth, &r_u->status))
2584                 return False;
2585
2586         return True;
2587 }
2588
2589 /*******************************************************************
2590 ********************************************************************/
2591
2592 bool spoolss_io_q_enumprinterdata(const char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
2593 {
2594         prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
2595         depth++;
2596
2597         if(!prs_align(ps))
2598                 return False;
2599         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
2600                 return False;
2601         if(!prs_uint32("index", ps, depth, &q_u->index))
2602                 return False;
2603         if(!prs_uint32("valuesize", ps, depth, &q_u->valuesize))
2604                 return False;
2605         if(!prs_uint32("datasize", ps, depth, &q_u->datasize))
2606                 return False;
2607
2608         return True;
2609 }
2610
2611 /*******************************************************************
2612 ********************************************************************/
2613
2614 bool make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u,
2615                 const POLICY_HND *hnd,
2616                 uint32 idx, uint32 valuelen, uint32 datalen)
2617 {
2618         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
2619         q_u->index=idx;
2620         q_u->valuesize=valuelen;
2621         q_u->datasize=datalen;
2622
2623         return True;
2624 }
2625
2626 /*******************************************************************
2627 ********************************************************************/
2628
2629 bool make_spoolss_q_enumprinterdataex(SPOOL_Q_ENUMPRINTERDATAEX *q_u,
2630                                       const POLICY_HND *hnd, const char *key,
2631                                       uint32 size)
2632 {
2633         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
2634         init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
2635         q_u->size = size;
2636
2637         return True;
2638 }
2639
2640 /*******************************************************************
2641 ********************************************************************/
2642 bool make_spoolss_q_setprinterdata(SPOOL_Q_SETPRINTERDATA *q_u, const POLICY_HND *hnd,
2643                                    char* value, uint32 data_type, char* data, uint32 data_size)
2644 {
2645         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
2646         q_u->type = data_type;
2647         init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
2648
2649         q_u->max_len = q_u->real_len = data_size;
2650         q_u->data = (unsigned char *)data;
2651
2652         return True;
2653 }
2654
2655 /*******************************************************************
2656 ********************************************************************/
2657
2658 bool spoolss_io_q_setprinterdata(const char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
2659 {
2660         prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
2661         depth++;
2662
2663         if(!prs_align(ps))
2664                 return False;
2665         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
2666                 return False;
2667         if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
2668                 return False;
2669
2670         if(!prs_align(ps))
2671                 return False;
2672
2673         if(!prs_uint32("type", ps, depth, &q_u->type))
2674                 return False;
2675
2676         if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
2677                 return False;
2678
2679         switch (q_u->type)
2680         {
2681                 case REG_SZ:
2682                 case REG_BINARY:
2683                 case REG_DWORD:
2684                 case REG_MULTI_SZ:
2685                         if (q_u->max_len) {
2686                                 if (UNMARSHALLING(ps))
2687                                         q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
2688                                 if(q_u->data == NULL)
2689                                         return False;
2690                                 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
2691                                         return False;
2692                         }
2693                         if(!prs_align(ps))
2694                                 return False;
2695                         break;
2696         }
2697
2698         if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
2699                 return False;
2700
2701         return True;
2702 }
2703
2704 /*******************************************************************
2705 ********************************************************************/
2706
2707 bool spoolss_io_r_setprinterdata(const char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
2708 {
2709         prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
2710         depth++;
2711
2712         if(!prs_align(ps))
2713                 return False;
2714         if(!prs_werror("status",     ps, depth, &r_u->status))
2715                 return False;
2716
2717         return True;
2718 }
2719
2720 /*******************************************************************
2721  Parse a SPOOL_R_GETJOB structure.
2722 ********************************************************************/
2723
2724 bool spoolss_io_r_getjob(const char *desc, SPOOL_R_GETJOB *r_u, prs_struct *ps, int depth)
2725 {
2726         prs_debug(ps, depth, desc, "spoolss_io_r_getjob");
2727         depth++;
2728
2729         if (!prs_align(ps))
2730                 return False;
2731
2732         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
2733                 return False;
2734
2735         if (!prs_align(ps))
2736                 return False;
2737
2738         if (!prs_uint32("needed", ps, depth, &r_u->needed))
2739                 return False;
2740
2741         if (!prs_werror("status", ps, depth, &r_u->status))
2742                 return False;
2743
2744         return True;
2745 }
2746
2747 /*******************************************************************
2748  Parse a SPOOL_Q_GETJOB structure.
2749 ********************************************************************/
2750
2751 bool spoolss_io_q_getjob(const char *desc, SPOOL_Q_GETJOB *q_u, prs_struct *ps, int depth)
2752 {
2753         prs_debug(ps, depth, desc, "");
2754         depth++;
2755
2756         if(!prs_align(ps))
2757                 return False;
2758
2759         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
2760                 return False;
2761         if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
2762                 return False;
2763         if(!prs_uint32("level", ps, depth, &q_u->level))
2764                 return False;
2765
2766         if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
2767                 return False;
2768
2769         if(!prs_align(ps))
2770                 return False;
2771
2772         if(!prs_uint32("offered", ps, depth, &q_u->offered))
2773                 return False;
2774
2775         return True;
2776 }
2777
2778 void free_devmode(DEVICEMODE *devmode)
2779 {
2780         if (devmode!=NULL) {
2781                 SAFE_FREE(devmode->dev_private);
2782                 SAFE_FREE(devmode);
2783         }
2784 }
2785
2786 void free_printer_info_1(PRINTER_INFO_1 *printer)
2787 {
2788         SAFE_FREE(printer);
2789 }
2790
2791 void free_printer_info_2(PRINTER_INFO_2 *printer)
2792 {
2793         if (printer!=NULL) {
2794                 free_devmode(printer->devmode);
2795                 printer->devmode = NULL;
2796                 SAFE_FREE(printer);
2797         }
2798 }
2799
2800 void free_printer_info_3(PRINTER_INFO_3 *printer)
2801 {
2802         SAFE_FREE(printer);
2803 }
2804
2805 void free_printer_info_4(PRINTER_INFO_4 *printer)
2806 {
2807         SAFE_FREE(printer);
2808 }
2809
2810 void free_printer_info_5(PRINTER_INFO_5 *printer)
2811 {
2812         SAFE_FREE(printer);
2813 }
2814
2815 void free_printer_info_6(PRINTER_INFO_6 *printer)
2816 {
2817         SAFE_FREE(printer);
2818 }
2819
2820 void free_printer_info_7(PRINTER_INFO_7 *printer)
2821 {
2822         SAFE_FREE(printer);
2823 }
2824
2825 void free_job_info_2(JOB_INFO_2 *job)
2826 {
2827     if (job!=NULL)
2828         free_devmode(job->devmode);
2829 }
2830
2831 /*******************************************************************
2832  * read a structure.
2833  ********************************************************************/
2834 bool make_spoolss_q_enumprinterkey(SPOOL_Q_ENUMPRINTERKEY *q_u,
2835                                    POLICY_HND *hnd, const char *key,
2836                                    uint32 size)
2837 {
2838         DEBUG(5,("make_spoolss_q_enumprinterkey\n"));
2839
2840         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
2841         init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
2842         q_u->size = size;
2843
2844         return True;
2845 }
2846
2847 /*******************************************************************
2848  * read a structure.
2849  ********************************************************************/
2850
2851 bool spoolss_io_q_enumprinterkey(const char *desc, SPOOL_Q_ENUMPRINTERKEY *q_u, prs_struct *ps, int depth)
2852 {
2853         prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterkey");
2854         depth++;
2855
2856         if(!prs_align(ps))
2857                 return False;
2858         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
2859                 return False;
2860
2861         if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
2862                 return False;
2863
2864         if(!prs_align(ps))
2865                 return False;
2866
2867         if(!prs_uint32("size", ps, depth, &q_u->size))
2868                 return False;
2869
2870         return True;
2871 }
2872
2873 /*******************************************************************
2874  * write a structure.
2875  ********************************************************************/
2876
2877 bool spoolss_io_r_enumprinterkey(const char *desc, SPOOL_R_ENUMPRINTERKEY *r_u, prs_struct *ps, int depth)
2878 {
2879         prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterkey");
2880         depth++;
2881
2882         if(!prs_align(ps))
2883                 return False;
2884
2885         if (!smb_io_buffer5("", &r_u->keys, ps, depth))
2886                 return False;
2887
2888         if(!prs_align(ps))
2889                 return False;
2890
2891         if(!prs_uint32("needed",     ps, depth, &r_u->needed))
2892                 return False;
2893
2894         if(!prs_werror("status",     ps, depth, &r_u->status))
2895                 return False;
2896
2897         return True;
2898 }
2899
2900 /*******************************************************************
2901  * read a structure.
2902  ********************************************************************/
2903
2904 bool spoolss_io_q_enumprinterdataex(const char *desc, SPOOL_Q_ENUMPRINTERDATAEX *q_u, prs_struct *ps, int depth)
2905 {
2906         prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdataex");
2907         depth++;
2908
2909         if(!prs_align(ps))
2910                 return False;
2911         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
2912                 return False;
2913
2914         if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
2915                 return False;
2916
2917         if(!prs_align(ps))
2918                 return False;
2919
2920         if(!prs_uint32("size", ps, depth, &q_u->size))
2921                 return False;
2922
2923         return True;
2924 }
2925
2926 /*******************************************************************
2927 ********************************************************************/
2928
2929 static bool spoolss_io_printer_enum_values_ctr(const char *desc, prs_struct *ps,
2930                                 PRINTER_ENUM_VALUES_CTR *ctr, int depth)
2931 {
2932         int     i;
2933         uint32  valuename_offset,
2934                 data_offset,
2935                 current_offset;
2936         const uint32 basic_unit = 20; /* size of static portion of enum_values */
2937
2938         prs_debug(ps, depth, desc, "spoolss_io_printer_enum_values_ctr");
2939         depth++;
2940
2941         /*
2942          * offset data begins at 20 bytes per structure * size_of_array.
2943          * Don't forget the uint32 at the beginning
2944          * */
2945
2946         current_offset = basic_unit * ctr->size_of_array;
2947
2948         /* first loop to write basic enum_value information */
2949
2950         if (UNMARSHALLING(ps) && ctr->size_of_array) {
2951                 ctr->values = PRS_ALLOC_MEM(ps, PRINTER_ENUM_VALUES, ctr->size_of_array);
2952                 if (!ctr->values)
2953                         return False;
2954         }
2955
2956         for (i=0; i<ctr->size_of_array; i++) {
2957                 uint32 base_offset, return_offset;
2958
2959                 base_offset = prs_offset(ps);
2960
2961                 valuename_offset = current_offset;
2962                 if (!prs_uint32("valuename_offset", ps, depth, &valuename_offset))
2963                         return False;
2964
2965                 /* Read or write the value. */
2966
2967                 return_offset = prs_offset(ps);
2968
2969                 if (!prs_set_offset(ps, base_offset + valuename_offset)) {
2970                         return False;
2971                 }
2972
2973                 if (!prs_unistr("valuename", ps, depth, &ctr->values[i].valuename))
2974                         return False;
2975
2976                 /* And go back. */
2977                 if (!prs_set_offset(ps, return_offset))
2978                         return False;
2979
2980                 if (!prs_uint32("value_len", ps, depth, &ctr->values[i].value_len))
2981                         return False;
2982
2983                 if (!prs_uint32("type", ps, depth, &ctr->values[i].type))
2984                         return False;
2985
2986                 data_offset = ctr->values[i].value_len + valuename_offset;
2987
2988                 if (!prs_uint32("data_offset", ps, depth, &data_offset))
2989                         return False;
2990
2991                 if (!prs_uint32("data_len", ps, depth, &ctr->values[i].data_len))
2992                         return False;
2993
2994                 /* Read or write the data. */
2995
2996                 return_offset = prs_offset(ps);
2997
2998                 if (!prs_set_offset(ps, base_offset + data_offset)) {
2999                         return False;
3000                 }
3001
3002                 if ( ctr->values[i].data_len ) {
3003                         if ( UNMARSHALLING(ps) ) {
3004                                 ctr->values[i].data = PRS_ALLOC_MEM(ps, uint8, ctr->values[i].data_len);
3005                                 if (!ctr->values[i].data)
3006                                         return False;
3007                         }
3008                         if (!prs_uint8s(False, "data", ps, depth, ctr->values[i].data, ctr->values[i].data_len))
3009                                 return False;
3010                 }
3011
3012                 current_offset  = data_offset + ctr->values[i].data_len - basic_unit;
3013                 /* account for 2 byte alignment */
3014                 current_offset += (current_offset % 2);
3015
3016                 /* Remember how far we got. */
3017                 data_offset = prs_offset(ps);
3018
3019                 /* And go back. */
3020                 if (!prs_set_offset(ps, return_offset))
3021                         return False;
3022
3023         }
3024
3025         /* Go to the last data offset we got to. */
3026
3027         if (!prs_set_offset(ps, data_offset))
3028                 return False;
3029
3030         /* And ensure we're 2 byte aligned. */
3031
3032         if ( !prs_align_uint16(ps) )
3033                 return False;
3034
3035         return True;
3036 }
3037
3038 /*******************************************************************
3039  * write a structure.
3040  ********************************************************************/
3041
3042 bool spoolss_io_r_enumprinterdataex(const char *desc, SPOOL_R_ENUMPRINTERDATAEX *r_u, prs_struct *ps, int depth)
3043 {
3044         uint32 data_offset, end_offset;
3045         prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdataex");
3046         depth++;
3047
3048         if(!prs_align(ps))
3049                 return False;
3050
3051         if (!prs_uint32("size", ps, depth, &r_u->ctr.size))
3052                 return False;
3053
3054         data_offset = prs_offset(ps);
3055
3056         if (!prs_set_offset(ps, data_offset + r_u->ctr.size))
3057                 return False;
3058
3059         if(!prs_align(ps))
3060                 return False;
3061
3062         if(!prs_uint32("needed",     ps, depth, &r_u->needed))
3063                 return False;
3064
3065         if(!prs_uint32("returned",   ps, depth, &r_u->returned))
3066                 return False;
3067
3068         if(!prs_werror("status",     ps, depth, &r_u->status))
3069                 return False;
3070
3071         r_u->ctr.size_of_array = r_u->returned;
3072
3073         end_offset = prs_offset(ps);
3074
3075         if (!prs_set_offset(ps, data_offset))
3076                 return False;
3077
3078         if (r_u->ctr.size)
3079                 if (!spoolss_io_printer_enum_values_ctr("", ps, &r_u->ctr, depth ))
3080                         return False;
3081
3082         if (!prs_set_offset(ps, end_offset))
3083                 return False;
3084         return True;
3085 }
3086
3087 /*******************************************************************
3088  * init a structure.
3089  ********************************************************************/
3090
3091 bool make_spoolss_q_enumforms(SPOOL_Q_ENUMFORMS *q_u, POLICY_HND *handle,
3092                               uint32 level, RPC_BUFFER *buffer,
3093                               uint32 offered)
3094 {
3095         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
3096         q_u->level = level;
3097         q_u->buffer=buffer;
3098         q_u->offered=offered;
3099
3100         return True;
3101 }
3102
3103 /*******************************************************************
3104  * init a structure.
3105  ********************************************************************/
3106
3107 bool make_spoolss_q_getjob(SPOOL_Q_GETJOB *q_u, POLICY_HND *handle,
3108                            uint32 jobid, uint32 level, RPC_BUFFER *buffer,
3109                            uint32 offered)
3110 {
3111         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
3112         q_u->jobid = jobid;
3113         q_u->level = level;
3114         q_u->buffer = buffer;
3115         q_u->offered = offered;
3116
3117         return True;
3118 }