Context Navigation

source: branches/samba-3.0/source/rpc_client/cli_spoolss.c

Visit:

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

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

Download in other formats: