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