source/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,
  36                                 const char *environment,
  37                                 uint32 level,
  38                              NEW_BUFFER *buffer, uint32 offered,
  39                              uint32 *needed, uint32 *returned)
  40 {
  41         prs_struct rbuf;
  42         prs_struct buf;
  43         SPOOL_Q_ENUMPRINTERDRIVERS q_o;
  44         SPOOL_R_ENUMPRINTERDRIVERS r_o;
  45
  46         struct cli_connection *con = NULL;
  47
  48         if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
  49                 return False;
  50
  51         prs_init(&buf , 0, 4, False);
  52         prs_init(&rbuf, 0, 4, True );
  53
  54         /* create and send a MSRPC command with api SPOOLSS_ENUM_PRINTERS */
  55
  56         DEBUG(5,("SPOOLSS Enum Printer Drivers (Server: %s Environment: %s level: %d)\n",
  57                                 srv_name, environment, level));
  58
  59         make_spoolss_q_enumprinterdrivers(&q_o, srv_name, environment,
  60                                 level, buffer, offered);
  61
  62         /* turn parameters into data stream */
  63         if (!spoolss_io_q_enumprinterdrivers("", &q_o, &buf, 0) ) {
  64                 prs_free_data(&rbuf);
  65                 prs_free_data(&buf );
  66
  67                 cli_connection_unlink(con);
  68         }
  69
  70         if(!rpc_con_pipe_req(con, SPOOLSS_ENUMPRINTERDRIVERS, &buf, &rbuf)) {
  71                 prs_free_data(&rbuf);
  72                 prs_free_data(&buf );
  73
  74                 cli_connection_unlink(con);
  75         }
  76
  77         prs_free_data(&buf);
  78         ZERO_STRUCT(r_o);
  79
  80         buffer->prs.io=UNMARSHALL;
  81         buffer->prs.offset=0;
  82         r_o.buffer=buffer;
  83
  84         if(!new_spoolss_io_r_enumprinterdrivers("", &r_o, &rbuf, 0)) {
  85                 prs_free_data(&rbuf);
  86                 cli_connection_unlink(con);
  87         }
  88
  89         *needed=r_o.needed;
  90         *returned=r_o.returned;
  91
  92         prs_free_data(&rbuf);
  93         prs_free_data(&buf );
  94
  95         cli_connection_unlink(con);
  96
  97         return r_o.status;
  98 }
  99
 100 /****************************************************************************
 101 do a SPOOLSS Enum Printers
 102 ****************************************************************************/
 103 uint32 spoolss_enum_printers(uint32 flags, fstring srv_name, uint32 level,
 104                              NEW_BUFFER *buffer, uint32 offered,
 105                              uint32 *needed, uint32 *returned)
 106 {
 107         prs_struct rbuf;
 108         prs_struct buf;
 109         SPOOL_Q_ENUMPRINTERS q_o;
 110         SPOOL_R_ENUMPRINTERS r_o;
 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 , 0, 4, False);
 118         prs_init(&rbuf, 0, 4, True );
 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_free_data(&rbuf);
 129                 prs_free_data(&buf );
 130
 131                 cli_connection_unlink(con);
 132         }
 133
 134         if(!rpc_con_pipe_req(con, SPOOLSS_ENUMPRINTERS, &buf, &rbuf)) {
 135                 prs_free_data(&rbuf);
 136                 prs_free_data(&buf );
 137
 138                 cli_connection_unlink(con);
 139         }
 140
 141         prs_free_data(&buf );
 142         ZERO_STRUCT(r_o);
 143
 144         buffer->prs.io=UNMARSHALL;
 145         buffer->prs.offset=0;
 146         r_o.buffer=buffer;
 147
 148         if(!new_spoolss_io_r_enumprinters("", &r_o, &rbuf, 0)) {
 149                 prs_free_data(&rbuf);
 150                 cli_connection_unlink(con);
 151         }
 152
 153         *needed=r_o.needed;
 154         *returned=r_o.returned;
 155
 156         prs_free_data(&rbuf);
 157         prs_free_data(&buf );
 158
 159         cli_connection_unlink(con);
 160
 161         return r_o.status;
 162 }
 163
 164 /****************************************************************************
 165 do a SPOOLSS Enum Jobs
 166 ****************************************************************************/
 167 uint32 spoolss_enum_jobs(const POLICY_HND *hnd, uint32 firstjob, uint32 numofjobs,
 168                          uint32 level, NEW_BUFFER *buffer, uint32 offered,
 169                          uint32 *needed, uint32 *returned)
 170 {
 171         prs_struct rbuf;
 172         prs_struct buf;
 173         SPOOL_Q_ENUMJOBS q_o;
 174         SPOOL_R_ENUMJOBS r_o;
 175
 176         if (hnd == NULL)
 177                 return NT_STATUS_INVALID_PARAMETER;
 178
 179         prs_init(&buf , 0, 4, False);
 180         prs_init(&rbuf, 0, 4, True );
 181
 182         /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
 183
 184         DEBUG(5,("SPOOLSS Enum Jobs level: %d)\n", level));
 185
 186         make_spoolss_q_enumjobs(&q_o, hnd, firstjob, numofjobs, level, buffer, offered);
 187
 188         /* turn parameters into data stream */
 189         if (!spoolss_io_q_enumjobs("", &q_o, &buf, 0)) {
 190                 prs_free_data(&rbuf);
 191                 prs_free_data(&buf );
 192         }
 193
 194         if(!rpc_hnd_pipe_req(hnd, SPOOLSS_ENUMJOBS, &buf, &rbuf))
 195         {
 196                 prs_free_data(&rbuf);
 197                 prs_free_data(&buf );
 198         }
 199
 200         ZERO_STRUCT(r_o);
 201         prs_free_data(&buf );
 202
 203         r_o.buffer=buffer;
 204
 205         if(!spoolss_io_r_enumjobs("", &r_o, &rbuf, 0)) {
 206                 prs_free_data(&rbuf);
 207         }
 208
 209         *needed=r_o.needed;
 210         *returned=r_o.returned;
 211
 212         prs_free_data(&rbuf);
 213         prs_free_data(&buf );
 214
 215         return r_o.status;
 216 }
 217
 218 /****************************************************************************
 219 do a SPOOLSS Enum printer datas
 220 ****************************************************************************/
 221 uint32 spoolss_enum_printerdata(const POLICY_HND *hnd, uint32 idx,
 222                         uint32 *valuelen, uint16 *value, uint32 *rvaluelen,
 223                         uint32 *type,
 224                         uint32 *datalen, uint8 *data, uint32 *rdatalen)
 225 {
 226         prs_struct rbuf;
 227         prs_struct buf;
 228         SPOOL_Q_ENUMPRINTERDATA q_o;
 229         SPOOL_R_ENUMPRINTERDATA r_o;
 230
 231         if (hnd == NULL)
 232                 return NT_STATUS_INVALID_PARAMETER;
 233
 234         prs_init(&buf , 0, 4, False);
 235         prs_init(&rbuf, 0, 4, True );
 236
 237         /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
 238
 239         DEBUG(5,("SPOOLSS Enum Printer data)\n"));
 240
 241         make_spoolss_q_enumprinterdata(&q_o, hnd, idx, *valuelen, *datalen);
 242
 243         /* turn parameters into data stream */
 244         if (!spoolss_io_q_enumprinterdata("", &q_o, &buf, 0)) {
 245                 prs_free_data(&rbuf);
 246                 prs_free_data(&buf );
 247         }
 248
 249         if(!rpc_hnd_pipe_req(hnd, SPOOLSS_ENUMPRINTERDATA, &buf, &rbuf)) {
 250                 prs_free_data(&rbuf);
 251                 prs_free_data(&buf );
 252         }
 253
 254         ZERO_STRUCT(r_o);
 255         prs_free_data(&buf );
 256
 257         r_o.data=data;
 258         r_o.value=value;
 259
 260         if(!spoolss_io_r_enumprinterdata("", &r_o, &rbuf, 0)) {
 261                 prs_free_data(&rbuf);
 262         }
 263
 264         *valuelen=r_o.valuesize;
 265         *rvaluelen=r_o.realvaluesize;
 266         *type=r_o.type;
 267         *datalen=r_o.datasize;
 268         *rdatalen=r_o.realdatasize;
 269
 270         prs_free_data(&rbuf);
 271         prs_free_data(&buf );
 272
 273         return r_o.status;
 274 }
 275
 276 /****************************************************************************
 277 do a SPOOLSS Enum printer datas
 278 ****************************************************************************/
 279 uint32 spoolss_getprinter(const POLICY_HND *hnd, uint32 level,
 280                              NEW_BUFFER *buffer, uint32 offered,
 281                              uint32 *needed)
 282 {
 283         prs_struct rbuf;
 284         prs_struct buf;
 285         SPOOL_Q_GETPRINTER q_o;
 286         SPOOL_R_GETPRINTER r_o;
 287
 288         if (hnd == NULL)
 289                 return NT_STATUS_INVALID_PARAMETER;
 290
 291         prs_init(&buf , 0, 4, False);
 292         prs_init(&rbuf, 0, 4, True );
 293
 294         /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
 295
 296         DEBUG(5,("SPOOLSS Enum Printer data)\n"));
 297
 298         make_spoolss_q_getprinter(&q_o, hnd, level, buffer, offered);
 299
 300         /* turn parameters into data stream */
 301         if (!spoolss_io_q_getprinter("", &q_o, &buf, 0)) {
 302                 prs_free_data(&rbuf);
 303                 prs_free_data(&buf );
 304         }
 305
 306         if(!rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTER, &buf, &rbuf)) {
 307                 prs_free_data(&rbuf);
 308                 prs_free_data(&buf );
 309         }
 310
 311         ZERO_STRUCT(r_o);
 312         prs_free_data(&buf );
 313
 314         buffer->prs.io=UNMARSHALL;
 315         buffer->prs.offset=0;
 316         r_o.buffer=buffer;
 317
 318         if(!spoolss_io_r_getprinter("", &r_o, &rbuf, 0)) {
 319                 prs_free_data(&rbuf);
 320         }
 321
 322         *needed=r_o.needed;
 323
 324         prs_free_data(&rbuf);
 325         prs_free_data(&buf );
 326
 327         return r_o.status;
 328 }
 329
 330 /****************************************************************************
 331 do a SPOOLSS Enum printer driver
 332 ****************************************************************************/
 333 uint32 spoolss_getprinterdriver(const POLICY_HND *hnd,
 334                                 const char *environment, uint32 level,
 335                                 NEW_BUFFER *buffer, uint32 offered,
 336                                 uint32 *needed)
 337 {
 338         prs_struct rbuf;
 339         prs_struct buf;
 340         SPOOL_Q_GETPRINTERDRIVER2 q_o;
 341         SPOOL_R_GETPRINTERDRIVER2 r_o;
 342
 343         if (hnd == NULL)
 344                 return NT_STATUS_INVALID_PARAMETER;
 345
 346         prs_init(&buf , 0, 4, False);
 347         prs_init(&rbuf, 0, 4, True );
 348
 349         /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
 350
 351         DEBUG(5,("SPOOLSS Enum Printer driver)\n"));
 352
 353         make_spoolss_q_getprinterdriver2(&q_o, hnd, environment, level, 2, 0, buffer, offered);
 354
 355         /* turn parameters into data stream */
 356         if (!spoolss_io_q_getprinterdriver2("", &q_o, &buf, 0)) {
 357                 prs_free_data(&rbuf);
 358                 prs_free_data(&buf );
 359         }
 360
 361         if(!rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTERDRIVER2, &buf, &rbuf)) {
 362                 prs_free_data(&rbuf);
 363                 prs_free_data(&buf );
 364         }
 365
 366         ZERO_STRUCT(r_o);
 367         prs_free_data(&buf );
 368
 369         buffer->prs.io=UNMARSHALL;
 370         buffer->prs.offset=0;
 371         r_o.buffer=buffer;
 372
 373         if(!spoolss_io_r_getprinterdriver2("", &r_o, &rbuf, 0)) {
 374                 prs_free_data(&rbuf);
 375         }
 376
 377         *needed=r_o.needed;
 378
 379         prs_free_data(&rbuf);
 380         prs_free_data(&buf );
 381
 382         return r_o.status;
 383 }
 384
 385 /****************************************************************************
 386 do a SPOOLSS Open Printer Ex
 387 ****************************************************************************/
 388 BOOL spoolss_open_printer_ex(  const char *printername,
 389                          const char *datatype, uint32 access_required,
 390                          const char *station,  const char *username,
 391                         POLICY_HND *hnd)
 392 {
 393         prs_struct rbuf;
 394         prs_struct buf;
 395         SPOOL_Q_OPEN_PRINTER_EX q_o;
 396         BOOL valid_pol = False;
 397         fstring srv_name;
 398         char *s;
 399
 400         struct cli_connection *con = NULL;
 401
 402         memset(srv_name, 0, sizeof(srv_name));
 403         fstrcpy(srv_name, printername);
 404
 405         s = strchr(&srv_name[2], '\\');
 406
 407         if (s != NULL)
 408                 *s = 0;
 409
 410         if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
 411                 return False;
 412
 413         if (hnd == NULL) return False;
 414
 415         prs_init(&buf , 0, 4, False);
 416         prs_init(&rbuf, 0, 4, True );
 417
 418         /* create and send a MSRPC command with api SPOOLSS_OPENPRINTEREX */
 419
 420         DEBUG(5,("SPOOLSS Open Printer Ex\n"));
 421
 422         make_spoolss_q_open_printer_ex(&q_o, printername, datatype,
 423                                        access_required, station, username);
 424
 425         /* turn parameters into data stream */
 426         if (spoolss_io_q_open_printer_ex("", &q_o, &buf, 0) &&
 427             rpc_con_pipe_req(con, SPOOLSS_OPENPRINTEREX, &buf, &rbuf))
 428         {
 429                 SPOOL_R_OPEN_PRINTER_EX r_o;
 430                 BOOL p;
 431
 432                 spoolss_io_r_open_printer_ex("", &r_o, &rbuf, 0);
 433                 p = rbuf.offset != 0;
 434
 435                 if (p && r_o.status != 0)
 436                 {
 437                         /* report error code */
 438                         DEBUG(5,("SPOOLSS_OPENPRINTEREX: %s\n", get_nt_error_msg(r_o.status)));
 439                         p = False;
 440                 }
 441
 442                 if (p)
 443                 {
 444                         /* ok, at last: we're happy. return the policy handle */
 445                         *hnd = r_o.handle;
 446
 447                         valid_pol = register_policy_hnd(get_global_hnd_cache(),
 448                                                         cli_con_sec_ctx(con),
 449                                                         hnd, access_required) &&
 450                                     set_policy_con(get_global_hnd_cache(),
 451                                                hnd, con,
 452                                                cli_connection_unlink);
 453                 }
 454         }
 455
 456         prs_free_data(&rbuf);
 457         prs_free_data(&buf );
 458
 459         return valid_pol;
 460 }
 461
 462 /****************************************************************************
 463 do a SPOOL Close
 464 ****************************************************************************/
 465 BOOL spoolss_closeprinter(POLICY_HND *hnd)
 466 {
 467         prs_struct rbuf;
 468         prs_struct buf;
 469         SPOOL_Q_CLOSEPRINTER q_c;
 470         BOOL valid_close = False;
 471
 472         if (hnd == NULL) return False;
 473
 474         /* create and send a MSRPC command with api SPOOLSS_CLOSEPRINTER */
 475
 476         prs_init(&buf , 0, 4, False);
 477         prs_init(&rbuf, 0, 4, True );
 478
 479         DEBUG(4,("SPOOL Close Printer\n"));
 480
 481         /* store the parameters */
 482         make_spoolss_q_closeprinter(&q_c, hnd);
 483
 484         /* turn parameters into data stream */
 485         if (spoolss_io_q_closeprinter("", &q_c, &buf, 0) &&
 486             rpc_hnd_pipe_req(hnd, SPOOLSS_CLOSEPRINTER, &buf, &rbuf))
 487         {
 488                 SPOOL_R_CLOSEPRINTER r_c;
 489                 BOOL p;
 490
 491                 spoolss_io_r_closeprinter("", &r_c, &rbuf, 0);
 492                 p = rbuf.offset != 0;
 493
 494                 if (p && r_c.status != 0)
 495                 {
 496                         /* report error code */
 497                         DEBUG(0,("SPOOL_CLOSEPRINTER: %s\n", get_nt_error_msg(r_c.status)));
 498                         p = False;
 499                 }
 500         }
 501
 502         prs_free_data(&rbuf);
 503         prs_free_data(&buf );
 504
 505         close_policy_hnd(get_global_hnd_cache(), hnd);
 506
 507         return valid_close;
 508 }
 509
 510 /****************************************************************************
 511 do a SPOOLSS Get printer datas
 512 ****************************************************************************/
 513 uint32 spoolss_getprinterdata(const POLICY_HND *hnd, const UNISTR2 *valuename,
 514                         uint32 in_size,
 515                         uint32 *type,
 516                         uint32 *out_size,
 517                         uint8 *data,
 518                         uint32 *needed)
 519 {
 520         prs_struct rbuf;
 521         prs_struct buf;
 522         SPOOL_Q_GETPRINTERDATA q_o;
 523         SPOOL_R_GETPRINTERDATA r_o;
 524
 525         if (hnd == NULL)
 526                 return NT_STATUS_INVALID_PARAMETER;
 527
 528         prs_init(&buf , 0, 4, False);
 529         prs_init(&rbuf, 0, 4, True );
 530
 531         /* create and send a MSRPC command with api SPOOLSS_GETPRINTERDATA */
 532
 533         DEBUG(5,("SPOOLSS Get Printer data)\n"));
 534
 535         make_spoolss_q_getprinterdata(&q_o, hnd, valuename, in_size);
 536
 537         /* turn parameters into data stream */
 538         if (!spoolss_io_q_getprinterdata("", &q_o, &buf, 0)) {
 539                 prs_free_data(&rbuf);
 540                 prs_free_data(&buf );
 541         }
 542
 543         if(!rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTERDATA, &buf, &rbuf)) {
 544                 prs_free_data(&rbuf);
 545                 prs_free_data(&buf );
 546         }
 547
 548         ZERO_STRUCT(r_o);
 549         prs_free_data(&buf );
 550
 551         r_o.data=data;
 552
 553         if(!spoolss_io_r_getprinterdata("", &r_o, &rbuf, 0)) {
 554                 prs_free_data(&rbuf);
 555         }
 556
 557         *type=r_o.type;
 558         *out_size=r_o.size;
 559         *needed=r_o.needed;
 560
 561         prs_free_data(&rbuf);
 562         prs_free_data(&buf );
 563
 564         return r_o.status;
 565 }
 566
 567 /****************************************************************************
 568 do a SPOOLSS Get Printer Driver Direcotry
 569 ****************************************************************************/
 570 uint32 spoolss_getprinterdriverdir(fstring srv_name, fstring env_name, uint32 level,
 571                              NEW_BUFFER *buffer, uint32 offered,
 572                              uint32 *needed)
 573 {
 574         prs_struct rbuf;
 575         prs_struct buf;
 576         SPOOL_Q_GETPRINTERDRIVERDIR q_o;
 577         SPOOL_R_GETPRINTERDRIVERDIR r_o;
 578
 579         struct cli_connection *con = NULL;
 580
 581         if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
 582                 return False;
 583
 584         prs_init(&buf , 0, 4, False);
 585         prs_init(&rbuf, 0, 4, True );
 586
 587         /* create and send a MSRPC command with api SPOOLSS_ENUM_PRINTERS */
 588
 589         DEBUG(5,("SPOOLSS GetPrinterDriverDir (Server: %s Env: %s level: %d)\n", srv_name, env_name, level));
 590
 591         make_spoolss_q_getprinterdriverdir(&q_o, srv_name, env_name, level, buffer, offered);
 592
 593         /* turn parameters into data stream */
 594         if (!spoolss_io_q_getprinterdriverdir("", &q_o, &buf, 0) ) {
 595                 prs_free_data(&rbuf);
 596                 prs_free_data(&buf );
 597
 598                 cli_connection_unlink(con);
 599         }
 600
 601         if(!rpc_con_pipe_req(con, SPOOLSS_GETPRINTERDRIVERDIRECTORY, &buf, &rbuf)) {
 602                 prs_free_data(&rbuf);
 603                 prs_free_data(&buf );
 604
 605                 cli_connection_unlink(con);
 606         }
 607
 608         prs_free_data(&buf );
 609         ZERO_STRUCT(r_o);
 610
 611         buffer->prs.io=UNMARSHALL;
 612         buffer->prs.offset=0;
 613         r_o.buffer=buffer;
 614
 615         if(!spoolss_io_r_getprinterdriverdir("", &r_o, &rbuf, 0)) {
 616                 prs_free_data(&rbuf);
 617                 cli_connection_unlink(con);
 618         }
 619
 620         *needed=r_o.needed;
 621
 622         prs_free_data(&rbuf);
 623         prs_free_data(&buf );
 624
 625         cli_connection_unlink(con);
 626
 627         return r_o.status;
 628 }
 629