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