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