Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

source: branches/samba-3.2.x/source/rpc_client/cli_spoolss.c

Visit:

Last change on this file was 133, checked in by Paul Smedley, 17 years ago
Update trunk to 3.2.0pre3
File size: 53.2 KB

Line
1	/*
2	Unix SMB/CIFS implementation.
3	RPC pipe client
4
5	Copyright (C) Gerald Carter 2001-2005,
6	Copyright (C) Tim Potter 2000-2002,
7	Copyright (C) Andrew Tridgell 1994-2000,
8	Copyright (C) Jean-Francois Micouleau 1999-2000.
9	Copyright (C) Jeremy Allison 2005.
10
11	This program is free software; you can redistribute it and/or modify
12	it under the terms of the GNU General Public License as published by
13	the Free Software Foundation; either version 3 of the License, or
14	(at your option) any later version.
15
16	This program is distributed in the hope that it will be useful,
17	but WITHOUT ANY WARRANTY; without even the implied warranty of
18	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	GNU General Public License for more details.
20
21	You should have received a copy of the GNU General Public License
22	along with this program. If not, see <http://www.gnu.org/licenses/>.
23	*/
24
25	#include "includes.h"
26	#include "rpc_client.h"
27
28	/*********************************************************************
29	Decode various spoolss rpc's and info levels
30	********************************************************************/
31
32	/**********************************************************************
33	**********************************************************************/
34
35	static bool decode_printer_info_0(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
36	uint32 returned, PRINTER_INFO_0 **info)
37	{
38	uint32 i;
39	PRINTER_INFO_0 *inf;
40
41	if (returned) {
42	inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_0, returned);
43	if (!inf) {
44	return False;
45	}
46	memset(inf, 0, returned*sizeof(PRINTER_INFO_0));
47	} else {
48	inf = NULL;
49	}
50
51	prs_set_offset(&buffer->prs,0);
52
53	for (i=0; i<returned; i++) {
54	if (!smb_io_printer_info_0("", buffer, &inf[i], 0)) {
55	return False;
56	}
57	}
58
59	*info=inf;
60	return True;
61	}
62
63	/**********************************************************************
64	**********************************************************************/
65
66	static bool decode_printer_info_1(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
67	uint32 returned, PRINTER_INFO_1 **info)
68	{
69	uint32 i;
70	PRINTER_INFO_1 *inf;
71
72	if (returned) {
73	inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_1, returned);
74	if (!inf) {
75	return False;
76	}
77	memset(inf, 0, returned*sizeof(PRINTER_INFO_1));
78	} else {
79	inf = NULL;
80	}
81
82	prs_set_offset(&buffer->prs,0);
83
84	for (i=0; i<returned; i++) {
85	if (!smb_io_printer_info_1("", buffer, &inf[i], 0)) {
86	return False;
87	}
88	}
89
90	*info=inf;
91	return True;
92	}
93
94	/**********************************************************************
95	**********************************************************************/
96
97	static bool decode_printer_info_2(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
98	uint32 returned, PRINTER_INFO_2 **info)
99	{
100	uint32 i;
101	PRINTER_INFO_2 *inf;
102
103	if (returned) {
104	inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_2, returned);
105	if (!inf) {
106	return False;
107	}
108	memset(inf, 0, returned*sizeof(PRINTER_INFO_2));
109	} else {
110	inf = NULL;
111	}
112
113	prs_set_offset(&buffer->prs,0);
114
115	for (i=0; i<returned; i++) {
116	/* a little initialization as we go */
117	inf[i].secdesc = NULL;
118	if (!smb_io_printer_info_2("", buffer, &inf[i], 0)) {
119	return False;
120	}
121	}
122
123	*info=inf;
124	return True;
125	}
126
127	/**********************************************************************
128	**********************************************************************/
129
130	static bool decode_printer_info_3(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
131	uint32 returned, PRINTER_INFO_3 **info)
132	{
133	uint32 i;
134	PRINTER_INFO_3 *inf;
135
136	if (returned) {
137	inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_3, returned);
138	if (!inf) {
139	return False;
140	}
141	memset(inf, 0, returned*sizeof(PRINTER_INFO_3));
142	} else {
143	inf = NULL;
144	}
145
146	prs_set_offset(&buffer->prs,0);
147
148	for (i=0; i<returned; i++) {
149	inf[i].secdesc = NULL;
150	if (!smb_io_printer_info_3("", buffer, &inf[i], 0)) {
151	return False;
152	}
153	}
154
155	*info=inf;
156	return True;
157	}
158
159	/**********************************************************************
160	**********************************************************************/
161
162	static bool decode_printer_info_7(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
163	uint32 returned, PRINTER_INFO_7 **info)
164	{
165	uint32 i;
166	PRINTER_INFO_7 *inf;
167
168	if (returned) {
169	inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_7, returned);
170	if (!inf) {
171	return False;
172	}
173	memset(inf, 0, returned*sizeof(PRINTER_INFO_7));
174	} else {
175	inf = NULL;
176	}
177
178	prs_set_offset(&buffer->prs,0);
179
180	for (i=0; i<returned; i++) {
181	if (!smb_io_printer_info_7("", buffer, &inf[i], 0)) {
182	return False;
183	}
184	}
185
186	*info=inf;
187	return True;
188	}
189
190
191	/**********************************************************************
192	**********************************************************************/
193
194	static bool decode_port_info_1(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
195	uint32 returned, PORT_INFO_1 **info)
196	{
197	uint32 i;
198	PORT_INFO_1 *inf;
199
200	if (returned) {
201	inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_1, returned);
202	if (!inf) {
203	return False;
204	}
205	memset(inf, 0, returned*sizeof(PORT_INFO_1));
206	} else {
207	inf = NULL;
208	}
209
210	prs_set_offset(&buffer->prs, 0);
211
212	for (i=0; i<returned; i++) {
213	if (!smb_io_port_info_1("", buffer, &(inf[i]), 0)) {
214	return False;
215	}
216	}
217
218	*info=inf;
219	return True;
220	}
221
222	/**********************************************************************
223	**********************************************************************/
224
225	static bool decode_port_info_2(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
226	uint32 returned, PORT_INFO_2 **info)
227	{
228	uint32 i;
229	PORT_INFO_2 *inf;
230
231	if (returned) {
232	inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_2, returned);
233	if (!inf) {
234	return False;
235	}
236	memset(inf, 0, returned*sizeof(PORT_INFO_2));
237	} else {
238	inf = NULL;
239	}
240
241	prs_set_offset(&buffer->prs, 0);
242
243	for (i=0; i<returned; i++) {
244	if (!smb_io_port_info_2("", buffer, &(inf[i]), 0)) {
245	return False;
246	}
247	}
248
249	*info=inf;
250	return True;
251	}
252
253	/**********************************************************************
254	**********************************************************************/
255
256	static bool decode_printer_driver_1(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
257	uint32 returned, DRIVER_INFO_1 **info)
258	{
259	uint32 i;
260	DRIVER_INFO_1 *inf;
261
262	if (returned) {
263	inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_1, returned);
264	if (!inf) {
265	return False;
266	}
267	memset(inf, 0, returned*sizeof(DRIVER_INFO_1));
268	} else {
269	inf = NULL;
270	}
271
272	prs_set_offset(&buffer->prs,0);
273
274	for (i=0; i<returned; i++) {
275	if (!smb_io_printer_driver_info_1("", buffer, &(inf[i]), 0)) {
276	return False;
277	}
278	}
279
280	*info=inf;
281	return True;
282	}
283
284	/**********************************************************************
285	**********************************************************************/
286
287	static bool decode_printer_driver_2(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
288	uint32 returned, DRIVER_INFO_2 **info)
289	{
290	uint32 i;
291	DRIVER_INFO_2 *inf;
292
293	if (returned) {
294	inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_2, returned);
295	if (!inf) {
296	return False;
297	}
298	memset(inf, 0, returned*sizeof(DRIVER_INFO_2));
299	} else {
300	inf = NULL;
301	}
302
303	prs_set_offset(&buffer->prs,0);
304
305	for (i=0; i<returned; i++) {
306	if (!smb_io_printer_driver_info_2("", buffer, &(inf[i]), 0)) {
307	return False;
308	}
309	}
310
311	*info=inf;
312	return True;
313	}
314
315	/**********************************************************************
316	**********************************************************************/
317
318	static bool decode_printer_driver_3(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
319	uint32 returned, DRIVER_INFO_3 **info)
320	{
321	uint32 i;
322	DRIVER_INFO_3 *inf;
323
324	if (returned) {
325	inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_3, returned);
326	if (!inf) {
327	return False;
328	}
329	memset(inf, 0, returned*sizeof(DRIVER_INFO_3));
330	} else {
331	inf = NULL;
332	}
333
334	prs_set_offset(&buffer->prs,0);
335
336	for (i=0; i<returned; i++) {
337	if (!smb_io_printer_driver_info_3("", buffer, &(inf[i]), 0)) {
338	return False;
339	}
340	}
341
342	*info=inf;
343	return True;
344	}
345
346	/**********************************************************************
347	**********************************************************************/
348
349	static bool decode_printerdriverdir_1 (TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
350	uint32 returned, DRIVER_DIRECTORY_1 **info
351	)
352	{
353	DRIVER_DIRECTORY_1 *inf;
354
355	inf=TALLOC_P(mem_ctx, DRIVER_DIRECTORY_1);
356	if (!inf) {
357	return False;
358	}
359	memset(inf, 0, sizeof(DRIVER_DIRECTORY_1));
360
361	prs_set_offset(&buffer->prs, 0);
362
363	if (!smb_io_driverdir_1("", buffer, inf, 0)) {
364	return False;
365	}
366
367	*info=inf;
368	return True;
369	}
370
371	/**********************************************************************
372	**********************************************************************/
373
374	static bool decode_jobs_1(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
375	uint32 num_jobs, JOB_INFO_1 **jobs)
376	{
377	uint32 i;
378
379	if (num_jobs) {
380	*jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_1, num_jobs);
381	if (*jobs == NULL) {
382	return False;
383	}
384	} else {
385	*jobs = NULL;
386	}
387	prs_set_offset(&buffer->prs,0);
388
389	for (i = 0; i < num_jobs; i++) {
390	if (!smb_io_job_info_1("", buffer, &((*jobs)[i]), 0)) {
391	return False;
392	}
393	}
394
395	return True;
396	}
397
398	/**********************************************************************
399	**********************************************************************/
400
401	static bool decode_jobs_2(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
402	uint32 num_jobs, JOB_INFO_2 **jobs)
403	{
404	uint32 i;
405
406	if (num_jobs) {
407	*jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_2, num_jobs);
408	if (*jobs == NULL) {
409	return False;
410	}
411	} else {
412	*jobs = NULL;
413	}
414	prs_set_offset(&buffer->prs,0);
415
416	for (i = 0; i < num_jobs; i++) {
417	if (!smb_io_job_info_2("", buffer, &((*jobs)[i]), 0)) {
418	return False;
419	}
420	}
421
422	return True;
423	}
424
425	/**********************************************************************
426	**********************************************************************/
427
428	static bool decode_forms_1(TALLOC_CTX mem_ctx, RPC_BUFFER buffer,
429	uint32 num_forms, FORM_1 **forms)
430	{
431	int i;
432
433	if (num_forms) {
434	*forms = TALLOC_ARRAY(mem_ctx, FORM_1, num_forms);
435	if (*forms == NULL) {
436	return False;
437	}
438	} else {
439	*forms = NULL;
440	}
441
442	prs_set_offset(&buffer->prs,0);
443
444	for (i = 0; i < num_forms; i++) {
445	if (!smb_io_form_1("", buffer, &((*forms)[i]), 0)) {
446	return False;
447	}
448	}
449
450	return True;
451	}
452
453	/**********************************************************************
454	**********************************************************************/
455
456	WERROR rpccli_spoolss_open_printer_ex(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
457	const char printername, const char datatype, uint32 access_required,
458	const char station, const char username, POLICY_HND *pol)
459	{
460	prs_struct qbuf, rbuf;
461	SPOOL_Q_OPEN_PRINTER_EX in;
462	SPOOL_R_OPEN_PRINTER_EX out;
463
464	ZERO_STRUCT(in);
465	ZERO_STRUCT(out);
466
467	make_spoolss_q_open_printer_ex( &in, printername, datatype,
468	access_required, station, username );
469
470	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_OPENPRINTEREX,
471	in, out,
472	qbuf, rbuf,
473	spoolss_io_q_open_printer_ex,
474	spoolss_io_r_open_printer_ex,
475	WERR_GENERAL_FAILURE );
476
477	memcpy( pol, &out.handle, sizeof(POLICY_HND) );
478
479	return out.status;
480	}
481
482	/**********************************************************************
483	**********************************************************************/
484
485	WERROR rpccli_spoolss_close_printer(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
486	POLICY_HND *pol)
487	{
488	prs_struct qbuf, rbuf;
489	SPOOL_Q_CLOSEPRINTER in;
490	SPOOL_R_CLOSEPRINTER out;
491
492	ZERO_STRUCT(in);
493	ZERO_STRUCT(out);
494
495	make_spoolss_q_closeprinter( &in, pol );
496
497	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_CLOSEPRINTER,
498	in, out,
499	qbuf, rbuf,
500	spoolss_io_q_closeprinter,
501	spoolss_io_r_closeprinter,
502	WERR_GENERAL_FAILURE );
503
504	return out.status;
505	}
506
507	/**********************************************************************
508	**********************************************************************/
509
510	WERROR rpccli_spoolss_enum_printers(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
511	char *name, uint32 flags, uint32 level,
512	uint32 num_printers, PRINTER_INFO_CTR ctr)
513	{
514	prs_struct qbuf, rbuf;
515	SPOOL_Q_ENUMPRINTERS in;
516	SPOOL_R_ENUMPRINTERS out;
517	RPC_BUFFER buffer;
518	uint32 offered;
519
520	ZERO_STRUCT(in);
521	ZERO_STRUCT(out);
522
523	offered = 0;
524	rpcbuf_init(&buffer, offered, mem_ctx);
525	make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
526
527	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERS,
528	in, out,
529	qbuf, rbuf,
530	spoolss_io_q_enumprinters,
531	spoolss_io_r_enumprinters,
532	WERR_GENERAL_FAILURE );
533
534	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
535	offered = out.needed;
536
537	ZERO_STRUCT(in);
538	ZERO_STRUCT(out);
539
540	rpcbuf_init(&buffer, offered, mem_ctx);
541	make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
542
543	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERS,
544	in, out,
545	qbuf, rbuf,
546	spoolss_io_q_enumprinters,
547	spoolss_io_r_enumprinters,
548	WERR_GENERAL_FAILURE );
549	}
550
551	if ( !W_ERROR_IS_OK(out.status) )
552	return out.status;
553
554	switch (level) {
555	case 0:
556	if (!decode_printer_info_0(mem_ctx, out.buffer, out.returned, &ctr->printers_0)) {
557	return WERR_GENERAL_FAILURE;
558	}
559	break;
560	case 1:
561	if (!decode_printer_info_1(mem_ctx, out.buffer, out.returned, &ctr->printers_1)) {
562	return WERR_GENERAL_FAILURE;
563	}
564	break;
565	case 2:
566	if (!decode_printer_info_2(mem_ctx, out.buffer, out.returned, &ctr->printers_2)) {
567	return WERR_GENERAL_FAILURE;
568	}
569	break;
570	case 3:
571	if (!decode_printer_info_3(mem_ctx, out.buffer, out.returned, &ctr->printers_3)) {
572	return WERR_GENERAL_FAILURE;
573	}
574	break;
575	default:
576	return WERR_UNKNOWN_LEVEL;
577	}
578
579	*num_printers = out.returned;
580
581	return out.status;
582	}
583
584	/**********************************************************************
585	**********************************************************************/
586
587	WERROR rpccli_spoolss_enum_ports(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
588	uint32 level, uint32 num_ports, PORT_INFO_CTR ctr)
589	{
590	prs_struct qbuf, rbuf;
591	SPOOL_Q_ENUMPORTS in;
592	SPOOL_R_ENUMPORTS out;
593	RPC_BUFFER buffer;
594	fstring server;
595	uint32 offered;
596
597	ZERO_STRUCT(in);
598	ZERO_STRUCT(out);
599
600	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
601	strupper_m(server);
602
603	offered = 0;
604	rpcbuf_init(&buffer, offered, mem_ctx);
605	make_spoolss_q_enumports( &in, server, level, &buffer, offered );
606
607	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPORTS,
608	in, out,
609	qbuf, rbuf,
610	spoolss_io_q_enumports,
611	spoolss_io_r_enumports,
612	WERR_GENERAL_FAILURE );
613
614	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
615	offered = out.needed;
616
617	ZERO_STRUCT(in);
618	ZERO_STRUCT(out);
619
620	rpcbuf_init(&buffer, offered, mem_ctx);
621	make_spoolss_q_enumports( &in, server, level, &buffer, offered );
622
623	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPORTS,
624	in, out,
625	qbuf, rbuf,
626	spoolss_io_q_enumports,
627	spoolss_io_r_enumports,
628	WERR_GENERAL_FAILURE );
629	}
630
631	if ( !W_ERROR_IS_OK(out.status) )
632	return out.status;
633
634	switch (level) {
635	case 1:
636	if (!decode_port_info_1(mem_ctx, out.buffer, out.returned, &ctr->port.info_1)) {
637	return WERR_GENERAL_FAILURE;
638	}
639	break;
640	case 2:
641	if (!decode_port_info_2(mem_ctx, out.buffer, out.returned, &ctr->port.info_2)) {
642	return WERR_GENERAL_FAILURE;
643	}
644	break;
645	default:
646	return WERR_UNKNOWN_LEVEL;
647	}
648
649	*num_ports = out.returned;
650
651	return out.status;
652	}
653
654	/**********************************************************************
655	**********************************************************************/
656
657	WERROR rpccli_spoolss_getprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
658	POLICY_HND *pol, uint32 level,
659	PRINTER_INFO_CTR *ctr)
660	{
661	prs_struct qbuf, rbuf;
662	SPOOL_Q_GETPRINTER in;
663	SPOOL_R_GETPRINTER out;
664	RPC_BUFFER buffer;
665	uint32 offered;
666
667	ZERO_STRUCT(in);
668	ZERO_STRUCT(out);
669
670	/* Initialise input parameters */
671
672	offered = 0;
673	rpcbuf_init(&buffer, offered, mem_ctx);
674	make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
675
676	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTER,
677	in, out,
678	qbuf, rbuf,
679	spoolss_io_q_getprinter,
680	spoolss_io_r_getprinter,
681	WERR_GENERAL_FAILURE );
682
683	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
684	offered = out.needed;
685
686	ZERO_STRUCT(in);
687	ZERO_STRUCT(out);
688
689	rpcbuf_init(&buffer, offered, mem_ctx);
690	make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
691
692	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTER,
693	in, out,
694	qbuf, rbuf,
695	spoolss_io_q_getprinter,
696	spoolss_io_r_getprinter,
697	WERR_GENERAL_FAILURE );
698	}
699
700	if ( !W_ERROR_IS_OK(out.status) )
701	return out.status;
702
703	switch (level) {
704	case 0:
705	if (!decode_printer_info_0(mem_ctx, out.buffer, 1, &ctr->printers_0)) {
706	return WERR_GENERAL_FAILURE;
707	}
708	break;
709	case 1:
710	if (!decode_printer_info_1(mem_ctx, out.buffer, 1, &ctr->printers_1)) {
711	return WERR_GENERAL_FAILURE;
712	}
713	break;
714	case 2:
715	if (!decode_printer_info_2(mem_ctx, out.buffer, 1, &ctr->printers_2)) {
716	return WERR_GENERAL_FAILURE;
717	}
718	break;
719	case 3:
720	if (!decode_printer_info_3(mem_ctx, out.buffer, 1, &ctr->printers_3)) {
721	return WERR_GENERAL_FAILURE;
722	}
723	break;
724	case 7:
725	if (!decode_printer_info_7(mem_ctx, out.buffer, 1, &ctr->printers_7)) {
726	return WERR_GENERAL_FAILURE;
727	}
728	break;
729	default:
730	return WERR_UNKNOWN_LEVEL;
731	}
732
733	return out.status;
734	}
735
736	/**********************************************************************
737	**********************************************************************/
738
739	WERROR rpccli_spoolss_setprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
740	POLICY_HND *pol, uint32 level,
741	PRINTER_INFO_CTR *ctr, uint32 command)
742	{
743	prs_struct qbuf, rbuf;
744	SPOOL_Q_SETPRINTER in;
745	SPOOL_R_SETPRINTER out;
746
747	ZERO_STRUCT(in);
748	ZERO_STRUCT(out);
749
750	make_spoolss_q_setprinter( mem_ctx, &in, pol, level, ctr, command );
751
752	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTER,
753	in, out,
754	qbuf, rbuf,
755	spoolss_io_q_setprinter,
756	spoolss_io_r_setprinter,
757	WERR_GENERAL_FAILURE );
758
759	return out.status;
760	}
761
762	/**********************************************************************
763	**********************************************************************/
764
765	WERROR rpccli_spoolss_getprinterdriver(struct rpc_pipe_client *cli,
766	TALLOC_CTX *mem_ctx,
767	POLICY_HND *pol, uint32 level,
768	const char env, int version, PRINTER_DRIVER_CTR ctr)
769	{
770	prs_struct qbuf, rbuf;
771	SPOOL_Q_GETPRINTERDRIVER2 in;
772	SPOOL_R_GETPRINTERDRIVER2 out;
773	RPC_BUFFER buffer;
774	fstring server;
775	uint32 offered;
776
777	ZERO_STRUCT(in);
778	ZERO_STRUCT(out);
779
780	fstrcpy(server, cli->cli->desthost);
781	strupper_m(server);
782
783	offered = 0;
784	rpcbuf_init(&buffer, offered, mem_ctx);
785	make_spoolss_q_getprinterdriver2( &in, pol, env, level,
786	version, 2, &buffer, offered);
787
788	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVER2,
789	in, out,
790	qbuf, rbuf,
791	spoolss_io_q_getprinterdriver2,
792	spoolss_io_r_getprinterdriver2,
793	WERR_GENERAL_FAILURE );
794
795	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
796	offered = out.needed;
797
798	ZERO_STRUCT(in);
799	ZERO_STRUCT(out);
800
801	rpcbuf_init(&buffer, offered, mem_ctx);
802	make_spoolss_q_getprinterdriver2( &in, pol, env, level,
803	version, 2, &buffer, offered);
804
805	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVER2,
806	in, out,
807	qbuf, rbuf,
808	spoolss_io_q_getprinterdriver2,
809	spoolss_io_r_getprinterdriver2,
810	WERR_GENERAL_FAILURE );
811	}
812
813	if ( !W_ERROR_IS_OK(out.status) )
814	return out.status;
815
816	switch (level) {
817	case 1:
818	if (!decode_printer_driver_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
819	return WERR_GENERAL_FAILURE;
820	}
821	break;
822	case 2:
823	if (!decode_printer_driver_2(mem_ctx, out.buffer, 1, &ctr->info2)) {
824	return WERR_GENERAL_FAILURE;
825	}
826	break;
827	case 3:
828	if (!decode_printer_driver_3(mem_ctx, out.buffer, 1, &ctr->info3)) {
829	return WERR_GENERAL_FAILURE;
830	}
831	break;
832	default:
833	return WERR_UNKNOWN_LEVEL;
834	}
835
836	return out.status;
837	}
838
839	/**********************************************************************
840	**********************************************************************/
841
842	WERROR rpccli_spoolss_enumprinterdrivers (struct rpc_pipe_client *cli,
843	TALLOC_CTX *mem_ctx,
844	uint32 level, const char *env,
845	uint32 *num_drivers,
846	PRINTER_DRIVER_CTR *ctr)
847	{
848	prs_struct qbuf, rbuf;
849	SPOOL_Q_ENUMPRINTERDRIVERS in;
850	SPOOL_R_ENUMPRINTERDRIVERS out;
851	RPC_BUFFER buffer;
852	fstring server;
853	uint32 offered;
854
855	ZERO_STRUCT(in);
856	ZERO_STRUCT(out);
857
858	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
859	strupper_m(server);
860
861	offered = 0;
862	rpcbuf_init(&buffer, offered, mem_ctx);
863	make_spoolss_q_enumprinterdrivers( &in, server, env, level,
864	&buffer, offered);
865
866	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDRIVERS,
867	in, out,
868	qbuf, rbuf,
869	spoolss_io_q_enumprinterdrivers,
870	spoolss_io_r_enumprinterdrivers,
871	WERR_GENERAL_FAILURE );
872
873	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
874	offered = out.needed;
875
876	ZERO_STRUCT(in);
877	ZERO_STRUCT(out);
878
879	rpcbuf_init(&buffer, offered, mem_ctx);
880	make_spoolss_q_enumprinterdrivers( &in, server, env, level,
881	&buffer, offered);
882
883	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDRIVERS,
884	in, out,
885	qbuf, rbuf,
886	spoolss_io_q_enumprinterdrivers,
887	spoolss_io_r_enumprinterdrivers,
888	WERR_GENERAL_FAILURE );
889	}
890
891	*num_drivers = out.returned;
892
893	if ( !W_ERROR_IS_OK(out.status) )
894	return out.status;
895
896	if ( out.returned ) {
897
898	switch (level) {
899	case 1:
900	if (!decode_printer_driver_1(mem_ctx, out.buffer, out.returned, &ctr->info1)) {
901	return WERR_GENERAL_FAILURE;
902	}
903	break;
904	case 2:
905	if (!decode_printer_driver_2(mem_ctx, out.buffer, out.returned, &ctr->info2)) {
906	return WERR_GENERAL_FAILURE;
907	}
908	break;
909	case 3:
910	if (!decode_printer_driver_3(mem_ctx, out.buffer, out.returned, &ctr->info3)) {
911	return WERR_GENERAL_FAILURE;
912	}
913	break;
914	default:
915	return WERR_UNKNOWN_LEVEL;
916	}
917	}
918
919	return out.status;
920	}
921
922
923	/**********************************************************************
924	**********************************************************************/
925
926	WERROR rpccli_spoolss_getprinterdriverdir (struct rpc_pipe_client *cli,
927	TALLOC_CTX *mem_ctx,
928	uint32 level, char *env,
929	DRIVER_DIRECTORY_CTR *ctr)
930	{
931	prs_struct qbuf, rbuf;
932	SPOOL_Q_GETPRINTERDRIVERDIR in;
933	SPOOL_R_GETPRINTERDRIVERDIR out;
934	RPC_BUFFER buffer;
935	fstring server;
936	uint32 offered;
937
938	ZERO_STRUCT(in);
939	ZERO_STRUCT(out);
940
941	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
942	strupper_m(server);
943
944	offered = 0;
945	rpcbuf_init(&buffer, offered, mem_ctx);
946	make_spoolss_q_getprinterdriverdir( &in, server, env, level,
947	&buffer, offered );
948
949	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
950	in, out,
951	qbuf, rbuf,
952	spoolss_io_q_getprinterdriverdir,
953	spoolss_io_r_getprinterdriverdir,
954	WERR_GENERAL_FAILURE );
955
956	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
957	offered = out.needed;
958
959	ZERO_STRUCT(in);
960	ZERO_STRUCT(out);
961
962	rpcbuf_init(&buffer, offered, mem_ctx);
963	make_spoolss_q_getprinterdriverdir( &in, server, env, level,
964	&buffer, offered );
965
966	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
967	in, out,
968	qbuf, rbuf,
969	spoolss_io_q_getprinterdriverdir,
970	spoolss_io_r_getprinterdriverdir,
971	WERR_GENERAL_FAILURE );
972	}
973
974	if (!W_ERROR_IS_OK(out.status))
975	return out.status;
976
977	if (!decode_printerdriverdir_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
978	return WERR_GENERAL_FAILURE;
979	}
980
981	return out.status;
982	}
983
984	/**********************************************************************
985	**********************************************************************/
986
987	WERROR rpccli_spoolss_addprinterdriver (struct rpc_pipe_client *cli,
988	TALLOC_CTX *mem_ctx, uint32 level,
989	PRINTER_DRIVER_CTR *ctr)
990	{
991	prs_struct qbuf, rbuf;
992	SPOOL_Q_ADDPRINTERDRIVER in;
993	SPOOL_R_ADDPRINTERDRIVER out;
994	fstring server;
995
996	ZERO_STRUCT(in);
997	ZERO_STRUCT(out);
998
999	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
1000	strupper_m(server);
1001
1002	make_spoolss_q_addprinterdriver( mem_ctx, &in, server, level, ctr );
1003
1004	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDPRINTERDRIVER,
1005	in, out,
1006	qbuf, rbuf,
1007	spoolss_io_q_addprinterdriver,
1008	spoolss_io_r_addprinterdriver,
1009	WERR_GENERAL_FAILURE );
1010
1011	return out.status;
1012	}
1013
1014	/**********************************************************************
1015	**********************************************************************/
1016
1017	WERROR rpccli_spoolss_addprinterex (struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1018	uint32 level, PRINTER_INFO_CTR*ctr)
1019	{
1020	prs_struct qbuf, rbuf;
1021	SPOOL_Q_ADDPRINTEREX in;
1022	SPOOL_R_ADDPRINTEREX out;
1023	fstring server, client, user;
1024
1025	ZERO_STRUCT(in);
1026	ZERO_STRUCT(out);
1027
1028	slprintf(client, sizeof(fstring)-1, "\\\\%s", global_myname());
1029	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
1030
1031	strupper_m(client);
1032	strupper_m(server);
1033
1034	fstrcpy (user, cli->user_name);
1035
1036	make_spoolss_q_addprinterex( mem_ctx, &in, server, client,
1037	user, level, ctr);
1038
1039	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDPRINTEREX,
1040	in, out,
1041	qbuf, rbuf,
1042	spoolss_io_q_addprinterex,
1043	spoolss_io_r_addprinterex,
1044	WERR_GENERAL_FAILURE );
1045
1046	return out.status;
1047	}
1048
1049	/**********************************************************************
1050	**********************************************************************/
1051
1052	WERROR rpccli_spoolss_deleteprinterdriverex(struct rpc_pipe_client *cli,
1053	TALLOC_CTX mem_ctx, const char arch,
1054	const char *driver, int version)
1055	{
1056	prs_struct qbuf, rbuf;
1057	SPOOL_Q_DELETEPRINTERDRIVEREX in;
1058	SPOOL_R_DELETEPRINTERDRIVEREX out;
1059	fstring server;
1060
1061	ZERO_STRUCT(in);
1062	ZERO_STRUCT(out);
1063
1064	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
1065	strupper_m(server);
1066
1067	make_spoolss_q_deleteprinterdriverex( mem_ctx, &in, server, arch, driver, version );
1068
1069	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDRIVEREX,
1070	in, out,
1071	qbuf, rbuf,
1072	spoolss_io_q_deleteprinterdriverex,
1073	spoolss_io_r_deleteprinterdriverex,
1074	WERR_GENERAL_FAILURE );
1075
1076	return out.status;
1077	}
1078
1079	/**********************************************************************
1080	**********************************************************************/
1081
1082	WERROR rpccli_spoolss_deleteprinterdriver (struct rpc_pipe_client *cli,
1083	TALLOC_CTX mem_ctx, const char arch,
1084	const char *driver)
1085	{
1086	prs_struct qbuf, rbuf;
1087	SPOOL_Q_DELETEPRINTERDRIVER in;
1088	SPOOL_R_DELETEPRINTERDRIVER out;
1089	fstring server;
1090
1091	ZERO_STRUCT(in);
1092	ZERO_STRUCT(out);
1093
1094	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
1095	strupper_m(server);
1096
1097	make_spoolss_q_deleteprinterdriver( mem_ctx, &in, server, arch, driver );
1098
1099	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDRIVER,
1100	in, out,
1101	qbuf, rbuf,
1102	spoolss_io_q_deleteprinterdriver,
1103	spoolss_io_r_deleteprinterdriver,
1104	WERR_GENERAL_FAILURE );
1105
1106	return out.status;
1107	}
1108
1109	/**********************************************************************
1110	**********************************************************************/
1111
1112	WERROR rpccli_spoolss_getprintprocessordirectory(struct rpc_pipe_client *cli,
1113	TALLOC_CTX *mem_ctx,
1114	char name, char environment,
1115	fstring procdir)
1116	{
1117	prs_struct qbuf, rbuf;
1118	SPOOL_Q_GETPRINTPROCESSORDIRECTORY in;
1119	SPOOL_R_GETPRINTPROCESSORDIRECTORY out;
1120	int level = 1;
1121	RPC_BUFFER buffer;
1122	uint32 offered;
1123
1124	ZERO_STRUCT(in);
1125	ZERO_STRUCT(out);
1126
1127	offered = 0;
1128	rpcbuf_init(&buffer, offered, mem_ctx);
1129	make_spoolss_q_getprintprocessordirectory( &in, name,
1130	environment, level, &buffer, offered );
1131
1132	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1133	in, out,
1134	qbuf, rbuf,
1135	spoolss_io_q_getprintprocessordirectory,
1136	spoolss_io_r_getprintprocessordirectory,
1137	WERR_GENERAL_FAILURE );
1138
1139	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1140	offered = out.needed;
1141
1142	ZERO_STRUCT(in);
1143	ZERO_STRUCT(out);
1144
1145	rpcbuf_init(&buffer, offered, mem_ctx);
1146	make_spoolss_q_getprintprocessordirectory( &in, name,
1147	environment, level, &buffer, offered );
1148
1149	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1150	in, out,
1151	qbuf, rbuf,
1152	spoolss_io_q_getprintprocessordirectory,
1153	spoolss_io_r_getprintprocessordirectory,
1154	WERR_GENERAL_FAILURE );
1155	}
1156
1157	if ( !W_ERROR_IS_OK(out.status) )
1158	return out.status;
1159
1160	fstrcpy(procdir, "Not implemented!");
1161
1162	return out.status;
1163	}
1164
1165	/**********************************************************************
1166	**********************************************************************/
1167
1168	WERROR rpccli_spoolss_addform(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1169	POLICY_HND handle, uint32 level, FORM form)
1170	{
1171	prs_struct qbuf, rbuf;
1172	SPOOL_Q_ADDFORM in;
1173	SPOOL_R_ADDFORM out;
1174
1175	ZERO_STRUCT(in);
1176	ZERO_STRUCT(out);
1177
1178	make_spoolss_q_addform( &in, handle, level, form );
1179
1180	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDFORM,
1181	in, out,
1182	qbuf, rbuf,
1183	spoolss_io_q_addform,
1184	spoolss_io_r_addform,
1185	WERR_GENERAL_FAILURE );
1186
1187	return out.status;
1188	}
1189
1190	/**********************************************************************
1191	**********************************************************************/
1192
1193	WERROR rpccli_spoolss_setform(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1194	POLICY_HND *handle, uint32 level,
1195	const char form_name, FORM form)
1196	{
1197	prs_struct qbuf, rbuf;
1198	SPOOL_Q_SETFORM in;
1199	SPOOL_R_SETFORM out;
1200
1201	ZERO_STRUCT(in);
1202	ZERO_STRUCT(out);
1203
1204	make_spoolss_q_setform( &in, handle, level, form_name, form );
1205
1206	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETFORM,
1207	in, out,
1208	qbuf, rbuf,
1209	spoolss_io_q_setform,
1210	spoolss_io_r_setform,
1211	WERR_GENERAL_FAILURE );
1212
1213	return out.status;
1214	}
1215
1216	/**********************************************************************
1217	**********************************************************************/
1218
1219	WERROR rpccli_spoolss_getform(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1220	POLICY_HND handle, const char formname,
1221	uint32 level, FORM_1 *form)
1222	{
1223	prs_struct qbuf, rbuf;
1224	SPOOL_Q_GETFORM in;
1225	SPOOL_R_GETFORM out;
1226	RPC_BUFFER buffer;
1227	uint32 offered;
1228
1229	ZERO_STRUCT(in);
1230	ZERO_STRUCT(out);
1231
1232	offered = 0;
1233	rpcbuf_init(&buffer, offered, mem_ctx);
1234	make_spoolss_q_getform( &in, handle, formname, level, &buffer, offered );
1235
1236	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETFORM,
1237	in, out,
1238	qbuf, rbuf,
1239	spoolss_io_q_getform,
1240	spoolss_io_r_getform,
1241	WERR_GENERAL_FAILURE );
1242
1243	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1244	offered = out.needed;
1245
1246	ZERO_STRUCT(in);
1247	ZERO_STRUCT(out);
1248
1249	rpcbuf_init(&buffer, offered, mem_ctx);
1250	make_spoolss_q_getform( &in, handle, formname, level, &buffer, offered );
1251
1252	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETFORM,
1253	in, out,
1254	qbuf, rbuf,
1255	spoolss_io_q_getform,
1256	spoolss_io_r_getform,
1257	WERR_GENERAL_FAILURE );
1258	}
1259
1260	if (!W_ERROR_IS_OK(out.status))
1261	return out.status;
1262
1263	if (!smb_io_form_1("", out.buffer, form, 0)) {
1264	return WERR_GENERAL_FAILURE;
1265	}
1266
1267	return out.status;
1268	}
1269
1270	/**********************************************************************
1271	**********************************************************************/
1272
1273	WERROR rpccli_spoolss_deleteform(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1274	POLICY_HND handle, const char form_name)
1275	{
1276	prs_struct qbuf, rbuf;
1277	SPOOL_Q_DELETEFORM in;
1278	SPOOL_R_DELETEFORM out;
1279
1280	ZERO_STRUCT(in);
1281	ZERO_STRUCT(out);
1282
1283	make_spoolss_q_deleteform( &in, handle, form_name );
1284
1285	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEFORM,
1286	in, out,
1287	qbuf, rbuf,
1288	spoolss_io_q_deleteform,
1289	spoolss_io_r_deleteform,
1290	WERR_GENERAL_FAILURE );
1291
1292	return out.status;
1293	}
1294
1295	/**********************************************************************
1296	**********************************************************************/
1297
1298	WERROR rpccli_spoolss_enumforms(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1299	POLICY_HND handle, int level, uint32 num_forms,
1300	FORM_1 **forms)
1301	{
1302	prs_struct qbuf, rbuf;
1303	SPOOL_Q_ENUMFORMS in;
1304	SPOOL_R_ENUMFORMS out;
1305	RPC_BUFFER buffer;
1306	uint32 offered;
1307
1308	ZERO_STRUCT(in);
1309	ZERO_STRUCT(out);
1310
1311	offered = 0;
1312	rpcbuf_init(&buffer, offered, mem_ctx);
1313	make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
1314
1315	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMFORMS,
1316	in, out,
1317	qbuf, rbuf,
1318	spoolss_io_q_enumforms,
1319	spoolss_io_r_enumforms,
1320	WERR_GENERAL_FAILURE );
1321
1322	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1323	offered = out.needed;
1324
1325	ZERO_STRUCT(in);
1326	ZERO_STRUCT(out);
1327
1328	rpcbuf_init(&buffer, offered, mem_ctx);
1329	make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
1330
1331	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMFORMS,
1332	in, out,
1333	qbuf, rbuf,
1334	spoolss_io_q_enumforms,
1335	spoolss_io_r_enumforms,
1336	WERR_GENERAL_FAILURE );
1337	}
1338
1339	if (!W_ERROR_IS_OK(out.status))
1340	return out.status;
1341
1342	*num_forms = out.numofforms;
1343
1344	if (!decode_forms_1(mem_ctx, out.buffer, *num_forms, forms)) {
1345	return WERR_GENERAL_FAILURE;
1346	}
1347
1348	return out.status;
1349	}
1350
1351	/**********************************************************************
1352	**********************************************************************/
1353
1354	WERROR rpccli_spoolss_enumjobs(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1355	POLICY_HND *hnd, uint32 level, uint32 firstjob,
1356	uint32 num_jobs, uint32 returned, JOB_INFO_CTR ctr)
1357	{
1358	prs_struct qbuf, rbuf;
1359	SPOOL_Q_ENUMJOBS in;
1360	SPOOL_R_ENUMJOBS out;
1361	RPC_BUFFER buffer;
1362	uint32 offered;
1363
1364	ZERO_STRUCT(in);
1365	ZERO_STRUCT(out);
1366
1367	offered = 0;
1368	rpcbuf_init(&buffer, offered, mem_ctx);
1369	make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
1370	&buffer, offered );
1371
1372	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMJOBS,
1373	in, out,
1374	qbuf, rbuf,
1375	spoolss_io_q_enumjobs,
1376	spoolss_io_r_enumjobs,
1377	WERR_GENERAL_FAILURE );
1378
1379	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1380	offered = out.needed;
1381
1382	ZERO_STRUCT(in);
1383	ZERO_STRUCT(out);
1384
1385	rpcbuf_init(&buffer, offered, mem_ctx);
1386	make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
1387	&buffer, offered );
1388
1389	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMJOBS,
1390	in, out,
1391	qbuf, rbuf,
1392	spoolss_io_q_enumjobs,
1393	spoolss_io_r_enumjobs,
1394	WERR_GENERAL_FAILURE );
1395	}
1396
1397	if (!W_ERROR_IS_OK(out.status))
1398	return out.status;
1399
1400	switch(level) {
1401	case 1:
1402	if (!decode_jobs_1(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_1)) {
1403	return WERR_GENERAL_FAILURE;
1404	}
1405	break;
1406	case 2:
1407	if (!decode_jobs_2(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_2)) {
1408	return WERR_GENERAL_FAILURE;
1409	}
1410	break;
1411	default:
1412	DEBUG(3, ("unsupported info level %d", level));
1413	return WERR_UNKNOWN_LEVEL;
1414	}
1415
1416	*returned = out.returned;
1417
1418	return out.status;
1419	}
1420
1421	/**********************************************************************
1422	**********************************************************************/
1423
1424	WERROR rpccli_spoolss_setjob(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1425	POLICY_HND *hnd, uint32 jobid, uint32 level,
1426	uint32 command)
1427	{
1428	prs_struct qbuf, rbuf;
1429	SPOOL_Q_SETJOB in;
1430	SPOOL_R_SETJOB out;
1431
1432	ZERO_STRUCT(in);
1433	ZERO_STRUCT(out);
1434
1435	make_spoolss_q_setjob( &in, hnd, jobid, level, command );
1436
1437	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETJOB,
1438	in, out,
1439	qbuf, rbuf,
1440	spoolss_io_q_setjob,
1441	spoolss_io_r_setjob,
1442	WERR_GENERAL_FAILURE );
1443
1444	return out.status;
1445	}
1446
1447	/**********************************************************************
1448	**********************************************************************/
1449
1450	WERROR rpccli_spoolss_getjob(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1451	POLICY_HND *hnd, uint32 jobid, uint32 level,
1452	JOB_INFO_CTR *ctr)
1453	{
1454	prs_struct qbuf, rbuf;
1455	SPOOL_Q_GETJOB in;
1456	SPOOL_R_GETJOB out;
1457	RPC_BUFFER buffer;
1458	uint32 offered;
1459
1460	ZERO_STRUCT(in);
1461	ZERO_STRUCT(out);
1462
1463	offered = 0;
1464	rpcbuf_init(&buffer, offered, mem_ctx);
1465	make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
1466
1467	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETJOB,
1468	in, out,
1469	qbuf, rbuf,
1470	spoolss_io_q_getjob,
1471	spoolss_io_r_getjob,
1472	WERR_GENERAL_FAILURE );
1473
1474	if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1475	offered = out.needed;
1476
1477	ZERO_STRUCT(in);
1478	ZERO_STRUCT(out);
1479
1480	rpcbuf_init(&buffer, offered, mem_ctx);
1481	make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
1482
1483	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETJOB,
1484	in, out,
1485	qbuf, rbuf,
1486	spoolss_io_q_getjob,
1487	spoolss_io_r_getjob,
1488	WERR_GENERAL_FAILURE );
1489	}
1490
1491	if (!W_ERROR_IS_OK(out.status))
1492	return out.status;
1493
1494	switch(level) {
1495	case 1:
1496	if (!decode_jobs_1(mem_ctx, out.buffer, 1, &ctr->job.job_info_1)) {
1497	return WERR_GENERAL_FAILURE;
1498	}
1499	break;
1500	case 2:
1501	if (!decode_jobs_2(mem_ctx, out.buffer, 1, &ctr->job.job_info_2)) {
1502	return WERR_GENERAL_FAILURE;
1503	}
1504	break;
1505	default:
1506	return WERR_UNKNOWN_LEVEL;
1507	}
1508
1509	return out.status;
1510	}
1511
1512	/**********************************************************************
1513	**********************************************************************/
1514
1515	WERROR rpccli_spoolss_startpageprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1516	POLICY_HND *hnd)
1517	{
1518	prs_struct qbuf, rbuf;
1519	SPOOL_Q_STARTPAGEPRINTER in;
1520	SPOOL_R_STARTPAGEPRINTER out;
1521
1522	ZERO_STRUCT(in);
1523	ZERO_STRUCT(out);
1524
1525	make_spoolss_q_startpageprinter( &in, hnd );
1526
1527	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_STARTPAGEPRINTER,
1528	in, out,
1529	qbuf, rbuf,
1530	spoolss_io_q_startpageprinter,
1531	spoolss_io_r_startpageprinter,
1532	WERR_GENERAL_FAILURE );
1533
1534	return out.status;
1535	}
1536
1537	/**********************************************************************
1538	**********************************************************************/
1539
1540	WERROR rpccli_spoolss_endpageprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1541	POLICY_HND *hnd)
1542	{
1543	prs_struct qbuf, rbuf;
1544	SPOOL_Q_ENDPAGEPRINTER in;
1545	SPOOL_R_ENDPAGEPRINTER out;
1546
1547	ZERO_STRUCT(in);
1548	ZERO_STRUCT(out);
1549
1550	make_spoolss_q_endpageprinter( &in, hnd );
1551
1552	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENDPAGEPRINTER,
1553	in, out,
1554	qbuf, rbuf,
1555	spoolss_io_q_endpageprinter,
1556	spoolss_io_r_endpageprinter,
1557	WERR_GENERAL_FAILURE );
1558
1559	return out.status;
1560	}
1561
1562	/**********************************************************************
1563	**********************************************************************/
1564
1565	WERROR rpccli_spoolss_startdocprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1566	POLICY_HND hnd, char docname,
1567	char outputfile, char datatype,
1568	uint32 *jobid)
1569	{
1570	prs_struct qbuf, rbuf;
1571	SPOOL_Q_STARTDOCPRINTER in;
1572	SPOOL_R_STARTDOCPRINTER out;
1573	uint32 level = 1;
1574
1575	ZERO_STRUCT(in);
1576	ZERO_STRUCT(out);
1577
1578	make_spoolss_q_startdocprinter( &in, hnd, level, docname,
1579	outputfile, datatype );
1580
1581	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_STARTDOCPRINTER,
1582	in, out,
1583	qbuf, rbuf,
1584	spoolss_io_q_startdocprinter,
1585	spoolss_io_r_startdocprinter,
1586	WERR_GENERAL_FAILURE );
1587
1588	*jobid = out.jobid;
1589
1590	return out.status;
1591	}
1592
1593	/**********************************************************************
1594	**********************************************************************/
1595
1596	WERROR rpccli_spoolss_enddocprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1597	POLICY_HND *hnd)
1598	{
1599	prs_struct qbuf, rbuf;
1600	SPOOL_Q_ENDDOCPRINTER in;
1601	SPOOL_R_ENDDOCPRINTER out;
1602
1603	ZERO_STRUCT(in);
1604	ZERO_STRUCT(out);
1605
1606	make_spoolss_q_enddocprinter( &in, hnd );
1607
1608	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENDDOCPRINTER,
1609	in, out,
1610	qbuf, rbuf,
1611	spoolss_io_q_enddocprinter,
1612	spoolss_io_r_enddocprinter,
1613	WERR_GENERAL_FAILURE );
1614
1615	return out.status;
1616	}
1617
1618	/**********************************************************************
1619	**********************************************************************/
1620
1621	WERROR rpccli_spoolss_getprinterdata(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1622	POLICY_HND hnd, const char valuename,
1623	REGISTRY_VALUE *value)
1624	{
1625	prs_struct qbuf, rbuf;
1626	SPOOL_Q_GETPRINTERDATA in;
1627	SPOOL_R_GETPRINTERDATA out;
1628	uint32 offered;
1629
1630	ZERO_STRUCT(in);
1631	ZERO_STRUCT(out);
1632
1633	offered = 0;
1634	make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1635
1636	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATA,
1637	in, out,
1638	qbuf, rbuf,
1639	spoolss_io_q_getprinterdata,
1640	spoolss_io_r_getprinterdata,
1641	WERR_GENERAL_FAILURE );
1642
1643	if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1644	offered = out.needed;
1645
1646	ZERO_STRUCT(in);
1647	ZERO_STRUCT(out);
1648
1649	make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1650
1651	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATA,
1652	in, out,
1653	qbuf, rbuf,
1654	spoolss_io_q_getprinterdata,
1655	spoolss_io_r_getprinterdata,
1656	WERR_GENERAL_FAILURE );
1657	}
1658
1659	if (!W_ERROR_IS_OK(out.status))
1660	return out.status;
1661
1662	/* Return output parameters */
1663
1664	if (out.needed) {
1665	value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
1666	} else {
1667	value->data_p = NULL;
1668	}
1669	value->type = out.type;
1670	value->size = out.size;
1671
1672	return out.status;
1673	}
1674
1675	/**********************************************************************
1676	**********************************************************************/
1677
1678	WERROR rpccli_spoolss_getprinterdataex(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1679	POLICY_HND hnd, const char keyname,
1680	const char *valuename,
1681	REGISTRY_VALUE *value)
1682	{
1683	prs_struct qbuf, rbuf;
1684	SPOOL_Q_GETPRINTERDATAEX in;
1685	SPOOL_R_GETPRINTERDATAEX out;
1686	uint32 offered = 0;
1687
1688	ZERO_STRUCT(in);
1689	ZERO_STRUCT(out);
1690
1691	make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
1692
1693	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATAEX,
1694	in, out,
1695	qbuf, rbuf,
1696	spoolss_io_q_getprinterdataex,
1697	spoolss_io_r_getprinterdataex,
1698	WERR_GENERAL_FAILURE );
1699
1700	if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1701	offered = out.needed;
1702
1703	ZERO_STRUCT(in);
1704	ZERO_STRUCT(out);
1705
1706	make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
1707
1708	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATAEX,
1709	in, out,
1710	qbuf, rbuf,
1711	spoolss_io_q_getprinterdataex,
1712	spoolss_io_r_getprinterdataex,
1713	WERR_GENERAL_FAILURE );
1714	}
1715
1716	if (!W_ERROR_IS_OK(out.status))
1717	return out.status;
1718
1719	/* Return output parameters */
1720
1721	if (out.needed) {
1722	value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
1723	} else {
1724	value->data_p = NULL;
1725	}
1726	value->type = out.type;
1727	value->size = out.needed;
1728
1729	return out.status;
1730	}
1731
1732	/**********************************************************************
1733	**********************************************************************/
1734
1735	WERROR rpccli_spoolss_setprinterdata(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1736	POLICY_HND hnd, REGISTRY_VALUE value)
1737	{
1738	prs_struct qbuf, rbuf;
1739	SPOOL_Q_SETPRINTERDATA in;
1740	SPOOL_R_SETPRINTERDATA out;
1741
1742	ZERO_STRUCT(in);
1743	ZERO_STRUCT(out);
1744
1745	make_spoolss_q_setprinterdata( &in, hnd, value->valuename,
1746	value->type, (char *)value->data_p, value->size);
1747
1748	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTERDATA,
1749	in, out,
1750	qbuf, rbuf,
1751	spoolss_io_q_setprinterdata,
1752	spoolss_io_r_setprinterdata,
1753	WERR_GENERAL_FAILURE );
1754
1755	return out.status;
1756	}
1757
1758	/**********************************************************************
1759	**********************************************************************/
1760
1761	WERROR rpccli_spoolss_setprinterdataex(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1762	POLICY_HND hnd, char keyname,
1763	REGISTRY_VALUE *value)
1764	{
1765	prs_struct qbuf, rbuf;
1766	SPOOL_Q_SETPRINTERDATAEX in;
1767	SPOOL_R_SETPRINTERDATAEX out;
1768
1769	ZERO_STRUCT(in);
1770	ZERO_STRUCT(out);
1771
1772	make_spoolss_q_setprinterdataex( &in, hnd, keyname, value->valuename,
1773	value->type, (char *)value->data_p, value->size);
1774
1775	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTERDATAEX,
1776	in, out,
1777	qbuf, rbuf,
1778	spoolss_io_q_setprinterdataex,
1779	spoolss_io_r_setprinterdataex,
1780	WERR_GENERAL_FAILURE );
1781
1782	return out.status;
1783	}
1784
1785	/**********************************************************************
1786	**********************************************************************/
1787
1788	WERROR rpccli_spoolss_enumprinterdata(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1789	POLICY_HND *hnd, uint32 ndx,
1790	uint32 value_offered, uint32 data_offered,
1791	uint32 value_needed, uint32 data_needed,
1792	REGISTRY_VALUE *value)
1793	{
1794	prs_struct qbuf, rbuf;
1795	SPOOL_Q_ENUMPRINTERDATA in;
1796	SPOOL_R_ENUMPRINTERDATA out;
1797
1798	ZERO_STRUCT(in);
1799	ZERO_STRUCT(out);
1800
1801	make_spoolss_q_enumprinterdata( &in, hnd, ndx, value_offered, data_offered );
1802
1803	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATA,
1804	in, out,
1805	qbuf, rbuf,
1806	spoolss_io_q_enumprinterdata,
1807	spoolss_io_r_enumprinterdata,
1808	WERR_GENERAL_FAILURE );
1809
1810	if ( value_needed )
1811	*value_needed = out.realvaluesize;
1812	if ( data_needed )
1813	*data_needed = out.realdatasize;
1814
1815	if (!W_ERROR_IS_OK(out.status))
1816	return out.status;
1817
1818	if (value) {
1819	rpcstr_pull(value->valuename, out.value, sizeof(value->valuename), -1,
1820	STR_TERMINATE);
1821	if (out.realdatasize) {
1822	value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data,
1823	out.realdatasize);
1824	} else {
1825	value->data_p = NULL;
1826	}
1827	value->type = out.type;
1828	value->size = out.realdatasize;
1829	}
1830
1831	return out.status;
1832	}
1833
1834	/**********************************************************************
1835	**********************************************************************/
1836
1837	WERROR rpccli_spoolss_enumprinterdataex(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1838	POLICY_HND hnd, const char keyname,
1839	REGVAL_CTR *ctr)
1840	{
1841	prs_struct qbuf, rbuf;
1842	SPOOL_Q_ENUMPRINTERDATAEX in;
1843	SPOOL_R_ENUMPRINTERDATAEX out;
1844	int i;
1845	uint32 offered;
1846
1847	ZERO_STRUCT(in);
1848	ZERO_STRUCT(out);
1849
1850	offered = 0;
1851	make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1852
1853	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATAEX,
1854	in, out,
1855	qbuf, rbuf,
1856	spoolss_io_q_enumprinterdataex,
1857	spoolss_io_r_enumprinterdataex,
1858	WERR_GENERAL_FAILURE );
1859
1860	if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1861	offered = out.needed;
1862
1863	ZERO_STRUCT(in);
1864	ZERO_STRUCT(out);
1865
1866	make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1867
1868	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATAEX,
1869	in, out,
1870	qbuf, rbuf,
1871	spoolss_io_q_enumprinterdataex,
1872	spoolss_io_r_enumprinterdataex,
1873	WERR_GENERAL_FAILURE );
1874	}
1875
1876	if (!W_ERROR_IS_OK(out.status))
1877	return out.status;
1878
1879	for (i = 0; i < out.returned; i++) {
1880	PRINTER_ENUM_VALUES *v = &out.ctr.values[i];
1881	fstring name;
1882
1883	rpcstr_pull(name, v->valuename.buffer, sizeof(name), -1,
1884	STR_TERMINATE);
1885	regval_ctr_addvalue(ctr, name, v->type, (const char *)v->data, v->data_len);
1886	}
1887
1888	return out.status;
1889	}
1890
1891	/**********************************************************************
1892	**********************************************************************/
1893
1894	WERROR rpccli_spoolss_writeprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1895	POLICY_HND hnd, uint32 data_size, char data,
1896	uint32 *num_written)
1897	{
1898	prs_struct qbuf, rbuf;
1899	SPOOL_Q_WRITEPRINTER in;
1900	SPOOL_R_WRITEPRINTER out;
1901
1902	ZERO_STRUCT(in);
1903	ZERO_STRUCT(out);
1904
1905	make_spoolss_q_writeprinter( &in, hnd, data_size, data );
1906
1907	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_WRITEPRINTER,
1908	in, out,
1909	qbuf, rbuf,
1910	spoolss_io_q_writeprinter,
1911	spoolss_io_r_writeprinter,
1912	WERR_GENERAL_FAILURE );
1913
1914	if (num_written)
1915	*num_written = out.buffer_written;
1916
1917	return out.status;
1918	}
1919
1920	/**********************************************************************
1921	**********************************************************************/
1922
1923	WERROR rpccli_spoolss_deleteprinterdata(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1924	POLICY_HND hnd, char valuename)
1925	{
1926	prs_struct qbuf, rbuf;
1927	SPOOL_Q_DELETEPRINTERDATA in;
1928	SPOOL_R_DELETEPRINTERDATA out;
1929
1930	ZERO_STRUCT(in);
1931	ZERO_STRUCT(out);
1932
1933	make_spoolss_q_deleteprinterdata( &in, hnd, valuename );
1934
1935	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDATA,
1936	in, out,
1937	qbuf, rbuf,
1938	spoolss_io_q_deleteprinterdata,
1939	spoolss_io_r_deleteprinterdata,
1940	WERR_GENERAL_FAILURE );
1941
1942	return out.status;
1943	}
1944
1945	/**********************************************************************
1946	**********************************************************************/
1947
1948	WERROR rpccli_spoolss_deleteprinterdataex(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1949	POLICY_HND hnd, char keyname,
1950	char *valuename)
1951	{
1952	prs_struct qbuf, rbuf;
1953	SPOOL_Q_DELETEPRINTERDATAEX in;
1954	SPOOL_R_DELETEPRINTERDATAEX out;
1955
1956	ZERO_STRUCT(in);
1957	ZERO_STRUCT(out);
1958
1959	make_spoolss_q_deleteprinterdataex( &in, hnd, keyname, valuename );
1960
1961	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDATAEX,
1962	in, out,
1963	qbuf, rbuf,
1964	spoolss_io_q_deleteprinterdataex,
1965	spoolss_io_r_deleteprinterdataex,
1966	WERR_GENERAL_FAILURE );
1967
1968	return out.status;
1969	}
1970
1971	/**********************************************************************
1972	**********************************************************************/
1973
1974	WERROR rpccli_spoolss_enumprinterkey(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1975	POLICY_HND hnd, const char keyname,
1976	uint16 *keylist, uint32 len)
1977	{
1978	prs_struct qbuf, rbuf;
1979	SPOOL_Q_ENUMPRINTERKEY in;
1980	SPOOL_R_ENUMPRINTERKEY out;
1981	uint32 offered = 0;
1982
1983	ZERO_STRUCT(in);
1984	ZERO_STRUCT(out);
1985
1986	make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
1987
1988	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERKEY,
1989	in, out,
1990	qbuf, rbuf,
1991	spoolss_io_q_enumprinterkey,
1992	spoolss_io_r_enumprinterkey,
1993	WERR_GENERAL_FAILURE );
1994
1995	if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1996	offered = out.needed;
1997
1998	ZERO_STRUCT(in);
1999	ZERO_STRUCT(out);
2000
2001	make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
2002
2003	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERKEY,
2004	in, out,
2005	qbuf, rbuf,
2006	spoolss_io_q_enumprinterkey,
2007	spoolss_io_r_enumprinterkey,
2008	WERR_GENERAL_FAILURE );
2009	}
2010
2011	if ( !W_ERROR_IS_OK(out.status) )
2012	return out.status;
2013
2014	if (keylist) {
2015	*keylist = SMB_MALLOC_ARRAY(uint16, out.keys.buf_len);
2016	if (!*keylist) {
2017	return WERR_NOMEM;
2018	}
2019	memcpy(keylist, out.keys.buffer, out.keys.buf_len 2);
2020	if (len)
2021	len = out.keys.buf_len 2;
2022	}
2023
2024	return out.status;
2025	}
2026
2027	/**********************************************************************
2028	**********************************************************************/
2029
2030	WERROR rpccli_spoolss_deleteprinterkey(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
2031	POLICY_HND hnd, char keyname)
2032	{
2033	prs_struct qbuf, rbuf;
2034	SPOOL_Q_DELETEPRINTERKEY in;
2035	SPOOL_R_DELETEPRINTERKEY out;
2036
2037	ZERO_STRUCT(in);
2038	ZERO_STRUCT(out);
2039
2040	make_spoolss_q_deleteprinterkey( &in, hnd, keyname );
2041
2042	CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERKEY,
2043	in, out,
2044	qbuf, rbuf,
2045	spoolss_io_q_deleteprinterkey,
2046	spoolss_io_r_deleteprinterkey,
2047	WERR_GENERAL_FAILURE );
2048
2049	return out.status;
2050	}
2051
2052	/ @} /

Note: See TracBrowser for help on using the repository browser.

Download in other formats: