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