source/rpc_parse/parse_spoolss.c

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