Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: branches/samba-3.3.x/source/rpc_client/cli_spoolss.c@ 614

Visit:

Last change on this file since 614 was 206, checked in by Herwig Bauernfeind, 17 years ago
Import Samba 3.3 branch at 3.0.0 level (psmedley's port)
File size: 54.0 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, &syntax_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, &syntax_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	if (!rpcbuf_init(&buffer, offered, mem_ctx))
525	return WERR_NOMEM;
526	make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
527
528	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_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	if (!rpcbuf_init(&buffer, offered, mem_ctx))
542	return WERR_NOMEM;
543	make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
544
545	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERS,
546	in, out,
547	qbuf, rbuf,
548	spoolss_io_q_enumprinters,
549	spoolss_io_r_enumprinters,
550	WERR_GENERAL_FAILURE );
551	}
552
553	if ( !W_ERROR_IS_OK(out.status) )
554	return out.status;
555
556	switch (level) {
557	case 0:
558	if (!decode_printer_info_0(mem_ctx, out.buffer, out.returned, &ctr->printers_0)) {
559	return WERR_GENERAL_FAILURE;
560	}
561	break;
562	case 1:
563	if (!decode_printer_info_1(mem_ctx, out.buffer, out.returned, &ctr->printers_1)) {
564	return WERR_GENERAL_FAILURE;
565	}
566	break;
567	case 2:
568	if (!decode_printer_info_2(mem_ctx, out.buffer, out.returned, &ctr->printers_2)) {
569	return WERR_GENERAL_FAILURE;
570	}
571	break;
572	case 3:
573	if (!decode_printer_info_3(mem_ctx, out.buffer, out.returned, &ctr->printers_3)) {
574	return WERR_GENERAL_FAILURE;
575	}
576	break;
577	default:
578	return WERR_UNKNOWN_LEVEL;
579	}
580
581	*num_printers = out.returned;
582
583	return out.status;
584	}
585
586	/**********************************************************************
587	**********************************************************************/
588
589	WERROR rpccli_spoolss_enum_ports(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
590	uint32 level, uint32 num_ports, PORT_INFO_CTR ctr)
591	{
592	prs_struct qbuf, rbuf;
593	SPOOL_Q_ENUMPORTS in;
594	SPOOL_R_ENUMPORTS out;
595	RPC_BUFFER buffer;
596	fstring server;
597	uint32 offered;
598
599	ZERO_STRUCT(in);
600	ZERO_STRUCT(out);
601
602	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
603	strupper_m(server);
604
605	offered = 0;
606	if (!rpcbuf_init(&buffer, offered, mem_ctx))
607	return WERR_NOMEM;
608	make_spoolss_q_enumports( &in, server, level, &buffer, offered );
609
610	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPORTS,
611	in, out,
612	qbuf, rbuf,
613	spoolss_io_q_enumports,
614	spoolss_io_r_enumports,
615	WERR_GENERAL_FAILURE );
616
617	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
618	offered = out.needed;
619
620	ZERO_STRUCT(in);
621	ZERO_STRUCT(out);
622
623	if (!rpcbuf_init(&buffer, offered, mem_ctx))
624	return WERR_NOMEM;
625	make_spoolss_q_enumports( &in, server, level, &buffer, offered );
626
627	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPORTS,
628	in, out,
629	qbuf, rbuf,
630	spoolss_io_q_enumports,
631	spoolss_io_r_enumports,
632	WERR_GENERAL_FAILURE );
633	}
634
635	if ( !W_ERROR_IS_OK(out.status) )
636	return out.status;
637
638	switch (level) {
639	case 1:
640	if (!decode_port_info_1(mem_ctx, out.buffer, out.returned, &ctr->port.info_1)) {
641	return WERR_GENERAL_FAILURE;
642	}
643	break;
644	case 2:
645	if (!decode_port_info_2(mem_ctx, out.buffer, out.returned, &ctr->port.info_2)) {
646	return WERR_GENERAL_FAILURE;
647	}
648	break;
649	default:
650	return WERR_UNKNOWN_LEVEL;
651	}
652
653	*num_ports = out.returned;
654
655	return out.status;
656	}
657
658	/**********************************************************************
659	**********************************************************************/
660
661	WERROR rpccli_spoolss_getprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
662	POLICY_HND *pol, uint32 level,
663	PRINTER_INFO_CTR *ctr)
664	{
665	prs_struct qbuf, rbuf;
666	SPOOL_Q_GETPRINTER in;
667	SPOOL_R_GETPRINTER out;
668	RPC_BUFFER buffer;
669	uint32 offered;
670
671	ZERO_STRUCT(in);
672	ZERO_STRUCT(out);
673
674	/* Initialise input parameters */
675
676	offered = 0;
677	if (!rpcbuf_init(&buffer, offered, mem_ctx))
678	return WERR_NOMEM;
679	make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
680
681	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTER,
682	in, out,
683	qbuf, rbuf,
684	spoolss_io_q_getprinter,
685	spoolss_io_r_getprinter,
686	WERR_GENERAL_FAILURE );
687
688	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
689	offered = out.needed;
690
691	ZERO_STRUCT(in);
692	ZERO_STRUCT(out);
693
694	if (!rpcbuf_init(&buffer, offered, mem_ctx))
695	return WERR_NOMEM;
696	make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
697
698	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTER,
699	in, out,
700	qbuf, rbuf,
701	spoolss_io_q_getprinter,
702	spoolss_io_r_getprinter,
703	WERR_GENERAL_FAILURE );
704	}
705
706	if ( !W_ERROR_IS_OK(out.status) )
707	return out.status;
708
709	switch (level) {
710	case 0:
711	if (!decode_printer_info_0(mem_ctx, out.buffer, 1, &ctr->printers_0)) {
712	return WERR_GENERAL_FAILURE;
713	}
714	break;
715	case 1:
716	if (!decode_printer_info_1(mem_ctx, out.buffer, 1, &ctr->printers_1)) {
717	return WERR_GENERAL_FAILURE;
718	}
719	break;
720	case 2:
721	if (!decode_printer_info_2(mem_ctx, out.buffer, 1, &ctr->printers_2)) {
722	return WERR_GENERAL_FAILURE;
723	}
724	break;
725	case 3:
726	if (!decode_printer_info_3(mem_ctx, out.buffer, 1, &ctr->printers_3)) {
727	return WERR_GENERAL_FAILURE;
728	}
729	break;
730	case 7:
731	if (!decode_printer_info_7(mem_ctx, out.buffer, 1, &ctr->printers_7)) {
732	return WERR_GENERAL_FAILURE;
733	}
734	break;
735	default:
736	return WERR_UNKNOWN_LEVEL;
737	}
738
739	return out.status;
740	}
741
742	/**********************************************************************
743	**********************************************************************/
744
745	WERROR rpccli_spoolss_setprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
746	POLICY_HND *pol, uint32 level,
747	PRINTER_INFO_CTR *ctr, uint32 command)
748	{
749	prs_struct qbuf, rbuf;
750	SPOOL_Q_SETPRINTER in;
751	SPOOL_R_SETPRINTER out;
752
753	ZERO_STRUCT(in);
754	ZERO_STRUCT(out);
755
756	make_spoolss_q_setprinter( mem_ctx, &in, pol, level, ctr, command );
757
758	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETPRINTER,
759	in, out,
760	qbuf, rbuf,
761	spoolss_io_q_setprinter,
762	spoolss_io_r_setprinter,
763	WERR_GENERAL_FAILURE );
764
765	return out.status;
766	}
767
768	/**********************************************************************
769	**********************************************************************/
770
771	WERROR rpccli_spoolss_getprinterdriver(struct rpc_pipe_client *cli,
772	TALLOC_CTX *mem_ctx,
773	POLICY_HND *pol, uint32 level,
774	const char env, int version, PRINTER_DRIVER_CTR ctr)
775	{
776	prs_struct qbuf, rbuf;
777	SPOOL_Q_GETPRINTERDRIVER2 in;
778	SPOOL_R_GETPRINTERDRIVER2 out;
779	RPC_BUFFER buffer;
780	fstring server;
781	uint32 offered;
782
783	ZERO_STRUCT(in);
784	ZERO_STRUCT(out);
785
786	fstrcpy(server, cli->desthost);
787	strupper_m(server);
788
789	offered = 0;
790	if (!rpcbuf_init(&buffer, offered, mem_ctx))
791	return WERR_NOMEM;
792	make_spoolss_q_getprinterdriver2( &in, pol, env, level,
793	version, 2, &buffer, offered);
794
795	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDRIVER2,
796	in, out,
797	qbuf, rbuf,
798	spoolss_io_q_getprinterdriver2,
799	spoolss_io_r_getprinterdriver2,
800	WERR_GENERAL_FAILURE );
801
802	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
803	offered = out.needed;
804
805	ZERO_STRUCT(in);
806	ZERO_STRUCT(out);
807
808	if (!rpcbuf_init(&buffer, offered, mem_ctx))
809	return WERR_NOMEM;
810	make_spoolss_q_getprinterdriver2( &in, pol, env, level,
811	version, 2, &buffer, offered);
812
813	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDRIVER2,
814	in, out,
815	qbuf, rbuf,
816	spoolss_io_q_getprinterdriver2,
817	spoolss_io_r_getprinterdriver2,
818	WERR_GENERAL_FAILURE );
819	}
820
821	if ( !W_ERROR_IS_OK(out.status) )
822	return out.status;
823
824	switch (level) {
825	case 1:
826	if (!decode_printer_driver_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
827	return WERR_GENERAL_FAILURE;
828	}
829	break;
830	case 2:
831	if (!decode_printer_driver_2(mem_ctx, out.buffer, 1, &ctr->info2)) {
832	return WERR_GENERAL_FAILURE;
833	}
834	break;
835	case 3:
836	if (!decode_printer_driver_3(mem_ctx, out.buffer, 1, &ctr->info3)) {
837	return WERR_GENERAL_FAILURE;
838	}
839	break;
840	default:
841	return WERR_UNKNOWN_LEVEL;
842	}
843
844	return out.status;
845	}
846
847	/**********************************************************************
848	**********************************************************************/
849
850	WERROR rpccli_spoolss_enumprinterdrivers (struct rpc_pipe_client *cli,
851	TALLOC_CTX *mem_ctx,
852	uint32 level, const char *env,
853	uint32 *num_drivers,
854	PRINTER_DRIVER_CTR *ctr)
855	{
856	prs_struct qbuf, rbuf;
857	SPOOL_Q_ENUMPRINTERDRIVERS in;
858	SPOOL_R_ENUMPRINTERDRIVERS out;
859	RPC_BUFFER buffer;
860	fstring server;
861	uint32 offered;
862
863	ZERO_STRUCT(in);
864	ZERO_STRUCT(out);
865
866	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
867	strupper_m(server);
868
869	offered = 0;
870	if (!rpcbuf_init(&buffer, offered, mem_ctx))
871	return WERR_NOMEM;
872	make_spoolss_q_enumprinterdrivers( &in, server, env, level,
873	&buffer, offered);
874
875	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDRIVERS,
876	in, out,
877	qbuf, rbuf,
878	spoolss_io_q_enumprinterdrivers,
879	spoolss_io_r_enumprinterdrivers,
880	WERR_GENERAL_FAILURE );
881
882	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
883	offered = out.needed;
884
885	ZERO_STRUCT(in);
886	ZERO_STRUCT(out);
887
888	if (!rpcbuf_init(&buffer, offered, mem_ctx))
889	return WERR_NOMEM;
890	make_spoolss_q_enumprinterdrivers( &in, server, env, level,
891	&buffer, offered);
892
893	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDRIVERS,
894	in, out,
895	qbuf, rbuf,
896	spoolss_io_q_enumprinterdrivers,
897	spoolss_io_r_enumprinterdrivers,
898	WERR_GENERAL_FAILURE );
899	}
900
901	*num_drivers = out.returned;
902
903	if ( !W_ERROR_IS_OK(out.status) )
904	return out.status;
905
906	if ( out.returned ) {
907
908	switch (level) {
909	case 1:
910	if (!decode_printer_driver_1(mem_ctx, out.buffer, out.returned, &ctr->info1)) {
911	return WERR_GENERAL_FAILURE;
912	}
913	break;
914	case 2:
915	if (!decode_printer_driver_2(mem_ctx, out.buffer, out.returned, &ctr->info2)) {
916	return WERR_GENERAL_FAILURE;
917	}
918	break;
919	case 3:
920	if (!decode_printer_driver_3(mem_ctx, out.buffer, out.returned, &ctr->info3)) {
921	return WERR_GENERAL_FAILURE;
922	}
923	break;
924	default:
925	return WERR_UNKNOWN_LEVEL;
926	}
927	}
928
929	return out.status;
930	}
931
932
933	/**********************************************************************
934	**********************************************************************/
935
936	WERROR rpccli_spoolss_getprinterdriverdir (struct rpc_pipe_client *cli,
937	TALLOC_CTX *mem_ctx,
938	uint32 level, char *env,
939	DRIVER_DIRECTORY_CTR *ctr)
940	{
941	prs_struct qbuf, rbuf;
942	SPOOL_Q_GETPRINTERDRIVERDIR in;
943	SPOOL_R_GETPRINTERDRIVERDIR out;
944	RPC_BUFFER buffer;
945	fstring server;
946	uint32 offered;
947
948	ZERO_STRUCT(in);
949	ZERO_STRUCT(out);
950
951	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
952	strupper_m(server);
953
954	offered = 0;
955	if (!rpcbuf_init(&buffer, offered, mem_ctx))
956	return WERR_NOMEM;
957	make_spoolss_q_getprinterdriverdir( &in, server, env, level,
958	&buffer, offered );
959
960	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
961	in, out,
962	qbuf, rbuf,
963	spoolss_io_q_getprinterdriverdir,
964	spoolss_io_r_getprinterdriverdir,
965	WERR_GENERAL_FAILURE );
966
967	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
968	offered = out.needed;
969
970	ZERO_STRUCT(in);
971	ZERO_STRUCT(out);
972
973	if (!rpcbuf_init(&buffer, offered, mem_ctx))
974	return WERR_NOMEM;
975	make_spoolss_q_getprinterdriverdir( &in, server, env, level,
976	&buffer, offered );
977
978	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
979	in, out,
980	qbuf, rbuf,
981	spoolss_io_q_getprinterdriverdir,
982	spoolss_io_r_getprinterdriverdir,
983	WERR_GENERAL_FAILURE );
984	}
985
986	if (!W_ERROR_IS_OK(out.status))
987	return out.status;
988
989	if (!decode_printerdriverdir_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
990	return WERR_GENERAL_FAILURE;
991	}
992
993	return out.status;
994	}
995
996	/**********************************************************************
997	**********************************************************************/
998
999	WERROR rpccli_spoolss_addprinterdriver (struct rpc_pipe_client *cli,
1000	TALLOC_CTX *mem_ctx, uint32 level,
1001	PRINTER_DRIVER_CTR *ctr)
1002	{
1003	prs_struct qbuf, rbuf;
1004	SPOOL_Q_ADDPRINTERDRIVER in;
1005	SPOOL_R_ADDPRINTERDRIVER out;
1006	fstring server;
1007
1008	ZERO_STRUCT(in);
1009	ZERO_STRUCT(out);
1010
1011	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1012	strupper_m(server);
1013
1014	make_spoolss_q_addprinterdriver( mem_ctx, &in, server, level, ctr );
1015
1016	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ADDPRINTERDRIVER,
1017	in, out,
1018	qbuf, rbuf,
1019	spoolss_io_q_addprinterdriver,
1020	spoolss_io_r_addprinterdriver,
1021	WERR_GENERAL_FAILURE );
1022
1023	return out.status;
1024	}
1025
1026	/**********************************************************************
1027	**********************************************************************/
1028
1029	WERROR rpccli_spoolss_addprinterex (struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1030	uint32 level, PRINTER_INFO_CTR*ctr)
1031	{
1032	prs_struct qbuf, rbuf;
1033	SPOOL_Q_ADDPRINTEREX in;
1034	SPOOL_R_ADDPRINTEREX out;
1035	fstring server, client, user;
1036
1037	ZERO_STRUCT(in);
1038	ZERO_STRUCT(out);
1039
1040	slprintf(client, sizeof(fstring)-1, "\\\\%s", global_myname());
1041	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1042
1043	strupper_m(client);
1044	strupper_m(server);
1045
1046	fstrcpy (user, cli->auth->user_name);
1047
1048	make_spoolss_q_addprinterex( mem_ctx, &in, server, client,
1049	user, level, ctr);
1050
1051	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ADDPRINTEREX,
1052	in, out,
1053	qbuf, rbuf,
1054	spoolss_io_q_addprinterex,
1055	spoolss_io_r_addprinterex,
1056	WERR_GENERAL_FAILURE );
1057
1058	return out.status;
1059	}
1060
1061	/**********************************************************************
1062	**********************************************************************/
1063
1064	WERROR rpccli_spoolss_deleteprinterdriverex(struct rpc_pipe_client *cli,
1065	TALLOC_CTX mem_ctx, const char arch,
1066	const char *driver, int version)
1067	{
1068	prs_struct qbuf, rbuf;
1069	SPOOL_Q_DELETEPRINTERDRIVEREX in;
1070	SPOOL_R_DELETEPRINTERDRIVEREX out;
1071	fstring server;
1072
1073	ZERO_STRUCT(in);
1074	ZERO_STRUCT(out);
1075
1076	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1077	strupper_m(server);
1078
1079	make_spoolss_q_deleteprinterdriverex( mem_ctx, &in, server, arch, driver, version );
1080
1081	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_DELETEPRINTERDRIVEREX,
1082	in, out,
1083	qbuf, rbuf,
1084	spoolss_io_q_deleteprinterdriverex,
1085	spoolss_io_r_deleteprinterdriverex,
1086	WERR_GENERAL_FAILURE );
1087
1088	return out.status;
1089	}
1090
1091	/**********************************************************************
1092	**********************************************************************/
1093
1094	WERROR rpccli_spoolss_deleteprinterdriver (struct rpc_pipe_client *cli,
1095	TALLOC_CTX mem_ctx, const char arch,
1096	const char *driver)
1097	{
1098	prs_struct qbuf, rbuf;
1099	SPOOL_Q_DELETEPRINTERDRIVER in;
1100	SPOOL_R_DELETEPRINTERDRIVER out;
1101	fstring server;
1102
1103	ZERO_STRUCT(in);
1104	ZERO_STRUCT(out);
1105
1106	slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1107	strupper_m(server);
1108
1109	make_spoolss_q_deleteprinterdriver( mem_ctx, &in, server, arch, driver );
1110
1111	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_DELETEPRINTERDRIVER,
1112	in, out,
1113	qbuf, rbuf,
1114	spoolss_io_q_deleteprinterdriver,
1115	spoolss_io_r_deleteprinterdriver,
1116	WERR_GENERAL_FAILURE );
1117
1118	return out.status;
1119	}
1120
1121	/**********************************************************************
1122	**********************************************************************/
1123
1124	WERROR rpccli_spoolss_getprintprocessordirectory(struct rpc_pipe_client *cli,
1125	TALLOC_CTX *mem_ctx,
1126	char name, char environment,
1127	fstring procdir)
1128	{
1129	prs_struct qbuf, rbuf;
1130	SPOOL_Q_GETPRINTPROCESSORDIRECTORY in;
1131	SPOOL_R_GETPRINTPROCESSORDIRECTORY out;
1132	int level = 1;
1133	RPC_BUFFER buffer;
1134	uint32 offered;
1135
1136	ZERO_STRUCT(in);
1137	ZERO_STRUCT(out);
1138
1139	offered = 0;
1140	if (!rpcbuf_init(&buffer, offered, mem_ctx))
1141	return WERR_NOMEM;
1142	make_spoolss_q_getprintprocessordirectory( &in, name,
1143	environment, level, &buffer, offered );
1144
1145	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1146	in, out,
1147	qbuf, rbuf,
1148	spoolss_io_q_getprintprocessordirectory,
1149	spoolss_io_r_getprintprocessordirectory,
1150	WERR_GENERAL_FAILURE );
1151
1152	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1153	offered = out.needed;
1154
1155	ZERO_STRUCT(in);
1156	ZERO_STRUCT(out);
1157
1158	if (!rpcbuf_init(&buffer, offered, mem_ctx))
1159	return WERR_NOMEM;
1160	make_spoolss_q_getprintprocessordirectory( &in, name,
1161	environment, level, &buffer, offered );
1162
1163	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
1164	in, out,
1165	qbuf, rbuf,
1166	spoolss_io_q_getprintprocessordirectory,
1167	spoolss_io_r_getprintprocessordirectory,
1168	WERR_GENERAL_FAILURE );
1169	}
1170
1171	if ( !W_ERROR_IS_OK(out.status) )
1172	return out.status;
1173
1174	fstrcpy(procdir, "Not implemented!");
1175
1176	return out.status;
1177	}
1178
1179	/**********************************************************************
1180	**********************************************************************/
1181
1182	WERROR rpccli_spoolss_addform(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1183	POLICY_HND handle, uint32 level, FORM form)
1184	{
1185	prs_struct qbuf, rbuf;
1186	SPOOL_Q_ADDFORM in;
1187	SPOOL_R_ADDFORM out;
1188
1189	ZERO_STRUCT(in);
1190	ZERO_STRUCT(out);
1191
1192	make_spoolss_q_addform( &in, handle, level, form );
1193
1194	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ADDFORM,
1195	in, out,
1196	qbuf, rbuf,
1197	spoolss_io_q_addform,
1198	spoolss_io_r_addform,
1199	WERR_GENERAL_FAILURE );
1200
1201	return out.status;
1202	}
1203
1204	/**********************************************************************
1205	**********************************************************************/
1206
1207	WERROR rpccli_spoolss_setform(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1208	POLICY_HND *handle, uint32 level,
1209	const char form_name, FORM form)
1210	{
1211	prs_struct qbuf, rbuf;
1212	SPOOL_Q_SETFORM in;
1213	SPOOL_R_SETFORM out;
1214
1215	ZERO_STRUCT(in);
1216	ZERO_STRUCT(out);
1217
1218	make_spoolss_q_setform( &in, handle, level, form_name, form );
1219
1220	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETFORM,
1221	in, out,
1222	qbuf, rbuf,
1223	spoolss_io_q_setform,
1224	spoolss_io_r_setform,
1225	WERR_GENERAL_FAILURE );
1226
1227	return out.status;
1228	}
1229
1230	/**********************************************************************
1231	**********************************************************************/
1232
1233	WERROR rpccli_spoolss_getform(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1234	POLICY_HND handle, const char formname,
1235	uint32 level, FORM_1 *form)
1236	{
1237	prs_struct qbuf, rbuf;
1238	SPOOL_Q_GETFORM in;
1239	SPOOL_R_GETFORM out;
1240	RPC_BUFFER buffer;
1241	uint32 offered;
1242
1243	ZERO_STRUCT(in);
1244	ZERO_STRUCT(out);
1245
1246	offered = 0;
1247	if (!rpcbuf_init(&buffer, offered, mem_ctx))
1248	return WERR_NOMEM;
1249	make_spoolss_q_getform( &in, handle, formname, level, &buffer, offered );
1250
1251	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETFORM,
1252	in, out,
1253	qbuf, rbuf,
1254	spoolss_io_q_getform,
1255	spoolss_io_r_getform,
1256	WERR_GENERAL_FAILURE );
1257
1258	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1259	offered = out.needed;
1260
1261	ZERO_STRUCT(in);
1262	ZERO_STRUCT(out);
1263
1264	if (!rpcbuf_init(&buffer, offered, mem_ctx))
1265	return WERR_NOMEM;
1266	make_spoolss_q_getform( &in, handle, formname, level, &buffer, offered );
1267
1268	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETFORM,
1269	in, out,
1270	qbuf, rbuf,
1271	spoolss_io_q_getform,
1272	spoolss_io_r_getform,
1273	WERR_GENERAL_FAILURE );
1274	}
1275
1276	if (!W_ERROR_IS_OK(out.status))
1277	return out.status;
1278
1279	if (!smb_io_form_1("", out.buffer, form, 0)) {
1280	return WERR_GENERAL_FAILURE;
1281	}
1282
1283	return out.status;
1284	}
1285
1286	/**********************************************************************
1287	**********************************************************************/
1288
1289	WERROR rpccli_spoolss_deleteform(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1290	POLICY_HND handle, const char form_name)
1291	{
1292	prs_struct qbuf, rbuf;
1293	SPOOL_Q_DELETEFORM in;
1294	SPOOL_R_DELETEFORM out;
1295
1296	ZERO_STRUCT(in);
1297	ZERO_STRUCT(out);
1298
1299	make_spoolss_q_deleteform( &in, handle, form_name );
1300
1301	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_DELETEFORM,
1302	in, out,
1303	qbuf, rbuf,
1304	spoolss_io_q_deleteform,
1305	spoolss_io_r_deleteform,
1306	WERR_GENERAL_FAILURE );
1307
1308	return out.status;
1309	}
1310
1311	/**********************************************************************
1312	**********************************************************************/
1313
1314	WERROR rpccli_spoolss_enumforms(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1315	POLICY_HND handle, int level, uint32 num_forms,
1316	FORM_1 **forms)
1317	{
1318	prs_struct qbuf, rbuf;
1319	SPOOL_Q_ENUMFORMS in;
1320	SPOOL_R_ENUMFORMS out;
1321	RPC_BUFFER buffer;
1322	uint32 offered;
1323
1324	ZERO_STRUCT(in);
1325	ZERO_STRUCT(out);
1326
1327	offered = 0;
1328	if (!rpcbuf_init(&buffer, offered, mem_ctx))
1329	return WERR_NOMEM;
1330	make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
1331
1332	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_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	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1340	offered = out.needed;
1341
1342	ZERO_STRUCT(in);
1343	ZERO_STRUCT(out);
1344
1345	if (!rpcbuf_init(&buffer, offered, mem_ctx))
1346	return WERR_NOMEM;
1347	make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
1348
1349	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMFORMS,
1350	in, out,
1351	qbuf, rbuf,
1352	spoolss_io_q_enumforms,
1353	spoolss_io_r_enumforms,
1354	WERR_GENERAL_FAILURE );
1355	}
1356
1357	if (!W_ERROR_IS_OK(out.status))
1358	return out.status;
1359
1360	*num_forms = out.numofforms;
1361
1362	if (!decode_forms_1(mem_ctx, out.buffer, *num_forms, forms)) {
1363	return WERR_GENERAL_FAILURE;
1364	}
1365
1366	return out.status;
1367	}
1368
1369	/**********************************************************************
1370	**********************************************************************/
1371
1372	WERROR rpccli_spoolss_enumjobs(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1373	POLICY_HND *hnd, uint32 level, uint32 firstjob,
1374	uint32 num_jobs, uint32 returned, JOB_INFO_CTR ctr)
1375	{
1376	prs_struct qbuf, rbuf;
1377	SPOOL_Q_ENUMJOBS in;
1378	SPOOL_R_ENUMJOBS out;
1379	RPC_BUFFER buffer;
1380	uint32 offered;
1381
1382	ZERO_STRUCT(in);
1383	ZERO_STRUCT(out);
1384
1385	offered = 0;
1386	if (!rpcbuf_init(&buffer, offered, mem_ctx))
1387	return WERR_NOMEM;
1388	make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
1389	&buffer, offered );
1390
1391	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMJOBS,
1392	in, out,
1393	qbuf, rbuf,
1394	spoolss_io_q_enumjobs,
1395	spoolss_io_r_enumjobs,
1396	WERR_GENERAL_FAILURE );
1397
1398	if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
1399	offered = out.needed;
1400
1401	ZERO_STRUCT(in);
1402	ZERO_STRUCT(out);
1403
1404	if (!rpcbuf_init(&buffer, offered, mem_ctx))
1405	return WERR_NOMEM;
1406	make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level,
1407	&buffer, offered );
1408
1409	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMJOBS,
1410	in, out,
1411	qbuf, rbuf,
1412	spoolss_io_q_enumjobs,
1413	spoolss_io_r_enumjobs,
1414	WERR_GENERAL_FAILURE );
1415	}
1416
1417	if (!W_ERROR_IS_OK(out.status))
1418	return out.status;
1419
1420	switch(level) {
1421	case 1:
1422	if (!decode_jobs_1(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_1)) {
1423	return WERR_GENERAL_FAILURE;
1424	}
1425	break;
1426	case 2:
1427	if (!decode_jobs_2(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_2)) {
1428	return WERR_GENERAL_FAILURE;
1429	}
1430	break;
1431	default:
1432	DEBUG(3, ("unsupported info level %d", level));
1433	return WERR_UNKNOWN_LEVEL;
1434	}
1435
1436	*returned = out.returned;
1437
1438	return out.status;
1439	}
1440
1441	/**********************************************************************
1442	**********************************************************************/
1443
1444	WERROR rpccli_spoolss_setjob(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1445	POLICY_HND *hnd, uint32 jobid, uint32 level,
1446	uint32 command)
1447	{
1448	prs_struct qbuf, rbuf;
1449	SPOOL_Q_SETJOB in;
1450	SPOOL_R_SETJOB out;
1451
1452	ZERO_STRUCT(in);
1453	ZERO_STRUCT(out);
1454
1455	make_spoolss_q_setjob( &in, hnd, jobid, level, command );
1456
1457	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETJOB,
1458	in, out,
1459	qbuf, rbuf,
1460	spoolss_io_q_setjob,
1461	spoolss_io_r_setjob,
1462	WERR_GENERAL_FAILURE );
1463
1464	return out.status;
1465	}
1466
1467	/**********************************************************************
1468	**********************************************************************/
1469
1470	WERROR rpccli_spoolss_getjob(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1471	POLICY_HND *hnd, uint32 jobid, uint32 level,
1472	JOB_INFO_CTR *ctr)
1473	{
1474	prs_struct qbuf, rbuf;
1475	SPOOL_Q_GETJOB in;
1476	SPOOL_R_GETJOB out;
1477	RPC_BUFFER buffer;
1478	uint32 offered;
1479
1480	ZERO_STRUCT(in);
1481	ZERO_STRUCT(out);
1482
1483	offered = 0;
1484	if (!rpcbuf_init(&buffer, offered, mem_ctx))
1485	return WERR_NOMEM;
1486	make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
1487
1488	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETJOB,
1489	in, out,
1490	qbuf, rbuf,
1491	spoolss_io_q_getjob,
1492	spoolss_io_r_getjob,
1493	WERR_GENERAL_FAILURE );
1494
1495	if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1496	offered = out.needed;
1497
1498	ZERO_STRUCT(in);
1499	ZERO_STRUCT(out);
1500
1501	if (!rpcbuf_init(&buffer, offered, mem_ctx))
1502	return WERR_NOMEM;
1503	make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
1504
1505	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETJOB,
1506	in, out,
1507	qbuf, rbuf,
1508	spoolss_io_q_getjob,
1509	spoolss_io_r_getjob,
1510	WERR_GENERAL_FAILURE );
1511	}
1512
1513	if (!W_ERROR_IS_OK(out.status))
1514	return out.status;
1515
1516	switch(level) {
1517	case 1:
1518	if (!decode_jobs_1(mem_ctx, out.buffer, 1, &ctr->job.job_info_1)) {
1519	return WERR_GENERAL_FAILURE;
1520	}
1521	break;
1522	case 2:
1523	if (!decode_jobs_2(mem_ctx, out.buffer, 1, &ctr->job.job_info_2)) {
1524	return WERR_GENERAL_FAILURE;
1525	}
1526	break;
1527	default:
1528	return WERR_UNKNOWN_LEVEL;
1529	}
1530
1531	return out.status;
1532	}
1533
1534	/**********************************************************************
1535	**********************************************************************/
1536
1537	WERROR rpccli_spoolss_startpageprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1538	POLICY_HND *hnd)
1539	{
1540	prs_struct qbuf, rbuf;
1541	SPOOL_Q_STARTPAGEPRINTER in;
1542	SPOOL_R_STARTPAGEPRINTER out;
1543
1544	ZERO_STRUCT(in);
1545	ZERO_STRUCT(out);
1546
1547	make_spoolss_q_startpageprinter( &in, hnd );
1548
1549	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_STARTPAGEPRINTER,
1550	in, out,
1551	qbuf, rbuf,
1552	spoolss_io_q_startpageprinter,
1553	spoolss_io_r_startpageprinter,
1554	WERR_GENERAL_FAILURE );
1555
1556	return out.status;
1557	}
1558
1559	/**********************************************************************
1560	**********************************************************************/
1561
1562	WERROR rpccli_spoolss_endpageprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1563	POLICY_HND *hnd)
1564	{
1565	prs_struct qbuf, rbuf;
1566	SPOOL_Q_ENDPAGEPRINTER in;
1567	SPOOL_R_ENDPAGEPRINTER out;
1568
1569	ZERO_STRUCT(in);
1570	ZERO_STRUCT(out);
1571
1572	make_spoolss_q_endpageprinter( &in, hnd );
1573
1574	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENDPAGEPRINTER,
1575	in, out,
1576	qbuf, rbuf,
1577	spoolss_io_q_endpageprinter,
1578	spoolss_io_r_endpageprinter,
1579	WERR_GENERAL_FAILURE );
1580
1581	return out.status;
1582	}
1583
1584	/**********************************************************************
1585	**********************************************************************/
1586
1587	WERROR rpccli_spoolss_startdocprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1588	POLICY_HND hnd, char docname,
1589	char outputfile, char datatype,
1590	uint32 *jobid)
1591	{
1592	prs_struct qbuf, rbuf;
1593	SPOOL_Q_STARTDOCPRINTER in;
1594	SPOOL_R_STARTDOCPRINTER out;
1595	uint32 level = 1;
1596
1597	ZERO_STRUCT(in);
1598	ZERO_STRUCT(out);
1599
1600	make_spoolss_q_startdocprinter( &in, hnd, level, docname,
1601	outputfile, datatype );
1602
1603	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_STARTDOCPRINTER,
1604	in, out,
1605	qbuf, rbuf,
1606	spoolss_io_q_startdocprinter,
1607	spoolss_io_r_startdocprinter,
1608	WERR_GENERAL_FAILURE );
1609
1610	*jobid = out.jobid;
1611
1612	return out.status;
1613	}
1614
1615	/**********************************************************************
1616	**********************************************************************/
1617
1618	WERROR rpccli_spoolss_enddocprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1619	POLICY_HND *hnd)
1620	{
1621	prs_struct qbuf, rbuf;
1622	SPOOL_Q_ENDDOCPRINTER in;
1623	SPOOL_R_ENDDOCPRINTER out;
1624
1625	ZERO_STRUCT(in);
1626	ZERO_STRUCT(out);
1627
1628	make_spoolss_q_enddocprinter( &in, hnd );
1629
1630	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENDDOCPRINTER,
1631	in, out,
1632	qbuf, rbuf,
1633	spoolss_io_q_enddocprinter,
1634	spoolss_io_r_enddocprinter,
1635	WERR_GENERAL_FAILURE );
1636
1637	return out.status;
1638	}
1639
1640	/**********************************************************************
1641	**********************************************************************/
1642
1643	WERROR rpccli_spoolss_getprinterdata(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1644	POLICY_HND hnd, const char valuename,
1645	REGISTRY_VALUE *value)
1646	{
1647	prs_struct qbuf, rbuf;
1648	SPOOL_Q_GETPRINTERDATA in;
1649	SPOOL_R_GETPRINTERDATA out;
1650	uint32 offered;
1651
1652	ZERO_STRUCT(in);
1653	ZERO_STRUCT(out);
1654
1655	offered = 0;
1656	make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1657
1658	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATA,
1659	in, out,
1660	qbuf, rbuf,
1661	spoolss_io_q_getprinterdata,
1662	spoolss_io_r_getprinterdata,
1663	WERR_GENERAL_FAILURE );
1664
1665	if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1666	offered = out.needed;
1667
1668	ZERO_STRUCT(in);
1669	ZERO_STRUCT(out);
1670
1671	make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
1672
1673	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATA,
1674	in, out,
1675	qbuf, rbuf,
1676	spoolss_io_q_getprinterdata,
1677	spoolss_io_r_getprinterdata,
1678	WERR_GENERAL_FAILURE );
1679	}
1680
1681	if (!W_ERROR_IS_OK(out.status))
1682	return out.status;
1683
1684	/* Return output parameters */
1685
1686	if (out.needed) {
1687	value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
1688	} else {
1689	value->data_p = NULL;
1690	}
1691	value->type = out.type;
1692	value->size = out.size;
1693
1694	return out.status;
1695	}
1696
1697	/**********************************************************************
1698	**********************************************************************/
1699
1700	WERROR rpccli_spoolss_getprinterdataex(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1701	POLICY_HND hnd, const char keyname,
1702	const char *valuename,
1703	REGISTRY_VALUE *value)
1704	{
1705	prs_struct qbuf, rbuf;
1706	SPOOL_Q_GETPRINTERDATAEX in;
1707	SPOOL_R_GETPRINTERDATAEX out;
1708	uint32 offered = 0;
1709
1710	ZERO_STRUCT(in);
1711	ZERO_STRUCT(out);
1712
1713	make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
1714
1715	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATAEX,
1716	in, out,
1717	qbuf, rbuf,
1718	spoolss_io_q_getprinterdataex,
1719	spoolss_io_r_getprinterdataex,
1720	WERR_GENERAL_FAILURE );
1721
1722	if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1723	offered = out.needed;
1724
1725	ZERO_STRUCT(in);
1726	ZERO_STRUCT(out);
1727
1728	make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
1729
1730	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_GETPRINTERDATAEX,
1731	in, out,
1732	qbuf, rbuf,
1733	spoolss_io_q_getprinterdataex,
1734	spoolss_io_r_getprinterdataex,
1735	WERR_GENERAL_FAILURE );
1736	}
1737
1738	if (!W_ERROR_IS_OK(out.status))
1739	return out.status;
1740
1741	/* Return output parameters */
1742
1743	if (out.needed) {
1744	value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
1745	} else {
1746	value->data_p = NULL;
1747	}
1748	value->type = out.type;
1749	value->size = out.needed;
1750
1751	return out.status;
1752	}
1753
1754	/**********************************************************************
1755	**********************************************************************/
1756
1757	WERROR rpccli_spoolss_setprinterdata(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1758	POLICY_HND hnd, REGISTRY_VALUE value)
1759	{
1760	prs_struct qbuf, rbuf;
1761	SPOOL_Q_SETPRINTERDATA in;
1762	SPOOL_R_SETPRINTERDATA out;
1763
1764	ZERO_STRUCT(in);
1765	ZERO_STRUCT(out);
1766
1767	make_spoolss_q_setprinterdata( &in, hnd, value->valuename,
1768	value->type, (char *)value->data_p, value->size);
1769
1770	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETPRINTERDATA,
1771	in, out,
1772	qbuf, rbuf,
1773	spoolss_io_q_setprinterdata,
1774	spoolss_io_r_setprinterdata,
1775	WERR_GENERAL_FAILURE );
1776
1777	return out.status;
1778	}
1779
1780	/**********************************************************************
1781	**********************************************************************/
1782
1783	WERROR rpccli_spoolss_setprinterdataex(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1784	POLICY_HND hnd, char keyname,
1785	REGISTRY_VALUE *value)
1786	{
1787	prs_struct qbuf, rbuf;
1788	SPOOL_Q_SETPRINTERDATAEX in;
1789	SPOOL_R_SETPRINTERDATAEX out;
1790
1791	ZERO_STRUCT(in);
1792	ZERO_STRUCT(out);
1793
1794	make_spoolss_q_setprinterdataex( &in, hnd, keyname, value->valuename,
1795	value->type, (char *)value->data_p, value->size);
1796
1797	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_SETPRINTERDATAEX,
1798	in, out,
1799	qbuf, rbuf,
1800	spoolss_io_q_setprinterdataex,
1801	spoolss_io_r_setprinterdataex,
1802	WERR_GENERAL_FAILURE );
1803
1804	return out.status;
1805	}
1806
1807	/**********************************************************************
1808	**********************************************************************/
1809
1810	WERROR rpccli_spoolss_enumprinterdata(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1811	POLICY_HND *hnd, uint32 ndx,
1812	uint32 value_offered, uint32 data_offered,
1813	uint32 value_needed, uint32 data_needed,
1814	REGISTRY_VALUE *value)
1815	{
1816	prs_struct qbuf, rbuf;
1817	SPOOL_Q_ENUMPRINTERDATA in;
1818	SPOOL_R_ENUMPRINTERDATA out;
1819
1820	ZERO_STRUCT(in);
1821	ZERO_STRUCT(out);
1822
1823	make_spoolss_q_enumprinterdata( &in, hnd, ndx, value_offered, data_offered );
1824
1825	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATA,
1826	in, out,
1827	qbuf, rbuf,
1828	spoolss_io_q_enumprinterdata,
1829	spoolss_io_r_enumprinterdata,
1830	WERR_GENERAL_FAILURE );
1831
1832	if ( value_needed )
1833	*value_needed = out.realvaluesize;
1834	if ( data_needed )
1835	*data_needed = out.realdatasize;
1836
1837	if (!W_ERROR_IS_OK(out.status))
1838	return out.status;
1839
1840	if (value) {
1841	rpcstr_pull(value->valuename, out.value, sizeof(value->valuename), -1,
1842	STR_TERMINATE);
1843	if (out.realdatasize) {
1844	value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data,
1845	out.realdatasize);
1846	} else {
1847	value->data_p = NULL;
1848	}
1849	value->type = out.type;
1850	value->size = out.realdatasize;
1851	}
1852
1853	return out.status;
1854	}
1855
1856	/**********************************************************************
1857	**********************************************************************/
1858
1859	WERROR rpccli_spoolss_enumprinterdataex(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1860	POLICY_HND hnd, const char keyname,
1861	REGVAL_CTR *ctr)
1862	{
1863	prs_struct qbuf, rbuf;
1864	SPOOL_Q_ENUMPRINTERDATAEX in;
1865	SPOOL_R_ENUMPRINTERDATAEX out;
1866	int i;
1867	uint32 offered;
1868
1869	ZERO_STRUCT(in);
1870	ZERO_STRUCT(out);
1871
1872	offered = 0;
1873	make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1874
1875	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATAEX,
1876	in, out,
1877	qbuf, rbuf,
1878	spoolss_io_q_enumprinterdataex,
1879	spoolss_io_r_enumprinterdataex,
1880	WERR_GENERAL_FAILURE );
1881
1882	if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
1883	offered = out.needed;
1884
1885	ZERO_STRUCT(in);
1886	ZERO_STRUCT(out);
1887
1888	make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
1889
1890	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERDATAEX,
1891	in, out,
1892	qbuf, rbuf,
1893	spoolss_io_q_enumprinterdataex,
1894	spoolss_io_r_enumprinterdataex,
1895	WERR_GENERAL_FAILURE );
1896	}
1897
1898	if (!W_ERROR_IS_OK(out.status))
1899	return out.status;
1900
1901	for (i = 0; i < out.returned; i++) {
1902	PRINTER_ENUM_VALUES *v = &out.ctr.values[i];
1903	fstring name;
1904
1905	rpcstr_pull(name, v->valuename.buffer, sizeof(name), -1,
1906	STR_TERMINATE);
1907	regval_ctr_addvalue(ctr, name, v->type, (const char *)v->data, v->data_len);
1908	}
1909
1910	return out.status;
1911	}
1912
1913	/**********************************************************************
1914	**********************************************************************/
1915
1916	WERROR rpccli_spoolss_writeprinter(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1917	POLICY_HND hnd, uint32 data_size, char data,
1918	uint32 *num_written)
1919	{
1920	prs_struct qbuf, rbuf;
1921	SPOOL_Q_WRITEPRINTER in;
1922	SPOOL_R_WRITEPRINTER out;
1923
1924	ZERO_STRUCT(in);
1925	ZERO_STRUCT(out);
1926
1927	make_spoolss_q_writeprinter( &in, hnd, data_size, data );
1928
1929	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_WRITEPRINTER,
1930	in, out,
1931	qbuf, rbuf,
1932	spoolss_io_q_writeprinter,
1933	spoolss_io_r_writeprinter,
1934	WERR_GENERAL_FAILURE );
1935
1936	if (num_written)
1937	*num_written = out.buffer_written;
1938
1939	return out.status;
1940	}
1941
1942	/**********************************************************************
1943	**********************************************************************/
1944
1945	WERROR rpccli_spoolss_deleteprinterdata(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1946	POLICY_HND hnd, char valuename)
1947	{
1948	prs_struct qbuf, rbuf;
1949	SPOOL_Q_DELETEPRINTERDATA in;
1950	SPOOL_R_DELETEPRINTERDATA out;
1951
1952	ZERO_STRUCT(in);
1953	ZERO_STRUCT(out);
1954
1955	make_spoolss_q_deleteprinterdata( &in, hnd, valuename );
1956
1957	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_DELETEPRINTERDATA,
1958	in, out,
1959	qbuf, rbuf,
1960	spoolss_io_q_deleteprinterdata,
1961	spoolss_io_r_deleteprinterdata,
1962	WERR_GENERAL_FAILURE );
1963
1964	return out.status;
1965	}
1966
1967	/**********************************************************************
1968	**********************************************************************/
1969
1970	WERROR rpccli_spoolss_deleteprinterdataex(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1971	POLICY_HND hnd, char keyname,
1972	char *valuename)
1973	{
1974	prs_struct qbuf, rbuf;
1975	SPOOL_Q_DELETEPRINTERDATAEX in;
1976	SPOOL_R_DELETEPRINTERDATAEX out;
1977
1978	ZERO_STRUCT(in);
1979	ZERO_STRUCT(out);
1980
1981	make_spoolss_q_deleteprinterdataex( &in, hnd, keyname, valuename );
1982
1983	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_DELETEPRINTERDATAEX,
1984	in, out,
1985	qbuf, rbuf,
1986	spoolss_io_q_deleteprinterdataex,
1987	spoolss_io_r_deleteprinterdataex,
1988	WERR_GENERAL_FAILURE );
1989
1990	return out.status;
1991	}
1992
1993	/**********************************************************************
1994	**********************************************************************/
1995
1996	WERROR rpccli_spoolss_enumprinterkey(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
1997	POLICY_HND hnd, const char keyname,
1998	uint16 *keylist, uint32 len)
1999	{
2000	prs_struct qbuf, rbuf;
2001	SPOOL_Q_ENUMPRINTERKEY in;
2002	SPOOL_R_ENUMPRINTERKEY out;
2003	uint32 offered = 0;
2004
2005	ZERO_STRUCT(in);
2006	ZERO_STRUCT(out);
2007
2008	make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
2009
2010	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERKEY,
2011	in, out,
2012	qbuf, rbuf,
2013	spoolss_io_q_enumprinterkey,
2014	spoolss_io_r_enumprinterkey,
2015	WERR_GENERAL_FAILURE );
2016
2017	if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
2018	offered = out.needed;
2019
2020	ZERO_STRUCT(in);
2021	ZERO_STRUCT(out);
2022
2023	make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
2024
2025	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_ENUMPRINTERKEY,
2026	in, out,
2027	qbuf, rbuf,
2028	spoolss_io_q_enumprinterkey,
2029	spoolss_io_r_enumprinterkey,
2030	WERR_GENERAL_FAILURE );
2031	}
2032
2033	if ( !W_ERROR_IS_OK(out.status) )
2034	return out.status;
2035
2036	if (keylist) {
2037	*keylist = SMB_MALLOC_ARRAY(uint16, out.keys.buf_len);
2038	if (!*keylist) {
2039	return WERR_NOMEM;
2040	}
2041	memcpy(keylist, out.keys.buffer, out.keys.buf_len 2);
2042	if (len)
2043	len = out.keys.buf_len 2;
2044	}
2045
2046	return out.status;
2047	}
2048
2049	/**********************************************************************
2050	**********************************************************************/
2051
2052	WERROR rpccli_spoolss_deleteprinterkey(struct rpc_pipe_client cli, TALLOC_CTX mem_ctx,
2053	POLICY_HND hnd, char keyname)
2054	{
2055	prs_struct qbuf, rbuf;
2056	SPOOL_Q_DELETEPRINTERKEY in;
2057	SPOOL_R_DELETEPRINTERKEY out;
2058
2059	ZERO_STRUCT(in);
2060	ZERO_STRUCT(out);
2061
2062	make_spoolss_q_deleteprinterkey( &in, hnd, keyname );
2063
2064	CLI_DO_RPC_WERR( cli, mem_ctx, &syntax_spoolss, SPOOLSS_DELETEPRINTERKEY,
2065	in, out,
2066	qbuf, rbuf,
2067	spoolss_io_q_deleteprinterkey,
2068	spoolss_io_r_deleteprinterkey,
2069	WERR_GENERAL_FAILURE );
2070
2071	return out.status;
2072	}
2073
2074	/ @} /

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

Download in other formats: