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 reads or writes an DOC_INFO structure.
  75 ********************************************************************/
  76
  77 static bool smb_io_doc_info_1(const char *desc, DOC_INFO_1 *info_1, prs_struct *ps, int depth)
  78 {
  79         if (info_1 == NULL) return False;
  80
  81         prs_debug(ps, depth, desc, "smb_io_doc_info_1");
  82         depth++;
  83
  84         if(!prs_align(ps))
  85                 return False;
  86
  87         if(!prs_uint32("p_docname",    ps, depth, &info_1->p_docname))
  88                 return False;
  89         if(!prs_uint32("p_outputfile", ps, depth, &info_1->p_outputfile))
  90                 return False;
  91         if(!prs_uint32("p_datatype",   ps, depth, &info_1->p_datatype))
  92                 return False;
  93
  94         if(!smb_io_unistr2("", &info_1->docname,    info_1->p_docname,    ps, depth))
  95                 return False;
  96         if(!smb_io_unistr2("", &info_1->outputfile, info_1->p_outputfile, ps, depth))
  97                 return False;
  98         if(!smb_io_unistr2("", &info_1->datatype,   info_1->p_datatype,   ps, depth))
  99                 return False;
 100
 101         return True;
 102 }
 103
 104 /*******************************************************************
 105 reads or writes an DOC_INFO structure.
 106 ********************************************************************/
 107
 108 static bool smb_io_doc_info(const char *desc, DOC_INFO *info, prs_struct *ps, int depth)
 109 {
 110         uint32 useless_ptr=0;
 111
 112         if (info == NULL) return False;
 113
 114         prs_debug(ps, depth, desc, "smb_io_doc_info");
 115         depth++;
 116
 117         if(!prs_align(ps))
 118                 return False;
 119
 120         if(!prs_uint32("switch_value", ps, depth, &info->switch_value))
 121                 return False;
 122
 123         if(!prs_uint32("doc_info_X ptr", ps, depth, &useless_ptr))
 124                 return False;
 125
 126         switch (info->switch_value)
 127         {
 128                 case 1:
 129                         if(!smb_io_doc_info_1("",&info->doc_info_1, ps, depth))
 130                                 return False;
 131                         break;
 132                 case 2:
 133                         /*
 134                           this is just a placeholder
 135
 136                           MSDN July 1998 says doc_info_2 is only on
 137                           Windows 95, and as Win95 doesn't do RPC to print
 138                           this case is nearly impossible
 139
 140                           Maybe one day with Windows for dishwasher 2037 ...
 141
 142                         */
 143                         /* smb_io_doc_info_2("",&info->doc_info_2, ps, depth); */
 144                         break;
 145                 default:
 146                         DEBUG(0,("Something is obviously wrong somewhere !\n"));
 147                         break;
 148         }
 149
 150         return True;
 151 }
 152
 153 /*******************************************************************
 154 reads or writes an DOC_INFO_CONTAINER structure.
 155 ********************************************************************/
 156
 157 static bool smb_io_doc_info_container(const char *desc, DOC_INFO_CONTAINER *cont, prs_struct *ps, int depth)
 158 {
 159         if (cont == NULL) return False;
 160
 161         prs_debug(ps, depth, desc, "smb_io_doc_info_container");
 162         depth++;
 163
 164         if(!prs_align(ps))
 165                 return False;
 166
 167         if(!prs_uint32("level", ps, depth, &cont->level))
 168                 return False;
 169
 170         if(!smb_io_doc_info("",&cont->docinfo, ps, depth))
 171                 return False;
 172
 173         return True;
 174 }
 175
 176 /*******************************************************************
 177 reads or writes an NOTIFY OPTION TYPE structure.
 178 ********************************************************************/
 179
 180 /* NOTIFY_OPTION_TYPE and NOTIFY_OPTION_TYPE_DATA are really one
 181    structure.  The _TYPE structure is really the deferred referrants (i.e
 182    the notify fields array) of the _TYPE structure. -tpot */
 183
 184 static bool smb_io_notify_option_type(const char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
 185 {
 186         prs_debug(ps, depth, desc, "smb_io_notify_option_type");
 187         depth++;
 188
 189         if (!prs_align(ps))
 190                 return False;
 191
 192         if(!prs_uint16("type", ps, depth, &type->type))
 193                 return False;
 194         if(!prs_uint16("reserved0", ps, depth, &type->reserved0))
 195                 return False;
 196         if(!prs_uint32("reserved1", ps, depth, &type->reserved1))
 197                 return False;
 198         if(!prs_uint32("reserved2", ps, depth, &type->reserved2))
 199                 return False;
 200         if(!prs_uint32("count", ps, depth, &type->count))
 201                 return False;
 202         if(!prs_uint32("fields_ptr", ps, depth, &type->fields_ptr))
 203                 return False;
 204
 205         return True;
 206 }
 207
 208 /*******************************************************************
 209 reads or writes an NOTIFY OPTION TYPE DATA.
 210 ********************************************************************/
 211
 212 static bool smb_io_notify_option_type_data(const char *desc, SPOOL_NOTIFY_OPTION_TYPE *type, prs_struct *ps, int depth)
 213 {
 214         int i;
 215
 216         prs_debug(ps, depth, desc, "smb_io_notify_option_type_data");
 217         depth++;
 218
 219         /* if there are no fields just return */
 220         if (type->fields_ptr==0)
 221                 return True;
 222
 223         if(!prs_align(ps))
 224                 return False;
 225
 226         if(!prs_uint32("count2", ps, depth, &type->count2))
 227                 return False;
 228
 229         if (type->count2 != type->count)
 230                 DEBUG(4,("What a mess, count was %x now is %x !\n", type->count, type->count2));
 231
 232         if (type->count2 > MAX_NOTIFY_TYPE_FOR_NOW) {
 233                 return False;
 234         }
 235
 236         /* parse the option type data */
 237         for(i=0;i<type->count2;i++)
 238                 if(!prs_uint16("fields",ps,depth,&type->fields[i]))
 239                         return False;
 240         return True;
 241 }
 242
 243 /*******************************************************************
 244 reads or writes an NOTIFY OPTION structure.
 245 ********************************************************************/
 246
 247 static bool smb_io_notify_option_type_ctr(const char *desc, SPOOL_NOTIFY_OPTION_TYPE_CTR *ctr , prs_struct *ps, int depth)
 248 {
 249         int i;
 250
 251         prs_debug(ps, depth, desc, "smb_io_notify_option_type_ctr");
 252         depth++;
 253
 254         if(!prs_uint32("count", ps, depth, &ctr->count))
 255                 return False;
 256
 257         /* reading */
 258         if (UNMARSHALLING(ps) && ctr->count)
 259                 if((ctr->type=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION_TYPE,ctr->count)) == NULL)
 260                         return False;
 261
 262         /* the option type struct */
 263         for(i=0;i<ctr->count;i++)
 264                 if(!smb_io_notify_option_type("", &ctr->type[i] , ps, depth))
 265                         return False;
 266
 267         /* the type associated with the option type struct */
 268         for(i=0;i<ctr->count;i++)
 269                 if(!smb_io_notify_option_type_data("", &ctr->type[i] , ps, depth))
 270                         return False;
 271
 272         return True;
 273 }
 274
 275 /*******************************************************************
 276 reads or writes an NOTIFY OPTION structure.
 277 ********************************************************************/
 278
 279 static bool smb_io_notify_option(const char *desc, SPOOL_NOTIFY_OPTION *option, prs_struct *ps, int depth)
 280 {
 281         prs_debug(ps, depth, desc, "smb_io_notify_option");
 282         depth++;
 283
 284         if(!prs_uint32("version", ps, depth, &option->version))
 285                 return False;
 286         if(!prs_uint32("flags", ps, depth, &option->flags))
 287                 return False;
 288         if(!prs_uint32("count", ps, depth, &option->count))
 289                 return False;
 290         if(!prs_uint32("option_type_ptr", ps, depth, &option->option_type_ptr))
 291                 return False;
 292
 293         /* marshalling or unmarshalling, that would work */
 294         if (option->option_type_ptr!=0) {
 295                 if(!smb_io_notify_option_type_ctr("", &option->ctr ,ps, depth))
 296                         return False;
 297         }
 298         else {
 299                 option->ctr.type=NULL;
 300                 option->ctr.count=0;
 301         }
 302
 303         return True;
 304 }
 305
 306 /*******************************************************************
 307 reads or writes an NOTIFY INFO DATA structure.
 308 ********************************************************************/
 309
 310 static bool smb_io_notify_info_data(const char *desc,SPOOL_NOTIFY_INFO_DATA *data, prs_struct *ps, int depth)
 311 {
 312         uint32 useless_ptr=0x0FF0ADDE;
 313
 314         prs_debug(ps, depth, desc, "smb_io_notify_info_data");
 315         depth++;
 316
 317         if(!prs_align(ps))
 318                 return False;
 319         if(!prs_uint16("type",           ps, depth, &data->type))
 320                 return False;
 321         if(!prs_uint16("field",          ps, depth, &data->field))
 322                 return False;
 323
 324         if(!prs_uint32("how many words", ps, depth, &data->size))
 325                 return False;
 326         if(!prs_uint32("id",             ps, depth, &data->id))
 327                 return False;
 328         if(!prs_uint32("how many words", ps, depth, &data->size))
 329                 return False;
 330
 331         switch (data->enc_type) {
 332
 333                 /* One and two value data has two uint32 values */
 334
 335         case NOTIFY_ONE_VALUE:
 336         case NOTIFY_TWO_VALUE:
 337
 338                 if(!prs_uint32("value[0]", ps, depth, &data->notify_data.value[0]))
 339                         return False;
 340                 if(!prs_uint32("value[1]", ps, depth, &data->notify_data.value[1]))
 341                         return False;
 342                 break;
 343
 344                 /* Pointers and strings have a string length and a
 345                    pointer.  For a string the length is expressed as
 346                    the number of uint16 characters plus a trailing
 347                    \0\0. */
 348
 349         case NOTIFY_POINTER:
 350
 351                 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length ))
 352                         return False;
 353                 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
 354                         return False;
 355
 356                 break;
 357
 358         case NOTIFY_STRING:
 359
 360                 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
 361                         return False;
 362
 363                 if(!prs_uint32("pointer", ps, depth, &useless_ptr))
 364                         return False;
 365
 366                 break;
 367
 368         case NOTIFY_SECDESC:
 369                 if( !prs_uint32( "sd size", ps, depth, &data->notify_data.sd.size ) )
 370                         return False;
 371                 if( !prs_uint32( "pointer", ps, depth, &useless_ptr ) )
 372                         return False;
 373
 374                 break;
 375
 376         default:
 377                 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data\n",
 378                           data->enc_type));
 379                 break;
 380         }
 381
 382         return True;
 383 }
 384
 385 /*******************************************************************
 386 reads or writes an NOTIFY INFO DATA structure.
 387 ********************************************************************/
 388
 389 bool smb_io_notify_info_data_strings(const char *desc,SPOOL_NOTIFY_INFO_DATA *data,
 390                                      prs_struct *ps, int depth)
 391 {
 392         prs_debug(ps, depth, desc, "smb_io_notify_info_data_strings");
 393         depth++;
 394
 395         if(!prs_align(ps))
 396                 return False;
 397
 398         switch(data->enc_type) {
 399
 400                 /* No data for values */
 401
 402         case NOTIFY_ONE_VALUE:
 403         case NOTIFY_TWO_VALUE:
 404
 405                 break;
 406
 407                 /* Strings start with a length in uint16s */
 408
 409         case NOTIFY_STRING:
 410
 411                 if (MARSHALLING(ps))
 412                         data->notify_data.data.length /= 2;
 413
 414                 if(!prs_uint32("string length", ps, depth, &data->notify_data.data.length))
 415                         return False;
 416
 417                 if (UNMARSHALLING(ps) && data->notify_data.data.length) {
 418                         data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16,
 419                                                                 data->notify_data.data.length);
 420
 421                         if (!data->notify_data.data.string)
 422                                 return False;
 423                 }
 424
 425                 if (!prs_uint16uni(True, "string", ps, depth, data->notify_data.data.string,
 426                                    data->notify_data.data.length))
 427                         return False;
 428
 429                 if (MARSHALLING(ps))
 430                         data->notify_data.data.length *= 2;
 431
 432                 break;
 433
 434         case NOTIFY_POINTER:
 435
 436                 if (UNMARSHALLING(ps) && data->notify_data.data.length) {
 437                         data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16,
 438                                                                 data->notify_data.data.length);
 439
 440                         if (!data->notify_data.data.string)
 441                                 return False;
 442                 }
 443
 444                 if(!prs_uint8s(True,"buffer",ps,depth,(uint8*)data->notify_data.data.string,data->notify_data.data.length))
 445                         return False;
 446
 447                 break;
 448
 449         case NOTIFY_SECDESC:
 450                 if( !prs_uint32("secdesc size ", ps, depth, &data->notify_data.sd.size ) )
 451                         return False;
 452                 if ( !sec_io_desc( "sec_desc", &data->notify_data.sd.desc, ps, depth ) )
 453                         return False;
 454                 break;
 455
 456         default:
 457                 DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data_strings\n",
 458                           data->enc_type));
 459                 break;
 460         }
 461
 462 #if 0
 463         if (isvalue==False) {
 464
 465                 /* length of string in unicode include \0 */
 466                 x=data->notify_data.data.length+1;
 467
 468                 if (data->field != 16)
 469                 if(!prs_uint32("string length", ps, depth, &x ))
 470                         return False;
 471
 472                 if (MARSHALLING(ps)) {
 473                         /* These are already in little endian format. Don't byte swap. */
 474                         if (x == 1) {
 475
 476                                 /* No memory allocated for this string
 477                                    therefore following the data.string
 478                                    pointer is a bad idea.  Use a pointer to
 479                                    the uint32 length union member to
 480                                    provide a source for a unicode NULL */
 481
 482                                 if(!prs_uint8s(True,"string",ps,depth, (uint8 *)&data->notify_data.data.length,x*2))
 483                                         return False;
 484                         } else {
 485
 486                                 if (data->field == 16)
 487                                         x /= 2;
 488
 489                                 if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
 490                                         return False;
 491                         }
 492                 } else {
 493
 494                         /* Tallocate memory for string */
 495
 496                         if (x) {
 497                                 data->notify_data.data.string = PRS_ALLOC_MEM(ps, uint16, x * 2);
 498                                 if (!data->notify_data.data.string)
 499                                         return False;
 500                         } else {
 501                                 data->notify_data.data.string = NULL;
 502                         }
 503
 504                         if(!prs_uint16uni(True,"string",ps,depth,data->notify_data.data.string,x))
 505                                 return False;
 506                 }
 507         }
 508
 509 #endif
 510
 511 #if 0   /* JERRY */
 512         /* Win2k does not seem to put this parse align here */
 513         if(!prs_align(ps))
 514                 return False;
 515 #endif
 516
 517         return True;
 518 }
 519
 520 /*******************************************************************
 521 reads or writes an NOTIFY INFO structure.
 522 ********************************************************************/
 523
 524 static bool smb_io_notify_info(const char *desc, SPOOL_NOTIFY_INFO *info, prs_struct *ps, int depth)
 525 {
 526         int i;
 527
 528         prs_debug(ps, depth, desc, "smb_io_notify_info");
 529         depth++;
 530
 531         if(!prs_align(ps))
 532                 return False;
 533
 534         if(!prs_uint32("count", ps, depth, &info->count))
 535                 return False;
 536         if(!prs_uint32("version", ps, depth, &info->version))
 537                 return False;
 538         if(!prs_uint32("flags", ps, depth, &info->flags))
 539                 return False;
 540         if(!prs_uint32("count", ps, depth, &info->count))
 541                 return False;
 542
 543         for (i=0;i<info->count;i++) {
 544                 if(!smb_io_notify_info_data(desc, &info->data[i], ps, depth))
 545                         return False;
 546         }
 547
 548         /* now do the strings at the end of the stream */
 549         for (i=0;i<info->count;i++) {
 550                 if(!smb_io_notify_info_data_strings(desc, &info->data[i], ps, depth))
 551                         return False;
 552         }
 553
 554         return True;
 555 }
 556
 557 /*******************************************************************
 558 ********************************************************************/
 559
 560 bool spool_io_user_level_1( const char *desc, prs_struct *ps, int depth, SPOOL_USER_1 *q_u )
 561 {
 562         prs_debug(ps, depth, desc, "");
 563         depth++;
 564
 565         if (!prs_align(ps))
 566                 return False;
 567
 568         if (!prs_uint32("size", ps, depth, &q_u->size))
 569                 return False;
 570
 571         if (!prs_io_unistr2_p("", ps, depth, &q_u->client_name))
 572                 return False;
 573         if (!prs_io_unistr2_p("", ps, depth, &q_u->user_name))
 574                 return False;
 575
 576         if (!prs_uint32("build", ps, depth, &q_u->build))
 577                 return False;
 578         if (!prs_uint32("major", ps, depth, &q_u->major))
 579                 return False;
 580         if (!prs_uint32("minor", ps, depth, &q_u->minor))
 581                 return False;
 582         if (!prs_uint32("processor", ps, depth, &q_u->processor))
 583                 return False;
 584
 585         if (!prs_io_unistr2("", ps, depth, q_u->client_name))
 586                 return False;
 587         if (!prs_align(ps))
 588                 return False;
 589
 590         if (!prs_io_unistr2("", ps, depth, q_u->user_name))
 591                 return False;
 592
 593         return True;
 594 }
 595
 596 /*******************************************************************
 597 ********************************************************************/
 598
 599 static bool spool_io_user_level(const char *desc, SPOOL_USER_CTR *q_u, prs_struct *ps, int depth)
 600 {
 601         if (q_u==NULL)
 602                 return False;
 603
 604         prs_debug(ps, depth, desc, "spool_io_user_level");
 605         depth++;
 606
 607         if (!prs_align(ps))
 608                 return False;
 609
 610         if (!prs_uint32("level", ps, depth, &q_u->level))
 611                 return False;
 612
 613         switch ( q_u->level )
 614         {
 615                 case 1:
 616                         if ( !prs_pointer( "" , ps, depth, (void*)&q_u->user.user1,
 617                                 sizeof(SPOOL_USER_1), (PRS_POINTER_CAST)spool_io_user_level_1 ))
 618                         {
 619                                 return False;
 620                         }
 621                         break;
 622                 default:
 623                         return False;
 624         }
 625
 626         return True;
 627 }
 628
 629 /*******************************************************************
 630  * read or write a DEVICEMODE struct.
 631  * on reading allocate memory for the private member
 632  ********************************************************************/
 633
 634 #define DM_NUM_OPTIONAL_FIELDS          8
 635
 636 bool spoolss_io_devmode(const char *desc, prs_struct *ps, int depth, DEVICEMODE *devmode)
 637 {
 638         int available_space;            /* size of the device mode left to parse */
 639                                         /* only important on unmarshalling       */
 640         int i = 0;
 641         uint16 *unistr_buffer;
 642         int j;
 643
 644         struct optional_fields {
 645                 fstring         name;
 646                 uint32*         field;
 647         } opt_fields[DM_NUM_OPTIONAL_FIELDS] = {
 648                 { "icmmethod",          NULL },
 649                 { "icmintent",          NULL },
 650                 { "mediatype",          NULL },
 651                 { "dithertype",         NULL },
 652                 { "reserved1",          NULL },
 653                 { "reserved2",          NULL },
 654                 { "panningwidth",       NULL },
 655                 { "panningheight",      NULL }
 656         };
 657
 658         /* assign at run time to keep non-gcc compilers happy */
 659
 660         opt_fields[0].field = &devmode->icmmethod;
 661         opt_fields[1].field = &devmode->icmintent;
 662         opt_fields[2].field = &devmode->mediatype;
 663         opt_fields[3].field = &devmode->dithertype;
 664         opt_fields[4].field = &devmode->reserved1;
 665         opt_fields[5].field = &devmode->reserved2;
 666         opt_fields[6].field = &devmode->panningwidth;
 667         opt_fields[7].field = &devmode->panningheight;
 668
 669
 670         prs_debug(ps, depth, desc, "spoolss_io_devmode");
 671         depth++;
 672
 673         if (UNMARSHALLING(ps)) {
 674                 devmode->devicename.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
 675                 if (devmode->devicename.buffer == NULL)
 676                         return False;
 677                 unistr_buffer = devmode->devicename.buffer;
 678         }
 679         else {
 680                 /* devicename is a static sized string but the buffer we set is not */
 681                 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
 682                 memset( unistr_buffer, 0x0, MAXDEVICENAME );
 683                 for ( j=0; devmode->devicename.buffer[j]; j++ )
 684                         unistr_buffer[j] = devmode->devicename.buffer[j];
 685         }
 686
 687         if (!prs_uint16uni(True,"devicename", ps, depth, unistr_buffer, MAXDEVICENAME))
 688                 return False;
 689
 690         if (!prs_uint16("specversion",      ps, depth, &devmode->specversion))
 691                 return False;
 692
 693         if (!prs_uint16("driverversion",    ps, depth, &devmode->driverversion))
 694                 return False;
 695         if (!prs_uint16("size",             ps, depth, &devmode->size))
 696                 return False;
 697         if (!prs_uint16("driverextra",      ps, depth, &devmode->driverextra))
 698                 return False;
 699         if (!prs_uint32("fields",           ps, depth, &devmode->fields))
 700                 return False;
 701         if (!prs_uint16("orientation",      ps, depth, &devmode->orientation))
 702                 return False;
 703         if (!prs_uint16("papersize",        ps, depth, &devmode->papersize))
 704                 return False;
 705         if (!prs_uint16("paperlength",      ps, depth, &devmode->paperlength))
 706                 return False;
 707         if (!prs_uint16("paperwidth",       ps, depth, &devmode->paperwidth))
 708                 return False;
 709         if (!prs_uint16("scale",            ps, depth, &devmode->scale))
 710                 return False;
 711         if (!prs_uint16("copies",           ps, depth, &devmode->copies))
 712                 return False;
 713         if (!prs_uint16("defaultsource",    ps, depth, &devmode->defaultsource))
 714                 return False;
 715         if (!prs_uint16("printquality",     ps, depth, &devmode->printquality))
 716                 return False;
 717         if (!prs_uint16("color",            ps, depth, &devmode->color))
 718                 return False;
 719         if (!prs_uint16("duplex",           ps, depth, &devmode->duplex))
 720                 return False;
 721         if (!prs_uint16("yresolution",      ps, depth, &devmode->yresolution))
 722                 return False;
 723         if (!prs_uint16("ttoption",         ps, depth, &devmode->ttoption))
 724                 return False;
 725         if (!prs_uint16("collate",          ps, depth, &devmode->collate))
 726                 return False;
 727
 728         if (UNMARSHALLING(ps)) {
 729                 devmode->formname.buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
 730                 if (devmode->formname.buffer == NULL)
 731                         return False;
 732                 unistr_buffer = devmode->formname.buffer;
 733         }
 734         else {
 735                 /* devicename is a static sized string but the buffer we set is not */
 736                 unistr_buffer = PRS_ALLOC_MEM(ps, uint16, MAXDEVICENAME);
 737                 memset( unistr_buffer, 0x0, MAXDEVICENAME );
 738                 for ( j=0; devmode->formname.buffer[j]; j++ )
 739                         unistr_buffer[j] = devmode->formname.buffer[j];
 740         }
 741
 742         if (!prs_uint16uni(True, "formname",  ps, depth, unistr_buffer, MAXDEVICENAME))
 743                 return False;
 744         if (!prs_uint16("logpixels",        ps, depth, &devmode->logpixels))
 745                 return False;
 746         if (!prs_uint32("bitsperpel",       ps, depth, &devmode->bitsperpel))
 747                 return False;
 748         if (!prs_uint32("pelswidth",        ps, depth, &devmode->pelswidth))
 749                 return False;
 750         if (!prs_uint32("pelsheight",       ps, depth, &devmode->pelsheight))
 751                 return False;
 752         if (!prs_uint32("displayflags",     ps, depth, &devmode->displayflags))
 753                 return False;
 754         if (!prs_uint32("displayfrequency", ps, depth, &devmode->displayfrequency))
 755                 return False;
 756         /*
 757          * every device mode I've ever seen on the wire at least has up
 758          * to the displayfrequency field.   --jerry (05-09-2002)
 759          */
 760
 761         /* add uint32's + uint16's + two UNICODE strings */
 762
 763         available_space = devmode->size - (sizeof(uint32)*6 + sizeof(uint16)*18 + sizeof(uint16)*64);
 764
 765         /* Sanity check - we only have uint32's left tp parse */
 766
 767         if ( available_space && ((available_space % sizeof(uint32)) != 0) ) {
 768                 DEBUG(0,("spoolss_io_devmode: available_space [%d] no in multiple of 4 bytes (size = %d)!\n",
 769                         available_space, devmode->size));
 770                 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
 771                 return False;
 772         }
 773
 774         /*
 775          * Conditional parsing.  Assume that the DeviceMode has been
 776          * zero'd by the caller.
 777          */
 778
 779         while ((available_space > 0)  && (i < DM_NUM_OPTIONAL_FIELDS))
 780         {
 781                 DEBUG(11, ("spoolss_io_devmode: [%d] bytes left to parse in devmode\n", available_space));
 782                 if (!prs_uint32(opt_fields[i].name, ps, depth, opt_fields[i].field))
 783                         return False;
 784                 available_space -= sizeof(uint32);
 785                 i++;
 786         }
 787
 788         /* Sanity Check - we should no available space at this point unless
 789            MS changes the device mode structure */
 790
 791         if (available_space) {
 792                 DEBUG(0,("spoolss_io_devmode: I've parsed all I know and there is still stuff left|\n"));
 793                 DEBUG(0,("spoolss_io_devmode: available_space = [%d], devmode_size = [%d]!\n",
 794                         available_space, devmode->size));
 795                 DEBUG(0,("spoolss_io_devmode: please report to samba-technical@samba.org!\n"));
 796                 return False;
 797         }
 798
 799
 800         if (devmode->driverextra!=0) {
 801                 if (UNMARSHALLING(ps)) {
 802                         devmode->dev_private=PRS_ALLOC_MEM(ps, uint8, devmode->driverextra);
 803                         if(devmode->dev_private == NULL)
 804                                 return False;
 805                         DEBUG(7,("spoolss_io_devmode: allocated memory [%d] for dev_private\n",devmode->driverextra));
 806                 }
 807
 808                 DEBUG(7,("spoolss_io_devmode: parsing [%d] bytes of dev_private\n",devmode->driverextra));
 809                 if (!prs_uint8s(False, "dev_private",  ps, depth,
 810                                 devmode->dev_private, devmode->driverextra))
 811                         return False;
 812         }
 813
 814         return True;
 815 }
 816
 817 /*******************************************************************
 818  Read or write a DEVICEMODE container
 819 ********************************************************************/
 820
 821 static bool spoolss_io_devmode_cont(const char *desc, DEVMODE_CTR *dm_c, prs_struct *ps, int depth)
 822 {
 823         if (dm_c==NULL)
 824                 return False;
 825
 826         prs_debug(ps, depth, desc, "spoolss_io_devmode_cont");
 827         depth++;
 828
 829         if(!prs_align(ps))
 830                 return False;
 831
 832         if (!prs_uint32("size", ps, depth, &dm_c->size))
 833                 return False;
 834
 835         if (!prs_uint32("devmode_ptr", ps, depth, &dm_c->devmode_ptr))
 836                 return False;
 837
 838         if (dm_c->size==0 || dm_c->devmode_ptr==0) {
 839                 if (UNMARSHALLING(ps))
 840                         /* if while reading there is no DEVMODE ... */
 841                         dm_c->devmode=NULL;
 842                 return True;
 843         }
 844
 845         /* so we have a DEVICEMODE to follow */
 846         if (UNMARSHALLING(ps)) {
 847                 DEBUG(9,("Allocating memory for spoolss_io_devmode\n"));
 848                 dm_c->devmode=PRS_ALLOC_MEM(ps,DEVICEMODE,1);
 849                 if(dm_c->devmode == NULL)
 850                         return False;
 851         }
 852
 853         /* this is bad code, shouldn't be there */
 854         if (!prs_uint32("size", ps, depth, &dm_c->size))
 855                 return False;
 856
 857         if (!spoolss_io_devmode(desc, ps, depth, dm_c->devmode))
 858                 return False;
 859
 860         return True;
 861 }
 862
 863 /*******************************************************************
 864 ********************************************************************/
 865
 866 static bool spoolss_io_printer_default(const char *desc, PRINTER_DEFAULT *pd, prs_struct *ps, int depth)
 867 {
 868         if (pd==NULL)
 869                 return False;
 870
 871         prs_debug(ps, depth, desc, "spoolss_io_printer_default");
 872         depth++;
 873
 874         if (!prs_uint32("datatype_ptr", ps, depth, &pd->datatype_ptr))
 875                 return False;
 876
 877         if (!smb_io_unistr2("datatype", &pd->datatype, pd->datatype_ptr, ps,depth))
 878                 return False;
 879
 880         if (!prs_align(ps))
 881                 return False;
 882
 883         if (!spoolss_io_devmode_cont("", &pd->devmode_cont, ps, depth))
 884                 return False;
 885
 886         if (!prs_align(ps))
 887                 return False;
 888
 889         if (!prs_uint32("access_required", ps, depth, &pd->access_required))
 890                 return False;
 891
 892         return True;
 893 }
 894
 895 /*******************************************************************
 896  * init a structure.
 897  ********************************************************************/
 898
 899 bool make_spoolss_q_open_printer_ex(SPOOL_Q_OPEN_PRINTER_EX *q_u,
 900                 const fstring printername,
 901                 const fstring datatype,
 902                 uint32 access_required,
 903                 const fstring clientname,
 904                 const fstring user_name)
 905 {
 906         DEBUG(5,("make_spoolss_q_open_printer_ex\n"));
 907
 908         q_u->printername = TALLOC_P( talloc_tos(), UNISTR2 );
 909         if (!q_u->printername) {
 910                 return False;
 911         }
 912         init_unistr2(q_u->printername, printername, UNI_STR_TERMINATE);
 913
 914         q_u->printer_default.datatype_ptr = 0;
 915
 916         q_u->printer_default.devmode_cont.size=0;
 917         q_u->printer_default.devmode_cont.devmode_ptr=0;
 918         q_u->printer_default.devmode_cont.devmode=NULL;
 919         q_u->printer_default.access_required=access_required;
 920
 921         q_u->user_switch = 1;
 922
 923         q_u->user_ctr.level                 = 1;
 924         q_u->user_ctr.user.user1            = TALLOC_P( talloc_tos(), SPOOL_USER_1 );
 925         if (!q_u->user_ctr.user.user1) {
 926                 return False;
 927         }
 928         q_u->user_ctr.user.user1->size      = strlen(clientname) + strlen(user_name) + 10;
 929         q_u->user_ctr.user.user1->build     = 1381;
 930         q_u->user_ctr.user.user1->major     = 2;
 931         q_u->user_ctr.user.user1->minor     = 0;
 932         q_u->user_ctr.user.user1->processor = 0;
 933
 934         q_u->user_ctr.user.user1->client_name = TALLOC_P( talloc_tos(), UNISTR2 );
 935         if (!q_u->user_ctr.user.user1->client_name) {
 936                 return False;
 937         }
 938         q_u->user_ctr.user.user1->user_name   = TALLOC_P( talloc_tos(), UNISTR2 );
 939         if (!q_u->user_ctr.user.user1->user_name) {
 940                 return False;
 941         }
 942
 943         init_unistr2(q_u->user_ctr.user.user1->client_name, clientname, UNI_STR_TERMINATE);
 944         init_unistr2(q_u->user_ctr.user.user1->user_name, user_name, UNI_STR_TERMINATE);
 945
 946         return True;
 947 }
 948
 949 /*******************************************************************
 950  * init a structure.
 951  ********************************************************************/
 952
 953 bool make_spoolss_q_addprinterex( TALLOC_CTX *mem_ctx, SPOOL_Q_ADDPRINTEREX *q_u,
 954         const char *srv_name, const char* clientname, const char* user_name,
 955         uint32 level, PRINTER_INFO_CTR *ctr)
 956 {
 957         DEBUG(5,("make_spoolss_q_addprinterex\n"));
 958
 959         if (!ctr || !ctr->printers_2)
 960                 return False;
 961
 962         ZERO_STRUCTP(q_u);
 963
 964         q_u->server_name = TALLOC_P( mem_ctx, UNISTR2 );
 965         if (!q_u->server_name) {
 966                 return False;
 967         }
 968         init_unistr2(q_u->server_name, srv_name, UNI_FLAGS_NONE);
 969
 970         q_u->level = level;
 971
 972         q_u->info.level = level;
 973         q_u->info.info_ptr = (ctr->printers_2!=NULL)?1:0;
 974         switch (level) {
 975                 case 2:
 976                         /* init q_u->info.info2 from *info */
 977                         if (!make_spoolss_printer_info_2(mem_ctx, &q_u->info.info_2, ctr->printers_2)) {
 978                                 DEBUG(0,("make_spoolss_q_addprinterex: Unable to fill SPOOL_Q_ADDPRINTEREX struct!\n"));
 979                                 return False;
 980                         }
 981                         break;
 982                 default :
 983                         break;
 984         }
 985
 986         q_u->user_switch=1;
 987
 988         q_u->user_ctr.level                 = 1;
 989         q_u->user_ctr.user.user1            = TALLOC_P( talloc_tos(), SPOOL_USER_1 );
 990         if (!q_u->user_ctr.user.user1) {
 991                 return False;
 992         }
 993         q_u->user_ctr.user.user1->build     = 1381;
 994         q_u->user_ctr.user.user1->major     = 2;
 995         q_u->user_ctr.user.user1->minor     = 0;
 996         q_u->user_ctr.user.user1->processor = 0;
 997
 998         q_u->user_ctr.user.user1->client_name = TALLOC_P( mem_ctx, UNISTR2 );
 999         if (!q_u->user_ctr.user.user1->client_name) {
1000                 return False;
1001         }
1002         q_u->user_ctr.user.user1->user_name   = TALLOC_P( mem_ctx, UNISTR2 );
1003         if (!q_u->user_ctr.user.user1->user_name) {
1004                 return False;
1005         }
1006         init_unistr2(q_u->user_ctr.user.user1->client_name, clientname, UNI_STR_TERMINATE);
1007         init_unistr2(q_u->user_ctr.user.user1->user_name, user_name, UNI_STR_TERMINATE);
1008
1009         q_u->user_ctr.user.user1->size = q_u->user_ctr.user.user1->user_name->uni_str_len +
1010                                    q_u->user_ctr.user.user1->client_name->uni_str_len + 2;
1011
1012         return True;
1013 }
1014
1015 /*******************************************************************
1016 create a SPOOL_PRINTER_INFO_2 stuct from a PRINTER_INFO_2 struct
1017 *******************************************************************/
1018
1019 bool make_spoolss_printer_info_2(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_2 **spool_info2,
1020                                 PRINTER_INFO_2 *info)
1021 {
1022
1023         SPOOL_PRINTER_INFO_LEVEL_2 *inf;
1024
1025         /* allocate the necessary memory */
1026         if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_2))) {
1027                 DEBUG(0,("make_spoolss_printer_info_2: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_2 sruct!\n"));
1028                 return False;
1029         }
1030
1031         inf->servername_ptr     = (info->servername.buffer!=NULL)?1:0;
1032         inf->printername_ptr    = (info->printername.buffer!=NULL)?1:0;
1033         inf->sharename_ptr      = (info->sharename.buffer!=NULL)?1:0;
1034         inf->portname_ptr       = (info->portname.buffer!=NULL)?1:0;
1035         inf->drivername_ptr     = (info->drivername.buffer!=NULL)?1:0;
1036         inf->comment_ptr        = (info->comment.buffer!=NULL)?1:0;
1037         inf->location_ptr       = (info->location.buffer!=NULL)?1:0;
1038         inf->devmode_ptr        = (info->devmode!=NULL)?1:0;
1039         inf->sepfile_ptr        = (info->sepfile.buffer!=NULL)?1:0;
1040         inf->printprocessor_ptr = (info->printprocessor.buffer!=NULL)?1:0;
1041         inf->datatype_ptr       = (info->datatype.buffer!=NULL)?1:0;
1042         inf->parameters_ptr     = (info->parameters.buffer!=NULL)?1:0;
1043         inf->secdesc_ptr        = (info->secdesc!=NULL)?1:0;
1044         inf->attributes         = info->attributes;
1045         inf->priority           = info->priority;
1046         inf->default_priority   = info->defaultpriority;
1047         inf->starttime          = info->starttime;
1048         inf->untiltime          = info->untiltime;
1049         inf->cjobs              = info->cjobs;
1050         inf->averageppm = info->averageppm;
1051         init_unistr2_from_unistr(&inf->servername,      &info->servername);
1052         init_unistr2_from_unistr(&inf->printername,     &info->printername);
1053         init_unistr2_from_unistr(&inf->sharename,       &info->sharename);
1054         init_unistr2_from_unistr(&inf->portname,        &info->portname);
1055         init_unistr2_from_unistr(&inf->drivername,      &info->drivername);
1056         init_unistr2_from_unistr(&inf->comment,         &info->comment);
1057         init_unistr2_from_unistr(&inf->location,        &info->location);
1058         init_unistr2_from_unistr(&inf->sepfile,         &info->sepfile);
1059         init_unistr2_from_unistr(&inf->printprocessor,  &info->printprocessor);
1060         init_unistr2_from_unistr(&inf->datatype,        &info->datatype);
1061         init_unistr2_from_unistr(&inf->parameters,      &info->parameters);
1062         init_unistr2_from_unistr(&inf->datatype,        &info->datatype);
1063
1064         *spool_info2 = inf;
1065
1066         return True;
1067 }
1068
1069 /*******************************************************************
1070 create a SPOOL_PRINTER_INFO_3 struct from a PRINTER_INFO_3 struct
1071 *******************************************************************/
1072
1073 bool make_spoolss_printer_info_3(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_3 **spool_info3,
1074                                 PRINTER_INFO_3 *info)
1075 {
1076
1077         SPOOL_PRINTER_INFO_LEVEL_3 *inf;
1078
1079         /* allocate the necessary memory */
1080         if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_3))) {
1081                 DEBUG(0,("make_spoolss_printer_info_3: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_3 sruct!\n"));
1082                 return False;
1083         }
1084
1085         inf->secdesc_ptr        = (info->secdesc!=NULL)?1:0;
1086
1087         *spool_info3 = inf;
1088
1089         return True;
1090 }
1091
1092 /*******************************************************************
1093 create a SPOOL_PRINTER_INFO_7 struct from a PRINTER_INFO_7 struct
1094 *******************************************************************/
1095
1096 bool make_spoolss_printer_info_7(TALLOC_CTX *mem_ctx, SPOOL_PRINTER_INFO_LEVEL_7 **spool_info7,
1097                                 PRINTER_INFO_7 *info)
1098 {
1099
1100         SPOOL_PRINTER_INFO_LEVEL_7 *inf;
1101
1102         /* allocate the necessary memory */
1103         if (!(inf=TALLOC_P(mem_ctx, SPOOL_PRINTER_INFO_LEVEL_7))) {
1104                 DEBUG(0,("make_spoolss_printer_info_7: Unable to allocate SPOOL_PRINTER_INFO_LEVEL_7 struct!\n"));
1105                 return False;
1106         }
1107
1108         inf->guid_ptr           = (info->guid.buffer!=NULL)?1:0;
1109         inf->action             = info->action;
1110         init_unistr2_from_unistr(&inf->guid,            &info->guid);
1111
1112         *spool_info7 = inf;
1113
1114         return True;
1115 }
1116
1117
1118 /*******************************************************************
1119  * read a structure.
1120  * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1121  ********************************************************************/
1122
1123 bool spoolss_io_q_open_printer(const char *desc, SPOOL_Q_OPEN_PRINTER *q_u, prs_struct *ps, int depth)
1124 {
1125         if (q_u == NULL)
1126                 return False;
1127
1128         prs_debug(ps, depth, desc, "spoolss_io_q_open_printer");
1129         depth++;
1130
1131         if (!prs_align(ps))
1132                 return False;
1133
1134         if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->printername))
1135                 return False;
1136         if (!prs_io_unistr2("printername", ps, depth, q_u->printername))
1137                 return False;
1138
1139         if (!prs_align(ps))
1140                 return False;
1141
1142         if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth))
1143                 return False;
1144
1145         return True;
1146 }
1147
1148 /*******************************************************************
1149  * write a structure.
1150  * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1151  * called from spoolss_open_printer_ex (cli_spoolss.c)
1152  ********************************************************************/
1153
1154 bool spoolss_io_r_open_printer(const char *desc, SPOOL_R_OPEN_PRINTER *r_u, prs_struct *ps, int depth)
1155 {
1156         if (r_u == NULL) return False;
1157
1158         prs_debug(ps, depth, desc, "spoolss_io_r_open_printer");
1159         depth++;
1160
1161         if (!prs_align(ps))
1162                 return False;
1163
1164         if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
1165                 return False;
1166
1167         if (!prs_werror("status code", ps, depth, &(r_u->status)))
1168                 return False;
1169
1170         return True;
1171 }
1172
1173
1174 /*******************************************************************
1175  * read a structure.
1176  * called from spoolss_q_open_printer_ex (srv_spoolss.c)
1177  ********************************************************************/
1178
1179 bool spoolss_io_q_open_printer_ex(const char *desc, SPOOL_Q_OPEN_PRINTER_EX *q_u, prs_struct *ps, int depth)
1180 {
1181         if (q_u == NULL)
1182                 return False;
1183
1184         prs_debug(ps, depth, desc, "spoolss_io_q_open_printer_ex");
1185         depth++;
1186
1187         if (!prs_align(ps))
1188                 return False;
1189
1190         if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->printername))
1191                 return False;
1192         if (!prs_io_unistr2("printername", ps, depth, q_u->printername))
1193                 return False;
1194
1195         if (!prs_align(ps))
1196                 return False;
1197
1198         if (!spoolss_io_printer_default("", &q_u->printer_default, ps, depth))
1199                 return False;
1200
1201         if (!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
1202                 return False;
1203         if (!spool_io_user_level("", &q_u->user_ctr, ps, depth))
1204                 return False;
1205
1206         return True;
1207 }
1208
1209 /*******************************************************************
1210  * write a structure.
1211  * called from static spoolss_r_open_printer_ex (srv_spoolss.c)
1212  * called from spoolss_open_printer_ex (cli_spoolss.c)
1213  ********************************************************************/
1214
1215 bool spoolss_io_r_open_printer_ex(const char *desc, SPOOL_R_OPEN_PRINTER_EX *r_u, prs_struct *ps, int depth)
1216 {
1217         if (r_u == NULL) return False;
1218
1219         prs_debug(ps, depth, desc, "spoolss_io_r_open_printer_ex");
1220         depth++;
1221
1222         if (!prs_align(ps))
1223                 return False;
1224
1225         if (!smb_io_pol_hnd("printer handle",&(r_u->handle),ps,depth))
1226                 return False;
1227
1228         if (!prs_werror("status code", ps, depth, &(r_u->status)))
1229                 return False;
1230
1231         return True;
1232 }
1233
1234 /*******************************************************************
1235  * init a structure.
1236  ********************************************************************/
1237 bool make_spoolss_q_deleteprinterdriverex( TALLOC_CTX *mem_ctx,
1238                                            SPOOL_Q_DELETEPRINTERDRIVEREX *q_u,
1239                                            const char *server,
1240                                            const char* arch,
1241                                            const char* driver,
1242                                            int version)
1243 {
1244         DEBUG(5,("make_spoolss_q_deleteprinterdriverex\n"));
1245
1246         q_u->server_ptr = (server!=NULL)?1:0;
1247         q_u->delete_flags = DPD_DELETE_UNUSED_FILES;
1248
1249         /* these must be NULL terminated or else NT4 will
1250            complain about invalid parameters --jerry */
1251         init_unistr2(&q_u->server, server, UNI_STR_TERMINATE);
1252         init_unistr2(&q_u->arch, arch, UNI_STR_TERMINATE);
1253         init_unistr2(&q_u->driver, driver, UNI_STR_TERMINATE);
1254
1255         if (version >= 0) {
1256                 q_u->delete_flags |= DPD_DELETE_SPECIFIC_VERSION;
1257                 q_u->version = version;
1258         }
1259
1260         return True;
1261 }
1262
1263
1264 /*******************************************************************
1265  * init a structure.
1266  ********************************************************************/
1267 bool make_spoolss_q_deleteprinterdriver(
1268         TALLOC_CTX *mem_ctx,
1269         SPOOL_Q_DELETEPRINTERDRIVER *q_u,
1270         const char *server,
1271         const char* arch,
1272         const char* driver
1273 )
1274 {
1275         DEBUG(5,("make_spoolss_q_deleteprinterdriver\n"));
1276
1277         q_u->server_ptr = (server!=NULL)?1:0;
1278
1279         /* these must be NULL terminated or else NT4 will
1280            complain about invalid parameters --jerry */
1281         init_unistr2(&q_u->server, server, UNI_STR_TERMINATE);
1282         init_unistr2(&q_u->arch, arch, UNI_STR_TERMINATE);
1283         init_unistr2(&q_u->driver, driver, UNI_STR_TERMINATE);
1284
1285         return True;
1286 }
1287
1288 /*******************************************************************
1289  * make a structure.
1290  ********************************************************************/
1291
1292 bool make_spoolss_q_getprinterdata(SPOOL_Q_GETPRINTERDATA *q_u,
1293                                    const POLICY_HND *handle,
1294                                    const char *valuename, uint32 size)
1295 {
1296         if (q_u == NULL) return False;
1297
1298         DEBUG(5,("make_spoolss_q_getprinterdata\n"));
1299
1300         q_u->handle = *handle;
1301         init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
1302         q_u->size = size;
1303
1304         return True;
1305 }
1306
1307 /*******************************************************************
1308  * make a structure.
1309  ********************************************************************/
1310
1311 bool make_spoolss_q_getprinterdataex(SPOOL_Q_GETPRINTERDATAEX *q_u,
1312                                      const POLICY_HND *handle,
1313                                      const char *keyname,
1314                                      const char *valuename, uint32 size)
1315 {
1316         if (q_u == NULL) return False;
1317
1318         DEBUG(5,("make_spoolss_q_getprinterdataex\n"));
1319
1320         q_u->handle = *handle;
1321         init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
1322         init_unistr2(&q_u->keyname, keyname, UNI_STR_TERMINATE);
1323         q_u->size = size;
1324
1325         return True;
1326 }
1327
1328 /*******************************************************************
1329  * read a structure.
1330  * called from spoolss_q_getprinterdata (srv_spoolss.c)
1331  ********************************************************************/
1332
1333 bool spoolss_io_q_getprinterdata(const char *desc, SPOOL_Q_GETPRINTERDATA *q_u, prs_struct *ps, int depth)
1334 {
1335         if (q_u == NULL)
1336                 return False;
1337
1338         prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdata");
1339         depth++;
1340
1341         if (!prs_align(ps))
1342                 return False;
1343         if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1344                 return False;
1345         if (!prs_align(ps))
1346                 return False;
1347         if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1348                 return False;
1349         if (!prs_align(ps))
1350                 return False;
1351         if (!prs_uint32("size", ps, depth, &q_u->size))
1352                 return False;
1353
1354         return True;
1355 }
1356
1357 /*******************************************************************
1358  * read a structure.
1359  * called from spoolss_q_deleteprinterdata (srv_spoolss.c)
1360  ********************************************************************/
1361
1362 bool spoolss_io_q_deleteprinterdata(const char *desc, SPOOL_Q_DELETEPRINTERDATA *q_u, prs_struct *ps, int depth)
1363 {
1364         if (q_u == NULL)
1365                 return False;
1366
1367         prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdata");
1368         depth++;
1369
1370         if (!prs_align(ps))
1371                 return False;
1372         if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1373                 return False;
1374         if (!prs_align(ps))
1375                 return False;
1376         if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
1377                 return False;
1378
1379         return True;
1380 }
1381
1382 /*******************************************************************
1383  * write a structure.
1384  * called from spoolss_r_deleteprinterdata (srv_spoolss.c)
1385  ********************************************************************/
1386
1387 bool spoolss_io_r_deleteprinterdata(const char *desc, SPOOL_R_DELETEPRINTERDATA *r_u, prs_struct *ps, int depth)
1388 {
1389         prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdata");
1390         depth++;
1391         if(!prs_werror("status", ps, depth, &r_u->status))
1392                 return False;
1393
1394         return True;
1395 }
1396
1397 /*******************************************************************
1398  * read a structure.
1399  * called from spoolss_q_deleteprinterdataex (srv_spoolss.c)
1400  ********************************************************************/
1401
1402 bool spoolss_io_q_deleteprinterdataex(const char *desc, SPOOL_Q_DELETEPRINTERDATAEX *q_u, prs_struct *ps, int depth)
1403 {
1404         if (q_u == NULL)
1405                 return False;
1406
1407         prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdataex");
1408         depth++;
1409
1410         if (!prs_align(ps))
1411                 return False;
1412         if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1413                 return False;
1414
1415         if (!smb_io_unistr2("keyname  ", &q_u->keyname, True, ps, depth))
1416                 return False;
1417         if (!smb_io_unistr2("valuename", &q_u->valuename, True, ps, depth))
1418                 return False;
1419
1420         return True;
1421 }
1422
1423 /*******************************************************************
1424  * write a structure.
1425  * called from spoolss_r_deleteprinterdataex (srv_spoolss.c)
1426  ********************************************************************/
1427
1428 bool spoolss_io_r_deleteprinterdataex(const char *desc, SPOOL_R_DELETEPRINTERDATAEX *r_u, prs_struct *ps, int depth)
1429 {
1430         prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdataex");
1431         depth++;
1432
1433         if(!prs_werror("status", ps, depth, &r_u->status))
1434                 return False;
1435
1436         return True;
1437 }
1438
1439 /*******************************************************************
1440  * write a structure.
1441  * called from spoolss_r_getprinterdata (srv_spoolss.c)
1442  ********************************************************************/
1443
1444 bool spoolss_io_r_getprinterdata(const char *desc, SPOOL_R_GETPRINTERDATA *r_u, prs_struct *ps, int depth)
1445 {
1446         if (r_u == NULL)
1447                 return False;
1448
1449         prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdata");
1450         depth++;
1451
1452         if (!prs_align(ps))
1453                 return False;
1454         if (!prs_uint32("type", ps, depth, &r_u->type))
1455                 return False;
1456         if (!prs_uint32("size", ps, depth, &r_u->size))
1457                 return False;
1458
1459         if (UNMARSHALLING(ps) && r_u->size) {
1460                 r_u->data = PRS_ALLOC_MEM(ps, unsigned char, r_u->size);
1461                 if(!r_u->data)
1462                         return False;
1463         }
1464
1465         if (!prs_uint8s( False, "data", ps, depth, r_u->data, r_u->size ))
1466                 return False;
1467
1468         if (!prs_align(ps))
1469                 return False;
1470
1471         if (!prs_uint32("needed", ps, depth, &r_u->needed))
1472                 return False;
1473         if (!prs_werror("status", ps, depth, &r_u->status))
1474                 return False;
1475
1476         return True;
1477 }
1478
1479 /*******************************************************************
1480  * make a structure.
1481  ********************************************************************/
1482
1483 bool make_spoolss_q_closeprinter(SPOOL_Q_CLOSEPRINTER *q_u, POLICY_HND *hnd)
1484 {
1485         if (q_u == NULL) return False;
1486
1487         DEBUG(5,("make_spoolss_q_closeprinter\n"));
1488
1489         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
1490
1491         return True;
1492 }
1493
1494 /*******************************************************************
1495  * read a structure.
1496  * called from static spoolss_q_abortprinter (srv_spoolss.c)
1497  * called from spoolss_abortprinter (cli_spoolss.c)
1498  ********************************************************************/
1499
1500 bool spoolss_io_q_abortprinter(const char *desc, SPOOL_Q_ABORTPRINTER *q_u, prs_struct *ps, int depth)
1501 {
1502         if (q_u == NULL) return False;
1503
1504         prs_debug(ps, depth, desc, "spoolss_io_q_abortprinter");
1505         depth++;
1506
1507         if (!prs_align(ps))
1508                 return False;
1509
1510         if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1511                 return False;
1512
1513         return True;
1514 }
1515
1516 /*******************************************************************
1517  * write a structure.
1518  * called from spoolss_r_abortprinter (srv_spoolss.c)
1519  ********************************************************************/
1520
1521 bool spoolss_io_r_abortprinter(const char *desc, SPOOL_R_ABORTPRINTER *r_u, prs_struct *ps, int depth)
1522 {
1523         prs_debug(ps, depth, desc, "spoolss_io_r_abortprinter");
1524         depth++;
1525         if(!prs_werror("status", ps, depth, &r_u->status))
1526                 return False;
1527
1528         return True;
1529 }
1530
1531 /*******************************************************************
1532  * read a structure.
1533  * called from static spoolss_q_deleteprinter (srv_spoolss.c)
1534  * called from spoolss_deleteprinter (cli_spoolss.c)
1535  ********************************************************************/
1536
1537 bool spoolss_io_q_deleteprinter(const char *desc, SPOOL_Q_DELETEPRINTER *q_u, prs_struct *ps, int depth)
1538 {
1539         if (q_u == NULL) return False;
1540
1541         prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinter");
1542         depth++;
1543
1544         if (!prs_align(ps))
1545                 return False;
1546
1547         if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1548                 return False;
1549
1550         return True;
1551 }
1552
1553 /*******************************************************************
1554  * write a structure.
1555  * called from static spoolss_r_deleteprinter (srv_spoolss.c)
1556  * called from spoolss_deleteprinter (cli_spoolss.c)
1557  ********************************************************************/
1558
1559 bool spoolss_io_r_deleteprinter(const char *desc, SPOOL_R_DELETEPRINTER *r_u, prs_struct *ps, int depth)
1560 {
1561         prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinter");
1562         depth++;
1563
1564         if (!prs_align(ps))
1565                 return False;
1566
1567         if (!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
1568                 return False;
1569         if (!prs_werror("status", ps, depth, &r_u->status))
1570                 return False;
1571
1572         return True;
1573 }
1574
1575
1576 /*******************************************************************
1577  * read a structure.
1578  * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1579  * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1580  ********************************************************************/
1581
1582 bool spoolss_io_q_deleteprinterdriver(const char *desc, SPOOL_Q_DELETEPRINTERDRIVER *q_u, prs_struct *ps, int depth)
1583 {
1584         if (q_u == NULL) return False;
1585
1586         prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriver");
1587         depth++;
1588
1589         if (!prs_align(ps))
1590                 return False;
1591
1592         if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
1593                 return False;
1594         if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
1595                 return False;
1596         if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
1597                 return False;
1598         if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
1599                 return False;
1600
1601
1602         return True;
1603 }
1604
1605
1606 /*******************************************************************
1607  * write a structure.
1608  ********************************************************************/
1609 bool spoolss_io_r_deleteprinterdriver(const char *desc, SPOOL_R_DELETEPRINTERDRIVER *r_u, prs_struct *ps, int depth)
1610 {
1611         if (r_u == NULL) return False;
1612
1613         prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriver");
1614         depth++;
1615
1616         if (!prs_align(ps))
1617                 return False;
1618
1619         if (!prs_werror("status", ps, depth, &r_u->status))
1620                 return False;
1621
1622         return True;
1623 }
1624
1625
1626 /*******************************************************************
1627  * read a structure.
1628  * called from api_spoolss_deleteprinterdriver (srv_spoolss.c)
1629  * called from spoolss_deleteprinterdriver (cli_spoolss.c)
1630  ********************************************************************/
1631
1632 bool spoolss_io_q_deleteprinterdriverex(const char *desc, SPOOL_Q_DELETEPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
1633 {
1634         if (q_u == NULL) return False;
1635
1636         prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterdriverex");
1637         depth++;
1638
1639         if (!prs_align(ps))
1640                 return False;
1641
1642         if(!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
1643                 return False;
1644         if(!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
1645                 return False;
1646         if(!smb_io_unistr2("arch", &q_u->arch, True, ps, depth))
1647                 return False;
1648         if(!smb_io_unistr2("driver", &q_u->driver, True, ps, depth))
1649                 return False;
1650
1651         if (!prs_align(ps))
1652                 return False;
1653
1654         if(!prs_uint32("delete_flags ", ps, depth, &q_u->delete_flags))
1655                 return False;
1656         if(!prs_uint32("version      ", ps, depth, &q_u->version))
1657                 return False;
1658
1659
1660         return True;
1661 }
1662
1663
1664 /*******************************************************************
1665  * write a structure.
1666  ********************************************************************/
1667 bool spoolss_io_r_deleteprinterdriverex(const char *desc, SPOOL_R_DELETEPRINTERDRIVEREX *r_u, prs_struct *ps, int depth)
1668 {
1669         if (r_u == NULL) return False;
1670
1671         prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterdriverex");
1672         depth++;
1673
1674         if (!prs_align(ps))
1675                 return False;
1676
1677         if (!prs_werror("status", ps, depth, &r_u->status))
1678                 return False;
1679
1680         return True;
1681 }
1682
1683
1684
1685 /*******************************************************************
1686  * read a structure.
1687  * called from static spoolss_q_closeprinter (srv_spoolss.c)
1688  * called from spoolss_closeprinter (cli_spoolss.c)
1689  ********************************************************************/
1690
1691 bool spoolss_io_q_closeprinter(const char *desc, SPOOL_Q_CLOSEPRINTER *q_u, prs_struct *ps, int depth)
1692 {
1693         if (q_u == NULL) return False;
1694
1695         prs_debug(ps, depth, desc, "spoolss_io_q_closeprinter");
1696         depth++;
1697
1698         if (!prs_align(ps))
1699                 return False;
1700
1701         if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1702                 return False;
1703
1704         return True;
1705 }
1706
1707 /*******************************************************************
1708  * write a structure.
1709  * called from static spoolss_r_closeprinter (srv_spoolss.c)
1710  * called from spoolss_closeprinter (cli_spoolss.c)
1711  ********************************************************************/
1712
1713 bool spoolss_io_r_closeprinter(const char *desc, SPOOL_R_CLOSEPRINTER *r_u, prs_struct *ps, int depth)
1714 {
1715         prs_debug(ps, depth, desc, "spoolss_io_r_closeprinter");
1716         depth++;
1717
1718         if (!prs_align(ps))
1719                 return False;
1720
1721         if (!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
1722                 return False;
1723         if (!prs_werror("status", ps, depth, &r_u->status))
1724                 return False;
1725
1726         return True;
1727 }
1728
1729 /*******************************************************************
1730  * read a structure.
1731  * called from spoolss_q_startdocprinter (srv_spoolss.c)
1732  ********************************************************************/
1733
1734 bool spoolss_io_q_startdocprinter(const char *desc, SPOOL_Q_STARTDOCPRINTER *q_u, prs_struct *ps, int depth)
1735 {
1736         if (q_u == NULL) return False;
1737
1738         prs_debug(ps, depth, desc, "spoolss_io_q_startdocprinter");
1739         depth++;
1740
1741         if(!prs_align(ps))
1742                 return False;
1743
1744         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1745                 return False;
1746
1747         if(!smb_io_doc_info_container("",&q_u->doc_info_container, ps, depth))
1748                 return False;
1749
1750         return True;
1751 }
1752
1753 /*******************************************************************
1754  * write a structure.
1755  * called from spoolss_r_startdocprinter (srv_spoolss.c)
1756  ********************************************************************/
1757
1758 bool spoolss_io_r_startdocprinter(const char *desc, SPOOL_R_STARTDOCPRINTER *r_u, prs_struct *ps, int depth)
1759 {
1760         prs_debug(ps, depth, desc, "spoolss_io_r_startdocprinter");
1761         depth++;
1762         if(!prs_uint32("jobid", ps, depth, &r_u->jobid))
1763                 return False;
1764         if(!prs_werror("status", ps, depth, &r_u->status))
1765                 return False;
1766
1767         return True;
1768 }
1769
1770 /*******************************************************************
1771  * read a structure.
1772  * called from spoolss_q_enddocprinter (srv_spoolss.c)
1773  ********************************************************************/
1774
1775 bool spoolss_io_q_enddocprinter(const char *desc, SPOOL_Q_ENDDOCPRINTER *q_u, prs_struct *ps, int depth)
1776 {
1777         if (q_u == NULL) return False;
1778
1779         prs_debug(ps, depth, desc, "spoolss_io_q_enddocprinter");
1780         depth++;
1781
1782         if(!prs_align(ps))
1783                 return False;
1784
1785         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1786                 return False;
1787
1788         return True;
1789 }
1790
1791 /*******************************************************************
1792  * write a structure.
1793  * called from spoolss_r_enddocprinter (srv_spoolss.c)
1794  ********************************************************************/
1795
1796 bool spoolss_io_r_enddocprinter(const char *desc, SPOOL_R_ENDDOCPRINTER *r_u, prs_struct *ps, int depth)
1797 {
1798         prs_debug(ps, depth, desc, "spoolss_io_r_enddocprinter");
1799         depth++;
1800         if(!prs_werror("status", ps, depth, &r_u->status))
1801                 return False;
1802
1803         return True;
1804 }
1805
1806 /*******************************************************************
1807  * read a structure.
1808  * called from spoolss_q_startpageprinter (srv_spoolss.c)
1809  ********************************************************************/
1810
1811 bool spoolss_io_q_startpageprinter(const char *desc, SPOOL_Q_STARTPAGEPRINTER *q_u, prs_struct *ps, int depth)
1812 {
1813         if (q_u == NULL) return False;
1814
1815         prs_debug(ps, depth, desc, "spoolss_io_q_startpageprinter");
1816         depth++;
1817
1818         if(!prs_align(ps))
1819                 return False;
1820
1821         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1822                 return False;
1823
1824         return True;
1825 }
1826
1827 /*******************************************************************
1828  * write a structure.
1829  * called from spoolss_r_startpageprinter (srv_spoolss.c)
1830  ********************************************************************/
1831
1832 bool spoolss_io_r_startpageprinter(const char *desc, SPOOL_R_STARTPAGEPRINTER *r_u, prs_struct *ps, int depth)
1833 {
1834         prs_debug(ps, depth, desc, "spoolss_io_r_startpageprinter");
1835         depth++;
1836         if(!prs_werror("status", ps, depth, &r_u->status))
1837                 return False;
1838
1839         return True;
1840 }
1841
1842 /*******************************************************************
1843  * read a structure.
1844  * called from spoolss_q_endpageprinter (srv_spoolss.c)
1845  ********************************************************************/
1846
1847 bool spoolss_io_q_endpageprinter(const char *desc, SPOOL_Q_ENDPAGEPRINTER *q_u, prs_struct *ps, int depth)
1848 {
1849         if (q_u == NULL) return False;
1850
1851         prs_debug(ps, depth, desc, "spoolss_io_q_endpageprinter");
1852         depth++;
1853
1854         if(!prs_align(ps))
1855                 return False;
1856
1857         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1858                 return False;
1859
1860         return True;
1861 }
1862
1863 /*******************************************************************
1864  * write a structure.
1865  * called from spoolss_r_endpageprinter (srv_spoolss.c)
1866  ********************************************************************/
1867
1868 bool spoolss_io_r_endpageprinter(const char *desc, SPOOL_R_ENDPAGEPRINTER *r_u, prs_struct *ps, int depth)
1869 {
1870         prs_debug(ps, depth, desc, "spoolss_io_r_endpageprinter");
1871         depth++;
1872         if(!prs_werror("status", ps, depth, &r_u->status))
1873                 return False;
1874
1875         return True;
1876 }
1877
1878 /*******************************************************************
1879  * read a structure.
1880  * called from spoolss_q_writeprinter (srv_spoolss.c)
1881  ********************************************************************/
1882
1883 bool spoolss_io_q_writeprinter(const char *desc, SPOOL_Q_WRITEPRINTER *q_u, prs_struct *ps, int depth)
1884 {
1885         if (q_u == NULL) return False;
1886
1887         prs_debug(ps, depth, desc, "spoolss_io_q_writeprinter");
1888         depth++;
1889
1890         if(!prs_align(ps))
1891                 return False;
1892
1893         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
1894                 return False;
1895         if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size))
1896                 return False;
1897
1898         if (q_u->buffer_size!=0)
1899         {
1900                 if (UNMARSHALLING(ps))
1901                         q_u->buffer=PRS_ALLOC_MEM(ps, uint8, q_u->buffer_size);
1902                 if(q_u->buffer == NULL)
1903                         return False;
1904                 if(!prs_uint8s(True, "buffer", ps, depth, q_u->buffer, q_u->buffer_size))
1905                         return False;
1906         }
1907         if(!prs_align(ps))
1908                 return False;
1909         if(!prs_uint32("buffer_size2", ps, depth, &q_u->buffer_size2))
1910                 return False;
1911
1912         return True;
1913 }
1914
1915 /*******************************************************************
1916  * write a structure.
1917  * called from spoolss_r_writeprinter (srv_spoolss.c)
1918  ********************************************************************/
1919
1920 bool spoolss_io_r_writeprinter(const char *desc, SPOOL_R_WRITEPRINTER *r_u, prs_struct *ps, int depth)
1921 {
1922         prs_debug(ps, depth, desc, "spoolss_io_r_writeprinter");
1923         depth++;
1924         if(!prs_uint32("buffer_written", ps, depth, &r_u->buffer_written))
1925                 return False;
1926         if(!prs_werror("status", ps, depth, &r_u->status))
1927                 return False;
1928
1929         return True;
1930 }
1931
1932 /*******************************************************************
1933  * read a structure.
1934  * called from spoolss_q_rffpcnex (srv_spoolss.c)
1935  ********************************************************************/
1936
1937 bool spoolss_io_q_rffpcnex(const char *desc, SPOOL_Q_RFFPCNEX *q_u, prs_struct *ps, int depth)
1938 {
1939         prs_debug(ps, depth, desc, "spoolss_io_q_rffpcnex");
1940         depth++;
1941
1942         if(!prs_align(ps))
1943                 return False;
1944
1945         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
1946                 return False;
1947         if(!prs_uint32("flags", ps, depth, &q_u->flags))
1948                 return False;
1949         if(!prs_uint32("options", ps, depth, &q_u->options))
1950                 return False;
1951         if(!prs_uint32("localmachine_ptr", ps, depth, &q_u->localmachine_ptr))
1952                 return False;
1953         if(!smb_io_unistr2("localmachine", &q_u->localmachine, q_u->localmachine_ptr, ps, depth))
1954                 return False;
1955
1956         if(!prs_align(ps))
1957                 return False;
1958
1959         if(!prs_uint32("printerlocal", ps, depth, &q_u->printerlocal))
1960                 return False;
1961
1962         if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
1963                 return False;
1964
1965         if (q_u->option_ptr!=0) {
1966
1967                 if (UNMARSHALLING(ps))
1968                         if((q_u->option=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION,1)) == NULL)
1969                                 return False;
1970
1971                 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
1972                         return False;
1973         }
1974
1975         return True;
1976 }
1977
1978 /*******************************************************************
1979  * write a structure.
1980  * called from spoolss_r_rffpcnex (srv_spoolss.c)
1981  ********************************************************************/
1982
1983 bool spoolss_io_r_rffpcnex(const char *desc, SPOOL_R_RFFPCNEX *r_u, prs_struct *ps, int depth)
1984 {
1985         prs_debug(ps, depth, desc, "spoolss_io_r_rffpcnex");
1986         depth++;
1987
1988         if(!prs_werror("status", ps, depth, &r_u->status))
1989                 return False;
1990
1991         return True;
1992 }
1993
1994 /*******************************************************************
1995  * read a structure.
1996  * called from spoolss_q_rfnpcnex (srv_spoolss.c)
1997  ********************************************************************/
1998
1999 bool spoolss_io_q_rfnpcnex(const char *desc, SPOOL_Q_RFNPCNEX *q_u, prs_struct *ps, int depth)
2000 {
2001         prs_debug(ps, depth, desc, "spoolss_io_q_rfnpcnex");
2002         depth++;
2003
2004         if(!prs_align(ps))
2005                 return False;
2006
2007         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
2008                 return False;
2009
2010         if(!prs_uint32("change", ps, depth, &q_u->change))
2011                 return False;
2012
2013         if(!prs_uint32("option_ptr", ps, depth, &q_u->option_ptr))
2014                 return False;
2015
2016         if (q_u->option_ptr!=0) {
2017
2018                 if (UNMARSHALLING(ps))
2019                         if((q_u->option=PRS_ALLOC_MEM(ps,SPOOL_NOTIFY_OPTION,1)) == NULL)
2020                                 return False;
2021
2022                 if(!smb_io_notify_option("notify option", q_u->option, ps, depth))
2023                         return False;
2024         }
2025
2026         return True;
2027 }
2028
2029 /*******************************************************************
2030  * write a structure.
2031  * called from spoolss_r_rfnpcnex (srv_spoolss.c)
2032  ********************************************************************/
2033
2034 bool spoolss_io_r_rfnpcnex(const char *desc, SPOOL_R_RFNPCNEX *r_u, prs_struct *ps, int depth)
2035 {
2036         prs_debug(ps, depth, desc, "spoolss_io_r_rfnpcnex");
2037         depth++;
2038
2039         if(!prs_align(ps))
2040                 return False;
2041
2042         if (!prs_uint32("info_ptr", ps, depth, &r_u->info_ptr))
2043                 return False;
2044
2045         if(!smb_io_notify_info("notify info", &r_u->info ,ps,depth))
2046                 return False;
2047
2048         if(!prs_align(ps))
2049                 return False;
2050         if(!prs_werror("status", ps, depth, &r_u->status))
2051                 return False;
2052
2053         return True;
2054 }
2055
2056 /*******************************************************************
2057  * return the length of a uint16 (obvious, but the code is clean)
2058  ********************************************************************/
2059
2060 static uint32 size_of_uint16(uint16 *value)
2061 {
2062         return (sizeof(*value));
2063 }
2064
2065 /*******************************************************************
2066  * return the length of a uint32 (obvious, but the code is clean)
2067  ********************************************************************/
2068
2069 static uint32 size_of_uint32(uint32 *value)
2070 {
2071         return (sizeof(*value));
2072 }
2073
2074 /*******************************************************************
2075  * return the length of a NTTIME (obvious, but the code is clean)
2076  ********************************************************************/
2077
2078 static uint32 size_of_nttime(NTTIME *value)
2079 {
2080         return (sizeof(*value));
2081 }
2082
2083 /*******************************************************************
2084  * return the length of a uint32 (obvious, but the code is clean)
2085  ********************************************************************/
2086
2087 static uint32 size_of_device_mode(DEVICEMODE *devmode)
2088 {
2089         if (devmode==NULL)
2090                 return (4);
2091         else
2092                 return (4+devmode->size+devmode->driverextra);
2093 }
2094
2095 /*******************************************************************
2096  * return the length of a uint32 (obvious, but the code is clean)
2097  ********************************************************************/
2098
2099 static uint32 size_of_systemtime(SYSTEMTIME *systime)
2100 {
2101         if (systime==NULL)
2102                 return (4);
2103         else
2104                 return (sizeof(SYSTEMTIME) +4);
2105 }
2106
2107 /*******************************************************************
2108  Parse a DEVMODE structure and its relative pointer.
2109 ********************************************************************/
2110
2111 static bool smb_io_reldevmode(const char *desc, RPC_BUFFER *buffer, int depth, DEVICEMODE **devmode)
2112 {
2113         prs_struct *ps=&buffer->prs;
2114
2115         prs_debug(ps, depth, desc, "smb_io_reldevmode");
2116         depth++;
2117
2118         if (MARSHALLING(ps)) {
2119                 uint32 struct_offset = prs_offset(ps);
2120                 uint32 relative_offset;
2121
2122                 if (*devmode == NULL) {
2123                         relative_offset=0;
2124                         if (!prs_uint32("offset", ps, depth, &relative_offset))
2125                                 return False;
2126                         DEBUG(8, ("boing, the devmode was NULL\n"));
2127
2128                         return True;
2129                 }
2130
2131                 buffer->string_at_end -= ((*devmode)->size + (*devmode)->driverextra);
2132
2133                 if(!prs_set_offset(ps, buffer->string_at_end))
2134                         return False;
2135
2136                 /* write the DEVMODE */
2137                 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
2138                         return False;
2139
2140                 if(!prs_set_offset(ps, struct_offset))
2141                         return False;
2142
2143                 relative_offset=buffer->string_at_end - buffer->struct_start;
2144                 /* write its offset */
2145                 if (!prs_uint32("offset", ps, depth, &relative_offset))
2146                         return False;
2147         }
2148         else {
2149                 uint32 old_offset;
2150
2151                 /* read the offset */
2152                 if (!prs_uint32("offset", ps, depth, &buffer->string_at_end))
2153                         return False;
2154                 if (buffer->string_at_end == 0) {
2155                         *devmode = NULL;
2156                         return True;
2157                 }
2158
2159                 old_offset = prs_offset(ps);
2160                 if(!prs_set_offset(ps, buffer->string_at_end + buffer->struct_start))
2161                         return False;
2162
2163                 /* read the string */
2164                 if((*devmode=PRS_ALLOC_MEM(ps,DEVICEMODE,1)) == NULL)
2165                         return False;
2166                 if (!spoolss_io_devmode(desc, ps, depth, *devmode))
2167                         return False;
2168
2169                 if(!prs_set_offset(ps, old_offset))
2170                         return False;
2171         }
2172         return True;
2173 }
2174
2175 /*******************************************************************
2176  Parse a PRINTER_INFO_0 structure.
2177 ********************************************************************/
2178
2179 bool smb_io_printer_info_0(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_0 *info, int depth)
2180 {
2181         prs_struct *ps=&buffer->prs;
2182
2183         prs_debug(ps, depth, desc, "smb_io_printer_info_0");
2184         depth++;
2185
2186         buffer->struct_start=prs_offset(ps);
2187
2188         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2189                 return False;
2190         if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2191                 return False;
2192
2193         if(!prs_uint32("cjobs", ps, depth, &info->cjobs))
2194                 return False;
2195         if(!prs_uint32("total_jobs", ps, depth, &info->total_jobs))
2196                 return False;
2197         if(!prs_uint32("total_bytes", ps, depth, &info->total_bytes))
2198                 return False;
2199
2200         if(!prs_uint16("year", ps, depth, &info->year))
2201                 return False;
2202         if(!prs_uint16("month", ps, depth, &info->month))
2203                 return False;
2204         if(!prs_uint16("dayofweek", ps, depth, &info->dayofweek))
2205                 return False;
2206         if(!prs_uint16("day", ps, depth, &info->day))
2207                 return False;
2208         if(!prs_uint16("hour", ps, depth, &info->hour))
2209                 return False;
2210         if(!prs_uint16("minute", ps, depth, &info->minute))
2211                 return False;
2212         if(!prs_uint16("second", ps, depth, &info->second))
2213                 return False;
2214         if(!prs_uint16("milliseconds", ps, depth, &info->milliseconds))
2215                 return False;
2216
2217         if(!prs_uint32("global_counter", ps, depth, &info->global_counter))
2218                 return False;
2219         if(!prs_uint32("total_pages", ps, depth, &info->total_pages))
2220                 return False;
2221
2222         if(!prs_uint16("major_version", ps, depth, &info->major_version))
2223                 return False;
2224         if(!prs_uint16("build_version", ps, depth, &info->build_version))
2225                 return False;
2226         if(!prs_uint32("unknown7", ps, depth, &info->unknown7))
2227                 return False;
2228         if(!prs_uint32("unknown8", ps, depth, &info->unknown8))
2229                 return False;
2230         if(!prs_uint32("unknown9", ps, depth, &info->unknown9))
2231                 return False;
2232         if(!prs_uint32("session_counter", ps, depth, &info->session_counter))
2233                 return False;
2234         if(!prs_uint32("unknown11", ps, depth, &info->unknown11))
2235                 return False;
2236         if(!prs_uint32("printer_errors", ps, depth, &info->printer_errors))
2237                 return False;
2238         if(!prs_uint32("unknown13", ps, depth, &info->unknown13))
2239                 return False;
2240         if(!prs_uint32("unknown14", ps, depth, &info->unknown14))
2241                 return False;
2242         if(!prs_uint32("unknown15", ps, depth, &info->unknown15))
2243                 return False;
2244         if(!prs_uint32("unknown16", ps, depth, &info->unknown16))
2245                 return False;
2246         if(!prs_uint32("change_id", ps, depth, &info->change_id))
2247                 return False;
2248         if(!prs_uint32("unknown18", ps, depth, &info->unknown18))
2249                 return False;
2250         if(!prs_uint32("status"   , ps, depth, &info->status))
2251                 return False;
2252         if(!prs_uint32("unknown20", ps, depth, &info->unknown20))
2253                 return False;
2254         if(!prs_uint32("c_setprinter", ps, depth, &info->c_setprinter))
2255                 return False;
2256         if(!prs_uint16("unknown22", ps, depth, &info->unknown22))
2257                 return False;
2258         if(!prs_uint16("unknown23", ps, depth, &info->unknown23))
2259                 return False;
2260         if(!prs_uint16("unknown24", ps, depth, &info->unknown24))
2261                 return False;
2262         if(!prs_uint16("unknown25", ps, depth, &info->unknown25))
2263                 return False;
2264         if(!prs_uint16("unknown26", ps, depth, &info->unknown26))
2265                 return False;
2266         if(!prs_uint16("unknown27", ps, depth, &info->unknown27))
2267                 return False;
2268         if(!prs_uint16("unknown28", ps, depth, &info->unknown28))
2269                 return False;
2270         if(!prs_uint16("unknown29", ps, depth, &info->unknown29))
2271                 return False;
2272
2273         return True;
2274 }
2275
2276 /*******************************************************************
2277  Parse a PRINTER_INFO_1 structure.
2278 ********************************************************************/
2279
2280 bool smb_io_printer_info_1(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_1 *info, int depth)
2281 {
2282         prs_struct *ps=&buffer->prs;
2283
2284         prs_debug(ps, depth, desc, "smb_io_printer_info_1");
2285         depth++;
2286
2287         buffer->struct_start=prs_offset(ps);
2288
2289         if (!prs_uint32("flags", ps, depth, &info->flags))
2290                 return False;
2291         if (!smb_io_relstr("description", buffer, depth, &info->description))
2292                 return False;
2293         if (!smb_io_relstr("name", buffer, depth, &info->name))
2294                 return False;
2295         if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2296                 return False;
2297
2298         return True;
2299 }
2300
2301 /*******************************************************************
2302  Parse a PRINTER_INFO_2 structure.
2303 ********************************************************************/
2304
2305 bool smb_io_printer_info_2(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_2 *info, int depth)
2306 {
2307         prs_struct *ps=&buffer->prs;
2308         uint32 dm_offset, sd_offset, current_offset;
2309         uint32 dummy_value = 0, has_secdesc = 0;
2310
2311         prs_debug(ps, depth, desc, "smb_io_printer_info_2");
2312         depth++;
2313
2314         buffer->struct_start=prs_offset(ps);
2315
2316         if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2317                 return False;
2318         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2319                 return False;
2320         if (!smb_io_relstr("sharename", buffer, depth, &info->sharename))
2321                 return False;
2322         if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2323                 return False;
2324         if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2325                 return False;
2326         if (!smb_io_relstr("comment", buffer, depth, &info->comment))
2327                 return False;
2328         if (!smb_io_relstr("location", buffer, depth, &info->location))
2329                 return False;
2330
2331         /* save current offset and wind forwared by a uint32 */
2332         dm_offset = prs_offset(ps);
2333         if (!prs_uint32("devmode", ps, depth, &dummy_value))
2334                 return False;
2335
2336         if (!smb_io_relstr("sepfile", buffer, depth, &info->sepfile))
2337                 return False;
2338         if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2339                 return False;
2340         if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2341                 return False;
2342         if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2343                 return False;
2344
2345         /* save current offset for the sec_desc */
2346         sd_offset = prs_offset(ps);
2347         if (!prs_uint32("sec_desc", ps, depth, &has_secdesc))
2348                 return False;
2349
2350
2351         /* save current location so we can pick back up here */
2352         current_offset = prs_offset(ps);
2353
2354         /* parse the devmode */
2355         if (!prs_set_offset(ps, dm_offset))
2356                 return False;
2357         if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2358                 return False;
2359
2360         /* parse the sec_desc */
2361         if (info->secdesc) {
2362                 if (!prs_set_offset(ps, sd_offset))
2363                         return False;
2364                 if (!smb_io_relsecdesc("secdesc", buffer, depth, &info->secdesc))
2365                         return False;
2366         }
2367
2368         /* pick up where we left off */
2369         if (!prs_set_offset(ps, current_offset))
2370                 return False;
2371
2372         if (!prs_uint32("attributes", ps, depth, &info->attributes))
2373                 return False;
2374         if (!prs_uint32("priority", ps, depth, &info->priority))
2375                 return False;
2376         if (!prs_uint32("defpriority", ps, depth, &info->defaultpriority))
2377                 return False;
2378         if (!prs_uint32("starttime", ps, depth, &info->starttime))
2379                 return False;
2380         if (!prs_uint32("untiltime", ps, depth, &info->untiltime))
2381                 return False;
2382         if (!prs_uint32("status", ps, depth, &info->status))
2383                 return False;
2384         if (!prs_uint32("jobs", ps, depth, &info->cjobs))
2385                 return False;
2386         if (!prs_uint32("averageppm", ps, depth, &info->averageppm))
2387                 return False;
2388
2389         return True;
2390 }
2391
2392 /*******************************************************************
2393  Parse a PRINTER_INFO_3 structure.
2394 ********************************************************************/
2395
2396 bool smb_io_printer_info_3(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_3 *info, int depth)
2397 {
2398         uint32 offset = 0;
2399         prs_struct *ps=&buffer->prs;
2400
2401         prs_debug(ps, depth, desc, "smb_io_printer_info_3");
2402         depth++;
2403
2404         buffer->struct_start=prs_offset(ps);
2405
2406         if (MARSHALLING(ps)) {
2407                 /* Ensure the SD is 8 byte aligned in the buffer. */
2408                 uint32 start = prs_offset(ps); /* Remember the start position. */
2409                 uint32 off_val = 0;
2410
2411                 /* Write a dummy value. */
2412                 if (!prs_uint32("offset", ps, depth, &off_val))
2413                         return False;
2414
2415                 /* 8 byte align. */
2416                 if (!prs_align_uint64(ps))
2417                         return False;
2418
2419                 /* Remember where we must seek back to write the SD. */
2420                 offset = prs_offset(ps);
2421
2422                 /* Calculate the real offset for the SD. */
2423
2424                 off_val = offset - start;
2425
2426                 /* Seek back to where we store the SD offset & store. */
2427                 prs_set_offset(ps, start);
2428                 if (!prs_uint32("offset", ps, depth, &off_val))
2429                         return False;
2430
2431                 /* Return to after the 8 byte align. */
2432                 prs_set_offset(ps, offset);
2433
2434         } else {
2435                 if (!prs_uint32("offset", ps, depth, &offset))
2436                         return False;
2437                 /* Seek within the buffer. */
2438                 if (!prs_set_offset(ps, offset))
2439                         return False;
2440         }
2441         if (!sec_io_desc("sec_desc", &info->secdesc, ps, depth))
2442                 return False;
2443
2444         return True;
2445 }
2446
2447 /*******************************************************************
2448  Parse a PRINTER_INFO_4 structure.
2449 ********************************************************************/
2450
2451 bool smb_io_printer_info_4(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_4 *info, int depth)
2452 {
2453         prs_struct *ps=&buffer->prs;
2454
2455         prs_debug(ps, depth, desc, "smb_io_printer_info_4");
2456         depth++;
2457
2458         buffer->struct_start=prs_offset(ps);
2459
2460         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2461                 return False;
2462         if (!smb_io_relstr("servername", buffer, depth, &info->servername))
2463                 return False;
2464         if (!prs_uint32("attributes", ps, depth, &info->attributes))
2465                 return False;
2466         return True;
2467 }
2468
2469 /*******************************************************************
2470  Parse a PRINTER_INFO_5 structure.
2471 ********************************************************************/
2472
2473 bool smb_io_printer_info_5(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_5 *info, int depth)
2474 {
2475         prs_struct *ps=&buffer->prs;
2476
2477         prs_debug(ps, depth, desc, "smb_io_printer_info_5");
2478         depth++;
2479
2480         buffer->struct_start=prs_offset(ps);
2481
2482         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2483                 return False;
2484         if (!smb_io_relstr("portname", buffer, depth, &info->portname))
2485                 return False;
2486         if (!prs_uint32("attributes", ps, depth, &info->attributes))
2487                 return False;
2488         if (!prs_uint32("device_not_selected_timeout", ps, depth, &info->device_not_selected_timeout))
2489                 return False;
2490         if (!prs_uint32("transmission_retry_timeout", ps, depth, &info->transmission_retry_timeout))
2491                 return False;
2492         return True;
2493 }
2494
2495 /*******************************************************************
2496  Parse a PRINTER_INFO_6 structure.
2497 ********************************************************************/
2498
2499 bool smb_io_printer_info_6(const char *desc, RPC_BUFFER *buffer,
2500                            PRINTER_INFO_6 *info, int depth)
2501 {
2502         prs_struct *ps=&buffer->prs;
2503
2504         prs_debug(ps, depth, desc, "smb_io_printer_info_6");
2505         depth++;
2506
2507         if (!prs_uint32("status", ps, depth, &info->status))
2508                 return False;
2509
2510         return True;
2511 }
2512
2513 /*******************************************************************
2514  Parse a PRINTER_INFO_7 structure.
2515 ********************************************************************/
2516
2517 bool smb_io_printer_info_7(const char *desc, RPC_BUFFER *buffer, PRINTER_INFO_7 *info, int depth)
2518 {
2519         prs_struct *ps=&buffer->prs;
2520
2521         prs_debug(ps, depth, desc, "smb_io_printer_info_7");
2522         depth++;
2523
2524         buffer->struct_start=prs_offset(ps);
2525
2526         if (!smb_io_relstr("guid", buffer, depth, &info->guid))
2527                 return False;
2528         if (!prs_uint32("action", ps, depth, &info->action))
2529                 return False;
2530         return True;
2531 }
2532
2533 /*******************************************************************
2534  Parse a PORT_INFO_1 structure.
2535 ********************************************************************/
2536
2537 bool smb_io_port_info_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
2538 {
2539         prs_struct *ps=&buffer->prs;
2540
2541         prs_debug(ps, depth, desc, "smb_io_port_info_1");
2542         depth++;
2543
2544         buffer->struct_start=prs_offset(ps);
2545
2546         if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2547                 return False;
2548
2549         return True;
2550 }
2551
2552 /*******************************************************************
2553  Parse a PORT_INFO_2 structure.
2554 ********************************************************************/
2555
2556 bool smb_io_port_info_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2557 {
2558         prs_struct *ps=&buffer->prs;
2559
2560         prs_debug(ps, depth, desc, "smb_io_port_info_2");
2561         depth++;
2562
2563         buffer->struct_start=prs_offset(ps);
2564
2565         if (!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2566                 return False;
2567         if (!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2568                 return False;
2569         if (!smb_io_relstr("description", buffer, depth, &info->description))
2570                 return False;
2571         if (!prs_uint32("port_type", ps, depth, &info->port_type))
2572                 return False;
2573         if (!prs_uint32("reserved", ps, depth, &info->reserved))
2574                 return False;
2575
2576         return True;
2577 }
2578
2579 /*******************************************************************
2580  Parse a DRIVER_INFO_1 structure.
2581 ********************************************************************/
2582
2583 bool smb_io_printer_driver_info_1(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_1 *info, int depth)
2584 {
2585         prs_struct *ps=&buffer->prs;
2586
2587         prs_debug(ps, depth, desc, "smb_io_printer_driver_info_1");
2588         depth++;
2589
2590         buffer->struct_start=prs_offset(ps);
2591
2592         if (!smb_io_relstr("name", buffer, depth, &info->name))
2593                 return False;
2594
2595         return True;
2596 }
2597
2598 /*******************************************************************
2599  Parse a DRIVER_INFO_2 structure.
2600 ********************************************************************/
2601
2602 bool smb_io_printer_driver_info_2(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_2 *info, int depth)
2603 {
2604         prs_struct *ps=&buffer->prs;
2605
2606         prs_debug(ps, depth, desc, "smb_io_printer_driver_info_2");
2607         depth++;
2608
2609         buffer->struct_start=prs_offset(ps);
2610
2611         if (!prs_uint32("version", ps, depth, &info->version))
2612                 return False;
2613         if (!smb_io_relstr("name", buffer, depth, &info->name))
2614                 return False;
2615         if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2616                 return False;
2617         if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2618                 return False;
2619         if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2620                 return False;
2621         if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2622                 return False;
2623
2624         return True;
2625 }
2626
2627 /*******************************************************************
2628  Parse a DRIVER_INFO_3 structure.
2629 ********************************************************************/
2630
2631 bool smb_io_printer_driver_info_3(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_3 *info, int depth)
2632 {
2633         prs_struct *ps=&buffer->prs;
2634
2635         prs_debug(ps, depth, desc, "smb_io_printer_driver_info_3");
2636         depth++;
2637
2638         buffer->struct_start=prs_offset(ps);
2639
2640         if (!prs_uint32("version", ps, depth, &info->version))
2641                 return False;
2642         if (!smb_io_relstr("name", buffer, depth, &info->name))
2643                 return False;
2644         if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2645                 return False;
2646         if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2647                 return False;
2648         if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2649                 return False;
2650         if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2651                 return False;
2652         if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2653                 return False;
2654
2655         if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2656                 return False;
2657
2658         if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2659                 return False;
2660         if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2661                 return False;
2662
2663         return True;
2664 }
2665
2666 /*******************************************************************
2667  Parse a DRIVER_INFO_6 structure.
2668 ********************************************************************/
2669
2670 bool smb_io_printer_driver_info_6(const char *desc, RPC_BUFFER *buffer, DRIVER_INFO_6 *info, int depth)
2671 {
2672         prs_struct *ps=&buffer->prs;
2673
2674         prs_debug(ps, depth, desc, "smb_io_printer_driver_info_6");
2675         depth++;
2676
2677         buffer->struct_start=prs_offset(ps);
2678
2679         if (!prs_uint32("version", ps, depth, &info->version))
2680                 return False;
2681         if (!smb_io_relstr("name", buffer, depth, &info->name))
2682                 return False;
2683         if (!smb_io_relstr("architecture", buffer, depth, &info->architecture))
2684                 return False;
2685         if (!smb_io_relstr("driverpath", buffer, depth, &info->driverpath))
2686                 return False;
2687         if (!smb_io_relstr("datafile", buffer, depth, &info->datafile))
2688                 return False;
2689         if (!smb_io_relstr("configfile", buffer, depth, &info->configfile))
2690                 return False;
2691         if (!smb_io_relstr("helpfile", buffer, depth, &info->helpfile))
2692                 return False;
2693
2694         if (!smb_io_relarraystr("dependentfiles", buffer, depth, &info->dependentfiles))
2695                 return False;
2696
2697         if (!smb_io_relstr("monitorname", buffer, depth, &info->monitorname))
2698                 return False;
2699         if (!smb_io_relstr("defaultdatatype", buffer, depth, &info->defaultdatatype))
2700                 return False;
2701
2702         if (!smb_io_relarraystr("previousdrivernames", buffer, depth, &info->previousdrivernames))
2703                 return False;
2704
2705         if (!prs_uint64("date", ps, depth, &info->driver_date))
2706                 return False;
2707
2708         if (!prs_uint32("padding", ps, depth, &info->padding))
2709                 return False;
2710
2711         if (!prs_uint32("driver_version_low", ps, depth, &info->driver_version_low))
2712                 return False;
2713
2714         if (!prs_uint32("driver_version_high", ps, depth, &info->driver_version_high))
2715                 return False;
2716
2717         if (!smb_io_relstr("mfgname", buffer, depth, &info->mfgname))
2718                 return False;
2719         if (!smb_io_relstr("oem_url", buffer, depth, &info->oem_url))
2720                 return False;
2721         if (!smb_io_relstr("hardware_id", buffer, depth, &info->hardware_id))
2722                 return False;
2723         if (!smb_io_relstr("provider", buffer, depth, &info->provider))
2724                 return False;
2725
2726         return True;
2727 }
2728
2729 /*******************************************************************
2730  Parse a JOB_INFO_1 structure.
2731 ********************************************************************/
2732
2733 bool smb_io_job_info_1(const char *desc, RPC_BUFFER *buffer, JOB_INFO_1 *info, int depth)
2734 {
2735         prs_struct *ps=&buffer->prs;
2736
2737         prs_debug(ps, depth, desc, "smb_io_job_info_1");
2738         depth++;
2739
2740         buffer->struct_start=prs_offset(ps);
2741
2742         if (!prs_uint32("jobid", ps, depth, &info->jobid))
2743                 return False;
2744         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2745                 return False;
2746         if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2747                 return False;
2748         if (!smb_io_relstr("username", buffer, depth, &info->username))
2749                 return False;
2750         if (!smb_io_relstr("document", buffer, depth, &info->document))
2751                 return False;
2752         if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2753                 return False;
2754         if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2755                 return False;
2756         if (!prs_uint32("status", ps, depth, &info->status))
2757                 return False;
2758         if (!prs_uint32("priority", ps, depth, &info->priority))
2759                 return False;
2760         if (!prs_uint32("position", ps, depth, &info->position))
2761                 return False;
2762         if (!prs_uint32("totalpages", ps, depth, &info->totalpages))
2763                 return False;
2764         if (!prs_uint32("pagesprinted", ps, depth, &info->pagesprinted))
2765                 return False;
2766         if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted))
2767                 return False;
2768
2769         return True;
2770 }
2771
2772 /*******************************************************************
2773  Parse a JOB_INFO_2 structure.
2774 ********************************************************************/
2775
2776 bool smb_io_job_info_2(const char *desc, RPC_BUFFER *buffer, JOB_INFO_2 *info, int depth)
2777 {
2778         uint32 pipo=0;
2779         prs_struct *ps=&buffer->prs;
2780
2781         prs_debug(ps, depth, desc, "smb_io_job_info_2");
2782         depth++;
2783
2784         buffer->struct_start=prs_offset(ps);
2785
2786         if (!prs_uint32("jobid",ps, depth, &info->jobid))
2787                 return False;
2788         if (!smb_io_relstr("printername", buffer, depth, &info->printername))
2789                 return False;
2790         if (!smb_io_relstr("machinename", buffer, depth, &info->machinename))
2791                 return False;
2792         if (!smb_io_relstr("username", buffer, depth, &info->username))
2793                 return False;
2794         if (!smb_io_relstr("document", buffer, depth, &info->document))
2795                 return False;
2796         if (!smb_io_relstr("notifyname", buffer, depth, &info->notifyname))
2797                 return False;
2798         if (!smb_io_relstr("datatype", buffer, depth, &info->datatype))
2799                 return False;
2800
2801         if (!smb_io_relstr("printprocessor", buffer, depth, &info->printprocessor))
2802                 return False;
2803         if (!smb_io_relstr("parameters", buffer, depth, &info->parameters))
2804                 return False;
2805         if (!smb_io_relstr("drivername", buffer, depth, &info->drivername))
2806                 return False;
2807         if (!smb_io_reldevmode("devmode", buffer, depth, &info->devmode))
2808                 return False;
2809         if (!smb_io_relstr("text_status", buffer, depth, &info->text_status))
2810                 return False;
2811
2812 /*      SEC_DESC sec_desc;*/
2813         if (!prs_uint32("Hack! sec desc", ps, depth, &pipo))
2814                 return False;
2815
2816         if (!prs_uint32("status",ps, depth, &info->status))
2817                 return False;
2818         if (!prs_uint32("priority",ps, depth, &info->priority))
2819                 return False;
2820         if (!prs_uint32("position",ps, depth, &info->position))
2821                 return False;
2822         if (!prs_uint32("starttime",ps, depth, &info->starttime))
2823                 return False;
2824         if (!prs_uint32("untiltime",ps, depth, &info->untiltime))
2825                 return False;
2826         if (!prs_uint32("totalpages",ps, depth, &info->totalpages))
2827                 return False;
2828         if (!prs_uint32("size",ps, depth, &info->size))
2829                 return False;
2830         if (!spoolss_io_system_time("submitted", ps, depth, &info->submitted) )
2831                 return False;
2832         if (!prs_uint32("timeelapsed",ps, depth, &info->timeelapsed))
2833                 return False;
2834         if (!prs_uint32("pagesprinted",ps, depth, &info->pagesprinted))
2835                 return False;
2836
2837         return True;
2838 }
2839
2840 /*******************************************************************
2841 ********************************************************************/
2842
2843 bool smb_io_form_1(const char *desc, RPC_BUFFER *buffer, FORM_1 *info, int depth)
2844 {
2845         prs_struct *ps=&buffer->prs;
2846
2847         prs_debug(ps, depth, desc, "smb_io_form_1");
2848         depth++;
2849
2850         buffer->struct_start=prs_offset(ps);
2851
2852         if (!prs_uint32("flag", ps, depth, &info->flag))
2853                 return False;
2854
2855         if (!smb_io_relstr("name", buffer, depth, &info->name))
2856                 return False;
2857
2858         if (!prs_uint32("width", ps, depth, &info->width))
2859                 return False;
2860         if (!prs_uint32("length", ps, depth, &info->length))
2861                 return False;
2862         if (!prs_uint32("left", ps, depth, &info->left))
2863                 return False;
2864         if (!prs_uint32("top", ps, depth, &info->top))
2865                 return False;
2866         if (!prs_uint32("right", ps, depth, &info->right))
2867                 return False;
2868         if (!prs_uint32("bottom", ps, depth, &info->bottom))
2869                 return False;
2870
2871         return True;
2872 }
2873
2874
2875
2876 /*******************************************************************
2877  Parse a DRIVER_DIRECTORY_1 structure.
2878 ********************************************************************/
2879
2880 bool smb_io_driverdir_1(const char *desc, RPC_BUFFER *buffer, DRIVER_DIRECTORY_1 *info, int depth)
2881 {
2882         prs_struct *ps=&buffer->prs;
2883
2884         prs_debug(ps, depth, desc, "smb_io_driverdir_1");
2885         depth++;
2886
2887         buffer->struct_start=prs_offset(ps);
2888
2889         if (!smb_io_unistr(desc, &info->name, ps, depth))
2890                 return False;
2891
2892         return True;
2893 }
2894
2895 /*******************************************************************
2896  Parse a PORT_INFO_1 structure.
2897 ********************************************************************/
2898
2899 bool smb_io_port_1(const char *desc, RPC_BUFFER *buffer, PORT_INFO_1 *info, int depth)
2900 {
2901         prs_struct *ps=&buffer->prs;
2902
2903         prs_debug(ps, depth, desc, "smb_io_port_1");
2904         depth++;
2905
2906         buffer->struct_start=prs_offset(ps);
2907
2908         if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2909                 return False;
2910
2911         return True;
2912 }
2913
2914 /*******************************************************************
2915  Parse a PORT_INFO_2 structure.
2916 ********************************************************************/
2917
2918 bool smb_io_port_2(const char *desc, RPC_BUFFER *buffer, PORT_INFO_2 *info, int depth)
2919 {
2920         prs_struct *ps=&buffer->prs;
2921
2922         prs_debug(ps, depth, desc, "smb_io_port_2");
2923         depth++;
2924
2925         buffer->struct_start=prs_offset(ps);
2926
2927         if(!smb_io_relstr("port_name", buffer, depth, &info->port_name))
2928                 return False;
2929         if(!smb_io_relstr("monitor_name", buffer, depth, &info->monitor_name))
2930                 return False;
2931         if(!smb_io_relstr("description", buffer, depth, &info->description))
2932                 return False;
2933         if(!prs_uint32("port_type", ps, depth, &info->port_type))
2934                 return False;
2935         if(!prs_uint32("reserved", ps, depth, &info->reserved))
2936                 return False;
2937
2938         return True;
2939 }
2940
2941 /*******************************************************************
2942 ********************************************************************/
2943
2944 bool smb_io_printprocessor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_1 *info, int depth)
2945 {
2946         prs_struct *ps=&buffer->prs;
2947
2948         prs_debug(ps, depth, desc, "smb_io_printprocessor_info_1");
2949         depth++;
2950
2951         buffer->struct_start=prs_offset(ps);
2952
2953         if (smb_io_relstr("name", buffer, depth, &info->name))
2954                 return False;
2955
2956         return True;
2957 }
2958
2959 /*******************************************************************
2960 ********************************************************************/
2961
2962 bool smb_io_printprocdatatype_info_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCDATATYPE_1 *info, int depth)
2963 {
2964         prs_struct *ps=&buffer->prs;
2965
2966         prs_debug(ps, depth, desc, "smb_io_printprocdatatype_info_1");
2967         depth++;
2968
2969         buffer->struct_start=prs_offset(ps);
2970
2971         if (smb_io_relstr("name", buffer, depth, &info->name))
2972                 return False;
2973
2974         return True;
2975 }
2976
2977 /*******************************************************************
2978 ********************************************************************/
2979
2980 bool smb_io_printmonitor_info_1(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_1 *info, int depth)
2981 {
2982         prs_struct *ps=&buffer->prs;
2983
2984         prs_debug(ps, depth, desc, "smb_io_printmonitor_info_1");
2985         depth++;
2986
2987         buffer->struct_start=prs_offset(ps);
2988
2989         if (!smb_io_relstr("name", buffer, depth, &info->name))
2990                 return False;
2991
2992         return True;
2993 }
2994
2995 /*******************************************************************
2996 ********************************************************************/
2997
2998 bool smb_io_printmonitor_info_2(const char *desc, RPC_BUFFER *buffer, PRINTMONITOR_2 *info, int depth)
2999 {
3000         prs_struct *ps=&buffer->prs;
3001
3002         prs_debug(ps, depth, desc, "smb_io_printmonitor_info_2");
3003         depth++;
3004
3005         buffer->struct_start=prs_offset(ps);
3006
3007         if (!smb_io_relstr("name", buffer, depth, &info->name))
3008                 return False;
3009         if (!smb_io_relstr("environment", buffer, depth, &info->environment))
3010                 return False;
3011         if (!smb_io_relstr("dll_name", buffer, depth, &info->dll_name))
3012                 return False;
3013
3014         return True;
3015 }
3016
3017 /*******************************************************************
3018 return the size required by a struct in the stream
3019 ********************************************************************/
3020
3021 uint32 spoolss_size_printer_info_0(PRINTER_INFO_0 *info)
3022 {
3023         int size=0;
3024
3025         size+=size_of_relative_string( &info->printername );
3026         size+=size_of_relative_string( &info->servername );
3027
3028         size+=size_of_uint32( &info->cjobs);
3029         size+=size_of_uint32( &info->total_jobs);
3030         size+=size_of_uint32( &info->total_bytes);
3031
3032         size+=size_of_uint16( &info->year);
3033         size+=size_of_uint16( &info->month);
3034         size+=size_of_uint16( &info->dayofweek);
3035         size+=size_of_uint16( &info->day);
3036         size+=size_of_uint16( &info->hour);
3037         size+=size_of_uint16( &info->minute);
3038         size+=size_of_uint16( &info->second);
3039         size+=size_of_uint16( &info->milliseconds);
3040
3041         size+=size_of_uint32( &info->global_counter);
3042         size+=size_of_uint32( &info->total_pages);
3043
3044         size+=size_of_uint16( &info->major_version);
3045         size+=size_of_uint16( &info->build_version);
3046
3047         size+=size_of_uint32( &info->unknown7);
3048         size+=size_of_uint32( &info->unknown8);
3049         size+=size_of_uint32( &info->unknown9);
3050         size+=size_of_uint32( &info->session_counter);
3051         size+=size_of_uint32( &info->unknown11);
3052         size+=size_of_uint32( &info->printer_errors);
3053         size+=size_of_uint32( &info->unknown13);
3054         size+=size_of_uint32( &info->unknown14);
3055         size+=size_of_uint32( &info->unknown15);
3056         size+=size_of_uint32( &info->unknown16);
3057         size+=size_of_uint32( &info->change_id);
3058         size+=size_of_uint32( &info->unknown18);
3059         size+=size_of_uint32( &info->status);
3060         size+=size_of_uint32( &info->unknown20);
3061         size+=size_of_uint32( &info->c_setprinter);
3062
3063         size+=size_of_uint16( &info->unknown22);
3064         size+=size_of_uint16( &info->unknown23);
3065         size+=size_of_uint16( &info->unknown24);
3066         size+=size_of_uint16( &info->unknown25);
3067         size+=size_of_uint16( &info->unknown26);
3068         size+=size_of_uint16( &info->unknown27);
3069         size+=size_of_uint16( &info->unknown28);
3070         size+=size_of_uint16( &info->unknown29);
3071
3072         return size;
3073 }
3074
3075 /*******************************************************************
3076 return the size required by a struct in the stream
3077 ********************************************************************/
3078
3079 uint32 spoolss_size_printer_info_1(PRINTER_INFO_1 *info)
3080 {
3081         int size=0;
3082
3083         size+=size_of_uint32( &info->flags );
3084         size+=size_of_relative_string( &info->description );
3085         size+=size_of_relative_string( &info->name );
3086         size+=size_of_relative_string( &info->comment );
3087
3088         return size;
3089 }
3090
3091 /*******************************************************************
3092 return the size required by a struct in the stream
3093 ********************************************************************/
3094
3095 uint32 spoolss_size_printer_info_2(PRINTER_INFO_2 *info)
3096 {
3097         uint32 size=0;
3098
3099         size += 4;
3100
3101         size += sec_desc_size( info->secdesc );
3102
3103         size+=size_of_device_mode( info->devmode );
3104
3105         size+=size_of_relative_string( &info->servername );
3106         size+=size_of_relative_string( &info->printername );
3107         size+=size_of_relative_string( &info->sharename );
3108         size+=size_of_relative_string( &info->portname );
3109         size+=size_of_relative_string( &info->drivername );
3110         size+=size_of_relative_string( &info->comment );
3111         size+=size_of_relative_string( &info->location );
3112
3113         size+=size_of_relative_string( &info->sepfile );
3114         size+=size_of_relative_string( &info->printprocessor );
3115         size+=size_of_relative_string( &info->datatype );
3116         size+=size_of_relative_string( &info->parameters );
3117
3118         size+=size_of_uint32( &info->attributes );
3119         size+=size_of_uint32( &info->priority );
3120         size+=size_of_uint32( &info->defaultpriority );
3121         size+=size_of_uint32( &info->starttime );
3122         size+=size_of_uint32( &info->untiltime );
3123         size+=size_of_uint32( &info->status );
3124         size+=size_of_uint32( &info->cjobs );
3125         size+=size_of_uint32( &info->averageppm );
3126
3127         /*
3128          * add any adjustments for alignment.  This is
3129          * not optimal since we could be calling this
3130          * function from a loop (e.g. enumprinters), but
3131          * it is easier to maintain the calculation here and
3132          * not place the burden on the caller to remember.   --jerry
3133          */
3134         if ((size % 4) != 0)
3135                 size += 4 - (size % 4);
3136
3137         return size;
3138 }
3139
3140 /*******************************************************************
3141 return the size required by a struct in the stream
3142 ********************************************************************/
3143
3144 uint32 spoolss_size_printer_info_4(PRINTER_INFO_4 *info)
3145 {
3146         uint32 size=0;
3147
3148         size+=size_of_relative_string( &info->printername );
3149         size+=size_of_relative_string( &info->servername );
3150
3151         size+=size_of_uint32( &info->attributes );
3152         return size;
3153 }
3154
3155 /*******************************************************************
3156 return the size required by a struct in the stream
3157 ********************************************************************/
3158
3159 uint32 spoolss_size_printer_info_5(PRINTER_INFO_5 *info)
3160 {
3161         uint32 size=0;
3162
3163         size+=size_of_relative_string( &info->printername );
3164         size+=size_of_relative_string( &info->portname );
3165
3166         size+=size_of_uint32( &info->attributes );
3167         size+=size_of_uint32( &info->device_not_selected_timeout );
3168         size+=size_of_uint32( &info->transmission_retry_timeout );
3169         return size;
3170 }
3171
3172 /*******************************************************************
3173 return the size required by a struct in the stream
3174 ********************************************************************/
3175
3176 uint32 spoolss_size_printer_info_6(PRINTER_INFO_6 *info)
3177 {
3178         return sizeof(uint32);
3179 }
3180
3181 /*******************************************************************
3182 return the size required by a struct in the stream
3183 ********************************************************************/
3184
3185 uint32 spoolss_size_printer_info_3(PRINTER_INFO_3 *info)
3186 {
3187         /* The 8 is for the self relative pointer - 8 byte aligned.. */
3188         return 8 + (uint32)sec_desc_size( info->secdesc );
3189 }
3190
3191 /*******************************************************************
3192 return the size required by a struct in the stream
3193 ********************************************************************/
3194
3195 uint32 spoolss_size_printer_info_7(PRINTER_INFO_7 *info)
3196 {
3197         uint32 size=0;
3198
3199         size+=size_of_relative_string( &info->guid );
3200         size+=size_of_uint32( &info->action );
3201         return size;
3202 }
3203
3204 /*******************************************************************
3205 return the size required by a struct in the stream
3206 ********************************************************************/
3207
3208 uint32 spoolss_size_printer_driver_info_1(DRIVER_INFO_1 *info)
3209 {
3210         int size=0;
3211         size+=size_of_relative_string( &info->name );
3212
3213         return size;
3214 }
3215
3216 /*******************************************************************
3217 return the size required by a struct in the stream
3218 ********************************************************************/
3219
3220 uint32 spoolss_size_printer_driver_info_2(DRIVER_INFO_2 *info)
3221 {
3222         int size=0;
3223         size+=size_of_uint32( &info->version );
3224         size+=size_of_relative_string( &info->name );
3225         size+=size_of_relative_string( &info->architecture );
3226         size+=size_of_relative_string( &info->driverpath );
3227         size+=size_of_relative_string( &info->datafile );
3228         size+=size_of_relative_string( &info->configfile );
3229
3230         return size;
3231 }
3232
3233 /*******************************************************************
3234 return the size required by a string array.
3235 ********************************************************************/
3236
3237 uint32 spoolss_size_string_array(uint16 *string)
3238 {
3239         uint32 i = 0;
3240
3241         if (string) {
3242                 for (i=0; (string[i]!=0x0000) || (string[i+1]!=0x0000); i++);
3243         }
3244         i=i+2; /* to count all chars including the leading zero */
3245         i=2*i; /* because we need the value in bytes */
3246         i=i+4; /* the offset pointer size */
3247
3248         return i;
3249 }
3250
3251 /*******************************************************************
3252 return the size required by a struct in the stream
3253 ********************************************************************/
3254
3255 uint32 spoolss_size_printer_driver_info_3(DRIVER_INFO_3 *info)
3256 {
3257         int size=0;
3258
3259         size+=size_of_uint32( &info->version );
3260         size+=size_of_relative_string( &info->name );
3261         size+=size_of_relative_string( &info->architecture );
3262         size+=size_of_relative_string( &info->driverpath );
3263         size+=size_of_relative_string( &info->datafile );
3264         size+=size_of_relative_string( &info->configfile );
3265         size+=size_of_relative_string( &info->helpfile );
3266         size+=size_of_relative_string( &info->monitorname );
3267         size+=size_of_relative_string( &info->defaultdatatype );
3268
3269         size+=spoolss_size_string_array(info->dependentfiles);
3270
3271         return size;
3272 }
3273
3274 /*******************************************************************
3275 return the size required by a struct in the stream
3276 ********************************************************************/
3277
3278 uint32 spoolss_size_printer_driver_info_6(DRIVER_INFO_6 *info)
3279 {
3280         uint32 size=0;
3281
3282         size+=size_of_uint32( &info->version );
3283         size+=size_of_relative_string( &info->name );
3284         size+=size_of_relative_string( &info->architecture );
3285         size+=size_of_relative_string( &info->driverpath );
3286         size+=size_of_relative_string( &info->datafile );
3287         size+=size_of_relative_string( &info->configfile );
3288         size+=size_of_relative_string( &info->helpfile );
3289
3290         size+=spoolss_size_string_array(info->dependentfiles);
3291
3292         size+=size_of_relative_string( &info->monitorname );
3293         size+=size_of_relative_string( &info->defaultdatatype );
3294
3295         size+=spoolss_size_string_array(info->previousdrivernames);
3296
3297         size+=size_of_nttime(&info->driver_date);
3298         size+=size_of_uint32( &info->padding );
3299         size+=size_of_uint32( &info->driver_version_low );
3300         size+=size_of_uint32( &info->driver_version_high );
3301         size+=size_of_relative_string( &info->mfgname );
3302         size+=size_of_relative_string( &info->oem_url );
3303         size+=size_of_relative_string( &info->hardware_id );
3304         size+=size_of_relative_string( &info->provider );
3305
3306         return size;
3307 }
3308
3309 /*******************************************************************
3310 return the size required by a struct in the stream
3311 ********************************************************************/
3312
3313 uint32 spoolss_size_job_info_1(JOB_INFO_1 *info)
3314 {
3315         int size=0;
3316         size+=size_of_uint32( &info->jobid );
3317         size+=size_of_relative_string( &info->printername );
3318         size+=size_of_relative_string( &info->machinename );
3319         size+=size_of_relative_string( &info->username );
3320         size+=size_of_relative_string( &info->document );
3321         size+=size_of_relative_string( &info->datatype );
3322         size+=size_of_relative_string( &info->text_status );
3323         size+=size_of_uint32( &info->status );
3324         size+=size_of_uint32( &info->priority );
3325         size+=size_of_uint32( &info->position );
3326         size+=size_of_uint32( &info->totalpages );
3327         size+=size_of_uint32( &info->pagesprinted );
3328         size+=size_of_systemtime( &info->submitted );
3329
3330         return size;
3331 }
3332
3333 /*******************************************************************
3334 return the size required by a struct in the stream
3335 ********************************************************************/
3336
3337 uint32 spoolss_size_job_info_2(JOB_INFO_2 *info)
3338 {
3339         int size=0;
3340
3341         size+=4; /* size of sec desc ptr */
3342
3343         size+=size_of_uint32( &info->jobid );
3344         size+=size_of_relative_string( &info->printername );
3345         size+=size_of_relative_string( &info->machinename );
3346         size+=size_of_relative_string( &info->username );
3347         size+=size_of_relative_string( &info->document );
3348         size+=size_of_relative_string( &info->notifyname );
3349         size+=size_of_relative_string( &info->datatype );
3350         size+=size_of_relative_string( &info->printprocessor );
3351         size+=size_of_relative_string( &info->parameters );
3352         size+=size_of_relative_string( &info->drivername );
3353         size+=size_of_device_mode( info->devmode );
3354         size+=size_of_relative_string( &info->text_status );
3355 /*      SEC_DESC sec_desc;*/
3356         size+=size_of_uint32( &info->status );
3357         size+=size_of_uint32( &info->priority );
3358         size+=size_of_uint32( &info->position );
3359         size+=size_of_uint32( &info->starttime );
3360         size+=size_of_uint32( &info->untiltime );
3361         size+=size_of_uint32( &info->totalpages );
3362         size+=size_of_uint32( &info->size );
3363         size+=size_of_systemtime( &info->submitted );
3364         size+=size_of_uint32( &info->timeelapsed );
3365         size+=size_of_uint32( &info->pagesprinted );
3366
3367         return size;
3368 }
3369
3370 /*******************************************************************
3371 return the size required by a struct in the stream
3372 ********************************************************************/
3373
3374 uint32 spoolss_size_form_1(FORM_1 *info)
3375 {
3376         int size=0;
3377
3378         size+=size_of_uint32( &info->flag );
3379         size+=size_of_relative_string( &info->name );
3380         size+=size_of_uint32( &info->width );
3381         size+=size_of_uint32( &info->length );
3382         size+=size_of_uint32( &info->left );
3383         size+=size_of_uint32( &info->top );
3384         size+=size_of_uint32( &info->right );
3385         size+=size_of_uint32( &info->bottom );
3386
3387         return size;
3388 }
3389
3390 /*******************************************************************
3391 return the size required by a struct in the stream
3392 ********************************************************************/
3393
3394 uint32 spoolss_size_port_info_1(PORT_INFO_1 *info)
3395 {
3396         int size=0;
3397
3398         size+=size_of_relative_string( &info->port_name );
3399
3400         return size;
3401 }
3402
3403 /*******************************************************************
3404 return the size required by a struct in the stream
3405 ********************************************************************/
3406
3407 uint32 spoolss_size_driverdir_info_1(DRIVER_DIRECTORY_1 *info)
3408 {
3409         int size=0;
3410
3411         size=str_len_uni(&info->name);  /* the string length       */
3412         size=size+1;                    /* add the leading zero    */
3413         size=size*2;                    /* convert in char         */
3414
3415         return size;
3416 }
3417
3418 /*******************************************************************
3419 return the size required by a struct in the stream
3420 ********************************************************************/
3421
3422 uint32 spoolss_size_printprocessordirectory_info_1(PRINTPROCESSOR_DIRECTORY_1 *info)
3423 {
3424         int size=0;
3425
3426         size=str_len_uni(&info->name);  /* the string length       */
3427         size=size+1;                    /* add the leading zero    */
3428         size=size*2;                    /* convert in char         */
3429
3430         return size;
3431 }
3432
3433 /*******************************************************************
3434 return the size required by a struct in the stream
3435 ********************************************************************/
3436
3437 uint32 spoolss_size_port_info_2(PORT_INFO_2 *info)
3438 {
3439         int size=0;
3440
3441         size+=size_of_relative_string( &info->port_name );
3442         size+=size_of_relative_string( &info->monitor_name );
3443         size+=size_of_relative_string( &info->description );
3444
3445         size+=size_of_uint32( &info->port_type );
3446         size+=size_of_uint32( &info->reserved );
3447
3448         return size;
3449 }
3450
3451 /*******************************************************************
3452 return the size required by a struct in the stream
3453 ********************************************************************/
3454
3455 uint32 spoolss_size_printprocessor_info_1(PRINTPROCESSOR_1 *info)
3456 {
3457         int size=0;
3458         size+=size_of_relative_string( &info->name );
3459
3460         return size;
3461 }
3462
3463 /*******************************************************************
3464 return the size required by a struct in the stream
3465 ********************************************************************/
3466
3467 uint32 spoolss_size_printprocdatatype_info_1(PRINTPROCDATATYPE_1 *info)
3468 {
3469         int size=0;
3470         size+=size_of_relative_string( &info->name );
3471
3472         return size;
3473 }
3474
3475 /*******************************************************************
3476 return the size required by a struct in the stream
3477 ********************************************************************/
3478 uint32 spoolss_size_printer_enum_values(PRINTER_ENUM_VALUES *p)
3479 {
3480         uint32  size = 0;
3481
3482         if (!p)
3483                 return 0;
3484
3485         /* uint32(offset) + uint32(length) + length) */
3486         size += (size_of_uint32(&p->value_len)*2) + p->value_len;
3487         size += (size_of_uint32(&p->data_len)*2) + p->data_len + (p->data_len%2) ;
3488
3489         size += size_of_uint32(&p->type);
3490
3491         return size;
3492 }
3493
3494 /*******************************************************************
3495 return the size required by a struct in the stream
3496 ********************************************************************/
3497
3498 uint32 spoolss_size_printmonitor_info_1(PRINTMONITOR_1 *info)
3499 {
3500         int size=0;
3501         size+=size_of_relative_string( &info->name );
3502
3503         return size;
3504 }
3505
3506 /*******************************************************************
3507 return the size required by a struct in the stream
3508 ********************************************************************/
3509
3510 uint32 spoolss_size_printmonitor_info_2(PRINTMONITOR_2 *info)
3511 {
3512         int size=0;
3513         size+=size_of_relative_string( &info->name);
3514         size+=size_of_relative_string( &info->environment);
3515         size+=size_of_relative_string( &info->dll_name);
3516
3517         return size;
3518 }
3519
3520 /*******************************************************************
3521  * init a structure.
3522  ********************************************************************/
3523
3524 bool make_spoolss_q_getprinterdriver2(SPOOL_Q_GETPRINTERDRIVER2 *q_u,
3525                                const POLICY_HND *hnd,
3526                                const fstring architecture,
3527                                uint32 level, uint32 clientmajor, uint32 clientminor,
3528                                RPC_BUFFER *buffer, uint32 offered)
3529 {
3530         if (q_u == NULL)
3531                 return False;
3532
3533         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3534
3535         init_buf_unistr2(&q_u->architecture, &q_u->architecture_ptr, architecture);
3536
3537         q_u->level=level;
3538         q_u->clientmajorversion=clientmajor;
3539         q_u->clientminorversion=clientminor;
3540
3541         q_u->buffer=buffer;
3542         q_u->offered=offered;
3543
3544         return True;
3545 }
3546
3547 /*******************************************************************
3548  * read a structure.
3549  * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3550  ********************************************************************/
3551
3552 bool spoolss_io_q_getprinterdriver2(const char *desc, SPOOL_Q_GETPRINTERDRIVER2 *q_u, prs_struct *ps, int depth)
3553 {
3554         prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriver2");
3555         depth++;
3556
3557         if(!prs_align(ps))
3558                 return False;
3559
3560         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3561                 return False;
3562         if(!prs_uint32("architecture_ptr", ps, depth, &q_u->architecture_ptr))
3563                 return False;
3564         if(!smb_io_unistr2("architecture", &q_u->architecture, q_u->architecture_ptr, ps, depth))
3565                 return False;
3566
3567         if(!prs_align(ps))
3568                 return False;
3569         if(!prs_uint32("level", ps, depth, &q_u->level))
3570                 return False;
3571
3572         if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3573                 return False;
3574
3575         if(!prs_align(ps))
3576                 return False;
3577
3578         if(!prs_uint32("offered", ps, depth, &q_u->offered))
3579                 return False;
3580
3581         if(!prs_uint32("clientmajorversion", ps, depth, &q_u->clientmajorversion))
3582                 return False;
3583         if(!prs_uint32("clientminorversion", ps, depth, &q_u->clientminorversion))
3584                 return False;
3585
3586         return True;
3587 }
3588
3589 /*******************************************************************
3590  * read a structure.
3591  * called from spoolss_getprinterdriver2 (srv_spoolss.c)
3592  ********************************************************************/
3593
3594 bool spoolss_io_r_getprinterdriver2(const char *desc, SPOOL_R_GETPRINTERDRIVER2 *r_u, prs_struct *ps, int depth)
3595 {
3596         prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriver2");
3597         depth++;
3598
3599         if (!prs_align(ps))
3600                 return False;
3601
3602         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3603                 return False;
3604
3605         if (!prs_align(ps))
3606                 return False;
3607         if (!prs_uint32("needed", ps, depth, &r_u->needed))
3608                 return False;
3609         if (!prs_uint32("servermajorversion", ps, depth, &r_u->servermajorversion))
3610                 return False;
3611         if (!prs_uint32("serverminorversion", ps, depth, &r_u->serverminorversion))
3612                 return False;
3613         if (!prs_werror("status", ps, depth, &r_u->status))
3614                 return False;
3615
3616         return True;
3617 }
3618
3619 /*******************************************************************
3620  * init a structure.
3621  ********************************************************************/
3622
3623 bool make_spoolss_q_enumprinters(
3624         SPOOL_Q_ENUMPRINTERS *q_u,
3625         uint32 flags,
3626         char *servername,
3627         uint32 level,
3628         RPC_BUFFER *buffer,
3629         uint32 offered
3630 )
3631 {
3632         q_u->flags=flags;
3633
3634         q_u->servername_ptr = (servername != NULL) ? 1 : 0;
3635         init_buf_unistr2(&q_u->servername, &q_u->servername_ptr, servername);
3636
3637         q_u->level=level;
3638         q_u->buffer=buffer;
3639         q_u->offered=offered;
3640
3641         return True;
3642 }
3643
3644 /*******************************************************************
3645  * init a structure.
3646  ********************************************************************/
3647
3648 bool make_spoolss_q_enumports(SPOOL_Q_ENUMPORTS *q_u,
3649                                 fstring servername, uint32 level,
3650                                 RPC_BUFFER *buffer, uint32 offered)
3651 {
3652         q_u->name_ptr = (servername != NULL) ? 1 : 0;
3653         init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
3654
3655         q_u->level=level;
3656         q_u->buffer=buffer;
3657         q_u->offered=offered;
3658
3659         return True;
3660 }
3661
3662 /*******************************************************************
3663  * read a structure.
3664  * called from spoolss_enumprinters (srv_spoolss.c)
3665  ********************************************************************/
3666
3667 bool spoolss_io_q_enumprinters(const char *desc, SPOOL_Q_ENUMPRINTERS *q_u, prs_struct *ps, int depth)
3668 {
3669         prs_debug(ps, depth, desc, "spoolss_io_q_enumprinters");
3670         depth++;
3671
3672         if (!prs_align(ps))
3673                 return False;
3674
3675         if (!prs_uint32("flags", ps, depth, &q_u->flags))
3676                 return False;
3677         if (!prs_uint32("servername_ptr", ps, depth, &q_u->servername_ptr))
3678                 return False;
3679
3680         if (!smb_io_unistr2("", &q_u->servername, q_u->servername_ptr, ps, depth))
3681                 return False;
3682
3683         if (!prs_align(ps))
3684                 return False;
3685         if (!prs_uint32("level", ps, depth, &q_u->level))
3686                 return False;
3687
3688         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3689                 return False;
3690
3691         if (!prs_align(ps))
3692                 return False;
3693         if (!prs_uint32("offered", ps, depth, &q_u->offered))
3694                 return False;
3695
3696         return True;
3697 }
3698
3699 /*******************************************************************
3700  Parse a SPOOL_R_ENUMPRINTERS structure.
3701  ********************************************************************/
3702
3703 bool spoolss_io_r_enumprinters(const char *desc, SPOOL_R_ENUMPRINTERS *r_u, prs_struct *ps, int depth)
3704 {
3705         prs_debug(ps, depth, desc, "spoolss_io_r_enumprinters");
3706         depth++;
3707
3708         if (!prs_align(ps))
3709                 return False;
3710
3711         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3712                 return False;
3713
3714         if (!prs_align(ps))
3715                 return False;
3716
3717         if (!prs_uint32("needed", ps, depth, &r_u->needed))
3718                 return False;
3719
3720         if (!prs_uint32("returned", ps, depth, &r_u->returned))
3721                 return False;
3722
3723         if (!prs_werror("status", ps, depth, &r_u->status))
3724                 return False;
3725
3726         return True;
3727 }
3728
3729 /*******************************************************************
3730  * write a structure.
3731  * called from spoolss_r_enum_printers (srv_spoolss.c)
3732  *
3733  ********************************************************************/
3734
3735 bool spoolss_io_r_getprinter(const char *desc, SPOOL_R_GETPRINTER *r_u, prs_struct *ps, int depth)
3736 {
3737         prs_debug(ps, depth, desc, "spoolss_io_r_getprinter");
3738         depth++;
3739
3740         if (!prs_align(ps))
3741                 return False;
3742
3743         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
3744                 return False;
3745
3746         if (!prs_align(ps))
3747                 return False;
3748
3749         if (!prs_uint32("needed", ps, depth, &r_u->needed))
3750                 return False;
3751
3752         if (!prs_werror("status", ps, depth, &r_u->status))
3753                 return False;
3754
3755         return True;
3756 }
3757
3758 /*******************************************************************
3759  * read a structure.
3760  * called from spoolss_getprinter (srv_spoolss.c)
3761  ********************************************************************/
3762
3763 bool spoolss_io_q_getprinter(const char *desc, SPOOL_Q_GETPRINTER *q_u, prs_struct *ps, int depth)
3764 {
3765         prs_debug(ps, depth, desc, "spoolss_io_q_getprinter");
3766         depth++;
3767
3768         if (!prs_align(ps))
3769                 return False;
3770
3771         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
3772                 return False;
3773         if (!prs_uint32("level", ps, depth, &q_u->level))
3774                 return False;
3775
3776         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
3777                 return False;
3778
3779         if (!prs_align(ps))
3780                 return False;
3781         if (!prs_uint32("offered", ps, depth, &q_u->offered))
3782                 return False;
3783
3784         return True;
3785 }
3786
3787 /*******************************************************************
3788  * init a structure.
3789  ********************************************************************/
3790
3791 bool make_spoolss_q_getprinter(
3792         TALLOC_CTX *mem_ctx,
3793         SPOOL_Q_GETPRINTER *q_u,
3794         const POLICY_HND *hnd,
3795         uint32 level,
3796         RPC_BUFFER *buffer,
3797         uint32 offered
3798 )
3799 {
3800         if (q_u == NULL)
3801         {
3802                 return False;
3803         }
3804         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3805
3806         q_u->level=level;
3807         q_u->buffer=buffer;
3808         q_u->offered=offered;
3809
3810         return True;
3811 }
3812
3813 /*******************************************************************
3814  * init a structure.
3815  ********************************************************************/
3816 bool make_spoolss_q_setprinter(TALLOC_CTX *mem_ctx, SPOOL_Q_SETPRINTER *q_u,
3817                                 const POLICY_HND *hnd, uint32 level, PRINTER_INFO_CTR *info,
3818                                 uint32 command)
3819 {
3820         SEC_DESC *secdesc;
3821         DEVICEMODE *devmode;
3822
3823         if (!q_u || !info)
3824                 return False;
3825
3826         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
3827
3828         q_u->level = level;
3829         q_u->info.level = level;
3830         q_u->info.info_ptr = 1; /* Info is != NULL, see above */
3831         switch (level) {
3832
3833           /* There's no such thing as a setprinter level 1 */
3834
3835         case 2:
3836                 secdesc = info->printers_2->secdesc;
3837                 devmode = info->printers_2->devmode;
3838
3839                 make_spoolss_printer_info_2 (mem_ctx, &q_u->info.info_2, info->printers_2);
3840 #if 1   /* JERRY TEST */
3841                 q_u->secdesc_ctr = SMB_MALLOC_P(SEC_DESC_BUF);
3842                 if (!q_u->secdesc_ctr)
3843                         return False;
3844                 q_u->secdesc_ctr->sd = secdesc;
3845                 q_u->secdesc_ctr->sd_size = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3846
3847                 q_u->devmode_ctr.devmode_ptr = (devmode != NULL) ? 1 : 0;
3848                 q_u->devmode_ctr.size = (devmode != NULL) ? sizeof(DEVICEMODE) + (3*sizeof(uint32)) : 0;
3849                 q_u->devmode_ctr.devmode = devmode;
3850 #else
3851                 q_u->secdesc_ctr = NULL;
3852
3853                 q_u->devmode_ctr.devmode_ptr = 0;
3854                 q_u->devmode_ctr.size = 0;
3855                 q_u->devmode_ctr.devmode = NULL;
3856 #endif
3857                 break;
3858         case 3:
3859                 secdesc = info->printers_3->secdesc;
3860
3861                 make_spoolss_printer_info_3 (mem_ctx, &q_u->info.info_3, info->printers_3);
3862
3863                 q_u->secdesc_ctr = SMB_MALLOC_P(SEC_DESC_BUF);
3864                 if (!q_u->secdesc_ctr)
3865                         return False;
3866                 q_u->secdesc_ctr->sd_size = (secdesc) ? sizeof(SEC_DESC) + (2*sizeof(uint32)) : 0;
3867                 q_u->secdesc_ctr->sd = secdesc;
3868
3869                 break;
3870         case 7:
3871                 make_spoolss_printer_info_7 (mem_ctx, &q_u->info.info_7, info->printers_7);
3872                 break;
3873
3874         default:
3875                 DEBUG(0,("make_spoolss_q_setprinter: Unknown info level [%d]\n", level));
3876                         break;
3877         }
3878
3879
3880         q_u->command = command;
3881
3882         return True;
3883 }
3884
3885
3886 /*******************************************************************
3887 ********************************************************************/
3888
3889 bool spoolss_io_r_setprinter(const char *desc, SPOOL_R_SETPRINTER *r_u, prs_struct *ps, int depth)
3890 {
3891         prs_debug(ps, depth, desc, "spoolss_io_r_setprinter");
3892         depth++;
3893
3894         if(!prs_align(ps))
3895                 return False;
3896
3897         if(!prs_werror("status", ps, depth, &r_u->status))
3898                 return False;
3899
3900         return True;
3901 }
3902
3903 /*******************************************************************
3904  Marshall/unmarshall a SPOOL_Q_SETPRINTER struct.
3905 ********************************************************************/
3906
3907 bool spoolss_io_q_setprinter(const char *desc, SPOOL_Q_SETPRINTER *q_u, prs_struct *ps, int depth)
3908 {
3909         uint32 ptr_sec_desc = 0;
3910
3911         prs_debug(ps, depth, desc, "spoolss_io_q_setprinter");
3912         depth++;
3913
3914         if(!prs_align(ps))
3915                 return False;
3916
3917         if(!smb_io_pol_hnd("printer handle", &q_u->handle ,ps, depth))
3918                 return False;
3919         if(!prs_uint32("level", ps, depth, &q_u->level))
3920                 return False;
3921
3922         /* check for supported levels and structures we know about */
3923
3924         switch ( q_u->level ) {
3925                 case 0:
3926                 case 2:
3927                 case 3:
3928                 case 7:
3929                         /* supported levels */
3930                         break;
3931                 default:
3932                         DEBUG(0,("spoolss_io_q_setprinter: unsupported printer info level [%d]\n",
3933                                 q_u->level));
3934                         return True;
3935         }
3936
3937
3938         if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
3939                 return False;
3940
3941         if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
3942                 return False;
3943
3944         if(!prs_align(ps))
3945                 return False;
3946
3947         switch (q_u->level)
3948         {
3949                 case 2:
3950                 {
3951                         ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
3952                         break;
3953                 }
3954                 case 3:
3955                 {
3956                         /* FIXME ! Our parsing here is wrong I think,
3957                          * but for a level3 it makes no sense for
3958                          * ptr_sec_desc to be NULL. JRA. Based on
3959                          * a Vista sniff from Martin Zielinski <mz@seh.de>.
3960                          */
3961                         if (UNMARSHALLING(ps)) {
3962                                 ptr_sec_desc = 1;
3963                         } else {
3964                                 ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
3965                         }
3966                         break;
3967                 }
3968         }
3969         if (ptr_sec_desc)
3970         {
3971                 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
3972                         return False;
3973         } else {
3974                 uint32 dummy = 0;
3975
3976                 /* Parse a NULL security descriptor.  This should really
3977                    happen inside the sec_io_desc_buf() function. */
3978
3979                 prs_debug(ps, depth, "", "sec_io_desc_buf");
3980                 if (!prs_uint32("size", ps, depth + 1, &dummy))
3981                         return False;
3982                 if (!prs_uint32("ptr", ps, depth + 1, &dummy))
3983                         return False;
3984         }
3985
3986         if(!prs_uint32("command", ps, depth, &q_u->command))
3987                 return False;
3988
3989         return True;
3990 }
3991
3992 /*******************************************************************
3993 ********************************************************************/
3994
3995 bool spoolss_io_r_fcpn(const char *desc, SPOOL_R_FCPN *r_u, prs_struct *ps, int depth)
3996 {
3997         prs_debug(ps, depth, desc, "spoolss_io_r_fcpn");
3998         depth++;
3999
4000         if(!prs_align(ps))
4001                 return False;
4002
4003         if(!prs_werror("status", ps, depth, &r_u->status))
4004                 return False;
4005
4006         return True;
4007 }
4008
4009 /*******************************************************************
4010 ********************************************************************/
4011
4012 bool spoolss_io_q_fcpn(const char *desc, SPOOL_Q_FCPN *q_u, prs_struct *ps, int depth)
4013 {
4014
4015         prs_debug(ps, depth, desc, "spoolss_io_q_fcpn");
4016         depth++;
4017
4018         if(!prs_align(ps))
4019                 return False;
4020
4021         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4022                 return False;
4023
4024         return True;
4025 }
4026
4027
4028 /*******************************************************************
4029 ********************************************************************/
4030
4031 bool spoolss_io_r_addjob(const char *desc, SPOOL_R_ADDJOB *r_u, prs_struct *ps, int depth)
4032 {
4033         prs_debug(ps, depth, desc, "");
4034         depth++;
4035
4036         if(!prs_align(ps))
4037                 return False;
4038
4039         if(!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4040                 return False;
4041
4042         if(!prs_align(ps))
4043                 return False;
4044
4045         if(!prs_uint32("needed", ps, depth, &r_u->needed))
4046                 return False;
4047
4048         if(!prs_werror("status", ps, depth, &r_u->status))
4049                 return False;
4050
4051         return True;
4052 }
4053
4054 /*******************************************************************
4055 ********************************************************************/
4056
4057 bool spoolss_io_q_addjob(const char *desc, SPOOL_Q_ADDJOB *q_u, prs_struct *ps, int depth)
4058 {
4059         prs_debug(ps, depth, desc, "");
4060         depth++;
4061
4062         if(!prs_align(ps))
4063                 return False;
4064
4065         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
4066                 return False;
4067         if(!prs_uint32("level", ps, depth, &q_u->level))
4068                 return False;
4069
4070         if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4071                 return False;
4072
4073         if(!prs_align(ps))
4074                 return False;
4075
4076         if(!prs_uint32("offered", ps, depth, &q_u->offered))
4077                 return False;
4078
4079         return True;
4080 }
4081
4082 /*******************************************************************
4083 ********************************************************************/
4084
4085 bool spoolss_io_r_enumjobs(const char *desc, SPOOL_R_ENUMJOBS *r_u, prs_struct *ps, int depth)
4086 {
4087         prs_debug(ps, depth, desc, "spoolss_io_r_enumjobs");
4088         depth++;
4089
4090         if (!prs_align(ps))
4091                 return False;
4092
4093         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4094                 return False;
4095
4096         if (!prs_align(ps))
4097                 return False;
4098
4099         if (!prs_uint32("needed", ps, depth, &r_u->needed))
4100                 return False;
4101
4102         if (!prs_uint32("returned", ps, depth, &r_u->returned))
4103                 return False;
4104
4105         if (!prs_werror("status", ps, depth, &r_u->status))
4106                 return False;
4107
4108         return True;
4109 }
4110
4111 /*******************************************************************
4112 ********************************************************************/
4113
4114 bool make_spoolss_q_enumjobs(SPOOL_Q_ENUMJOBS *q_u, const POLICY_HND *hnd,
4115                                 uint32 firstjob,
4116                                 uint32 numofjobs,
4117                                 uint32 level,
4118                                 RPC_BUFFER *buffer,
4119                                 uint32 offered)
4120 {
4121         if (q_u == NULL)
4122         {
4123                 return False;
4124         }
4125         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
4126         q_u->firstjob = firstjob;
4127         q_u->numofjobs = numofjobs;
4128         q_u->level = level;
4129         q_u->buffer= buffer;
4130         q_u->offered = offered;
4131         return True;
4132 }
4133
4134 /*******************************************************************
4135 ********************************************************************/
4136
4137 bool spoolss_io_q_enumjobs(const char *desc, SPOOL_Q_ENUMJOBS *q_u, prs_struct *ps, int depth)
4138 {
4139         prs_debug(ps, depth, desc, "spoolss_io_q_enumjobs");
4140         depth++;
4141
4142         if (!prs_align(ps))
4143                 return False;
4144
4145         if (!smb_io_pol_hnd("printer handle",&q_u->handle, ps, depth))
4146                 return False;
4147
4148         if (!prs_uint32("firstjob", ps, depth, &q_u->firstjob))
4149                 return False;
4150         if (!prs_uint32("numofjobs", ps, depth, &q_u->numofjobs))
4151                 return False;
4152         if (!prs_uint32("level", ps, depth, &q_u->level))
4153                 return False;
4154
4155         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4156                 return False;
4157
4158         if(!prs_align(ps))
4159                 return False;
4160
4161         if (!prs_uint32("offered", ps, depth, &q_u->offered))
4162                 return False;
4163
4164         return True;
4165 }
4166
4167 /*******************************************************************
4168 ********************************************************************/
4169
4170 bool spoolss_io_r_schedulejob(const char *desc, SPOOL_R_SCHEDULEJOB *r_u, prs_struct *ps, int depth)
4171 {
4172         prs_debug(ps, depth, desc, "spoolss_io_r_schedulejob");
4173         depth++;
4174
4175         if(!prs_align(ps))
4176                 return False;
4177
4178         if(!prs_werror("status", ps, depth, &r_u->status))
4179                 return False;
4180
4181         return True;
4182 }
4183
4184 /*******************************************************************
4185 ********************************************************************/
4186
4187 bool spoolss_io_q_schedulejob(const char *desc, SPOOL_Q_SCHEDULEJOB *q_u, prs_struct *ps, int depth)
4188 {
4189         prs_debug(ps, depth, desc, "spoolss_io_q_schedulejob");
4190         depth++;
4191
4192         if(!prs_align(ps))
4193                 return False;
4194
4195         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4196                 return False;
4197         if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
4198                 return False;
4199
4200         return True;
4201 }
4202
4203 /*******************************************************************
4204 ********************************************************************/
4205
4206 bool spoolss_io_r_setjob(const char *desc, SPOOL_R_SETJOB *r_u, prs_struct *ps, int depth)
4207 {
4208         prs_debug(ps, depth, desc, "spoolss_io_r_setjob");
4209         depth++;
4210
4211         if(!prs_align(ps))
4212                 return False;
4213
4214         if(!prs_werror("status", ps, depth, &r_u->status))
4215                 return False;
4216
4217         return True;
4218 }
4219
4220 /*******************************************************************
4221 ********************************************************************/
4222
4223 bool spoolss_io_q_setjob(const char *desc, SPOOL_Q_SETJOB *q_u, prs_struct *ps, int depth)
4224 {
4225         prs_debug(ps, depth, desc, "spoolss_io_q_setjob");
4226         depth++;
4227
4228         if(!prs_align(ps))
4229                 return False;
4230
4231         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4232                 return False;
4233         if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
4234                 return False;
4235         /*
4236          * level is usually 0. If (level!=0) then I'm in trouble !
4237          * I will try to generate setjob command with level!=0, one day.
4238          */
4239         if(!prs_uint32("level", ps, depth, &q_u->level))
4240                 return False;
4241         if(!prs_uint32("command", ps, depth, &q_u->command))
4242                 return False;
4243
4244         return True;
4245 }
4246
4247 /*******************************************************************
4248  Parse a SPOOL_R_ENUMPRINTERDRIVERS structure.
4249 ********************************************************************/
4250
4251 bool spoolss_io_r_enumprinterdrivers(const char *desc, SPOOL_R_ENUMPRINTERDRIVERS *r_u, prs_struct *ps, int depth)
4252 {
4253         prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdrivers");
4254         depth++;
4255
4256         if (!prs_align(ps))
4257                 return False;
4258
4259         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4260                 return False;
4261
4262         if (!prs_align(ps))
4263                 return False;
4264
4265         if (!prs_uint32("needed", ps, depth, &r_u->needed))
4266                 return False;
4267
4268         if (!prs_uint32("returned", ps, depth, &r_u->returned))
4269                 return False;
4270
4271         if (!prs_werror("status", ps, depth, &r_u->status))
4272                 return False;
4273
4274         return True;
4275 }
4276
4277 /*******************************************************************
4278  * init a structure.
4279  ********************************************************************/
4280
4281 bool make_spoolss_q_enumprinterdrivers(SPOOL_Q_ENUMPRINTERDRIVERS *q_u,
4282                                 const char *name,
4283                                 const char *environment,
4284                                 uint32 level,
4285                                 RPC_BUFFER *buffer, uint32 offered)
4286 {
4287         init_buf_unistr2(&q_u->name, &q_u->name_ptr, name);
4288         init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, environment);
4289
4290         q_u->level=level;
4291         q_u->buffer=buffer;
4292         q_u->offered=offered;
4293
4294         return True;
4295 }
4296
4297 /*******************************************************************
4298  Parse a SPOOL_Q_ENUMPRINTERDRIVERS structure.
4299 ********************************************************************/
4300
4301 bool spoolss_io_q_enumprinterdrivers(const char *desc, SPOOL_Q_ENUMPRINTERDRIVERS *q_u, prs_struct *ps, int depth)
4302 {
4303
4304         prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdrivers");
4305         depth++;
4306
4307         if (!prs_align(ps))
4308                 return False;
4309
4310         if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
4311                 return False;
4312         if (!smb_io_unistr2("", &q_u->name, q_u->name_ptr,ps, depth))
4313                 return False;
4314
4315         if (!prs_align(ps))
4316                 return False;
4317         if (!prs_uint32("environment_ptr", ps, depth, &q_u->environment_ptr))
4318                 return False;
4319         if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
4320                 return False;
4321
4322         if (!prs_align(ps))
4323                 return False;
4324         if (!prs_uint32("level", ps, depth, &q_u->level))
4325                 return False;
4326
4327         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4328                 return False;
4329
4330         if (!prs_align(ps))
4331                 return False;
4332
4333         if (!prs_uint32("offered", ps, depth, &q_u->offered))
4334                 return False;
4335
4336         return True;
4337 }
4338
4339 /*******************************************************************
4340 ********************************************************************/
4341
4342 bool spoolss_io_q_enumforms(const char *desc, SPOOL_Q_ENUMFORMS *q_u, prs_struct *ps, int depth)
4343 {
4344
4345         prs_debug(ps, depth, desc, "spoolss_io_q_enumforms");
4346         depth++;
4347
4348         if (!prs_align(ps))
4349                 return False;
4350         if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4351                 return False;
4352         if (!prs_uint32("level", ps, depth, &q_u->level))
4353                 return False;
4354
4355         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4356                 return False;
4357
4358         if (!prs_align(ps))
4359                 return False;
4360         if (!prs_uint32("offered", ps, depth, &q_u->offered))
4361                 return False;
4362
4363         return True;
4364 }
4365
4366 /*******************************************************************
4367 ********************************************************************/
4368
4369 bool spoolss_io_r_enumforms(const char *desc, SPOOL_R_ENUMFORMS *r_u, prs_struct *ps, int depth)
4370 {
4371         prs_debug(ps, depth, desc, "spoolss_io_r_enumforms");
4372         depth++;
4373
4374         if (!prs_align(ps))
4375                 return False;
4376
4377         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4378                 return False;
4379
4380         if (!prs_align(ps))
4381                 return False;
4382
4383         if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
4384                 return False;
4385
4386         if (!prs_uint32("numofforms", ps, depth, &r_u->numofforms))
4387                 return False;
4388
4389         if (!prs_werror("status", ps, depth, &r_u->status))
4390                 return False;
4391
4392         return True;
4393 }
4394
4395 /*******************************************************************
4396 ********************************************************************/
4397
4398 bool spoolss_io_q_getform(const char *desc, SPOOL_Q_GETFORM *q_u, prs_struct *ps, int depth)
4399 {
4400
4401         prs_debug(ps, depth, desc, "spoolss_io_q_getform");
4402         depth++;
4403
4404         if (!prs_align(ps))
4405                 return False;
4406         if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
4407                 return False;
4408         if (!smb_io_unistr2("", &q_u->formname,True,ps,depth))
4409                 return False;
4410
4411         if (!prs_align(ps))
4412                 return False;
4413
4414         if (!prs_uint32("level", ps, depth, &q_u->level))
4415                 return False;
4416
4417         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4418                 return False;
4419
4420         if (!prs_align(ps))
4421                 return False;
4422         if (!prs_uint32("offered", ps, depth, &q_u->offered))
4423                 return False;
4424
4425         return True;
4426 }
4427
4428 /*******************************************************************
4429 ********************************************************************/
4430
4431 bool spoolss_io_r_getform(const char *desc, SPOOL_R_GETFORM *r_u, prs_struct *ps, int depth)
4432 {
4433         prs_debug(ps, depth, desc, "spoolss_io_r_getform");
4434         depth++;
4435
4436         if (!prs_align(ps))
4437                 return False;
4438
4439         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4440                 return False;
4441
4442         if (!prs_align(ps))
4443                 return False;
4444
4445         if (!prs_uint32("size of buffer needed", ps, depth, &r_u->needed))
4446                 return False;
4447
4448         if (!prs_werror("status", ps, depth, &r_u->status))
4449                 return False;
4450
4451         return True;
4452 }
4453
4454 /*******************************************************************
4455  Parse a SPOOL_R_ENUMPORTS structure.
4456 ********************************************************************/
4457
4458 bool spoolss_io_r_enumports(const char *desc, SPOOL_R_ENUMPORTS *r_u, prs_struct *ps, int depth)
4459 {
4460         prs_debug(ps, depth, desc, "spoolss_io_r_enumports");
4461         depth++;
4462
4463         if (!prs_align(ps))
4464                 return False;
4465
4466         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
4467                 return False;
4468
4469         if (!prs_align(ps))
4470                 return False;
4471
4472         if (!prs_uint32("needed", ps, depth, &r_u->needed))
4473                 return False;
4474
4475         if (!prs_uint32("returned", ps, depth, &r_u->returned))
4476                 return False;
4477
4478         if (!prs_werror("status", ps, depth, &r_u->status))
4479                 return False;
4480
4481         return True;
4482 }
4483
4484 /*******************************************************************
4485 ********************************************************************/
4486
4487 bool spoolss_io_q_enumports(const char *desc, SPOOL_Q_ENUMPORTS *q_u, prs_struct *ps, int depth)
4488 {
4489         prs_debug(ps, depth, desc, "");
4490         depth++;
4491
4492         if (!prs_align(ps))
4493                 return False;
4494
4495         if (!prs_uint32("", ps, depth, &q_u->name_ptr))
4496                 return False;
4497         if (!smb_io_unistr2("", &q_u->name,True,ps,depth))
4498                 return False;
4499
4500         if (!prs_align(ps))
4501                 return False;
4502         if (!prs_uint32("level", ps, depth, &q_u->level))
4503                 return False;
4504
4505         if (!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
4506                 return False;
4507
4508         if (!prs_align(ps))
4509                 return False;
4510         if (!prs_uint32("offered", ps, depth, &q_u->offered))
4511                 return False;
4512
4513         return True;
4514 }
4515
4516 /*******************************************************************
4517  Parse a SPOOL_PRINTER_INFO_LEVEL_1 structure.
4518 ********************************************************************/
4519
4520 bool spool_io_printer_info_level_1(const char *desc, SPOOL_PRINTER_INFO_LEVEL_1 *il, prs_struct *ps, int depth)
4521 {
4522         prs_debug(ps, depth, desc, "spool_io_printer_info_level_1");
4523         depth++;
4524
4525         if(!prs_align(ps))
4526                 return False;
4527
4528         if(!prs_uint32("flags", ps, depth, &il->flags))
4529                 return False;
4530         if(!prs_uint32("description_ptr", ps, depth, &il->description_ptr))
4531                 return False;
4532         if(!prs_uint32("name_ptr", ps, depth, &il->name_ptr))
4533                 return False;
4534         if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4535                 return False;
4536
4537         if(!smb_io_unistr2("description", &il->description, il->description_ptr, ps, depth))
4538                 return False;
4539         if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4540                 return False;
4541         if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4542                 return False;
4543
4544         return True;
4545 }
4546
4547 /*******************************************************************
4548  Parse a SPOOL_PRINTER_INFO_LEVEL_3 structure.
4549 ********************************************************************/
4550
4551 bool spool_io_printer_info_level_3(const char *desc, SPOOL_PRINTER_INFO_LEVEL_3 *il, prs_struct *ps, int depth)
4552 {
4553         prs_debug(ps, depth, desc, "spool_io_printer_info_level_3");
4554         depth++;
4555
4556         if(!prs_align(ps))
4557                 return False;
4558
4559         if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4560                 return False;
4561
4562         return True;
4563 }
4564
4565 /*******************************************************************
4566  Parse a SPOOL_PRINTER_INFO_LEVEL_2 structure.
4567 ********************************************************************/
4568
4569 bool spool_io_printer_info_level_2(const char *desc, SPOOL_PRINTER_INFO_LEVEL_2 *il, prs_struct *ps, int depth)
4570 {
4571         prs_debug(ps, depth, desc, "spool_io_printer_info_level_2");
4572         depth++;
4573
4574         if(!prs_align(ps))
4575                 return False;
4576
4577         if(!prs_uint32("servername_ptr", ps, depth, &il->servername_ptr))
4578                 return False;
4579         if(!prs_uint32("printername_ptr", ps, depth, &il->printername_ptr))
4580                 return False;
4581         if(!prs_uint32("sharename_ptr", ps, depth, &il->sharename_ptr))
4582                 return False;
4583         if(!prs_uint32("portname_ptr", ps, depth, &il->portname_ptr))
4584                 return False;
4585
4586         if(!prs_uint32("drivername_ptr", ps, depth, &il->drivername_ptr))
4587                 return False;
4588         if(!prs_uint32("comment_ptr", ps, depth, &il->comment_ptr))
4589                 return False;
4590         if(!prs_uint32("location_ptr", ps, depth, &il->location_ptr))
4591                 return False;
4592         if(!prs_uint32("devmode_ptr", ps, depth, &il->devmode_ptr))
4593                 return False;
4594         if(!prs_uint32("sepfile_ptr", ps, depth, &il->sepfile_ptr))
4595                 return False;
4596         if(!prs_uint32("printprocessor_ptr", ps, depth, &il->printprocessor_ptr))
4597                 return False;
4598         if(!prs_uint32("datatype_ptr", ps, depth, &il->datatype_ptr))
4599                 return False;
4600         if(!prs_uint32("parameters_ptr", ps, depth, &il->parameters_ptr))
4601                 return False;
4602         if(!prs_uint32("secdesc_ptr", ps, depth, &il->secdesc_ptr))
4603                 return False;
4604
4605         if(!prs_uint32("attributes", ps, depth, &il->attributes))
4606                 return False;
4607         if(!prs_uint32("priority", ps, depth, &il->priority))
4608                 return False;
4609         if(!prs_uint32("default_priority", ps, depth, &il->default_priority))
4610                 return False;
4611         if(!prs_uint32("starttime", ps, depth, &il->starttime))
4612                 return False;
4613         if(!prs_uint32("untiltime", ps, depth, &il->untiltime))
4614                 return False;
4615         if(!prs_uint32("status", ps, depth, &il->status))
4616                 return False;
4617         if(!prs_uint32("cjobs", ps, depth, &il->cjobs))
4618                 return False;
4619         if(!prs_uint32("averageppm", ps, depth, &il->averageppm))
4620                 return False;
4621
4622         if(!smb_io_unistr2("servername", &il->servername, il->servername_ptr, ps, depth))
4623                 return False;
4624         if(!smb_io_unistr2("printername", &il->printername, il->printername_ptr, ps, depth))
4625                 return False;
4626         if(!smb_io_unistr2("sharename", &il->sharename, il->sharename_ptr, ps, depth))
4627                 return False;
4628         if(!smb_io_unistr2("portname", &il->portname, il->portname_ptr, ps, depth))
4629                 return False;
4630         if(!smb_io_unistr2("drivername", &il->drivername, il->drivername_ptr, ps, depth))
4631                 return False;
4632         if(!smb_io_unistr2("comment", &il->comment, il->comment_ptr, ps, depth))
4633                 return False;
4634         if(!smb_io_unistr2("location", &il->location, il->location_ptr, ps, depth))
4635                 return False;
4636         if(!smb_io_unistr2("sepfile", &il->sepfile, il->sepfile_ptr, ps, depth))
4637                 return False;
4638         if(!smb_io_unistr2("printprocessor", &il->printprocessor, il->printprocessor_ptr, ps, depth))
4639                 return False;
4640         if(!smb_io_unistr2("datatype", &il->datatype, il->datatype_ptr, ps, depth))
4641                 return False;
4642         if(!smb_io_unistr2("parameters", &il->parameters, il->parameters_ptr, ps, depth))
4643                 return False;
4644
4645         return True;
4646 }
4647
4648 bool spool_io_printer_info_level_7(const char *desc, SPOOL_PRINTER_INFO_LEVEL_7 *il, prs_struct *ps, int depth)
4649 {
4650         prs_debug(ps, depth, desc, "spool_io_printer_info_level_7");
4651         depth++;
4652
4653         if(!prs_align(ps))
4654                 return False;
4655
4656         if(!prs_uint32("guid_ptr", ps, depth, &il->guid_ptr))
4657                 return False;
4658         if(!prs_uint32("action", ps, depth, &il->action))
4659                 return False;
4660
4661         if(!smb_io_unistr2("servername", &il->guid, il->guid_ptr, ps, depth))
4662                 return False;
4663         return True;
4664 }
4665
4666 /*******************************************************************
4667 ********************************************************************/
4668
4669 bool spool_io_printer_info_level(const char *desc, SPOOL_PRINTER_INFO_LEVEL *il, prs_struct *ps, int depth)
4670 {
4671         prs_debug(ps, depth, desc, "spool_io_printer_info_level");
4672         depth++;
4673
4674         if(!prs_align(ps))
4675                 return False;
4676         if(!prs_uint32("level", ps, depth, &il->level))
4677                 return False;
4678         if(!prs_uint32("info_ptr", ps, depth, &il->info_ptr))
4679                 return False;
4680
4681         /* if no struct inside just return */
4682         if (il->info_ptr==0) {
4683                 if (UNMARSHALLING(ps)) {
4684                         il->info_1=NULL;
4685                         il->info_2=NULL;
4686                 }
4687                 return True;
4688         }
4689
4690         switch (il->level) {
4691                 /*
4692                  * level 0 is used by setprinter when managing the queue
4693                  * (hold, stop, start a queue)
4694                  */
4695                 case 0:
4696                         break;
4697                 /* DOCUMENT ME!!! What is level 1 used for? */
4698                 case 1:
4699                 {
4700                         if (UNMARSHALLING(ps)) {
4701                                 if ((il->info_1=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_1,1)) == NULL)
4702                                         return False;
4703                         }
4704                         if (!spool_io_printer_info_level_1("", il->info_1, ps, depth))
4705                                 return False;
4706                         break;
4707                 }
4708                 /*
4709                  * level 2 is used by addprinter
4710                  * and by setprinter when updating printer's info
4711                  */
4712                 case 2:
4713                         if (UNMARSHALLING(ps)) {
4714                                 if ((il->info_2=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_2,1)) == NULL)
4715                                         return False;
4716                         }
4717                         if (!spool_io_printer_info_level_2("", il->info_2, ps, depth))
4718                                 return False;
4719                         break;
4720                 /* DOCUMENT ME!!! What is level 3 used for? */
4721                 case 3:
4722                 {
4723                         if (UNMARSHALLING(ps)) {
4724                                 if ((il->info_3=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_3,1)) == NULL)
4725                                         return False;
4726                         }
4727                         if (!spool_io_printer_info_level_3("", il->info_3, ps, depth))
4728                                 return False;
4729                         break;
4730                 }
4731                 case 7:
4732                         if (UNMARSHALLING(ps))
4733                                 if ((il->info_7=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_INFO_LEVEL_7,1)) == NULL)
4734                                         return False;
4735                         if (!spool_io_printer_info_level_7("", il->info_7, ps, depth))
4736                                 return False;
4737                         break;
4738         }
4739
4740         return True;
4741 }
4742
4743 /*******************************************************************
4744 ********************************************************************/
4745
4746 bool spoolss_io_q_addprinterex(const char *desc, SPOOL_Q_ADDPRINTEREX *q_u, prs_struct *ps, int depth)
4747 {
4748         uint32 ptr_sec_desc = 0;
4749
4750         prs_debug(ps, depth, desc, "spoolss_io_q_addprinterex");
4751         depth++;
4752
4753         if(!prs_align(ps))
4754                 return False;
4755
4756         if (!prs_io_unistr2_p("ptr", ps, depth, &q_u->server_name))
4757                 return False;
4758         if (!prs_io_unistr2("servername", ps, depth, q_u->server_name))
4759                 return False;
4760
4761         if(!prs_align(ps))
4762                 return False;
4763
4764         if(!prs_uint32("info_level", ps, depth, &q_u->level))
4765                 return False;
4766
4767         if(!spool_io_printer_info_level("", &q_u->info, ps, depth))
4768                 return False;
4769
4770         if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
4771                 return False;
4772
4773         if(!prs_align(ps))
4774                 return False;
4775
4776         switch (q_u->level) {
4777                 case 2:
4778                         ptr_sec_desc = q_u->info.info_2->secdesc_ptr;
4779                         break;
4780                 case 3:
4781                         ptr_sec_desc = q_u->info.info_3->secdesc_ptr;
4782                         break;
4783         }
4784         if (ptr_sec_desc) {
4785                 if (!sec_io_desc_buf(desc, &q_u->secdesc_ctr, ps, depth))
4786                         return False;
4787         } else {
4788                 uint32 dummy;
4789
4790                 /* Parse a NULL security descriptor.  This should really
4791                         happen inside the sec_io_desc_buf() function. */
4792
4793                 prs_debug(ps, depth, "", "sec_io_desc_buf");
4794                 if (!prs_uint32("size", ps, depth + 1, &dummy))
4795                         return False;
4796                 if (!prs_uint32("ptr", ps, depth + 1, &dummy))
4797                         return False;
4798         }
4799
4800         if(!prs_uint32("user_switch", ps, depth, &q_u->user_switch))
4801                 return False;
4802         if(!spool_io_user_level("", &q_u->user_ctr, ps, depth))
4803                 return False;
4804
4805         return True;
4806 }
4807
4808 /*******************************************************************
4809 ********************************************************************/
4810
4811 bool spoolss_io_r_addprinterex(const char *desc, SPOOL_R_ADDPRINTEREX *r_u,
4812                                prs_struct *ps, int depth)
4813 {
4814         prs_debug(ps, depth, desc, "spoolss_io_r_addprinterex");
4815         depth++;
4816
4817         if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
4818                 return False;
4819
4820         if(!prs_werror("status", ps, depth, &r_u->status))
4821                 return False;
4822
4823         return True;
4824 }
4825
4826 /*******************************************************************
4827 ********************************************************************/
4828
4829 bool spool_io_printer_driver_info_level_3(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **q_u,
4830                                           prs_struct *ps, int depth)
4831 {
4832         SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *il;
4833
4834         prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_3");
4835         depth++;
4836
4837         /* reading */
4838         if (UNMARSHALLING(ps)) {
4839                 il=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_DRIVER_INFO_LEVEL_3,1);
4840                 if(il == NULL)
4841                         return False;
4842                 *q_u=il;
4843         }
4844         else {
4845                 il=*q_u;
4846         }
4847
4848         if(!prs_align(ps))
4849                 return False;
4850
4851         if(!prs_uint32("cversion", ps, depth, &il->cversion))
4852                 return False;
4853         if(!prs_uint32("name", ps, depth, &il->name_ptr))
4854                 return False;
4855         if(!prs_uint32("environment", ps, depth, &il->environment_ptr))
4856                 return False;
4857         if(!prs_uint32("driverpath", ps, depth, &il->driverpath_ptr))
4858                 return False;
4859         if(!prs_uint32("datafile", ps, depth, &il->datafile_ptr))
4860                 return False;
4861         if(!prs_uint32("configfile", ps, depth, &il->configfile_ptr))
4862                 return False;
4863         if(!prs_uint32("helpfile", ps, depth, &il->helpfile_ptr))
4864                 return False;
4865         if(!prs_uint32("monitorname", ps, depth, &il->monitorname_ptr))
4866                 return False;
4867         if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
4868                 return False;
4869         if(!prs_uint32("dependentfilessize", ps, depth, &il->dependentfilessize))
4870                 return False;
4871         if(!prs_uint32("dependentfiles", ps, depth, &il->dependentfiles_ptr))
4872                 return False;
4873
4874         if(!prs_align(ps))
4875                 return False;
4876
4877         if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4878                 return False;
4879         if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
4880                 return False;
4881         if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
4882                 return False;
4883         if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
4884                 return False;
4885         if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
4886                 return False;
4887         if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
4888                 return False;
4889         if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
4890                 return False;
4891         if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
4892                 return False;
4893
4894         if(!prs_align(ps))
4895                 return False;
4896
4897         if (il->dependentfiles_ptr)
4898                 smb_io_buffer5("", &il->dependentfiles, ps, depth);
4899
4900         return True;
4901 }
4902
4903 /*******************************************************************
4904 parse a SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 structure
4905 ********************************************************************/
4906
4907 bool spool_io_printer_driver_info_level_6(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 **q_u,
4908                                           prs_struct *ps, int depth)
4909 {
4910         SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *il;
4911
4912         prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level_6");
4913         depth++;
4914
4915         /* reading */
4916         if (UNMARSHALLING(ps)) {
4917                 il=PRS_ALLOC_MEM(ps,SPOOL_PRINTER_DRIVER_INFO_LEVEL_6,1);
4918                 if(il == NULL)
4919                         return False;
4920                 *q_u=il;
4921         }
4922         else {
4923                 il=*q_u;
4924         }
4925
4926         if(!prs_align(ps))
4927                 return False;
4928
4929         /*
4930          * I know this seems weird, but I have no other explanation.
4931          * This is observed behavior on both NT4 and 2K servers.
4932          * --jerry
4933          */
4934
4935         if (!prs_align_uint64(ps))
4936                 return False;
4937
4938         /* parse the main elements the packet */
4939
4940         if(!prs_uint32("cversion       ", ps, depth, &il->version))
4941                 return False;
4942         if(!prs_uint32("name           ", ps, depth, &il->name_ptr))
4943                 return False;
4944         if(!prs_uint32("environment    ", ps, depth, &il->environment_ptr))
4945                 return False;
4946         if(!prs_uint32("driverpath     ", ps, depth, &il->driverpath_ptr))
4947                 return False;
4948         if(!prs_uint32("datafile       ", ps, depth, &il->datafile_ptr))
4949                 return False;
4950         if(!prs_uint32("configfile     ", ps, depth, &il->configfile_ptr))
4951                 return False;
4952         if(!prs_uint32("helpfile       ", ps, depth, &il->helpfile_ptr))
4953                 return False;
4954         if(!prs_uint32("monitorname    ", ps, depth, &il->monitorname_ptr))
4955                 return False;
4956         if(!prs_uint32("defaultdatatype", ps, depth, &il->defaultdatatype_ptr))
4957                 return False;
4958         if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_len))
4959                 return False;
4960         if(!prs_uint32("dependentfiles ", ps, depth, &il->dependentfiles_ptr))
4961                 return False;
4962         if(!prs_uint32("previousnames  ", ps, depth, &il->previousnames_len))
4963                 return False;
4964         if(!prs_uint32("previousnames  ", ps, depth, &il->previousnames_ptr))
4965                 return False;
4966         if(!smb_io_time("driverdate    ", &il->driverdate, ps, depth))
4967                 return False;
4968         if(!prs_uint32("dummy4         ", ps, depth, &il->dummy4))
4969                 return False;
4970         if(!prs_uint64("driverversion  ", ps, depth, &il->driverversion))
4971                 return False;
4972         if(!prs_uint32("mfgname        ", ps, depth, &il->mfgname_ptr))
4973                 return False;
4974         if(!prs_uint32("oemurl         ", ps, depth, &il->oemurl_ptr))
4975                 return False;
4976         if(!prs_uint32("hardwareid     ", ps, depth, &il->hardwareid_ptr))
4977                 return False;
4978         if(!prs_uint32("provider       ", ps, depth, &il->provider_ptr))
4979                 return False;
4980
4981         /* parse the structures in the packet */
4982
4983         if(!smb_io_unistr2("name", &il->name, il->name_ptr, ps, depth))
4984                 return False;
4985         if(!prs_align(ps))
4986                 return False;
4987
4988         if(!smb_io_unistr2("environment", &il->environment, il->environment_ptr, ps, depth))
4989                 return False;
4990         if(!prs_align(ps))
4991                 return False;
4992
4993         if(!smb_io_unistr2("driverpath", &il->driverpath, il->driverpath_ptr, ps, depth))
4994                 return False;
4995         if(!prs_align(ps))
4996                 return False;
4997
4998         if(!smb_io_unistr2("datafile", &il->datafile, il->datafile_ptr, ps, depth))
4999                 return False;
5000         if(!prs_align(ps))
5001                 return False;
5002
5003         if(!smb_io_unistr2("configfile", &il->configfile, il->configfile_ptr, ps, depth))
5004                 return False;
5005         if(!prs_align(ps))
5006                 return False;
5007
5008         if(!smb_io_unistr2("helpfile", &il->helpfile, il->helpfile_ptr, ps, depth))
5009                 return False;
5010         if(!prs_align(ps))
5011                 return False;
5012
5013         if(!smb_io_unistr2("monitorname", &il->monitorname, il->monitorname_ptr, ps, depth))
5014                 return False;
5015         if(!prs_align(ps))
5016                 return False;
5017
5018         if(!smb_io_unistr2("defaultdatatype", &il->defaultdatatype, il->defaultdatatype_ptr, ps, depth))
5019                 return False;
5020         if(!prs_align(ps))
5021                 return False;
5022         if (il->dependentfiles_ptr) {
5023                 if(!smb_io_buffer5("dependentfiles", &il->dependentfiles, ps, depth))
5024                         return False;
5025                 if(!prs_align(ps))
5026                         return False;
5027         }
5028         if (il->previousnames_ptr) {
5029                 if(!smb_io_buffer5("previousnames", &il->previousnames, ps, depth))
5030                         return False;
5031                 if(!prs_align(ps))
5032                         return False;
5033         }
5034         if(!smb_io_unistr2("mfgname", &il->mfgname, il->mfgname_ptr, ps, depth))
5035                 return False;
5036         if(!prs_align(ps))
5037                 return False;
5038         if(!smb_io_unistr2("oemurl", &il->oemurl, il->oemurl_ptr, ps, depth))
5039                 return False;
5040         if(!prs_align(ps))
5041                 return False;
5042         if(!smb_io_unistr2("hardwareid", &il->hardwareid, il->hardwareid_ptr, ps, depth))
5043                 return False;
5044         if(!prs_align(ps))
5045                 return False;
5046         if(!smb_io_unistr2("provider", &il->provider, il->provider_ptr, ps, depth))
5047                 return False;
5048
5049         return True;
5050 }
5051
5052 /*******************************************************************
5053  convert a buffer of UNICODE strings null terminated
5054  the buffer is terminated by a NULL
5055
5056  convert to an dos codepage array (null terminated)
5057
5058  dynamically allocate memory
5059
5060 ********************************************************************/
5061
5062 static bool uniarray_2_dosarray(BUFFER5 *buf5, fstring **ar)
5063 {
5064         fstring f;
5065         int n = 0;
5066         char *src;
5067
5068         if (buf5==NULL)
5069                 return False;
5070
5071         src = (char *)buf5->buffer;
5072         *ar = SMB_MALLOC_ARRAY(fstring, 1);
5073         if (!*ar) {
5074                 return False;
5075         }
5076
5077         while (src < ((char *)buf5->buffer) + buf5->buf_len*2) {
5078                 rpcstr_pull(f, src, sizeof(f)-1, -1, STR_TERMINATE);
5079                 src = skip_unibuf(src, 2*buf5->buf_len - PTR_DIFF(src,buf5->buffer));
5080                 *ar = SMB_REALLOC_ARRAY(*ar, fstring, n+2);
5081                 if (!*ar) {
5082                         return False;
5083                 }
5084                 fstrcpy((*ar)[n], f);
5085                 n++;
5086         }
5087
5088         fstrcpy((*ar)[n], "");
5089
5090         return True;
5091 }
5092
5093 /*******************************************************************
5094  read a UNICODE array with null terminated strings
5095  and null terminated array
5096  and size of array at beginning
5097 ********************************************************************/
5098
5099 bool smb_io_unibuffer(const char *desc, UNISTR2 *buffer, prs_struct *ps, int depth)
5100 {
5101         if (buffer==NULL) return False;
5102
5103         buffer->offset=0;
5104         buffer->uni_str_len=buffer->uni_max_len;
5105
5106         if(!prs_uint32("buffer_size", ps, depth, &buffer->uni_max_len))
5107                 return False;
5108
5109         if(!prs_unistr2(True, "buffer     ", ps, depth, buffer))
5110                 return False;
5111
5112         return True;
5113 }
5114
5115 /*******************************************************************
5116 ********************************************************************/
5117
5118 bool spool_io_printer_driver_info_level(const char *desc, SPOOL_PRINTER_DRIVER_INFO_LEVEL *il, prs_struct *ps, int depth)
5119 {
5120         prs_debug(ps, depth, desc, "spool_io_printer_driver_info_level");
5121         depth++;
5122
5123         if(!prs_align(ps))
5124                 return False;
5125         if(!prs_uint32("level", ps, depth, &il->level))
5126                 return False;
5127         if(!prs_uint32("ptr", ps, depth, &il->ptr))
5128                 return False;
5129
5130         if (il->ptr==0)
5131                 return True;
5132
5133         switch (il->level) {
5134                 case 3:
5135                         if(!spool_io_printer_driver_info_level_3("", &il->info_3, ps, depth))
5136                                 return False;
5137                         break;
5138                 case 6:
5139                         if(!spool_io_printer_driver_info_level_6("", &il->info_6, ps, depth))
5140                                 return False;
5141                         break;
5142         default:
5143                 return False;
5144         }
5145
5146         return True;
5147 }
5148
5149 /*******************************************************************
5150  init a SPOOL_Q_ADDPRINTERDRIVER struct
5151  ******************************************************************/
5152
5153 bool make_spoolss_q_addprinterdriver(TALLOC_CTX *mem_ctx,
5154                                 SPOOL_Q_ADDPRINTERDRIVER *q_u, const char* srv_name,
5155                                 uint32 level, PRINTER_DRIVER_CTR *info)
5156 {
5157         DEBUG(5,("make_spoolss_q_addprinterdriver\n"));
5158
5159         if (!srv_name || !info) {
5160                 return False;
5161         }
5162
5163         q_u->server_name_ptr = 1; /* srv_name is != NULL, see above */
5164         init_unistr2(&q_u->server_name, srv_name, UNI_STR_TERMINATE);
5165
5166         q_u->level = level;
5167
5168         q_u->info.level = level;
5169         q_u->info.ptr = 1;      /* Info is != NULL, see above */
5170         switch (level)
5171         {
5172         /* info level 3 is supported by Windows 95/98, WinNT and Win2k */
5173         case 3 :
5174                 make_spoolss_driver_info_3(mem_ctx, &q_u->info.info_3, info->info3);
5175                 break;
5176
5177         default:
5178                 DEBUG(0,("make_spoolss_q_addprinterdriver: Unknown info level [%d]\n", level));
5179                 break;
5180         }
5181
5182         return True;
5183 }
5184
5185 bool make_spoolss_driver_info_3(TALLOC_CTX *mem_ctx,
5186         SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 **spool_drv_info,
5187                                 DRIVER_INFO_3 *info3)
5188 {
5189         uint32          len = 0;
5190         SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *inf;
5191
5192         if (!(inf=TALLOC_ZERO_P(mem_ctx, SPOOL_PRINTER_DRIVER_INFO_LEVEL_3)))
5193                 return False;
5194
5195         inf->cversion   = info3->version;
5196         inf->name_ptr   = (info3->name.buffer!=NULL)?1:0;
5197         inf->environment_ptr    = (info3->architecture.buffer!=NULL)?1:0;
5198         inf->driverpath_ptr     = (info3->driverpath.buffer!=NULL)?1:0;
5199         inf->datafile_ptr       = (info3->datafile.buffer!=NULL)?1:0;
5200         inf->configfile_ptr     = (info3->configfile.buffer!=NULL)?1:0;
5201         inf->helpfile_ptr       = (info3->helpfile.buffer!=NULL)?1:0;
5202         inf->monitorname_ptr    = (info3->monitorname.buffer!=NULL)?1:0;
5203         inf->defaultdatatype_ptr        = (info3->defaultdatatype.buffer!=NULL)?1:0;
5204
5205         init_unistr2_from_unistr(&inf->name, &info3->name);
5206         init_unistr2_from_unistr(&inf->environment, &info3->architecture);
5207         init_unistr2_from_unistr(&inf->driverpath, &info3->driverpath);
5208         init_unistr2_from_unistr(&inf->datafile, &info3->datafile);
5209         init_unistr2_from_unistr(&inf->configfile, &info3->configfile);
5210         init_unistr2_from_unistr(&inf->helpfile, &info3->helpfile);
5211         init_unistr2_from_unistr(&inf->monitorname, &info3->monitorname);
5212         init_unistr2_from_unistr(&inf->defaultdatatype, &info3->defaultdatatype);
5213
5214         if (info3->dependentfiles) {
5215                 bool done = False;
5216                 bool null_char = False;
5217                 uint16 *ptr = info3->dependentfiles;
5218
5219                 while (!done) {
5220                         switch (*ptr) {
5221                                 case 0:
5222                                         /* the null_char bool is used to help locate
5223                                            two '\0's back to back */
5224                                         if (null_char) {
5225                                                 done = True;
5226                                         } else {
5227                                                 null_char = True;
5228                                         }
5229                                         break;
5230
5231                                 default:
5232                                         null_char = False;
5233                                         break;
5234                         }
5235                         len++;
5236                         ptr++;
5237                 }
5238         }
5239
5240         inf->dependentfiles_ptr = (info3->dependentfiles != NULL) ? 1 : 0;
5241         inf->dependentfilessize = (info3->dependentfiles != NULL) ? len : 0;
5242         if(!make_spoolss_buffer5(mem_ctx, &inf->dependentfiles, len, info3->dependentfiles)) {
5243                 SAFE_FREE(inf);
5244                 return False;
5245         }
5246
5247         *spool_drv_info = inf;
5248
5249         return True;
5250 }
5251
5252 /*******************************************************************
5253  make a BUFFER5 struct from a uint16*
5254  ******************************************************************/
5255
5256 bool make_spoolss_buffer5(TALLOC_CTX *mem_ctx, BUFFER5 *buf5, uint32 len, uint16 *src)
5257 {
5258
5259         buf5->buf_len = len;
5260         if (src) {
5261                 if (len) {
5262                         if((buf5->buffer=(uint16*)TALLOC_MEMDUP(mem_ctx, src, sizeof(uint16)*len)) == NULL) {
5263                                 DEBUG(0,("make_spoolss_buffer5: Unable to malloc memory for buffer!\n"));
5264                                 return False;
5265                         }
5266                 } else {
5267                         buf5->buffer = NULL;
5268                 }
5269         } else {
5270                 buf5->buffer=NULL;
5271         }
5272
5273         return True;
5274 }
5275
5276 /*******************************************************************
5277  fill in the prs_struct for a ADDPRINTERDRIVER request PDU
5278  ********************************************************************/
5279
5280 bool spoolss_io_q_addprinterdriver(const char *desc, SPOOL_Q_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
5281 {
5282         prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriver");
5283         depth++;
5284
5285         if(!prs_align(ps))
5286                 return False;
5287
5288         if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
5289                 return False;
5290         if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
5291                 return False;
5292
5293         if(!prs_align(ps))
5294                 return False;
5295         if(!prs_uint32("info_level", ps, depth, &q_u->level))
5296                 return False;
5297
5298         if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
5299                 return False;
5300
5301         return True;
5302 }
5303
5304 /*******************************************************************
5305 ********************************************************************/
5306
5307 bool spoolss_io_r_addprinterdriver(const char *desc, SPOOL_R_ADDPRINTERDRIVER *q_u, prs_struct *ps, int depth)
5308 {
5309         prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriver");
5310         depth++;
5311
5312         if(!prs_werror("status", ps, depth, &q_u->status))
5313                 return False;
5314
5315         return True;
5316 }
5317
5318 /*******************************************************************
5319  fill in the prs_struct for a ADDPRINTERDRIVER request PDU
5320  ********************************************************************/
5321
5322 bool spoolss_io_q_addprinterdriverex(const char *desc, SPOOL_Q_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
5323 {
5324         prs_debug(ps, depth, desc, "spoolss_io_q_addprinterdriverex");
5325         depth++;
5326
5327         if(!prs_align(ps))
5328                 return False;
5329
5330         if(!prs_uint32("server_name_ptr", ps, depth, &q_u->server_name_ptr))
5331                 return False;
5332         if(!smb_io_unistr2("server_name", &q_u->server_name, q_u->server_name_ptr, ps, depth))
5333                 return False;
5334
5335         if(!prs_align(ps))
5336                 return False;
5337         if(!prs_uint32("info_level", ps, depth, &q_u->level))
5338                 return False;
5339
5340         if(!spool_io_printer_driver_info_level("", &q_u->info, ps, depth))
5341                 return False;
5342
5343         if(!prs_align(ps))
5344                 return False;
5345         if(!prs_uint32("copy flags", ps, depth, &q_u->copy_flags))
5346                 return False;
5347
5348         return True;
5349 }
5350
5351 /*******************************************************************
5352 ********************************************************************/
5353
5354 bool spoolss_io_r_addprinterdriverex(const char *desc, SPOOL_R_ADDPRINTERDRIVEREX *q_u, prs_struct *ps, int depth)
5355 {
5356         prs_debug(ps, depth, desc, "spoolss_io_r_addprinterdriverex");
5357         depth++;
5358
5359         if(!prs_werror("status", ps, depth, &q_u->status))
5360                 return False;
5361
5362         return True;
5363 }
5364
5365 /*******************************************************************
5366 ********************************************************************/
5367
5368 bool uni_2_asc_printer_driver_3(SPOOL_PRINTER_DRIVER_INFO_LEVEL_3 *uni,
5369                                 NT_PRINTER_DRIVER_INFO_LEVEL_3 **asc)
5370 {
5371         NT_PRINTER_DRIVER_INFO_LEVEL_3 *d;
5372
5373         DEBUG(7,("uni_2_asc_printer_driver_3: Converting from UNICODE to ASCII\n"));
5374
5375         if (*asc==NULL)
5376         {
5377                 *asc=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_3);
5378                 if(*asc == NULL)
5379                         return False;
5380                 ZERO_STRUCTP(*asc);
5381         }
5382
5383         d=*asc;
5384
5385         d->cversion=uni->cversion;
5386
5387         unistr2_to_ascii(d->name,            &uni->name,            sizeof(d->name));
5388         unistr2_to_ascii(d->environment,     &uni->environment,     sizeof(d->environment));
5389         unistr2_to_ascii(d->driverpath,      &uni->driverpath,      sizeof(d->driverpath));
5390         unistr2_to_ascii(d->datafile,        &uni->datafile,        sizeof(d->datafile));
5391         unistr2_to_ascii(d->configfile,      &uni->configfile,      sizeof(d->configfile));
5392         unistr2_to_ascii(d->helpfile,        &uni->helpfile,        sizeof(d->helpfile));
5393         unistr2_to_ascii(d->monitorname,     &uni->monitorname,     sizeof(d->monitorname));
5394         unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype));
5395
5396         DEBUGADD(8,( "version:         %d\n", d->cversion));
5397         DEBUGADD(8,( "name:            %s\n", d->name));
5398         DEBUGADD(8,( "environment:     %s\n", d->environment));
5399         DEBUGADD(8,( "driverpath:      %s\n", d->driverpath));
5400         DEBUGADD(8,( "datafile:        %s\n", d->datafile));
5401         DEBUGADD(8,( "configfile:      %s\n", d->configfile));
5402         DEBUGADD(8,( "helpfile:        %s\n", d->helpfile));
5403         DEBUGADD(8,( "monitorname:     %s\n", d->monitorname));
5404         DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5405
5406         if (uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5407                 return True;
5408
5409         SAFE_FREE(*asc);
5410         return False;
5411 }
5412
5413 /*******************************************************************
5414 ********************************************************************/
5415 bool uni_2_asc_printer_driver_6(SPOOL_PRINTER_DRIVER_INFO_LEVEL_6 *uni,
5416                                 NT_PRINTER_DRIVER_INFO_LEVEL_6 **asc)
5417 {
5418         NT_PRINTER_DRIVER_INFO_LEVEL_6 *d;
5419
5420         DEBUG(7,("uni_2_asc_printer_driver_6: Converting from UNICODE to ASCII\n"));
5421
5422         if (*asc==NULL)
5423         {
5424                 *asc=SMB_MALLOC_P(NT_PRINTER_DRIVER_INFO_LEVEL_6);
5425                 if(*asc == NULL)
5426                         return False;
5427                 ZERO_STRUCTP(*asc);
5428         }
5429
5430         d=*asc;
5431
5432         d->version=uni->version;
5433
5434         unistr2_to_ascii(d->name,            &uni->name,            sizeof(d->name));
5435         unistr2_to_ascii(d->environment,     &uni->environment,     sizeof(d->environment));
5436         unistr2_to_ascii(d->driverpath,      &uni->driverpath,      sizeof(d->driverpath));
5437         unistr2_to_ascii(d->datafile,        &uni->datafile,        sizeof(d->datafile));
5438         unistr2_to_ascii(d->configfile,      &uni->configfile,      sizeof(d->configfile));
5439         unistr2_to_ascii(d->helpfile,        &uni->helpfile,        sizeof(d->helpfile));
5440         unistr2_to_ascii(d->monitorname,     &uni->monitorname,     sizeof(d->monitorname));
5441         unistr2_to_ascii(d->defaultdatatype, &uni->defaultdatatype, sizeof(d->defaultdatatype));
5442
5443         DEBUGADD(8,( "version:         %d\n", d->version));
5444         DEBUGADD(8,( "name:            %s\n", d->name));
5445         DEBUGADD(8,( "environment:     %s\n", d->environment));
5446         DEBUGADD(8,( "driverpath:      %s\n", d->driverpath));
5447         DEBUGADD(8,( "datafile:        %s\n", d->datafile));
5448         DEBUGADD(8,( "configfile:      %s\n", d->configfile));
5449         DEBUGADD(8,( "helpfile:        %s\n", d->helpfile));
5450         DEBUGADD(8,( "monitorname:     %s\n", d->monitorname));
5451         DEBUGADD(8,( "defaultdatatype: %s\n", d->defaultdatatype));
5452
5453         if (!uniarray_2_dosarray(&uni->dependentfiles, &d->dependentfiles ))
5454                 goto error;
5455         if (!uniarray_2_dosarray(&uni->previousnames, &d->previousnames ))
5456                 goto error;
5457
5458         return True;
5459
5460 error:
5461         SAFE_FREE(*asc);
5462         return False;
5463 }
5464
5465 bool uni_2_asc_printer_info_2(const SPOOL_PRINTER_INFO_LEVEL_2 *uni,
5466                               NT_PRINTER_INFO_LEVEL_2  *d)
5467 {
5468         DEBUG(7,("Converting from UNICODE to ASCII\n"));
5469
5470         d->attributes=uni->attributes;
5471         d->priority=uni->priority;
5472         d->default_priority=uni->default_priority;
5473         d->starttime=uni->starttime;
5474         d->untiltime=uni->untiltime;
5475         d->status=uni->status;
5476         d->cjobs=uni->cjobs;
5477
5478         unistr2_to_ascii(d->servername, &uni->servername, sizeof(d->servername));
5479         unistr2_to_ascii(d->printername, &uni->printername, sizeof(d->printername));
5480         unistr2_to_ascii(d->sharename, &uni->sharename, sizeof(d->sharename));
5481         unistr2_to_ascii(d->portname, &uni->portname, sizeof(d->portname));
5482         unistr2_to_ascii(d->drivername, &uni->drivername, sizeof(d->drivername));
5483         unistr2_to_ascii(d->comment, &uni->comment, sizeof(d->comment));
5484         unistr2_to_ascii(d->location, &uni->location, sizeof(d->location));
5485         unistr2_to_ascii(d->sepfile, &uni->sepfile, sizeof(d->sepfile));
5486         unistr2_to_ascii(d->printprocessor, &uni->printprocessor, sizeof(d->printprocessor));
5487         unistr2_to_ascii(d->datatype, &uni->datatype, sizeof(d->datatype));
5488         unistr2_to_ascii(d->parameters, &uni->parameters, sizeof(d->parameters));
5489
5490         return True;
5491 }
5492
5493 /*******************************************************************
5494  * init a structure.
5495  ********************************************************************/
5496
5497 bool make_spoolss_q_getprinterdriverdir(SPOOL_Q_GETPRINTERDRIVERDIR *q_u,
5498                                 fstring servername, fstring env_name, uint32 level,
5499                                 RPC_BUFFER *buffer, uint32 offered)
5500 {
5501         init_buf_unistr2(&q_u->name, &q_u->name_ptr, servername);
5502         init_buf_unistr2(&q_u->environment, &q_u->environment_ptr, env_name);
5503
5504         q_u->level=level;
5505         q_u->buffer=buffer;
5506         q_u->offered=offered;
5507
5508         return True;
5509 }
5510
5511 /*******************************************************************
5512  Parse a SPOOL_Q_GETPRINTERDRIVERDIR structure.
5513 ********************************************************************/
5514
5515 bool spoolss_io_q_getprinterdriverdir(const char *desc, SPOOL_Q_GETPRINTERDRIVERDIR *q_u, prs_struct *ps, int depth)
5516 {
5517         prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdriverdir");
5518         depth++;
5519
5520         if(!prs_align(ps))
5521                 return False;
5522         if(!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5523                 return False;
5524         if(!smb_io_unistr2("", &q_u->name, q_u->name_ptr, ps, depth))
5525                 return False;
5526
5527         if(!prs_align(ps))
5528                 return False;
5529
5530         if(!prs_uint32("", ps, depth, &q_u->environment_ptr))
5531                 return False;
5532         if(!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5533                 return False;
5534
5535         if(!prs_align(ps))
5536                 return False;
5537
5538         if(!prs_uint32("level", ps, depth, &q_u->level))
5539                 return False;
5540
5541         if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5542                 return False;
5543
5544         if(!prs_align(ps))
5545                 return False;
5546
5547         if(!prs_uint32("offered", ps, depth, &q_u->offered))
5548                 return False;
5549
5550         return True;
5551 }
5552
5553 /*******************************************************************
5554  Parse a SPOOL_R_GETPRINTERDRIVERDIR structure.
5555 ********************************************************************/
5556
5557 bool spoolss_io_r_getprinterdriverdir(const char *desc, SPOOL_R_GETPRINTERDRIVERDIR *r_u, prs_struct *ps, int depth)
5558 {
5559         prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdriverdir");
5560         depth++;
5561
5562         if (!prs_align(ps))
5563                 return False;
5564
5565         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5566                 return False;
5567
5568         if (!prs_align(ps))
5569                 return False;
5570
5571         if (!prs_uint32("needed", ps, depth, &r_u->needed))
5572                 return False;
5573
5574         if (!prs_werror("status", ps, depth, &r_u->status))
5575                 return False;
5576
5577         return True;
5578 }
5579
5580 /*******************************************************************
5581 ********************************************************************/
5582
5583 bool spoolss_io_r_enumprintprocessors(const char *desc, SPOOL_R_ENUMPRINTPROCESSORS *r_u, prs_struct *ps, int depth)
5584 {
5585         prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocessors");
5586         depth++;
5587
5588         if (!prs_align(ps))
5589                 return False;
5590
5591         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5592                 return False;
5593
5594         if (!prs_align(ps))
5595                 return False;
5596
5597         if (!prs_uint32("needed", ps, depth, &r_u->needed))
5598                 return False;
5599
5600         if (!prs_uint32("returned", ps, depth, &r_u->returned))
5601                 return False;
5602
5603         if (!prs_werror("status", ps, depth, &r_u->status))
5604                 return False;
5605
5606         return True;
5607 }
5608
5609 /*******************************************************************
5610 ********************************************************************/
5611
5612 bool spoolss_io_q_enumprintprocessors(const char *desc, SPOOL_Q_ENUMPRINTPROCESSORS *q_u, prs_struct *ps, int depth)
5613 {
5614         prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocessors");
5615         depth++;
5616
5617         if (!prs_align(ps))
5618                 return False;
5619
5620         if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5621                 return False;
5622         if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5623                 return False;
5624
5625         if (!prs_align(ps))
5626                 return False;
5627
5628         if (!prs_uint32("", ps, depth, &q_u->environment_ptr))
5629                 return False;
5630         if (!smb_io_unistr2("", &q_u->environment, q_u->environment_ptr, ps, depth))
5631                 return False;
5632
5633         if (!prs_align(ps))
5634                 return False;
5635
5636         if (!prs_uint32("level", ps, depth, &q_u->level))
5637                 return False;
5638
5639         if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5640                 return False;
5641
5642         if (!prs_align(ps))
5643                 return False;
5644
5645         if (!prs_uint32("offered", ps, depth, &q_u->offered))
5646                 return False;
5647
5648         return True;
5649 }
5650
5651 /*******************************************************************
5652 ********************************************************************/
5653
5654 bool spoolss_io_q_addprintprocessor(const char *desc, SPOOL_Q_ADDPRINTPROCESSOR *q_u, prs_struct *ps, int depth)
5655 {
5656         prs_debug(ps, depth, desc, "spoolss_io_q_addprintprocessor");
5657         depth++;
5658
5659         if (!prs_align(ps))
5660                 return False;
5661
5662         if (!prs_uint32("server_ptr", ps, depth, &q_u->server_ptr))
5663                 return False;
5664         if (!smb_io_unistr2("server", &q_u->server, q_u->server_ptr, ps, depth))
5665                 return False;
5666
5667         if (!prs_align(ps))
5668                 return False;
5669         if (!smb_io_unistr2("environment", &q_u->environment, True, ps, depth))
5670                 return False;
5671
5672         if (!prs_align(ps))
5673                 return False;
5674         if (!smb_io_unistr2("path", &q_u->path, True, ps, depth))
5675                 return False;
5676
5677         if (!prs_align(ps))
5678                 return False;
5679         if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5680                 return False;
5681
5682         return True;
5683 }
5684
5685 /*******************************************************************
5686 ********************************************************************/
5687
5688 bool spoolss_io_r_addprintprocessor(const char *desc, SPOOL_R_ADDPRINTPROCESSOR *r_u, prs_struct *ps, int depth)
5689 {
5690         prs_debug(ps, depth, desc, "spoolss_io_r_addprintproicessor");
5691         depth++;
5692
5693         if (!prs_align(ps))
5694                 return False;
5695
5696         if (!prs_werror("status", ps, depth, &r_u->status))
5697                 return False;
5698
5699         return True;
5700 }
5701
5702 /*******************************************************************
5703 ********************************************************************/
5704
5705 bool spoolss_io_r_enumprintprocdatatypes(const char *desc, SPOOL_R_ENUMPRINTPROCDATATYPES *r_u, prs_struct *ps, int depth)
5706 {
5707         prs_debug(ps, depth, desc, "spoolss_io_r_enumprintprocdatatypes");
5708         depth++;
5709
5710         if (!prs_align(ps))
5711                 return False;
5712
5713         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5714                 return False;
5715
5716         if (!prs_align(ps))
5717                 return False;
5718
5719         if (!prs_uint32("needed", ps, depth, &r_u->needed))
5720                 return False;
5721
5722         if (!prs_uint32("returned", ps, depth, &r_u->returned))
5723                 return False;
5724
5725         if (!prs_werror("status", ps, depth, &r_u->status))
5726                 return False;
5727
5728         return True;
5729 }
5730
5731 /*******************************************************************
5732 ********************************************************************/
5733
5734 bool spoolss_io_q_enumprintprocdatatypes(const char *desc, SPOOL_Q_ENUMPRINTPROCDATATYPES *q_u, prs_struct *ps, int depth)
5735 {
5736         prs_debug(ps, depth, desc, "spoolss_io_q_enumprintprocdatatypes");
5737         depth++;
5738
5739         if (!prs_align(ps))
5740                 return False;
5741
5742         if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5743                 return False;
5744         if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5745                 return False;
5746
5747         if (!prs_align(ps))
5748                 return False;
5749
5750         if (!prs_uint32("processor_ptr", ps, depth, &q_u->processor_ptr))
5751                 return False;
5752         if (!smb_io_unistr2("processor", &q_u->processor, q_u->processor_ptr, ps, depth))
5753                 return False;
5754
5755         if (!prs_align(ps))
5756                 return False;
5757
5758         if (!prs_uint32("level", ps, depth, &q_u->level))
5759                 return False;
5760
5761         if(!prs_rpcbuffer_p("buffer", ps, depth, &q_u->buffer))
5762                 return False;
5763
5764         if (!prs_align(ps))
5765                 return False;
5766
5767         if (!prs_uint32("offered", ps, depth, &q_u->offered))
5768                 return False;
5769
5770         return True;
5771 }
5772
5773 /*******************************************************************
5774  Parse a SPOOL_Q_ENUMPRINTMONITORS structure.
5775 ********************************************************************/
5776
5777 bool spoolss_io_q_enumprintmonitors(const char *desc, SPOOL_Q_ENUMPRINTMONITORS *q_u, prs_struct *ps, int depth)
5778 {
5779         prs_debug(ps, depth, desc, "spoolss_io_q_enumprintmonitors");
5780         depth++;
5781
5782         if (!prs_align(ps))
5783                 return False;
5784
5785         if (!prs_uint32("name_ptr", ps, depth, &q_u->name_ptr))
5786                 return False;
5787         if (!smb_io_unistr2("name", &q_u->name, True, ps, depth))
5788                 return False;
5789
5790         if (!prs_align(ps))
5791                 return False;
5792
5793         if (!prs_uint32("level", ps, depth, &q_u->level))
5794                 return False;
5795
5796         if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
5797                 return False;
5798
5799         if (!prs_align(ps))
5800                 return False;
5801
5802         if (!prs_uint32("offered", ps, depth, &q_u->offered))
5803                 return False;
5804
5805         return True;
5806 }
5807
5808 /*******************************************************************
5809 ********************************************************************/
5810
5811 bool spoolss_io_r_enumprintmonitors(const char *desc, SPOOL_R_ENUMPRINTMONITORS *r_u, prs_struct *ps, int depth)
5812 {
5813         prs_debug(ps, depth, desc, "spoolss_io_r_enumprintmonitors");
5814         depth++;
5815
5816         if (!prs_align(ps))
5817                 return False;
5818
5819         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
5820                 return False;
5821
5822         if (!prs_align(ps))
5823                 return False;
5824
5825         if (!prs_uint32("needed", ps, depth, &r_u->needed))
5826                 return False;
5827
5828         if (!prs_uint32("returned", ps, depth, &r_u->returned))
5829                 return False;
5830
5831         if (!prs_werror("status", ps, depth, &r_u->status))
5832                 return False;
5833
5834         return True;
5835 }
5836
5837 /*******************************************************************
5838 ********************************************************************/
5839
5840 bool spoolss_io_r_enumprinterdata(const char *desc, SPOOL_R_ENUMPRINTERDATA *r_u, prs_struct *ps, int depth)
5841 {
5842         prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdata");
5843         depth++;
5844
5845         if(!prs_align(ps))
5846                 return False;
5847         if(!prs_uint32("valuesize", ps, depth, &r_u->valuesize))
5848                 return False;
5849
5850         if (UNMARSHALLING(ps) && r_u->valuesize) {
5851                 r_u->value = PRS_ALLOC_MEM(ps, uint16, r_u->valuesize);
5852                 if (!r_u->value) {
5853                         DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata value\n"));
5854                         return False;
5855                 }
5856         }
5857
5858         if(!prs_uint16uni(False, "value", ps, depth, r_u->value, r_u->valuesize ))
5859                 return False;
5860
5861         if(!prs_align(ps))
5862                 return False;
5863
5864         if(!prs_uint32("realvaluesize", ps, depth, &r_u->realvaluesize))
5865                 return False;
5866
5867         if(!prs_uint32("type", ps, depth, &r_u->type))
5868                 return False;
5869
5870         if(!prs_uint32("datasize", ps, depth, &r_u->datasize))
5871                 return False;
5872
5873         if (UNMARSHALLING(ps) && r_u->datasize) {
5874                 r_u->data = PRS_ALLOC_MEM(ps, uint8, r_u->datasize);
5875                 if (!r_u->data) {
5876                         DEBUG(0, ("spoolss_io_r_enumprinterdata: out of memory for printerdata data\n"));
5877                         return False;
5878                 }
5879         }
5880
5881         if(!prs_uint8s(False, "data", ps, depth, r_u->data, r_u->datasize))
5882                 return False;
5883         if(!prs_align(ps))
5884                 return False;
5885
5886         if(!prs_uint32("realdatasize", ps, depth, &r_u->realdatasize))
5887                 return False;
5888         if(!prs_werror("status", ps, depth, &r_u->status))
5889                 return False;
5890
5891         return True;
5892 }
5893
5894 /*******************************************************************
5895 ********************************************************************/
5896
5897 bool spoolss_io_q_enumprinterdata(const char *desc, SPOOL_Q_ENUMPRINTERDATA *q_u, prs_struct *ps, int depth)
5898 {
5899         prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdata");
5900         depth++;
5901
5902         if(!prs_align(ps))
5903                 return False;
5904         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
5905                 return False;
5906         if(!prs_uint32("index", ps, depth, &q_u->index))
5907                 return False;
5908         if(!prs_uint32("valuesize", ps, depth, &q_u->valuesize))
5909                 return False;
5910         if(!prs_uint32("datasize", ps, depth, &q_u->datasize))
5911                 return False;
5912
5913         return True;
5914 }
5915
5916 /*******************************************************************
5917 ********************************************************************/
5918
5919 bool make_spoolss_q_enumprinterdata(SPOOL_Q_ENUMPRINTERDATA *q_u,
5920                 const POLICY_HND *hnd,
5921                 uint32 idx, uint32 valuelen, uint32 datalen)
5922 {
5923         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5924         q_u->index=idx;
5925         q_u->valuesize=valuelen;
5926         q_u->datasize=datalen;
5927
5928         return True;
5929 }
5930
5931 /*******************************************************************
5932 ********************************************************************/
5933
5934 bool make_spoolss_q_enumprinterdataex(SPOOL_Q_ENUMPRINTERDATAEX *q_u,
5935                                       const POLICY_HND *hnd, const char *key,
5936                                       uint32 size)
5937 {
5938         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5939         init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
5940         q_u->size = size;
5941
5942         return True;
5943 }
5944
5945 /*******************************************************************
5946 ********************************************************************/
5947 bool make_spoolss_q_setprinterdata(SPOOL_Q_SETPRINTERDATA *q_u, const POLICY_HND *hnd,
5948                                    char* value, uint32 data_type, char* data, uint32 data_size)
5949 {
5950         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5951         q_u->type = data_type;
5952         init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
5953
5954         q_u->max_len = q_u->real_len = data_size;
5955         q_u->data = (unsigned char *)data;
5956
5957         return True;
5958 }
5959
5960 /*******************************************************************
5961 ********************************************************************/
5962 bool make_spoolss_q_setprinterdataex(SPOOL_Q_SETPRINTERDATAEX *q_u, const POLICY_HND *hnd,
5963                                      char *key, char* value, uint32 data_type, char* data,
5964                                      uint32 data_size)
5965 {
5966         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
5967         q_u->type = data_type;
5968         init_unistr2(&q_u->value, value, UNI_STR_TERMINATE);
5969         init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
5970
5971         q_u->max_len = q_u->real_len = data_size;
5972         q_u->data = (unsigned char *)data;
5973
5974         return True;
5975 }
5976
5977 /*******************************************************************
5978 ********************************************************************/
5979
5980 bool spoolss_io_q_setprinterdata(const char *desc, SPOOL_Q_SETPRINTERDATA *q_u, prs_struct *ps, int depth)
5981 {
5982         prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdata");
5983         depth++;
5984
5985         if(!prs_align(ps))
5986                 return False;
5987         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
5988                 return False;
5989         if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
5990                 return False;
5991
5992         if(!prs_align(ps))
5993                 return False;
5994
5995         if(!prs_uint32("type", ps, depth, &q_u->type))
5996                 return False;
5997
5998         if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
5999                 return False;
6000
6001         switch (q_u->type)
6002         {
6003                 case REG_SZ:
6004                 case REG_BINARY:
6005                 case REG_DWORD:
6006                 case REG_MULTI_SZ:
6007                         if (q_u->max_len) {
6008                                 if (UNMARSHALLING(ps))
6009                                         q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
6010                                 if(q_u->data == NULL)
6011                                         return False;
6012                                 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
6013                                         return False;
6014                         }
6015                         if(!prs_align(ps))
6016                                 return False;
6017                         break;
6018         }
6019
6020         if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
6021                 return False;
6022
6023         return True;
6024 }
6025
6026 /*******************************************************************
6027 ********************************************************************/
6028
6029 bool spoolss_io_r_setprinterdata(const char *desc, SPOOL_R_SETPRINTERDATA *r_u, prs_struct *ps, int depth)
6030 {
6031         prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdata");
6032         depth++;
6033
6034         if(!prs_align(ps))
6035                 return False;
6036         if(!prs_werror("status",     ps, depth, &r_u->status))
6037                 return False;
6038
6039         return True;
6040 }
6041
6042 /*******************************************************************
6043 ********************************************************************/
6044 bool spoolss_io_q_resetprinter(const char *desc, SPOOL_Q_RESETPRINTER *q_u, prs_struct *ps, int depth)
6045 {
6046         prs_debug(ps, depth, desc, "spoolss_io_q_resetprinter");
6047         depth++;
6048
6049         if (!prs_align(ps))
6050                 return False;
6051         if (!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6052                 return False;
6053
6054         if (!prs_uint32("datatype_ptr", ps, depth, &q_u->datatype_ptr))
6055                 return False;
6056
6057         if (q_u->datatype_ptr) {
6058                 if (!smb_io_unistr2("datatype", &q_u->datatype, q_u->datatype_ptr?True:False, ps, depth))
6059                 return False;
6060         }
6061
6062         if (!spoolss_io_devmode_cont(desc, &q_u->devmode_ctr, ps, depth))
6063                 return False;
6064
6065         return True;
6066 }
6067
6068
6069 /*******************************************************************
6070 ********************************************************************/
6071 bool spoolss_io_r_resetprinter(const char *desc, SPOOL_R_RESETPRINTER *r_u, prs_struct *ps, int depth)
6072 {
6073         prs_debug(ps, depth, desc, "spoolss_io_r_resetprinter");
6074         depth++;
6075
6076         if(!prs_align(ps))
6077                 return False;
6078         if(!prs_werror("status",     ps, depth, &r_u->status))
6079                 return False;
6080
6081         return True;
6082 }
6083
6084 /*******************************************************************
6085 ********************************************************************/
6086
6087 static bool spoolss_io_addform(const char *desc, FORM *f, uint32 ptr, prs_struct *ps, int depth)
6088 {
6089         prs_debug(ps, depth, desc, "spoolss_io_addform");
6090         depth++;
6091         if(!prs_align(ps))
6092                 return False;
6093
6094         if (ptr!=0)
6095         {
6096                 if(!prs_uint32("flags",    ps, depth, &f->flags))
6097                         return False;
6098                 if(!prs_uint32("name_ptr", ps, depth, &f->name_ptr))
6099                         return False;
6100                 if(!prs_uint32("size_x",   ps, depth, &f->size_x))
6101                         return False;
6102                 if(!prs_uint32("size_y",   ps, depth, &f->size_y))
6103                         return False;
6104                 if(!prs_uint32("left",     ps, depth, &f->left))
6105                         return False;
6106                 if(!prs_uint32("top",      ps, depth, &f->top))
6107                         return False;
6108                 if(!prs_uint32("right",    ps, depth, &f->right))
6109                         return False;
6110                 if(!prs_uint32("bottom",   ps, depth, &f->bottom))
6111                         return False;
6112
6113                 if(!smb_io_unistr2("", &f->name, f->name_ptr, ps, depth))
6114                         return False;
6115         }
6116
6117         return True;
6118 }
6119
6120 /*******************************************************************
6121 ********************************************************************/
6122
6123 bool spoolss_io_q_deleteform(const char *desc, SPOOL_Q_DELETEFORM *q_u, prs_struct *ps, int depth)
6124 {
6125         prs_debug(ps, depth, desc, "spoolss_io_q_deleteform");
6126         depth++;
6127
6128         if(!prs_align(ps))
6129                 return False;
6130         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6131                 return False;
6132         if(!smb_io_unistr2("form name", &q_u->name, True, ps, depth))
6133                 return False;
6134
6135         return True;
6136 }
6137
6138 /*******************************************************************
6139 ********************************************************************/
6140
6141 bool spoolss_io_r_deleteform(const char *desc, SPOOL_R_DELETEFORM *r_u, prs_struct *ps, int depth)
6142 {
6143         prs_debug(ps, depth, desc, "spoolss_io_r_deleteform");
6144         depth++;
6145
6146         if(!prs_align(ps))
6147                 return False;
6148         if(!prs_werror("status",        ps, depth, &r_u->status))
6149                 return False;
6150
6151         return True;
6152 }
6153
6154 /*******************************************************************
6155 ********************************************************************/
6156
6157 bool spoolss_io_q_addform(const char *desc, SPOOL_Q_ADDFORM *q_u, prs_struct *ps, int depth)
6158 {
6159         uint32 useless_ptr=1;
6160         prs_debug(ps, depth, desc, "spoolss_io_q_addform");
6161         depth++;
6162
6163         if(!prs_align(ps))
6164                 return False;
6165         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6166                 return False;
6167         if(!prs_uint32("level",  ps, depth, &q_u->level))
6168                 return False;
6169         if(!prs_uint32("level2", ps, depth, &q_u->level2))
6170                 return False;
6171
6172         if (q_u->level==1)
6173         {
6174                 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
6175                         return False;
6176                 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
6177                         return False;
6178         }
6179
6180         return True;
6181 }
6182
6183 /*******************************************************************
6184 ********************************************************************/
6185
6186 bool spoolss_io_r_addform(const char *desc, SPOOL_R_ADDFORM *r_u, prs_struct *ps, int depth)
6187 {
6188         prs_debug(ps, depth, desc, "spoolss_io_r_addform");
6189         depth++;
6190
6191         if(!prs_align(ps))
6192                 return False;
6193         if(!prs_werror("status",        ps, depth, &r_u->status))
6194                 return False;
6195
6196         return True;
6197 }
6198
6199 /*******************************************************************
6200 ********************************************************************/
6201
6202 bool spoolss_io_q_setform(const char *desc, SPOOL_Q_SETFORM *q_u, prs_struct *ps, int depth)
6203 {
6204         uint32 useless_ptr=1;
6205         prs_debug(ps, depth, desc, "spoolss_io_q_setform");
6206         depth++;
6207
6208         if(!prs_align(ps))
6209                 return False;
6210         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6211                 return False;
6212         if(!smb_io_unistr2("", &q_u->name, True, ps, depth))
6213                 return False;
6214
6215         if(!prs_align(ps))
6216                 return False;
6217
6218         if(!prs_uint32("level",  ps, depth, &q_u->level))
6219                 return False;
6220         if(!prs_uint32("level2", ps, depth, &q_u->level2))
6221                 return False;
6222
6223         if (q_u->level==1)
6224         {
6225                 if(!prs_uint32("useless_ptr", ps, depth, &useless_ptr))
6226                         return False;
6227                 if(!spoolss_io_addform("", &q_u->form, useless_ptr, ps, depth))
6228                         return False;
6229         }
6230
6231         return True;
6232 }
6233
6234 /*******************************************************************
6235 ********************************************************************/
6236
6237 bool spoolss_io_r_setform(const char *desc, SPOOL_R_SETFORM *r_u, prs_struct *ps, int depth)
6238 {
6239         prs_debug(ps, depth, desc, "spoolss_io_r_setform");
6240         depth++;
6241
6242         if(!prs_align(ps))
6243                 return False;
6244         if(!prs_werror("status",        ps, depth, &r_u->status))
6245                 return False;
6246
6247         return True;
6248 }
6249
6250 /*******************************************************************
6251  Parse a SPOOL_R_GETJOB structure.
6252 ********************************************************************/
6253
6254 bool spoolss_io_r_getjob(const char *desc, SPOOL_R_GETJOB *r_u, prs_struct *ps, int depth)
6255 {
6256         prs_debug(ps, depth, desc, "spoolss_io_r_getjob");
6257         depth++;
6258
6259         if (!prs_align(ps))
6260                 return False;
6261
6262         if (!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
6263                 return False;
6264
6265         if (!prs_align(ps))
6266                 return False;
6267
6268         if (!prs_uint32("needed", ps, depth, &r_u->needed))
6269                 return False;
6270
6271         if (!prs_werror("status", ps, depth, &r_u->status))
6272                 return False;
6273
6274         return True;
6275 }
6276
6277 /*******************************************************************
6278  Parse a SPOOL_Q_GETJOB structure.
6279 ********************************************************************/
6280
6281 bool spoolss_io_q_getjob(const char *desc, SPOOL_Q_GETJOB *q_u, prs_struct *ps, int depth)
6282 {
6283         prs_debug(ps, depth, desc, "");
6284         depth++;
6285
6286         if(!prs_align(ps))
6287                 return False;
6288
6289         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6290                 return False;
6291         if(!prs_uint32("jobid", ps, depth, &q_u->jobid))
6292                 return False;
6293         if(!prs_uint32("level", ps, depth, &q_u->level))
6294                 return False;
6295
6296         if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
6297                 return False;
6298
6299         if(!prs_align(ps))
6300                 return False;
6301
6302         if(!prs_uint32("offered", ps, depth, &q_u->offered))
6303                 return False;
6304
6305         return True;
6306 }
6307
6308 void free_devmode(DEVICEMODE *devmode)
6309 {
6310         if (devmode!=NULL) {
6311                 SAFE_FREE(devmode->dev_private);
6312                 SAFE_FREE(devmode);
6313         }
6314 }
6315
6316 void free_printer_info_1(PRINTER_INFO_1 *printer)
6317 {
6318         SAFE_FREE(printer);
6319 }
6320
6321 void free_printer_info_2(PRINTER_INFO_2 *printer)
6322 {
6323         if (printer!=NULL) {
6324                 free_devmode(printer->devmode);
6325                 printer->devmode = NULL;
6326                 SAFE_FREE(printer);
6327         }
6328 }
6329
6330 void free_printer_info_3(PRINTER_INFO_3 *printer)
6331 {
6332         SAFE_FREE(printer);
6333 }
6334
6335 void free_printer_info_4(PRINTER_INFO_4 *printer)
6336 {
6337         SAFE_FREE(printer);
6338 }
6339
6340 void free_printer_info_5(PRINTER_INFO_5 *printer)
6341 {
6342         SAFE_FREE(printer);
6343 }
6344
6345 void free_printer_info_6(PRINTER_INFO_6 *printer)
6346 {
6347         SAFE_FREE(printer);
6348 }
6349
6350 void free_printer_info_7(PRINTER_INFO_7 *printer)
6351 {
6352         SAFE_FREE(printer);
6353 }
6354
6355 void free_job_info_2(JOB_INFO_2 *job)
6356 {
6357     if (job!=NULL)
6358         free_devmode(job->devmode);
6359 }
6360
6361 /*******************************************************************
6362  * init a structure.
6363  ********************************************************************/
6364
6365 bool make_spoolss_q_replyopenprinter(SPOOL_Q_REPLYOPENPRINTER *q_u,
6366                                const fstring string, uint32 printer, uint32 type)
6367 {
6368         if (q_u == NULL)
6369                 return False;
6370
6371         init_unistr2(&q_u->string, string, UNI_STR_TERMINATE);
6372
6373         q_u->printer=printer;
6374         q_u->type=type;
6375
6376         q_u->unknown0=0x0;
6377         q_u->unknown1=0x0;
6378
6379         return True;
6380 }
6381
6382 /*******************************************************************
6383  Parse a SPOOL_Q_REPLYOPENPRINTER structure.
6384 ********************************************************************/
6385
6386 bool spoolss_io_q_replyopenprinter(const char *desc, SPOOL_Q_REPLYOPENPRINTER *q_u, prs_struct *ps, int depth)
6387 {
6388         prs_debug(ps, depth, desc, "spoolss_io_q_replyopenprinter");
6389         depth++;
6390
6391         if(!prs_align(ps))
6392                 return False;
6393
6394         if(!smb_io_unistr2("", &q_u->string, True, ps, depth))
6395                 return False;
6396
6397         if(!prs_align(ps))
6398                 return False;
6399
6400         if(!prs_uint32("printer", ps, depth, &q_u->printer))
6401                 return False;
6402         if(!prs_uint32("type", ps, depth, &q_u->type))
6403                 return False;
6404
6405         if(!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6406                 return False;
6407         if(!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6408                 return False;
6409
6410         return True;
6411 }
6412
6413 /*******************************************************************
6414  Parse a SPOOL_R_REPLYOPENPRINTER structure.
6415 ********************************************************************/
6416
6417 bool spoolss_io_r_replyopenprinter(const char *desc, SPOOL_R_REPLYOPENPRINTER *r_u, prs_struct *ps, int depth)
6418 {
6419         prs_debug(ps, depth, desc, "spoolss_io_r_replyopenprinter");
6420         depth++;
6421
6422         if (!prs_align(ps))
6423                 return False;
6424
6425         if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6426                 return False;
6427
6428         if (!prs_werror("status", ps, depth, &r_u->status))
6429                 return False;
6430
6431         return True;
6432 }
6433
6434 /*******************************************************************
6435  * init a structure.
6436  ********************************************************************/
6437 bool make_spoolss_q_routerreplyprinter(SPOOL_Q_ROUTERREPLYPRINTER *q_u, POLICY_HND *hnd,
6438                                         uint32 condition, uint32 change_id)
6439 {
6440
6441         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6442
6443         q_u->condition = condition;
6444         q_u->change_id = change_id;
6445
6446         /* magic values */
6447         q_u->unknown1 = 0x1;
6448         memset(q_u->unknown2, 0x0, 5);
6449         q_u->unknown2[0] = 0x1;
6450
6451         return True;
6452 }
6453
6454 /*******************************************************************
6455  Parse a SPOOL_Q_ROUTERREPLYPRINTER structure.
6456 ********************************************************************/
6457 bool spoolss_io_q_routerreplyprinter (const char *desc, SPOOL_Q_ROUTERREPLYPRINTER *q_u, prs_struct *ps, int depth)
6458 {
6459
6460         prs_debug(ps, depth, desc, "spoolss_io_q_routerreplyprinter");
6461         depth++;
6462
6463         if (!prs_align(ps))
6464                 return False;
6465
6466         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6467                 return False;
6468
6469         if (!prs_uint32("condition", ps, depth, &q_u->condition))
6470                 return False;
6471
6472         if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6473                 return False;
6474
6475         if (!prs_uint32("change_id", ps, depth, &q_u->change_id))
6476                 return False;
6477
6478         if (!prs_uint8s(False, "dev_private",  ps, depth, q_u->unknown2, 5))
6479                 return False;
6480
6481         return True;
6482 }
6483
6484 /*******************************************************************
6485  Parse a SPOOL_R_ROUTERREPLYPRINTER structure.
6486 ********************************************************************/
6487 bool spoolss_io_r_routerreplyprinter (const char *desc, SPOOL_R_ROUTERREPLYPRINTER *r_u, prs_struct *ps, int depth)
6488 {
6489         prs_debug(ps, depth, desc, "spoolss_io_r_routerreplyprinter");
6490         depth++;
6491
6492         if (!prs_align(ps))
6493                 return False;
6494
6495         if (!prs_werror("status", ps, depth, &r_u->status))
6496                 return False;
6497
6498         return True;
6499 }
6500
6501 /*******************************************************************
6502  * init a structure.
6503  ********************************************************************/
6504
6505 bool make_spoolss_q_reply_closeprinter(SPOOL_Q_REPLYCLOSEPRINTER *q_u, POLICY_HND *hnd)
6506 {
6507         if (q_u == NULL)
6508                 return False;
6509
6510         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6511
6512         return True;
6513 }
6514
6515 /*******************************************************************
6516  Parse a SPOOL_Q_REPLYCLOSEPRINTER structure.
6517 ********************************************************************/
6518
6519 bool spoolss_io_q_replycloseprinter(const char *desc, SPOOL_Q_REPLYCLOSEPRINTER *q_u, prs_struct *ps, int depth)
6520 {
6521         prs_debug(ps, depth, desc, "spoolss_io_q_replycloseprinter");
6522         depth++;
6523
6524         if(!prs_align(ps))
6525                 return False;
6526
6527         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6528                 return False;
6529
6530         return True;
6531 }
6532
6533 /*******************************************************************
6534  Parse a SPOOL_R_REPLYCLOSEPRINTER structure.
6535 ********************************************************************/
6536
6537 bool spoolss_io_r_replycloseprinter(const char *desc, SPOOL_R_REPLYCLOSEPRINTER *r_u, prs_struct *ps, int depth)
6538 {
6539         prs_debug(ps, depth, desc, "spoolss_io_r_replycloseprinter");
6540         depth++;
6541
6542         if (!prs_align(ps))
6543                 return False;
6544
6545         if(!smb_io_pol_hnd("printer handle",&r_u->handle,ps,depth))
6546                 return False;
6547
6548         if (!prs_werror("status", ps, depth, &r_u->status))
6549                 return False;
6550
6551         return True;
6552 }
6553
6554 #if 0   /* JERRY - not currently used but could be :-) */
6555
6556 /*******************************************************************
6557  Deep copy a SPOOL_NOTIFY_INFO_DATA structure
6558  ******************************************************************/
6559 static bool copy_spool_notify_info_data(SPOOL_NOTIFY_INFO_DATA *dst,
6560                                 SPOOL_NOTIFY_INFO_DATA *src, int n)
6561 {
6562         int i;
6563
6564         memcpy(dst, src, sizeof(SPOOL_NOTIFY_INFO_DATA)*n);
6565
6566         for (i=0; i<n; i++) {
6567                 int len;
6568                 uint16 *s = NULL;
6569
6570                 if (src->size != POINTER)
6571                         continue;
6572                 len = src->notify_data.data.length;
6573                 s = SMB_MALLOC_ARRAY(uint16, len);
6574                 if (s == NULL) {
6575                         DEBUG(0,("copy_spool_notify_info_data: malloc() failed!\n"));
6576                         return False;
6577                 }
6578
6579                 memcpy(s, src->notify_data.data.string, len*2);
6580                 dst->notify_data.data.string = s;
6581         }
6582
6583         return True;
6584 }
6585
6586 /*******************************************************************
6587  Deep copy a SPOOL_NOTIFY_INFO structure
6588  ******************************************************************/
6589 static bool copy_spool_notify_info(SPOOL_NOTIFY_INFO *dst, SPOOL_NOTIFY_INFO *src)
6590 {
6591         if (!dst) {
6592                 DEBUG(0,("copy_spool_notify_info: NULL destination pointer!\n"));
6593                 return False;
6594         }
6595
6596         dst->version = src->version;
6597         dst->flags   = src->flags;
6598         dst->count   = src->count;
6599
6600         if (dst->count)
6601         {
6602                 dst->data = SMB_MALLOC_ARRAY(SPOOL_NOTIFY_INFO_DATA, dst->count);
6603
6604                 DEBUG(10,("copy_spool_notify_info: allocating space for [%d] PRINTER_NOTIFY_INFO_DATA entries\n",
6605                         dst->count));
6606
6607                 if (dst->data == NULL) {
6608                         DEBUG(0,("copy_spool_notify_info: malloc() failed for [%d] entries!\n",
6609                                 dst->count));
6610                         return False;
6611                 }
6612
6613                 return (copy_spool_notify_info_data(dst->data, src->data, src->count));
6614         }
6615
6616         return True;
6617 }
6618 #endif  /* JERRY */
6619
6620 /*******************************************************************
6621  * init a structure.
6622  ********************************************************************/
6623
6624 bool make_spoolss_q_reply_rrpcn(SPOOL_Q_REPLY_RRPCN *q_u, POLICY_HND *hnd,
6625                                 uint32 change_low, uint32 change_high,
6626                                 SPOOL_NOTIFY_INFO *info)
6627 {
6628         if (q_u == NULL)
6629                 return False;
6630
6631         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6632
6633         q_u->change_low=change_low;
6634         q_u->change_high=change_high;
6635
6636         q_u->unknown0=0x0;
6637         q_u->unknown1=0x0;
6638
6639         q_u->info_ptr=0x0FF0ADDE;
6640
6641         q_u->info.version=2;
6642
6643         if (info->count) {
6644                 DEBUG(10,("make_spoolss_q_reply_rrpcn: [%d] PRINTER_NOTIFY_INFO_DATA\n",
6645                         info->count));
6646                 q_u->info.version = info->version;
6647                 q_u->info.flags   = info->flags;
6648                 q_u->info.count   = info->count;
6649                 /* pointer field - be careful! */
6650                 q_u->info.data    = info->data;
6651         }
6652         else  {
6653         q_u->info.flags=PRINTER_NOTIFY_INFO_DISCARDED;
6654         q_u->info.count=0;
6655         }
6656
6657         return True;
6658 }
6659
6660 /*******************************************************************
6661  Parse a SPOOL_Q_REPLY_RRPCN structure.
6662 ********************************************************************/
6663
6664 bool spoolss_io_q_reply_rrpcn(const char *desc, SPOOL_Q_REPLY_RRPCN *q_u, prs_struct *ps, int depth)
6665 {
6666         prs_debug(ps, depth, desc, "spoolss_io_q_reply_rrpcn");
6667         depth++;
6668
6669         if(!prs_align(ps))
6670                 return False;
6671
6672         if(!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6673                 return False;
6674
6675         if (!prs_uint32("change_low", ps, depth, &q_u->change_low))
6676                 return False;
6677
6678         if (!prs_uint32("change_high", ps, depth, &q_u->change_high))
6679                 return False;
6680
6681         if (!prs_uint32("unknown0", ps, depth, &q_u->unknown0))
6682                 return False;
6683
6684         if (!prs_uint32("unknown1", ps, depth, &q_u->unknown1))
6685                 return False;
6686
6687         if (!prs_uint32("info_ptr", ps, depth, &q_u->info_ptr))
6688                 return False;
6689
6690         if(q_u->info_ptr!=0)
6691                 if(!smb_io_notify_info(desc, &q_u->info, ps, depth))
6692                         return False;
6693
6694         return True;
6695 }
6696
6697 /*******************************************************************
6698  Parse a SPOOL_R_REPLY_RRPCN structure.
6699 ********************************************************************/
6700
6701 bool spoolss_io_r_reply_rrpcn(const char *desc, SPOOL_R_REPLY_RRPCN *r_u, prs_struct *ps, int depth)
6702 {
6703         prs_debug(ps, depth, desc, "spoolss_io_r_reply_rrpcn");
6704         depth++;
6705
6706         if (!prs_align(ps))
6707                 return False;
6708
6709         if (!prs_uint32("unknown0", ps, depth, &r_u->unknown0))
6710                 return False;
6711
6712         if (!prs_werror("status", ps, depth, &r_u->status))
6713                 return False;
6714
6715         return True;
6716 }
6717
6718 /*******************************************************************
6719  * read a structure.
6720  * called from spoolss_q_getprinterdataex (srv_spoolss.c)
6721  ********************************************************************/
6722
6723 bool spoolss_io_q_getprinterdataex(const char *desc, SPOOL_Q_GETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6724 {
6725         if (q_u == NULL)
6726                 return False;
6727
6728         prs_debug(ps, depth, desc, "spoolss_io_q_getprinterdataex");
6729         depth++;
6730
6731         if (!prs_align(ps))
6732                 return False;
6733         if (!smb_io_pol_hnd("printer handle",&q_u->handle,ps,depth))
6734                 return False;
6735         if (!prs_align(ps))
6736                 return False;
6737         if (!smb_io_unistr2("keyname", &q_u->keyname,True,ps,depth))
6738                 return False;
6739         if (!prs_align(ps))
6740                 return False;
6741         if (!smb_io_unistr2("valuename", &q_u->valuename,True,ps,depth))
6742                 return False;
6743         if (!prs_align(ps))
6744                 return False;
6745         if (!prs_uint32("size", ps, depth, &q_u->size))
6746                 return False;
6747
6748         return True;
6749 }
6750
6751 /*******************************************************************
6752  * write a structure.
6753  * called from spoolss_r_getprinterdataex (srv_spoolss.c)
6754  ********************************************************************/
6755
6756 bool spoolss_io_r_getprinterdataex(const char *desc, SPOOL_R_GETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6757 {
6758         if (r_u == NULL)
6759                 return False;
6760
6761         prs_debug(ps, depth, desc, "spoolss_io_r_getprinterdataex");
6762         depth++;
6763
6764         if (!prs_align(ps))
6765                 return False;
6766         if (!prs_uint32("type", ps, depth, &r_u->type))
6767                 return False;
6768         if (!prs_uint32("size", ps, depth, &r_u->size))
6769                 return False;
6770
6771         if (UNMARSHALLING(ps) && r_u->size) {
6772                 r_u->data = PRS_ALLOC_MEM(ps, unsigned char, r_u->size);
6773                 if(!r_u->data)
6774                         return False;
6775         }
6776
6777         if (!prs_uint8s(False,"data", ps, depth, r_u->data, r_u->size))
6778                 return False;
6779
6780         if (!prs_align(ps))
6781                 return False;
6782
6783         if (!prs_uint32("needed", ps, depth, &r_u->needed))
6784                 return False;
6785         if (!prs_werror("status", ps, depth, &r_u->status))
6786                 return False;
6787
6788         return True;
6789 }
6790
6791 /*******************************************************************
6792  * read a structure.
6793  ********************************************************************/
6794
6795 bool spoolss_io_q_setprinterdataex(const char *desc, SPOOL_Q_SETPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6796 {
6797         prs_debug(ps, depth, desc, "spoolss_io_q_setprinterdataex");
6798         depth++;
6799
6800         if(!prs_align(ps))
6801                 return False;
6802         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6803                 return False;
6804         if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6805                 return False;
6806
6807         if(!prs_align(ps))
6808                 return False;
6809
6810         if(!smb_io_unistr2("", &q_u->value, True, ps, depth))
6811                 return False;
6812
6813         if(!prs_align(ps))
6814                 return False;
6815
6816         if(!prs_uint32("type", ps, depth, &q_u->type))
6817                 return False;
6818
6819         if(!prs_uint32("max_len", ps, depth, &q_u->max_len))
6820                 return False;
6821
6822         switch (q_u->type)
6823         {
6824                 case 0x1:
6825                 case 0x3:
6826                 case 0x4:
6827                 case 0x7:
6828                         if (q_u->max_len) {
6829                                 if (UNMARSHALLING(ps))
6830                                         q_u->data=PRS_ALLOC_MEM(ps, uint8, q_u->max_len);
6831                                 if(q_u->data == NULL)
6832                                         return False;
6833                                 if(!prs_uint8s(False,"data", ps, depth, q_u->data, q_u->max_len))
6834                                         return False;
6835                         }
6836                         if(!prs_align(ps))
6837                                 return False;
6838                         break;
6839         }
6840
6841         if(!prs_uint32("real_len", ps, depth, &q_u->real_len))
6842                 return False;
6843
6844         return True;
6845 }
6846
6847 /*******************************************************************
6848  * write a structure.
6849  ********************************************************************/
6850
6851 bool spoolss_io_r_setprinterdataex(const char *desc, SPOOL_R_SETPRINTERDATAEX *r_u, prs_struct *ps, int depth)
6852 {
6853         prs_debug(ps, depth, desc, "spoolss_io_r_setprinterdataex");
6854         depth++;
6855
6856         if(!prs_align(ps))
6857                 return False;
6858         if(!prs_werror("status",     ps, depth, &r_u->status))
6859                 return False;
6860
6861         return True;
6862 }
6863
6864 /*******************************************************************
6865  * read a structure.
6866  ********************************************************************/
6867 bool make_spoolss_q_enumprinterkey(SPOOL_Q_ENUMPRINTERKEY *q_u,
6868                                    POLICY_HND *hnd, const char *key,
6869                                    uint32 size)
6870 {
6871         DEBUG(5,("make_spoolss_q_enumprinterkey\n"));
6872
6873         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6874         init_unistr2(&q_u->key, key, UNI_STR_TERMINATE);
6875         q_u->size = size;
6876
6877         return True;
6878 }
6879
6880 /*******************************************************************
6881  * read a structure.
6882  ********************************************************************/
6883
6884 bool spoolss_io_q_enumprinterkey(const char *desc, SPOOL_Q_ENUMPRINTERKEY *q_u, prs_struct *ps, int depth)
6885 {
6886         prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterkey");
6887         depth++;
6888
6889         if(!prs_align(ps))
6890                 return False;
6891         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6892                 return False;
6893
6894         if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
6895                 return False;
6896
6897         if(!prs_align(ps))
6898                 return False;
6899
6900         if(!prs_uint32("size", ps, depth, &q_u->size))
6901                 return False;
6902
6903         return True;
6904 }
6905
6906 /*******************************************************************
6907  * write a structure.
6908  ********************************************************************/
6909
6910 bool spoolss_io_r_enumprinterkey(const char *desc, SPOOL_R_ENUMPRINTERKEY *r_u, prs_struct *ps, int depth)
6911 {
6912         prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterkey");
6913         depth++;
6914
6915         if(!prs_align(ps))
6916                 return False;
6917
6918         if (!smb_io_buffer5("", &r_u->keys, ps, depth))
6919                 return False;
6920
6921         if(!prs_align(ps))
6922                 return False;
6923
6924         if(!prs_uint32("needed",     ps, depth, &r_u->needed))
6925                 return False;
6926
6927         if(!prs_werror("status",     ps, depth, &r_u->status))
6928                 return False;
6929
6930         return True;
6931 }
6932
6933 /*******************************************************************
6934  * read a structure.
6935  ********************************************************************/
6936
6937 bool make_spoolss_q_deleteprinterkey(SPOOL_Q_DELETEPRINTERKEY *q_u,
6938                                      POLICY_HND *hnd, char *keyname)
6939 {
6940         DEBUG(5,("make_spoolss_q_deleteprinterkey\n"));
6941
6942         memcpy(&q_u->handle, hnd, sizeof(q_u->handle));
6943         init_unistr2(&q_u->keyname, keyname, UNI_STR_TERMINATE);
6944
6945         return True;
6946 }
6947
6948 /*******************************************************************
6949  * read a structure.
6950  ********************************************************************/
6951
6952 bool spoolss_io_q_deleteprinterkey(const char *desc, SPOOL_Q_DELETEPRINTERKEY *q_u, prs_struct *ps, int depth)
6953 {
6954         prs_debug(ps, depth, desc, "spoolss_io_q_deleteprinterkey");
6955         depth++;
6956
6957         if(!prs_align(ps))
6958                 return False;
6959         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6960                 return False;
6961
6962         if(!smb_io_unistr2("", &q_u->keyname, True, ps, depth))
6963                 return False;
6964
6965         return True;
6966 }
6967
6968 /*******************************************************************
6969  * write a structure.
6970  ********************************************************************/
6971
6972 bool spoolss_io_r_deleteprinterkey(const char *desc, SPOOL_R_DELETEPRINTERKEY *r_u, prs_struct *ps, int depth)
6973 {
6974         prs_debug(ps, depth, desc, "spoolss_io_r_deleteprinterkey");
6975         depth++;
6976
6977         if(!prs_align(ps))
6978                 return False;
6979
6980         if(!prs_werror("status",     ps, depth, &r_u->status))
6981                 return False;
6982
6983         return True;
6984 }
6985
6986
6987 /*******************************************************************
6988  * read a structure.
6989  ********************************************************************/
6990
6991 bool spoolss_io_q_enumprinterdataex(const char *desc, SPOOL_Q_ENUMPRINTERDATAEX *q_u, prs_struct *ps, int depth)
6992 {
6993         prs_debug(ps, depth, desc, "spoolss_io_q_enumprinterdataex");
6994         depth++;
6995
6996         if(!prs_align(ps))
6997                 return False;
6998         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
6999                 return False;
7000
7001         if(!smb_io_unistr2("", &q_u->key, True, ps, depth))
7002                 return False;
7003
7004         if(!prs_align(ps))
7005                 return False;
7006
7007         if(!prs_uint32("size", ps, depth, &q_u->size))
7008                 return False;
7009
7010         return True;
7011 }
7012
7013 /*******************************************************************
7014 ********************************************************************/
7015
7016 static bool spoolss_io_printer_enum_values_ctr(const char *desc, prs_struct *ps,
7017                                 PRINTER_ENUM_VALUES_CTR *ctr, int depth)
7018 {
7019         int     i;
7020         uint32  valuename_offset,
7021                 data_offset,
7022                 current_offset;
7023         const uint32 basic_unit = 20; /* size of static portion of enum_values */
7024
7025         prs_debug(ps, depth, desc, "spoolss_io_printer_enum_values_ctr");
7026         depth++;
7027
7028         /*
7029          * offset data begins at 20 bytes per structure * size_of_array.
7030          * Don't forget the uint32 at the beginning
7031          * */
7032
7033         current_offset = basic_unit * ctr->size_of_array;
7034
7035         /* first loop to write basic enum_value information */
7036
7037         if (UNMARSHALLING(ps) && ctr->size_of_array) {
7038                 ctr->values = PRS_ALLOC_MEM(ps, PRINTER_ENUM_VALUES, ctr->size_of_array);
7039                 if (!ctr->values)
7040                         return False;
7041         }
7042
7043         for (i=0; i<ctr->size_of_array; i++) {
7044                 uint32 base_offset, return_offset;
7045
7046                 base_offset = prs_offset(ps);
7047
7048                 valuename_offset = current_offset;
7049                 if (!prs_uint32("valuename_offset", ps, depth, &valuename_offset))
7050                         return False;
7051
7052                 /* Read or write the value. */
7053
7054                 return_offset = prs_offset(ps);
7055
7056                 if (!prs_set_offset(ps, base_offset + valuename_offset)) {
7057                         return False;
7058                 }
7059
7060                 if (!prs_unistr("valuename", ps, depth, &ctr->values[i].valuename))
7061                         return False;
7062
7063                 /* And go back. */
7064                 if (!prs_set_offset(ps, return_offset))
7065                         return False;
7066
7067                 if (!prs_uint32("value_len", ps, depth, &ctr->values[i].value_len))
7068                         return False;
7069
7070                 if (!prs_uint32("type", ps, depth, &ctr->values[i].type))
7071                         return False;
7072
7073                 data_offset = ctr->values[i].value_len + valuename_offset;
7074
7075                 if (!prs_uint32("data_offset", ps, depth, &data_offset))
7076                         return False;
7077
7078                 if (!prs_uint32("data_len", ps, depth, &ctr->values[i].data_len))
7079                         return False;
7080
7081                 /* Read or write the data. */
7082
7083                 return_offset = prs_offset(ps);
7084
7085                 if (!prs_set_offset(ps, base_offset + data_offset)) {
7086                         return False;
7087                 }
7088
7089                 if ( ctr->values[i].data_len ) {
7090                         if ( UNMARSHALLING(ps) ) {
7091                                 ctr->values[i].data = PRS_ALLOC_MEM(ps, uint8, ctr->values[i].data_len);
7092                                 if (!ctr->values[i].data)
7093                                         return False;
7094                         }
7095                         if (!prs_uint8s(False, "data", ps, depth, ctr->values[i].data, ctr->values[i].data_len))
7096                                 return False;
7097                 }
7098
7099                 current_offset  = data_offset + ctr->values[i].data_len - basic_unit;
7100                 /* account for 2 byte alignment */
7101                 current_offset += (current_offset % 2);
7102
7103                 /* Remember how far we got. */
7104                 data_offset = prs_offset(ps);
7105
7106                 /* And go back. */
7107                 if (!prs_set_offset(ps, return_offset))
7108                         return False;
7109
7110         }
7111
7112         /* Go to the last data offset we got to. */
7113
7114         if (!prs_set_offset(ps, data_offset))
7115                 return False;
7116
7117         /* And ensure we're 2 byte aligned. */
7118
7119         if ( !prs_align_uint16(ps) )
7120                 return False;
7121
7122         return True;
7123 }
7124
7125 /*******************************************************************
7126  * write a structure.
7127  ********************************************************************/
7128
7129 bool spoolss_io_r_enumprinterdataex(const char *desc, SPOOL_R_ENUMPRINTERDATAEX *r_u, prs_struct *ps, int depth)
7130 {
7131         uint32 data_offset, end_offset;
7132         prs_debug(ps, depth, desc, "spoolss_io_r_enumprinterdataex");
7133         depth++;
7134
7135         if(!prs_align(ps))
7136                 return False;
7137
7138         if (!prs_uint32("size", ps, depth, &r_u->ctr.size))
7139                 return False;
7140
7141         data_offset = prs_offset(ps);
7142
7143         if (!prs_set_offset(ps, data_offset + r_u->ctr.size))
7144                 return False;
7145
7146         if(!prs_align(ps))
7147                 return False;
7148
7149         if(!prs_uint32("needed",     ps, depth, &r_u->needed))
7150                 return False;
7151
7152         if(!prs_uint32("returned",   ps, depth, &r_u->returned))
7153                 return False;
7154
7155         if(!prs_werror("status",     ps, depth, &r_u->status))
7156                 return False;
7157
7158         r_u->ctr.size_of_array = r_u->returned;
7159
7160         end_offset = prs_offset(ps);
7161
7162         if (!prs_set_offset(ps, data_offset))
7163                 return False;
7164
7165         if (r_u->ctr.size)
7166                 if (!spoolss_io_printer_enum_values_ctr("", ps, &r_u->ctr, depth ))
7167                         return False;
7168
7169         if (!prs_set_offset(ps, end_offset))
7170                 return False;
7171         return True;
7172 }
7173
7174 /*******************************************************************
7175  * write a structure.
7176  ********************************************************************/
7177
7178 /*
7179    uint32 GetPrintProcessorDirectory(
7180        [in] unistr2 *name,
7181        [in] unistr2 *environment,
7182        [in] uint32 level,
7183        [in,out] RPC_BUFFER buffer,
7184        [in] uint32 offered,
7185        [out] uint32 needed,
7186        [out] uint32 returned
7187    );
7188
7189 */
7190
7191 bool make_spoolss_q_getprintprocessordirectory(SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, const char *name, char *environment, int level, RPC_BUFFER *buffer, uint32 offered)
7192 {
7193         DEBUG(5,("make_spoolss_q_getprintprocessordirectory\n"));
7194
7195         init_unistr2(&q_u->name, name, UNI_STR_TERMINATE);
7196         init_unistr2(&q_u->environment, environment, UNI_STR_TERMINATE);
7197
7198         q_u->level = level;
7199
7200         q_u->buffer = buffer;
7201         q_u->offered = offered;
7202
7203         return True;
7204 }
7205
7206 bool spoolss_io_q_getprintprocessordirectory(const char *desc, SPOOL_Q_GETPRINTPROCESSORDIRECTORY *q_u, prs_struct *ps, int depth)
7207 {
7208         uint32 ptr;
7209
7210         prs_debug(ps, depth, desc, "spoolss_io_q_getprintprocessordirectory");
7211         depth++;
7212
7213         if(!prs_align(ps))
7214                 return False;
7215
7216         if (!prs_uint32("ptr", ps, depth, &ptr))
7217                 return False;
7218
7219         if (ptr) {
7220                 if(!smb_io_unistr2("name", &q_u->name, True, ps, depth))
7221                         return False;
7222         }
7223
7224         if (!prs_align(ps))
7225                 return False;
7226
7227         if (!prs_uint32("ptr", ps, depth, &ptr))
7228                 return False;
7229
7230         if (ptr) {
7231                 if(!smb_io_unistr2("environment", &q_u->environment, True,
7232                                    ps, depth))
7233                         return False;
7234         }
7235
7236         if (!prs_align(ps))
7237                 return False;
7238
7239         if(!prs_uint32("level",   ps, depth, &q_u->level))
7240                 return False;
7241
7242         if(!prs_rpcbuffer_p("", ps, depth, &q_u->buffer))
7243                 return False;
7244
7245         if(!prs_align(ps))
7246                 return False;
7247
7248         if(!prs_uint32("offered", ps, depth, &q_u->offered))
7249                 return False;
7250
7251         return True;
7252 }
7253
7254 /*******************************************************************
7255  * write a structure.
7256  ********************************************************************/
7257
7258 bool spoolss_io_r_getprintprocessordirectory(const char *desc, SPOOL_R_GETPRINTPROCESSORDIRECTORY *r_u, prs_struct *ps, int depth)
7259 {
7260         prs_debug(ps, depth, desc, "spoolss_io_r_getprintprocessordirectory");
7261         depth++;
7262
7263         if(!prs_align(ps))
7264                 return False;
7265
7266         if(!prs_rpcbuffer_p("", ps, depth, &r_u->buffer))
7267                 return False;
7268
7269         if(!prs_align(ps))
7270                 return False;
7271
7272         if(!prs_uint32("needed",     ps, depth, &r_u->needed))
7273                 return False;
7274
7275         if(!prs_werror("status",     ps, depth, &r_u->status))
7276                 return False;
7277
7278         return True;
7279 }
7280
7281 bool smb_io_printprocessordirectory_1(const char *desc, RPC_BUFFER *buffer, PRINTPROCESSOR_DIRECTORY_1 *info, int depth)
7282 {
7283         prs_struct *ps=&buffer->prs;
7284
7285         prs_debug(ps, depth, desc, "smb_io_printprocessordirectory_1");
7286         depth++;
7287
7288         buffer->struct_start=prs_offset(ps);
7289
7290         if (!smb_io_unistr(desc, &info->name, ps, depth))
7291                 return False;
7292
7293         return True;
7294 }
7295
7296 /*******************************************************************
7297  * init a structure.
7298  ********************************************************************/
7299
7300 bool make_spoolss_q_addform(SPOOL_Q_ADDFORM *q_u, POLICY_HND *handle,
7301                             int level, FORM *form)
7302 {
7303         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7304         q_u->level = level;
7305         q_u->level2 = level;
7306         memcpy(&q_u->form, form, sizeof(FORM));
7307
7308         return True;
7309 }
7310
7311 /*******************************************************************
7312  * init a structure.
7313  ********************************************************************/
7314
7315 bool make_spoolss_q_setform(SPOOL_Q_SETFORM *q_u, POLICY_HND *handle,
7316                             int level, const char *form_name, FORM *form)
7317 {
7318         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7319         q_u->level = level;
7320         q_u->level2 = level;
7321         memcpy(&q_u->form, form, sizeof(FORM));
7322         init_unistr2(&q_u->name, form_name, UNI_STR_TERMINATE);
7323
7324         return True;
7325 }
7326
7327 /*******************************************************************
7328  * init a structure.
7329  ********************************************************************/
7330
7331 bool make_spoolss_q_deleteform(SPOOL_Q_DELETEFORM *q_u, POLICY_HND *handle,
7332                                const char *form)
7333 {
7334         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7335         init_unistr2(&q_u->name, form, UNI_STR_TERMINATE);
7336         return True;
7337 }
7338
7339 /*******************************************************************
7340  * init a structure.
7341  ********************************************************************/
7342
7343 bool make_spoolss_q_getform(SPOOL_Q_GETFORM *q_u, POLICY_HND *handle,
7344                             const char *formname, uint32 level,
7345                             RPC_BUFFER *buffer, uint32 offered)
7346 {
7347         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7348         q_u->level = level;
7349         init_unistr2(&q_u->formname, formname, UNI_STR_TERMINATE);
7350         q_u->buffer=buffer;
7351         q_u->offered=offered;
7352
7353         return True;
7354 }
7355
7356 /*******************************************************************
7357  * init a structure.
7358  ********************************************************************/
7359
7360 bool make_spoolss_q_enumforms(SPOOL_Q_ENUMFORMS *q_u, POLICY_HND *handle,
7361                               uint32 level, RPC_BUFFER *buffer,
7362                               uint32 offered)
7363 {
7364         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7365         q_u->level = level;
7366         q_u->buffer=buffer;
7367         q_u->offered=offered;
7368
7369         return True;
7370 }
7371
7372 /*******************************************************************
7373  * init a structure.
7374  ********************************************************************/
7375
7376 bool make_spoolss_q_setjob(SPOOL_Q_SETJOB *q_u, POLICY_HND *handle,
7377                            uint32 jobid, uint32 level, uint32 command)
7378 {
7379         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7380         q_u->jobid = jobid;
7381         q_u->level = level;
7382
7383         /* Hmm - the SPOOL_Q_SETJOB structure has a JOB_INFO ctr in it but
7384            the server side code has it marked as unused. */
7385
7386         q_u->command = command;
7387
7388         return True;
7389 }
7390
7391 /*******************************************************************
7392  * init a structure.
7393  ********************************************************************/
7394
7395 bool make_spoolss_q_getjob(SPOOL_Q_GETJOB *q_u, POLICY_HND *handle,
7396                            uint32 jobid, uint32 level, RPC_BUFFER *buffer,
7397                            uint32 offered)
7398 {
7399         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7400         q_u->jobid = jobid;
7401         q_u->level = level;
7402         q_u->buffer = buffer;
7403         q_u->offered = offered;
7404
7405         return True;
7406 }
7407
7408 /*******************************************************************
7409  * init a structure.
7410  ********************************************************************/
7411
7412 bool make_spoolss_q_startpageprinter(SPOOL_Q_STARTPAGEPRINTER *q_u,
7413                                      POLICY_HND *handle)
7414 {
7415         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7416
7417         return True;
7418 }
7419
7420 /*******************************************************************
7421  * init a structure.
7422  ********************************************************************/
7423
7424 bool make_spoolss_q_endpageprinter(SPOOL_Q_ENDPAGEPRINTER *q_u,
7425                                    POLICY_HND *handle)
7426 {
7427         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7428
7429         return True;
7430 }
7431
7432 /*******************************************************************
7433  * init a structure.
7434  ********************************************************************/
7435
7436 bool make_spoolss_q_startdocprinter(SPOOL_Q_STARTDOCPRINTER *q_u,
7437                                     POLICY_HND *handle, uint32 level,
7438                                     char *docname, char *outputfile,
7439                                     char *datatype)
7440 {
7441         DOC_INFO_CONTAINER *ctr = &q_u->doc_info_container;
7442
7443         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7444
7445         ctr->level = level;
7446
7447         switch (level) {
7448         case 1:
7449                 ctr->docinfo.switch_value = level;
7450
7451                 ctr->docinfo.doc_info_1.p_docname = docname ? 1 : 0;
7452                 ctr->docinfo.doc_info_1.p_outputfile = outputfile ? 1 : 0;
7453                 ctr->docinfo.doc_info_1.p_datatype = datatype ? 1 : 0;
7454
7455                 init_unistr2(&ctr->docinfo.doc_info_1.docname, docname, UNI_STR_TERMINATE);
7456                 init_unistr2(&ctr->docinfo.doc_info_1.outputfile, outputfile, UNI_STR_TERMINATE);
7457                 init_unistr2(&ctr->docinfo.doc_info_1.datatype, datatype, UNI_STR_TERMINATE);
7458
7459                 break;
7460         case 2:
7461                 /* DOC_INFO_2 is only used by Windows 9x and since it
7462                    doesn't do printing over RPC we don't have to worry
7463                    about it. */
7464         default:
7465                 DEBUG(3, ("unsupported info level %d\n", level));
7466                 return False;
7467         }
7468
7469         return True;
7470 }
7471
7472 /*******************************************************************
7473  * init a structure.
7474  ********************************************************************/
7475
7476 bool make_spoolss_q_enddocprinter(SPOOL_Q_ENDDOCPRINTER *q_u,
7477                                   POLICY_HND *handle)
7478 {
7479         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7480
7481         return True;
7482 }
7483
7484 /*******************************************************************
7485  * init a structure.
7486  ********************************************************************/
7487
7488 bool make_spoolss_q_writeprinter(SPOOL_Q_WRITEPRINTER *q_u,
7489                                  POLICY_HND *handle, uint32 data_size,
7490                                  char *data)
7491 {
7492         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7493         q_u->buffer_size = q_u->buffer_size2 = data_size;
7494         q_u->buffer = (unsigned char *)data;
7495         return True;
7496 }
7497
7498 /*******************************************************************
7499  * init a structure.
7500  ********************************************************************/
7501
7502 bool make_spoolss_q_deleteprinterdata(SPOOL_Q_DELETEPRINTERDATA *q_u,
7503                                  POLICY_HND *handle, char *valuename)
7504 {
7505         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7506         init_unistr2(&q_u->valuename, valuename, UNI_STR_TERMINATE);
7507
7508         return True;
7509 }
7510
7511 /*******************************************************************
7512  * init a structure.
7513  ********************************************************************/
7514
7515 bool make_spoolss_q_deleteprinterdataex(SPOOL_Q_DELETEPRINTERDATAEX *q_u,
7516                                         POLICY_HND *handle, char *key,
7517                                         char *value)
7518 {
7519         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7520         init_unistr2(&q_u->valuename, value, UNI_STR_TERMINATE);
7521         init_unistr2(&q_u->keyname, key, UNI_STR_TERMINATE);
7522
7523         return True;
7524 }
7525
7526 /*******************************************************************
7527  * init a structure.
7528  ********************************************************************/
7529
7530 bool make_spoolss_q_rffpcnex(SPOOL_Q_RFFPCNEX *q_u, POLICY_HND *handle,
7531                              uint32 flags, uint32 options, const char *localmachine,
7532                              uint32 printerlocal, SPOOL_NOTIFY_OPTION *option)
7533 {
7534         memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
7535
7536         q_u->flags = flags;
7537         q_u->options = options;
7538
7539         q_u->localmachine_ptr = 1;
7540
7541         init_unistr2(&q_u->localmachine, localmachine, UNI_STR_TERMINATE);
7542
7543         q_u->printerlocal = printerlocal;
7544
7545         if (option)
7546                 q_u->option_ptr = 1;
7547
7548         q_u->option = option;
7549
7550         return True;
7551 }
7552
7553
7554 /*******************************************************************
7555  ********************************************************************/
7556
7557 bool spoolss_io_q_xcvdataport(const char *desc, SPOOL_Q_XCVDATAPORT *q_u, prs_struct *ps, int depth)
7558 {
7559         prs_debug(ps, depth, desc, "spoolss_io_q_xcvdataport");
7560         depth++;
7561
7562         if(!prs_align(ps))
7563                 return False;
7564
7565         if(!smb_io_pol_hnd("printer handle", &q_u->handle, ps, depth))
7566                 return False;
7567
7568         if(!smb_io_unistr2("", &q_u->dataname, True, ps, depth))
7569                 return False;
7570
7571         if (!prs_align(ps))
7572                 return False;
7573
7574         if(!prs_rpcbuffer("", ps, depth, &q_u->indata))
7575                 return False;
7576
7577         if (!prs_align(ps))
7578                 return False;
7579
7580         if (!prs_uint32("indata_len", ps, depth, &q_u->indata_len))
7581                 return False;
7582         if (!prs_uint32("offered", ps, depth, &q_u->offered))
7583                 return False;
7584         if (!prs_uint32("unknown", ps, depth, &q_u->unknown))
7585                 return False;
7586
7587         return True;
7588 }
7589
7590 /*******************************************************************
7591  ********************************************************************/
7592
7593 bool spoolss_io_r_xcvdataport(const char *desc, SPOOL_R_XCVDATAPORT *r_u, prs_struct *ps, int depth)
7594 {
7595         prs_debug(ps, depth, desc, "spoolss_io_r_xcvdataport");
7596         depth++;
7597
7598         if(!prs_align(ps))
7599                 return False;
7600         if(!prs_rpcbuffer("", ps, depth, &r_u->outdata))
7601                 return False;
7602
7603         if (!prs_align(ps))
7604                 return False;
7605
7606         if (!prs_uint32("needed", ps, depth, &r_u->needed))
7607                 return False;
7608         if (!prs_uint32("unknown", ps, depth, &r_u->unknown))
7609                 return False;
7610
7611         if(!prs_werror("status", ps, depth, &r_u->status))
7612                 return False;
7613
7614         return True;
7615 }
7616
7617 /*******************************************************************
7618  ********************************************************************/
7619
7620 bool make_monitorui_buf( RPC_BUFFER *buf, const char *dllname )
7621 {
7622         UNISTR string;
7623
7624         if ( !buf )
7625                 return False;
7626
7627         init_unistr( &string, dllname );
7628
7629         if ( !prs_unistr( "ui_dll", &buf->prs, 0, &string ) )
7630                 return False;
7631
7632         return True;
7633 }
7634
7635 /*******************************************************************
7636  ********************************************************************/
7637
7638 #define PORT_DATA_1_PAD    540
7639
7640 static bool smb_io_port_data_1( const char *desc, RPC_BUFFER *buf, int depth, SPOOL_PORT_DATA_1 *p1 )
7641 {
7642         prs_struct *ps = &buf->prs;
7643         uint8 padding[PORT_DATA_1_PAD];
7644
7645         prs_debug(ps, depth, desc, "smb_io_port_data_1");
7646         depth++;
7647
7648         if(!prs_align(ps))
7649                 return False;
7650
7651         if( !prs_uint16s(True, "portname", ps, depth, p1->portname, MAX_PORTNAME))
7652                 return False;
7653
7654         if (!prs_uint32("version", ps, depth, &p1->version))
7655                 return False;
7656         if (!prs_uint32("protocol", ps, depth, &p1->protocol))
7657                 return False;
7658         if (!prs_uint32("size", ps, depth, &p1->size))
7659                 return False;
7660         if (!prs_uint32("reserved", ps, depth, &p1->reserved))
7661                 return False;
7662
7663         if( !prs_uint16s(True, "hostaddress", ps, depth, p1->hostaddress, MAX_NETWORK_NAME))
7664                 return False;
7665         if( !prs_uint16s(True, "snmpcommunity", ps, depth, p1->snmpcommunity, MAX_SNMP_COMM_NAME))
7666                 return False;
7667
7668         if (!prs_uint32("dblspool", ps, depth, &p1->dblspool))
7669                 return False;
7670
7671         if( !prs_uint16s(True, "queue", ps, depth, p1->queue, MAX_QUEUE_NAME))
7672                 return False;
7673         if( !prs_uint16s(True, "ipaddress", ps, depth, p1->ipaddress, MAX_IPADDR_STRING))
7674                 return False;
7675
7676         if( !prs_uint8s(False, "", ps, depth, padding, PORT_DATA_1_PAD))
7677                 return False;
7678
7679         if (!prs_uint32("port", ps, depth, &p1->port))
7680                 return False;
7681         if (!prs_uint32("snmpenabled", ps, depth, &p1->snmpenabled))
7682                 return False;
7683         if (!prs_uint32("snmpdevindex", ps, depth, &p1->snmpdevindex))
7684                 return False;
7685
7686         return True;
7687 }
7688
7689 /*******************************************************************
7690  ********************************************************************/
7691
7692 bool convert_port_data_1( NT_PORT_DATA_1 *port1, RPC_BUFFER *buf )
7693 {
7694         SPOOL_PORT_DATA_1 spdata_1;
7695
7696         ZERO_STRUCT( spdata_1 );
7697
7698         if ( !smb_io_port_data_1( "port_data_1", buf, 0, &spdata_1 ) )
7699                 return False;
7700
7701         rpcstr_pull(port1->name, spdata_1.portname, sizeof(port1->name), -1, 0);
7702         rpcstr_pull(port1->queue, spdata_1.queue, sizeof(port1->queue), -1, 0);
7703         rpcstr_pull(port1->hostaddr, spdata_1.hostaddress, sizeof(port1->hostaddr), -1, 0);
7704
7705         port1->port = spdata_1.port;
7706
7707         switch ( spdata_1.protocol ) {
7708         case 1:
7709                 port1->protocol = PORT_PROTOCOL_DIRECT;
7710                 break;
7711         case 2:
7712                 port1->protocol = PORT_PROTOCOL_LPR;
7713                 break;
7714         default:
7715                 DEBUG(3,("convert_port_data_1: unknown protocol [%d]!\n",
7716                         spdata_1.protocol));
7717                 return False;
7718         }
7719
7720         return True;
7721 }
7722