source3/rpc_parse/parse_spoolss.c

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