source3/rpc_client/cli_spoolss.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 1.9.
   4  *  RPC Pipe client / server routines
   5  *  Copyright (C) Andrew Tridgell              1992-2000,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   7  *  Copyright (C) Paul Ashton                  1997-2000,
   8  *  Copyright (C) Jean Francois Micouleau      1998-2000,
   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 #include "rpc_parse.h"
  27 #include "rpc_client.h"
  28 #include "nterr.h"
  29
  30 extern int DEBUGLEVEL;
  31
  32 /****************************************************************************
  33 do a SPOOLSS Enum Printer Drivers
  34 ****************************************************************************/
  35 uint32 spoolss_enum_printerdrivers(const char *srv_name, const char *environment,
  36                                    uint32 level, NEW_BUFFER *buffer, uint32 offered,
  37                                    uint32 *needed, uint32 *returned)
  38 {
  39         prs_struct rbuf;
  40         prs_struct buf;
  41         SPOOL_Q_ENUMPRINTERDRIVERS q_o;
  42         SPOOL_R_ENUMPRINTERDRIVERS r_o;
  43         TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
  44
  45         struct cli_connection *con = NULL;
  46
  47         if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
  48                 return False;
  49
  50         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, ctx, MARSHALL);
  51         prs_init(&rbuf, 0, 4, ctx, UNMARSHALL);
  52
  53         /* create and send a MSRPC command with api SPOOLSS_ENUM_PRINTERS */
  54
  55         DEBUG(5,("SPOOLSS Enum Printer Drivers (Server: %s Environment: %s level: %d)\n",
  56                                 srv_name, environment, level));
  57
  58         make_spoolss_q_enumprinterdrivers(&q_o, srv_name, environment,
  59                                 level, buffer, offered);
  60
  61         /* turn parameters into data stream */
  62         if (!spoolss_io_q_enumprinterdrivers("", &q_o, &buf, 0) ) {
  63                 prs_mem_free(&rbuf);
  64                 prs_mem_free(&buf );
  65
  66                 cli_connection_unlink(con);
  67         }
  68
  69         if(!rpc_con_pipe_req(con, SPOOLSS_ENUMPRINTERDRIVERS, &buf, &rbuf)) {
  70                 prs_mem_free(&rbuf);
  71                 prs_mem_free(&buf );
  72
  73                 cli_connection_unlink(con);
  74         }
  75
  76         prs_mem_free(&buf);
  77         ZERO_STRUCT(r_o);
  78
  79         prs_switch_type(&buffer->prs, UNMARSHALL);
  80         prs_set_offset(&buffer->prs, 0);
  81         r_o.buffer=buffer;
  82
  83         if(!new_spoolss_io_r_enumprinterdrivers("", &r_o, &rbuf, 0)) {
  84                 prs_mem_free(&rbuf);
  85                 cli_connection_unlink(con);
  86         }
  87
  88         *needed=r_o.needed;
  89         *returned=r_o.returned;
  90
  91         prs_mem_free(&rbuf);
  92         prs_mem_free(&buf );
  93
  94         cli_connection_unlink(con);
  95
  96         return r_o.status;
  97 }
  98
  99 /****************************************************************************
 100 do a SPOOLSS Enum Printers
 101 ****************************************************************************/
 102 uint32 spoolss_enum_printers(uint32 flags, fstring srv_name, uint32 level,
 103                              NEW_BUFFER *buffer, uint32 offered,
 104                              uint32 *needed, uint32 *returned)
 105 {
 106         prs_struct rbuf;
 107         prs_struct buf;
 108         SPOOL_Q_ENUMPRINTERS q_o;
 109         SPOOL_R_ENUMPRINTERS r_o;
 110         TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
 111
 112         struct cli_connection *con = NULL;
 113
 114         if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
 115                 return False;
 116
 117         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, ctx, MARSHALL);
 118         prs_init(&rbuf, 0, 4, ctx, UNMARSHALL);
 119
 120         /* create and send a MSRPC command with api SPOOLSS_ENUM_PRINTERS */
 121
 122         DEBUG(5,("SPOOLSS Enum Printers (Server: %s level: %d)\n", srv_name, level));
 123
 124         make_spoolss_q_enumprinters(&q_o, flags, "", level, buffer, offered);
 125
 126         /* turn parameters into data stream */
 127         if (!spoolss_io_q_enumprinters("", &q_o, &buf, 0) ) {
 128                 prs_mem_free(&rbuf);
 129                 prs_mem_free(&buf );
 130
 131                 cli_connection_unlink(con);
 132         }
 133
 134         if(!rpc_con_pipe_req(con, SPOOLSS_ENUMPRINTERS, &buf, &rbuf)) {
 135                 prs_mem_free(&rbuf);
 136                 prs_mem_free(&buf );
 137
 138                 cli_connection_unlink(con);
 139         }
 140
 141         prs_mem_free(&buf );
 142         ZERO_STRUCT(r_o);
 143
 144         prs_switch_type(&buffer->prs, UNMARSHALL);
 145         prs_set_offset(&buffer->prs, 0);
 146         r_o.buffer=buffer;
 147
 148         if(!new_spoolss_io_r_enumprinters("", &r_o, &rbuf, 0)) {
 149                 prs_mem_free(&rbuf);
 150                 cli_connection_unlink(con);
 151         }
 152
 153         *needed=r_o.needed;
 154         *returned=r_o.returned;
 155
 156         prs_mem_free(&rbuf);
 157         prs_mem_free(&buf );
 158
 159         cli_connection_unlink(con);
 160
 161         return r_o.status;
 162 }
 163
 164 /****************************************************************************
 165 do a SPOOLSS Enum Ports
 166 ****************************************************************************/
 167 uint32 spoolss_enum_ports(fstring srv_name, uint32 level,
 168                              NEW_BUFFER *buffer, uint32 offered,
 169                              uint32 *needed, uint32 *returned)
 170 {
 171         prs_struct rbuf;
 172         prs_struct buf;
 173         SPOOL_Q_ENUMPORTS q_o;
 174         SPOOL_R_ENUMPORTS r_o;
 175         TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
 176
 177         struct cli_connection *con = NULL;
 178
 179         if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
 180                 return False;
 181
 182         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, ctx, MARSHALL);
 183         prs_init(&rbuf, 0, 4, ctx, UNMARSHALL);
 184
 185         /* create and send a MSRPC command with api SPOOLSS_ENUMPORTS */
 186
 187         DEBUG(5,("SPOOLSS Enum Ports (Server: %s level: %d)\n", srv_name, level));
 188
 189         make_spoolss_q_enumports(&q_o, "", level, buffer, offered);
 190
 191         /* turn parameters into data stream */
 192         if (!spoolss_io_q_enumports("", &q_o, &buf, 0) ) {
 193                 prs_mem_free(&rbuf);
 194                 prs_mem_free(&buf );
 195
 196                 cli_connection_unlink(con);
 197         }
 198
 199         if(!rpc_con_pipe_req(con, SPOOLSS_ENUMPORTS, &buf, &rbuf)) {
 200                 prs_mem_free(&rbuf);
 201                 prs_mem_free(&buf );
 202
 203                 cli_connection_unlink(con);
 204         }
 205
 206         prs_mem_free(&buf );
 207         ZERO_STRUCT(r_o);
 208
 209         prs_switch_type(&buffer->prs, UNMARSHALL);
 210         prs_set_offset(&buffer->prs, 0);
 211         r_o.buffer=buffer;
 212
 213         if(!new_spoolss_io_r_enumports("", &r_o, &rbuf, 0)) {
 214                 prs_mem_free(&rbuf);
 215                 cli_connection_unlink(con);
 216         }
 217
 218         *needed=r_o.needed;
 219         *returned=r_o.returned;
 220
 221         prs_mem_free(&rbuf);
 222         prs_mem_free(&buf );
 223
 224         cli_connection_unlink(con);
 225
 226         return r_o.status;
 227 }
 228
 229 /****************************************************************************
 230 do a SPOOLSS Enum Jobs
 231 ****************************************************************************/
 232 uint32 spoolss_enum_jobs(const POLICY_HND *hnd, uint32 firstjob, uint32 numofjobs,
 233                          uint32 level, NEW_BUFFER *buffer, uint32 offered,
 234                          uint32 *needed, uint32 *returned)
 235 {
 236         prs_struct rbuf;
 237         prs_struct buf;
 238         SPOOL_Q_ENUMJOBS q_o;
 239         SPOOL_R_ENUMJOBS r_o;
 240         TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
 241
 242         if (hnd == NULL)
 243                 return NT_STATUS_INVALID_PARAMETER;
 244
 245         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, ctx, MARSHALL);
 246         prs_init(&rbuf, 0, 4, ctx, UNMARSHALL);
 247
 248         /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
 249
 250         DEBUG(5,("SPOOLSS Enum Jobs level: %d)\n", level));
 251
 252         make_spoolss_q_enumjobs(&q_o, hnd, firstjob, numofjobs, level, buffer, offered);
 253
 254         /* turn parameters into data stream */
 255         if (!spoolss_io_q_enumjobs("", &q_o, &buf, 0)) {
 256                 prs_mem_free(&rbuf);
 257                 prs_mem_free(&buf );
 258         }
 259
 260         if(!rpc_hnd_pipe_req(hnd, SPOOLSS_ENUMJOBS, &buf, &rbuf))
 261         {
 262                 prs_mem_free(&rbuf);
 263                 prs_mem_free(&buf );
 264         }
 265
 266         ZERO_STRUCT(r_o);
 267         prs_mem_free(&buf );
 268
 269         r_o.buffer=buffer;
 270
 271         if(!spoolss_io_r_enumjobs("", &r_o, &rbuf, 0)) {
 272                 prs_mem_free(&rbuf);
 273         }
 274
 275         *needed=r_o.needed;
 276         *returned=r_o.returned;
 277
 278         prs_mem_free(&rbuf);
 279         prs_mem_free(&buf );
 280
 281         return r_o.status;
 282 }
 283
 284 /***************************************************************************
 285 do a SPOOLSS Enum printer datas
 286 ****************************************************************************/
 287 uint32 spoolss_enum_printerdata(const POLICY_HND *hnd, uint32 idx,
 288                                 uint32 *valuelen, uint16 *value, uint32 *rvaluelen,
 289                                 uint32 *type, uint32 *datalen, uint8 *data,
 290                                 uint32 *rdatalen)
 291 {
 292         prs_struct rbuf;
 293         prs_struct buf;
 294         SPOOL_Q_ENUMPRINTERDATA q_o;
 295         SPOOL_R_ENUMPRINTERDATA r_o;
 296         TALLOC_CTX *mem_ctx = NULL;
 297
 298         if (hnd == NULL)
 299                 return NT_STATUS_INVALID_PARAMETER;
 300
 301         if ((mem_ctx=talloc_init()) == NULL)
 302         {
 303                 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
 304                 return False;
 305         }
 306         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, mem_ctx, MARSHALL);
 307         prs_init(&rbuf, 0, 4, mem_ctx, UNMARSHALL);
 308
 309         /* create and send a MSRPC command with api  SPOOLSS_ENUMPRINTERDATA*/
 310
 311         DEBUG(4,("SPOOLSS Enum Printer data\n"));
 312
 313         make_spoolss_q_enumprinterdata(&q_o, hnd, idx, *valuelen, *datalen);
 314
 315         /* turn parameters into data stream */
 316         if (!spoolss_io_q_enumprinterdata("", &q_o, &buf, 0)) {
 317                 prs_mem_free(&rbuf);
 318                 prs_mem_free(&buf );
 319         }
 320
 321         if(!rpc_hnd_pipe_req(hnd, SPOOLSS_ENUMPRINTERDATA, &buf, &rbuf)) {
 322                 prs_mem_free(&rbuf);
 323                 prs_mem_free(&buf );
 324         }
 325
 326         ZERO_STRUCT(r_o);
 327         prs_mem_free(&buf );
 328
 329         r_o.data=data;
 330         r_o.value=value;
 331
 332         if(!spoolss_io_r_enumprinterdata("", &r_o, &rbuf, 0)) {
 333                 prs_mem_free(&rbuf);
 334         }
 335
 336         *valuelen=r_o.valuesize;
 337         *rvaluelen=r_o.realvaluesize;
 338         *type=r_o.type;
 339         *datalen=r_o.datasize;
 340         *rdatalen=r_o.realdatasize;
 341
 342         prs_mem_free(&rbuf);
 343         prs_mem_free(&buf );
 344         if (mem_ctx)
 345                 talloc_destroy(mem_ctx);
 346
 347         return r_o.status;
 348 }
 349
 350 /****************************************************************************
 351 do a SPOOLSS Enum printer datas
 352 ****************************************************************************/
 353 uint32 spoolss_getprinter(const POLICY_HND *hnd, uint32 level,
 354                              NEW_BUFFER *buffer, uint32 offered,
 355                              uint32 *needed)
 356 {
 357         prs_struct rbuf;
 358         prs_struct buf;
 359         SPOOL_Q_GETPRINTER q_o;
 360         SPOOL_R_GETPRINTER r_o;
 361         TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
 362
 363         if (hnd == NULL)
 364                 return NT_STATUS_INVALID_PARAMETER;
 365
 366         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, ctx, MARSHALL);
 367         prs_init(&rbuf, 0, 4, ctx, UNMARSHALL);
 368
 369         /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
 370
 371         DEBUG(5,("SPOOLSS Enum Printer data)\n"));
 372
 373         make_spoolss_q_getprinter(&q_o, hnd, level, buffer, offered);
 374
 375         /* turn parameters into data stream */
 376         if (!spoolss_io_q_getprinter("", &q_o, &buf, 0)) {
 377                 prs_mem_free(&rbuf);
 378                 prs_mem_free(&buf );
 379         }
 380
 381         if(!rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTER, &buf, &rbuf)) {
 382                 prs_mem_free(&rbuf);
 383                 prs_mem_free(&buf );
 384         }
 385
 386         ZERO_STRUCT(r_o);
 387         prs_mem_free(&buf );
 388
 389         prs_switch_type(&buffer->prs, UNMARSHALL);
 390         prs_set_offset(&buffer->prs, 0);
 391         r_o.buffer=buffer;
 392
 393         if(!spoolss_io_r_getprinter("", &r_o, &rbuf, 0)) {
 394                 prs_mem_free(&rbuf);
 395         }
 396
 397         *needed=r_o.needed;
 398
 399         prs_mem_free(&rbuf);
 400         prs_mem_free(&buf );
 401
 402         return r_o.status;
 403 }
 404
 405 /****************************************************************************
 406 do a SPOOLSS Enum printer driver
 407 ****************************************************************************/
 408 uint32 spoolss_getprinterdriver(const POLICY_HND *hnd,
 409                                 const char *environment, uint32 level,
 410                                 NEW_BUFFER *buffer, uint32 offered,
 411                                 uint32 *needed)
 412 {
 413         prs_struct rbuf;
 414         prs_struct buf;
 415         SPOOL_Q_GETPRINTERDRIVER2 q_o;
 416         SPOOL_R_GETPRINTERDRIVER2 r_o;
 417         TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
 418
 419         if (hnd == NULL)
 420                 return NT_STATUS_INVALID_PARAMETER;
 421
 422         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, ctx, MARSHALL);
 423         prs_init(&rbuf, 0, 4, ctx, UNMARSHALL);
 424
 425         /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
 426
 427         DEBUG(5,("SPOOLSS Enum Printer driver)\n"));
 428
 429         make_spoolss_q_getprinterdriver2(&q_o, hnd, environment, level, 2, 0, buffer, offered);
 430
 431         /* turn parameters into data stream */
 432         if (!spoolss_io_q_getprinterdriver2("", &q_o, &buf, 0)) {
 433                 prs_mem_free(&rbuf);
 434                 prs_mem_free(&buf );
 435         }
 436
 437         if(!rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTERDRIVER2, &buf, &rbuf)) {
 438                 prs_mem_free(&rbuf);
 439                 prs_mem_free(&buf );
 440         }
 441
 442         ZERO_STRUCT(r_o);
 443         prs_mem_free(&buf );
 444
 445         prs_switch_type(&buffer->prs, UNMARSHALL);
 446         prs_set_offset(&buffer->prs, 0);
 447         r_o.buffer=buffer;
 448
 449         if(!spoolss_io_r_getprinterdriver2("", &r_o, &rbuf, 0)) {
 450                 prs_mem_free(&rbuf);
 451         }
 452
 453         *needed=r_o.needed;
 454
 455         prs_mem_free(&rbuf);
 456         prs_mem_free(&buf );
 457
 458         return r_o.status;
 459 }
 460
 461
 462
 463 /****************************************************************************
 464 do a SPOOLSS Open Printer Ex
 465 ****************************************************************************/
 466 BOOL spoolss_open_printer_ex(  const char *printername,
 467                          const char *datatype, uint32 access_required,
 468                          const char *station,  const char *username,
 469                         POLICY_HND *hnd)
 470 {
 471         prs_struct rbuf;
 472         prs_struct buf;
 473         SPOOL_Q_OPEN_PRINTER_EX q_o;
 474         BOOL valid_pol = False;
 475         fstring srv_name;
 476         char *s = NULL;
 477         struct cli_connection *con = NULL;
 478         TALLOC_CTX *mem_ctx = NULL;
 479
 480         memset(srv_name, 0, sizeof(srv_name));
 481         fstrcpy(srv_name, printername);
 482
 483         s = strchr(&srv_name[2], '\\');
 484         if (s != NULL)
 485                 *s = '\0';
 486
 487         if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
 488                 return False;
 489
 490         if (hnd == NULL)
 491                 return False;
 492
 493         if ((mem_ctx=talloc_init()) == NULL)
 494         {
 495                 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
 496                 return False;
 497         }
 498         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, mem_ctx, MARSHALL);
 499         prs_init(&rbuf, 0, 4, mem_ctx, UNMARSHALL);
 500
 501         /* create and send a MSRPC command with api SPOOLSS_OPENPRINTEREX */
 502
 503         DEBUG(5,("SPOOLSS Open Printer Ex\n"));
 504
 505         make_spoolss_q_open_printer_ex(&q_o, printername, datatype,
 506                                        access_required, station, username);
 507
 508         /* turn parameters into data stream */
 509         if (spoolss_io_q_open_printer_ex("", &q_o, &buf, 0) &&
 510             rpc_con_pipe_req(con, SPOOLSS_OPENPRINTEREX, &buf, &rbuf))
 511         {
 512                 SPOOL_R_OPEN_PRINTER_EX r_o;
 513                 BOOL p = True;
 514
 515                 spoolss_io_r_open_printer_ex("", &r_o, &rbuf, 0);
 516
 517                 if (prs_offset(&rbuf)!= 0 && r_o.status != 0)
 518                 {
 519                         /* report error code */
 520                         DEBUG(5,("SPOOLSS_OPENPRINTEREX: %s\n", get_nt_error_msg(r_o.status)));
 521                         p = False;
 522                 }
 523
 524                 if (p)
 525                 {
 526                         /* ok, at last: we're happy. return the policy handle */
 527                         *hnd = r_o.handle;
 528
 529                         /* associate the handle returned with the current
 530                            state of the clienjt connection */
 531                         valid_pol = RpcHndList_set_connection(hnd, con);
 532
 533                 }
 534         }
 535
 536         prs_mem_free(&rbuf);
 537         prs_mem_free(&buf );
 538         if (mem_ctx)
 539                 talloc_destroy(mem_ctx);
 540
 541         return valid_pol;
 542 }
 543
 544 /****************************************************************************
 545  do a SPOOLSS AddPrinterEx()
 546  **ALWAYS** uses as PRINTER_INFO level 2 struct
 547 ****************************************************************************/
 548 BOOL spoolss_addprinterex(POLICY_HND *hnd, PRINTER_INFO_2 *info2)
 549 {
 550 #if 0
 551         prs_struct rbuf;
 552         prs_struct buf;
 553         SPOOL_Q_ADDPRINTEREX q_o;
 554         BOOL valid_pol = False;
 555         fstring srv_name;
 556         char *s = NULL;
 557         struct cli_connection *con = NULL;
 558
 559
 560         memset(srv_name, 0, sizeof(srv_name));
 561         unistr_to_ascii(srv_name, info2->servername.buffer, sizeof(srv_name));
 562
 563         if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
 564                 return False;
 565
 566         if (hnd == NULL) return False;
 567
 568         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL);
 569         prs_init(&rbuf, 0, 4, UNMARSHALL);
 570 #endif
 571
 572         return True;
 573 }
 574
 575 /****************************************************************************
 576 do a SPOOL Close
 577 ****************************************************************************/
 578 BOOL spoolss_closeprinter(POLICY_HND *hnd)
 579 {
 580         prs_struct rbuf;
 581         prs_struct buf;
 582         SPOOL_Q_CLOSEPRINTER q_c;
 583         BOOL valid_close = False;
 584         TALLOC_CTX *mem_ctx = NULL;
 585
 586         if (hnd == NULL)
 587                 return False;
 588
 589         /* create and send a MSRPC command with api SPOOLSS_CLOSEPRINTER */
 590         if ((mem_ctx=talloc_init()) == NULL)
 591         {
 592                 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
 593                 return False;
 594         }
 595         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, mem_ctx, MARSHALL);
 596         prs_init(&rbuf, 0, 4, mem_ctx, UNMARSHALL);
 597
 598         DEBUG(4,("SPOOL Close Printer\n"));
 599
 600         /* store the parameters */
 601         make_spoolss_q_closeprinter(&q_c, hnd);
 602
 603         /* turn parameters into data stream */
 604         if (spoolss_io_q_closeprinter("", &q_c, &buf, 0) &&
 605             rpc_hnd_pipe_req(hnd, SPOOLSS_CLOSEPRINTER, &buf, &rbuf))
 606         {
 607                 SPOOL_R_CLOSEPRINTER r_c;
 608
 609                 spoolss_io_r_closeprinter("", &r_c, &rbuf, 0);
 610
 611                 if (prs_offset(&rbuf)!=0 && r_c.status != 0)
 612                 {
 613                         /* report error code */
 614                         DEBUG(0,("SPOOL_CLOSEPRINTER: %s\n", get_nt_error_msg(r_c.status)));
 615                 }
 616                 else
 617                         valid_close = True;
 618         }
 619
 620         prs_mem_free(&rbuf);
 621         prs_mem_free(&buf );
 622         if (mem_ctx)
 623                 talloc_destroy(mem_ctx);
 624
 625         /* disassociate with the cli_connection */
 626         RpcHndList_del_connection(hnd);
 627
 628         return valid_close;
 629 }
 630
 631 /****************************************************************************
 632 do a SPOOLSS Get printer datas
 633 ****************************************************************************/
 634 uint32 spoolss_getprinterdata(const POLICY_HND *hnd, const UNISTR2 *valuename,
 635                         uint32 in_size,
 636                         uint32 *type,
 637                         uint32 *out_size,
 638                         uint8 *data,
 639                         uint32 *needed)
 640 {
 641         prs_struct rbuf;
 642         prs_struct buf;
 643         SPOOL_Q_GETPRINTERDATA q_o;
 644         SPOOL_R_GETPRINTERDATA r_o;
 645         TALLOC_CTX *mem_ctx = NULL;
 646
 647         if (hnd == NULL)
 648                 return NT_STATUS_INVALID_PARAMETER;
 649
 650         if ((mem_ctx=talloc_init()) == NULL)
 651         {
 652                 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
 653                 return False;
 654         }
 655         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, mem_ctx, MARSHALL);
 656         prs_init(&rbuf, 0, 4, mem_ctx, UNMARSHALL);
 657
 658         /* create and send a MSRPC command with api SPOOLSS_GETPRINTERDATA */
 659
 660         DEBUG(5,("SPOOLSS Get Printer data)\n"));
 661
 662         make_spoolss_q_getprinterdata(&q_o, hnd, valuename, in_size);
 663
 664         /* turn parameters into data stream */
 665         if (!spoolss_io_q_getprinterdata("", &q_o, &buf, 0)) {
 666                 prs_mem_free(&rbuf);
 667                 prs_mem_free(&buf );
 668         }
 669
 670         if (!rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTERDATA, &buf, &rbuf)) {
 671                 prs_mem_free(&rbuf);
 672                 prs_mem_free(&buf );
 673         }
 674
 675         ZERO_STRUCT(r_o);
 676         prs_mem_free(&buf );
 677
 678         r_o.data=data;
 679
 680         if(!spoolss_io_r_getprinterdata("", &r_o, &rbuf, 0)) {
 681                 prs_mem_free(&rbuf);
 682         }
 683
 684         *type=r_o.type;
 685         *out_size=r_o.size;
 686         *needed=r_o.needed;
 687
 688         prs_mem_free(&rbuf);
 689         prs_mem_free(&buf );
 690
 691         return r_o.status;
 692 }
 693
 694 /****************************************************************************
 695 do a SPOOLSS Get Printer Driver Direcotry
 696 ****************************************************************************/
 697 uint32 spoolss_getprinterdriverdir(fstring srv_name, fstring env_name, uint32 level,
 698                              NEW_BUFFER *buffer, uint32 offered,
 699                              uint32 *needed)
 700 {
 701         prs_struct rbuf;
 702         prs_struct buf;
 703         SPOOL_Q_GETPRINTERDRIVERDIR q_o;
 704         SPOOL_R_GETPRINTERDRIVERDIR r_o;
 705         TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
 706
 707         struct cli_connection *con = NULL;
 708
 709         if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
 710                 return False;
 711
 712         prs_init(&buf , MAX_PDU_FRAG_LEN, 4, ctx, MARSHALL);
 713         prs_init(&rbuf, 0, 4, ctx, UNMARSHALL);
 714
 715         /* create and send a MSRPC command with api SPOOLSS_ENUM_PRINTERS */
 716
 717         DEBUG(5,("SPOOLSS GetPrinterDriverDir (Server: %s Env: %s level: %d)\n",
 718                   srv_name, env_name, level));
 719
 720         make_spoolss_q_getprinterdriverdir(&q_o, srv_name, env_name, level,
 721                                            buffer, offered);
 722
 723         /* turn parameters into data stream */
 724         if (!spoolss_io_q_getprinterdriverdir("", &q_o, &buf, 0) ) {
 725                 prs_mem_free(&rbuf);
 726                 prs_mem_free(&buf );
 727
 728                 cli_connection_unlink(con);
 729         }
 730
 731         if(!rpc_con_pipe_req(con, SPOOLSS_GETPRINTERDRIVERDIRECTORY, &buf, &rbuf)) {
 732                 prs_mem_free(&rbuf);
 733                 prs_mem_free(&buf );
 734
 735                 cli_connection_unlink(con);
 736         }
 737
 738         prs_mem_free(&buf );
 739         ZERO_STRUCT(r_o);
 740
 741         prs_switch_type(&buffer->prs, UNMARSHALL);
 742         prs_set_offset(&buffer->prs, 0);
 743         r_o.buffer=buffer;
 744
 745         if(!spoolss_io_r_getprinterdriverdir("", &r_o, &rbuf, 0)) {
 746                 prs_mem_free(&rbuf);
 747                 cli_connection_unlink(con);
 748         }
 749         *needed=r_o.needed;
 750
 751         prs_mem_free(&rbuf);
 752         prs_mem_free(&buf );
 753
 754         cli_connection_unlink(con);
 755
 756         return r_o.status;
 757 }
 758
 759