2 * Unix SMB/Netbios implementation.
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,
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.
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.
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.
26 #include "rpc_parse.h"
29 /****************************************************************************
30 do a SPOOLSS Enum Printer Drivers
31 ****************************************************************************/
32 uint32 spoolss_enum_printerdrivers(const char *srv_name, const char *environment,
33 uint32 level, NEW_BUFFER *buffer, uint32 offered,
34 uint32 *needed, uint32 *returned)
38 SPOOL_Q_ENUMPRINTERDRIVERS q_o;
39 SPOOL_R_ENUMPRINTERDRIVERS r_o;
40 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
42 struct cli_connection *con = NULL;
44 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
47 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
48 prs_init(&rbuf, 0, ctx, UNMARSHALL);
50 /* create and send a MSRPC command with api SPOOLSS_ENUM_PRINTERS */
52 DEBUG(5,("SPOOLSS Enum Printer Drivers (Server: %s Environment: %s level: %d)\n",
53 srv_name, environment, level));
55 make_spoolss_q_enumprinterdrivers(&q_o, srv_name, environment,
56 level, buffer, offered);
58 /* turn parameters into data stream */
59 if (spoolss_io_q_enumprinterdrivers("", &q_o, &buf, 0) &&
60 rpc_con_pipe_req(con, SPOOLSS_ENUMPRINTERDRIVERS, &buf, &rbuf))
65 prs_switch_type(&buffer->prs, UNMARSHALL);
66 prs_set_offset(&buffer->prs, 0);
69 if(spoolss_io_r_enumprinterdrivers("", &r_o, &rbuf, 0))
71 if (r_o.status != NT_STATUS_OK)
73 DEBUG(3,("SPOOLSS_ENUMPRINTERDRIVERS: %s\n", get_nt_error_msg(r_o.status)));
76 *returned=r_o.returned;
83 cli_connection_unlink(con);
88 /****************************************************************************
89 do a SPOOLSS Enum Printers
90 ****************************************************************************/
91 uint32 spoolss_enum_printers(uint32 flags, fstring srv_name, uint32 level,
92 NEW_BUFFER *buffer, uint32 offered,
93 uint32 *needed, uint32 *returned)
97 SPOOL_Q_ENUMPRINTERS q_o;
98 SPOOL_R_ENUMPRINTERS r_o;
99 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
101 struct cli_connection *con = NULL;
103 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
106 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
107 prs_init(&rbuf, 0, ctx, UNMARSHALL);
109 /* create and send a MSRPC command with api SPOOLSS_ENUM_PRINTERS */
111 DEBUG(5,("SPOOLSS Enum Printers (Server: %s level: %d)\n", srv_name, level));
113 make_spoolss_q_enumprinters(&q_o, flags, "", level, buffer, offered);
115 /* turn parameters into data stream */
116 if (spoolss_io_q_enumprinters("", &q_o, &buf, 0) &&
117 rpc_con_pipe_req(con, SPOOLSS_ENUMPRINTERS, &buf, &rbuf))
121 prs_switch_type(&buffer->prs, UNMARSHALL);
122 prs_set_offset(&buffer->prs, 0);
125 if(new_spoolss_io_r_enumprinters("", &r_o, &rbuf, 0))
127 if (r_o.status != NT_STATUS_OK)
129 /* report error code */
130 DEBUG(3,("SPOOLSS_ENUMPRINTERS: %s\n", get_nt_error_msg(r_o.status)));
134 *returned=r_o.returned;
142 cli_connection_unlink(con);
147 /****************************************************************************
148 do a SPOOLSS Enum Ports
149 ****************************************************************************/
150 uint32 spoolss_enum_ports(fstring srv_name, uint32 level,
151 NEW_BUFFER *buffer, uint32 offered,
152 uint32 *needed, uint32 *returned)
156 SPOOL_Q_ENUMPORTS q_o;
157 SPOOL_R_ENUMPORTS r_o;
158 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
160 struct cli_connection *con = NULL;
162 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
165 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
166 prs_init(&rbuf, 0, ctx, UNMARSHALL);
168 /* create and send a MSRPC command with api SPOOLSS_ENUMPORTS */
170 DEBUG(5,("SPOOLSS Enum Ports (Server: %s level: %d)\n", srv_name, level));
172 make_spoolss_q_enumports(&q_o, "", level, buffer, offered);
174 /* turn parameters into data stream */
175 if (spoolss_io_q_enumports("", &q_o, &buf, 0) &&
176 rpc_con_pipe_req(con, SPOOLSS_ENUMPORTS, &buf, &rbuf))
181 prs_switch_type(&buffer->prs, UNMARSHALL);
182 prs_set_offset(&buffer->prs, 0);
185 if(new_spoolss_io_r_enumports("", &r_o, &rbuf, 0))
187 if (r_o.status != NT_STATUS_OK)
189 DEBUG(3,("SPOOLSS_ENUMPORTS: %s\n", get_nt_error_msg(r_o.status)));
193 *returned=r_o.returned;
200 cli_connection_unlink(con);
205 /****************************************************************************
206 do a SPOOLSS Enum Jobs
207 ****************************************************************************/
208 uint32 spoolss_enum_jobs(const POLICY_HND *hnd, uint32 firstjob, uint32 numofjobs,
209 uint32 level, NEW_BUFFER *buffer, uint32 offered,
210 uint32 *needed, uint32 *returned)
214 SPOOL_Q_ENUMJOBS q_o;
215 SPOOL_R_ENUMJOBS r_o;
216 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
219 return NT_STATUS_INVALID_PARAMETER;
221 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
222 prs_init(&rbuf, 0, ctx, UNMARSHALL);
224 /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
226 DEBUG(5,("SPOOLSS Enum Jobs level: %d)\n", level));
228 make_spoolss_q_enumjobs(&q_o, hnd, firstjob, numofjobs, level, buffer, offered);
230 /* turn parameters into data stream */
231 if (spoolss_io_q_enumjobs("", &q_o, &buf, 0) &&
232 rpc_hnd_pipe_req(hnd, SPOOLSS_ENUMJOBS, &buf, &rbuf))
239 if(spoolss_io_r_enumjobs("", &r_o, &rbuf, 0))
241 if (r_o.status != NT_STATUS_OK)
243 DEBUG(3,("SPOOLSS_ENUMJOBS: %s\n", get_nt_error_msg(r_o.status)));
246 *returned=r_o.returned;
256 /***************************************************************************
257 do a SPOOLSS Enum printer datas
258 ****************************************************************************/
259 uint32 spoolss_enum_printerdata(const POLICY_HND *hnd, uint32 idx,
260 uint32 *valuelen, uint16 *value, uint32 *rvaluelen,
261 uint32 *type, uint32 *datalen, uint8 *data,
266 SPOOL_Q_ENUMPRINTERDATA q_o;
267 SPOOL_R_ENUMPRINTERDATA r_o;
268 TALLOC_CTX *mem_ctx = NULL;
271 return NT_STATUS_INVALID_PARAMETER;
273 if ((mem_ctx=talloc_init()) == NULL)
275 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
278 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
279 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
281 /* create and send a MSRPC command with api SPOOLSS_ENUMPRINTERDATA*/
283 DEBUG(4,("SPOOLSS Enum Printer data\n"));
285 make_spoolss_q_enumprinterdata(&q_o, hnd, idx, *valuelen, *datalen);
287 /* turn parameters into data stream */
288 if (spoolss_io_q_enumprinterdata("", &q_o, &buf, 0) &&
289 rpc_hnd_pipe_req(hnd, SPOOLSS_ENUMPRINTERDATA, &buf, &rbuf))
297 if(spoolss_io_r_enumprinterdata("", &r_o, &rbuf, 0))
299 if (r_o.status != NT_STATUS_OK)
301 DEBUG(3,("SPOOLSS_ENUMPRINTERDATA: %s\n", get_nt_error_msg(r_o.status)));
304 *valuelen=r_o.valuesize;
305 *rvaluelen=r_o.realvaluesize;
307 *datalen=r_o.datasize;
308 *rdatalen=r_o.realdatasize;
316 talloc_destroy(mem_ctx);
321 /****************************************************************************
322 do a SPOOLSS Enum printer datas
323 ****************************************************************************/
324 uint32 spoolss_getprinter(const POLICY_HND *hnd, uint32 level,
325 NEW_BUFFER *buffer, uint32 offered,
330 SPOOL_Q_GETPRINTER q_o;
331 SPOOL_R_GETPRINTER r_o;
332 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
335 return NT_STATUS_INVALID_PARAMETER;
337 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
338 prs_init(&rbuf, 0, ctx, UNMARSHALL);
340 /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
342 DEBUG(5,("SPOOLSS Enum Printer data)\n"));
344 make_spoolss_q_getprinter(&q_o, hnd, level, buffer, offered);
346 /* turn parameters into data stream */
347 if (spoolss_io_q_getprinter("", &q_o, &buf, 0) &&
348 rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTER, &buf, &rbuf))
353 prs_switch_type(&buffer->prs, UNMARSHALL);
354 prs_set_offset(&buffer->prs, 0);
357 if(!spoolss_io_r_getprinter("", &r_o, &rbuf, 0))
359 if (r_o.status != NT_STATUS_OK)
361 DEBUG(3,("SPOOLSS_GETPRINTER: %s\n", get_nt_error_msg(r_o.status)));
373 /****************************************************************************
374 do a SPOOLSS Enum printer driver
375 ****************************************************************************/
376 uint32 spoolss_getprinterdriver(const POLICY_HND *hnd,
377 const char *environment, uint32 level,
378 NEW_BUFFER *buffer, uint32 offered,
383 SPOOL_Q_GETPRINTERDRIVER2 q_o;
384 SPOOL_R_GETPRINTERDRIVER2 r_o;
385 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
388 return NT_STATUS_INVALID_PARAMETER;
390 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
391 prs_init(&rbuf, 0, ctx, UNMARSHALL);
393 /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
395 DEBUG(5,("SPOOLSS Enum Printer driver)\n"));
397 make_spoolss_q_getprinterdriver2(&q_o, hnd, environment, level, 2, 0, buffer, offered);
399 /* turn parameters into data stream */
400 if (spoolss_io_q_getprinterdriver2("", &q_o, &buf, 0) &&
401 rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTERDRIVER2, &buf, &rbuf))
406 prs_switch_type(&buffer->prs, UNMARSHALL);
407 prs_set_offset(&buffer->prs, 0);
410 if(spoolss_io_r_getprinterdriver2("", &r_o, &rbuf, 0))
412 if (r_o.status != NT_STATUS_OK)
414 DEBUG(3,("SPOOLSS_GETPRINTERDRIVER2: %s\n", get_nt_error_msg(r_o.status)));
429 /****************************************************************************
430 do a SPOOLSS Open Printer Ex
431 ****************************************************************************/
432 BOOL spoolss_open_printer_ex( const char *printername,
433 const char *datatype, uint32 access_required,
434 const char *station, const char *username,
439 SPOOL_Q_OPEN_PRINTER_EX q_o;
440 BOOL valid_pol = False;
443 struct cli_connection *con = NULL;
444 TALLOC_CTX *mem_ctx = NULL;
446 memset(srv_name, 0, sizeof(srv_name));
447 fstrcpy(srv_name, printername);
449 s = strchr_m(&srv_name[2], '\\');
453 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
459 if ((mem_ctx=talloc_init()) == NULL)
461 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
464 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
465 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
467 /* create and send a MSRPC command with api SPOOLSS_OPENPRINTEREX */
469 DEBUG(5,("SPOOLSS Open Printer Ex\n"));
471 make_spoolss_q_open_printer_ex(&q_o, printername, datatype,
472 access_required, station, username);
474 /* turn parameters into data stream */
475 if (spoolss_io_q_open_printer_ex("", &q_o, &buf, 0) &&
476 rpc_con_pipe_req(con, SPOOLSS_OPENPRINTEREX, &buf, &rbuf))
478 SPOOL_R_OPEN_PRINTER_EX r_o;
481 spoolss_io_r_open_printer_ex("", &r_o, &rbuf, 0);
483 if (prs_offset(&rbuf)!= 0 && r_o.status != 0)
485 /* report error code */
486 DEBUG(3,("SPOOLSS_OPENPRINTEREX: %s\n", get_nt_error_msg(r_o.status)));
492 /* ok, at last: we're happy. return the policy handle */
495 /* associate the handle returned with the current
496 state of the clienjt connection */
497 valid_pol = RpcHndList_set_connection(hnd, con);
505 talloc_destroy(mem_ctx);
510 /****************************************************************************
511 do a SPOOLSS AddPrinterEx()
512 **ALWAYS** uses as PRINTER_INFO level 2 struct
513 ****************************************************************************/
514 BOOL spoolss_addprinterex(POLICY_HND *hnd, const char* srv_name, PRINTER_INFO_2 *info2)
518 SPOOL_Q_ADDPRINTEREX q_o;
519 SPOOL_R_ADDPRINTEREX r_o;
520 struct cli_connection *con = NULL;
521 TALLOC_CTX *mem_ctx = NULL;
522 fstring the_client_name;
523 BOOL valid_pol = True;
527 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
528 return NT_STATUS_ACCESS_DENIED;
531 return NT_STATUS_INVALID_PARAMETER;
533 if ((mem_ctx=talloc_init()) == NULL)
535 DEBUG(0,("spoolss_addprinterex: talloc_init() failed!\n"));
536 return NT_STATUS_ACCESS_DENIED;
538 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
539 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
541 /* create and send a MSRPC command with api SPOOLSS_ENUMPORTS */
542 DEBUG(5,("SPOOLSS Add Printer Ex (Server: %s)\n", srv_name));
544 fstrcpy(the_client_name, "\\\\");
545 fstrcat(the_client_name, con->pCli_state->desthost);
546 strupper(the_client_name);
549 make_spoolss_q_addprinterex(mem_ctx, &q_o, srv_name, the_client_name,
550 /* "Administrator", */
551 con->pCli_state->user_name,
554 /* turn parameters into data stream and send the request */
555 if (spoolss_io_q_addprinterex("", &q_o, &buf, 0) &&
556 rpc_con_pipe_req(con, SPOOLSS_ADDPRINTEREX, &buf, &rbuf))
560 if(spoolss_io_r_addprinterex("", &r_o, &rbuf, 0))
562 if (r_o.status != NT_STATUS_OK)
564 /* report error code */
565 DEBUG(3,("SPOOLSS_ADDPRINTEREX: %s\n", get_nt_error_msg(r_o.status)));
572 /* ok, at last: we're happy. return the policy handle */
573 copy_policy_hnd( hnd, &r_o.handle);
575 /* associate the handle returned with the current
576 state of the clienjt connection */
577 RpcHndList_set_connection(hnd, con);
586 talloc_destroy(mem_ctx);
591 /****************************************************************************
593 ****************************************************************************/
594 BOOL spoolss_closeprinter(POLICY_HND *hnd)
598 SPOOL_Q_CLOSEPRINTER q_c;
599 BOOL valid_close = False;
600 TALLOC_CTX *mem_ctx = NULL;
605 /* create and send a MSRPC command with api SPOOLSS_CLOSEPRINTER */
606 if ((mem_ctx=talloc_init()) == NULL)
608 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
611 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
612 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
614 DEBUG(4,("SPOOL Close Printer\n"));
616 /* store the parameters */
617 make_spoolss_q_closeprinter(&q_c, hnd);
619 /* turn parameters into data stream */
620 if (spoolss_io_q_closeprinter("", &q_c, &buf, 0) &&
621 rpc_hnd_pipe_req(hnd, SPOOLSS_CLOSEPRINTER, &buf, &rbuf))
623 SPOOL_R_CLOSEPRINTER r_c;
625 spoolss_io_r_closeprinter("", &r_c, &rbuf, 0);
627 if (prs_offset(&rbuf)!=0 && r_c.status != 0)
629 /* report error code */
630 DEBUG(3,("SPOOL_CLOSEPRINTER: %s\n", get_nt_error_msg(r_c.status)));
639 talloc_destroy(mem_ctx);
641 /* disassociate with the cli_connection */
642 RpcHndList_del_connection(hnd);
647 /****************************************************************************
648 do a SPOOLSS Get printer datas
649 ****************************************************************************/
650 uint32 spoolss_getprinterdata(const POLICY_HND *hnd, const UNISTR2 *valuename,
659 SPOOL_Q_GETPRINTERDATA q_o;
660 SPOOL_R_GETPRINTERDATA r_o;
661 TALLOC_CTX *mem_ctx = NULL;
664 return NT_STATUS_INVALID_PARAMETER;
666 if ((mem_ctx=talloc_init()) == NULL)
668 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
671 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
672 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
674 /* create and send a MSRPC command with api SPOOLSS_GETPRINTERDATA */
676 DEBUG(5,("SPOOLSS Get Printer data)\n"));
678 make_spoolss_q_getprinterdata(&q_o, hnd,(UNISTR2 *)valuename, in_size);
680 /* turn parameters into data stream */
681 if (spoolss_io_q_getprinterdata("", &q_o, &buf, 0) &&
682 rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTERDATA, &buf, &rbuf))
689 if(spoolss_io_r_getprinterdata("", &r_o, &rbuf, 0))
691 if (r_o.status != NT_STATUS_OK)
693 DEBUG(3,("SPOOLSS_GETPRINTERDATA: %s\n", get_nt_error_msg(r_o.status)));
708 /****************************************************************************
709 do a SPOOLSS Get Printer Driver Direcotry
710 ****************************************************************************/
711 uint32 spoolss_getprinterdriverdir(fstring srv_name, fstring env_name, uint32 level,
712 NEW_BUFFER *buffer, uint32 offered,
717 SPOOL_Q_GETPRINTERDRIVERDIR q_o;
718 SPOOL_R_GETPRINTERDRIVERDIR r_o;
719 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
721 struct cli_connection *con = NULL;
723 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
726 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
727 prs_init(&rbuf, 0, ctx, UNMARSHALL);
729 /* create and send a MSRPC command with api SPOOLSS_ENUM_PRINTERS */
731 DEBUG(5,("SPOOLSS GetPrinterDriverDir (Server: %s Env: %s level: %d)\n",
732 srv_name, env_name, level));
734 make_spoolss_q_getprinterdriverdir(&q_o, srv_name, env_name, level,
737 /* turn parameters into data stream */
738 if (spoolss_io_q_getprinterdriverdir("", &q_o, &buf, 0) &&
739 rpc_con_pipe_req(con, SPOOLSS_GETPRINTERDRIVERDIRECTORY, &buf, &rbuf))
744 prs_switch_type(&buffer->prs, UNMARSHALL);
745 prs_set_offset(&buffer->prs, 0);
748 if(spoolss_io_r_getprinterdriverdir("", &r_o, &rbuf, 0))
750 if (r_o.status != NT_STATUS_OK)
752 DEBUG(3,("SPOOLSS_GETPRINTERDRIVERDIRECTORY: %s\n", get_nt_error_msg(r_o.status)));
762 cli_connection_unlink(con);
767 /******************************************************************************
769 *****************************************************************************/
770 uint32 spoolss_addprinterdriver(const char *srv_name, uint32 level, PRINTER_DRIVER_CTR *info)
774 SPOOL_Q_ADDPRINTERDRIVER q_o;
775 SPOOL_R_ADDPRINTERDRIVER r_o;
776 TALLOC_CTX *mem_ctx = NULL;
777 struct cli_connection *con = NULL;
779 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
782 if ((mem_ctx=talloc_init()) == NULL)
784 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
787 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
788 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
790 /* make the ADDPRINTERDRIVER PDU */
791 make_spoolss_q_addprinterdriver(mem_ctx, &q_o, srv_name, level, info);
793 /* turn the data into an io stream */
794 if (spoolss_io_q_addprinterdriver("", &q_o, &buf, 0) &&
795 rpc_con_pipe_req(con, SPOOLSS_ADDPRINTERDRIVER, &buf, &rbuf))
799 if(spoolss_io_r_addprinterdriver("", &r_o, &rbuf, 0))
801 if (r_o.status != NT_STATUS_OK)
803 /* report error code */
804 DEBUG(3,("SPOOLSS_ADDPRINTERDRIVER: %s\n", get_nt_error_msg(r_o.status)));
814 talloc_destroy(mem_ctx);