?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
me stupid.
[Samba.git] / source / rpc_client / cli_spoolss.c
bloba06f3afb6a42f8a898cd574924c57d4be3031086
1 /*
2 * Unix SMB/Netbios implementation.
3 * Version 1.9.
4 * RPC Pipe client / server routines
5 * Copyright (C) Andrew Tridgell 1992-2000,
6 * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
7 * Copyright (C) Paul Ashton 1997-2000,
8 * Copyright (C) Jean Francois Micouleau 1998-2000,
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 #include "includes.h"
26 #include "rpc_parse.h"
27 #include "nterr.h"
28
29 extern int DEBUGLEVEL;
30
31 /****************************************************************************
32 do a SPOOLSS Enum Printer Drivers
33 ****************************************************************************/
34 uint32 spoolss_enum_printerdrivers(const char *srv_name, const char *environment,
35 uint32 level, NEW_BUFFER *buffer, uint32 offered,
36 uint32 *needed, uint32 *returned)
37 {
38 prs_struct rbuf;
39 prs_struct buf;
40 SPOOL_Q_ENUMPRINTERDRIVERS q_o;
41 SPOOL_R_ENUMPRINTERDRIVERS r_o;
42 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
43
44 struct cli_connection *con = NULL;
45
46 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
47 return False;
48
49 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
50 prs_init(&rbuf, 0, ctx, UNMARSHALL);
51
52 /* create and send a MSRPC command with api SPOOLSS_ENUM_PRINTERS */
53
54 DEBUG(5,("SPOOLSS Enum Printer Drivers (Server: %s Environment: %s level: %d)\n",
55 srv_name, environment, level));
56
57 make_spoolss_q_enumprinterdrivers(&q_o, srv_name, environment,
58 level, buffer, offered);
59
60 /* turn parameters into data stream */
61 if (spoolss_io_q_enumprinterdrivers("", &q_o, &buf, 0) &&
62 rpc_con_pipe_req(con, SPOOLSS_ENUMPRINTERDRIVERS, &buf, &rbuf))
63 {
64 prs_mem_free(&buf);
65 ZERO_STRUCT(r_o);
66
67 prs_switch_type(&buffer->prs, UNMARSHALL);
68 prs_set_offset(&buffer->prs, 0);
69 r_o.buffer=buffer;
70
71 if(spoolss_io_r_enumprinterdrivers("", &r_o, &rbuf, 0))
72 {
73 if (r_o.status != NT_STATUS_NOPROBLEMO)
74 {
75 DEBUG(3,("SPOOLSS_ENUMPRINTERDRIVERS: %s\n", get_nt_error_msg(r_o.status)));
76 }
77 *needed=r_o.needed;
78 *returned=r_o.returned;
79 }
80 }
81
82 prs_mem_free(&rbuf);
83 prs_mem_free(&buf );
84
85 cli_connection_unlink(con);
86
87 return r_o.status;
88 }
89
90 /****************************************************************************
91 do a SPOOLSS Enum Printers
92 ****************************************************************************/
93 uint32 spoolss_enum_printers(uint32 flags, fstring srv_name, uint32 level,
94 NEW_BUFFER *buffer, uint32 offered,
95 uint32 *needed, uint32 *returned)
96 {
97 prs_struct rbuf;
98 prs_struct buf;
99 SPOOL_Q_ENUMPRINTERS q_o;
100 SPOOL_R_ENUMPRINTERS r_o;
101 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
102
103 struct cli_connection *con = NULL;
104
105 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
106 return False;
107
108 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
109 prs_init(&rbuf, 0, ctx, UNMARSHALL);
110
111 /* create and send a MSRPC command with api SPOOLSS_ENUM_PRINTERS */
112
113 DEBUG(5,("SPOOLSS Enum Printers (Server: %s level: %d)\n", srv_name, level));
114
115 make_spoolss_q_enumprinters(&q_o, flags, "", level, buffer, offered);
116
117 /* turn parameters into data stream */
118 if (spoolss_io_q_enumprinters("", &q_o, &buf, 0) &&
119 rpc_con_pipe_req(con, SPOOLSS_ENUMPRINTERS, &buf, &rbuf))
120 {
121 ZERO_STRUCT(r_o);
122
123 prs_switch_type(&buffer->prs, UNMARSHALL);
124 prs_set_offset(&buffer->prs, 0);
125 r_o.buffer=buffer;
126
127 if(new_spoolss_io_r_enumprinters("", &r_o, &rbuf, 0))
128 {
129 if (r_o.status != NT_STATUS_NOPROBLEMO)
130 {
131 /* report error code */
132 DEBUG(3,("SPOOLSS_ENUMPRINTERS: %s\n", get_nt_error_msg(r_o.status)));
133 }
134
135 *needed=r_o.needed;
136 *returned=r_o.returned;
137 }
138
139 }
140
141 prs_mem_free(&rbuf);
142 prs_mem_free(&buf );
143
144 cli_connection_unlink(con);
145
146 return r_o.status;
147 }
148
149 /****************************************************************************
150 do a SPOOLSS Enum Ports
151 ****************************************************************************/
152 uint32 spoolss_enum_ports(fstring srv_name, uint32 level,
153 NEW_BUFFER *buffer, uint32 offered,
154 uint32 *needed, uint32 *returned)
155 {
156 prs_struct rbuf;
157 prs_struct buf;
158 SPOOL_Q_ENUMPORTS q_o;
159 SPOOL_R_ENUMPORTS r_o;
160 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
161
162 struct cli_connection *con = NULL;
163
164 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
165 return False;
166
167 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
168 prs_init(&rbuf, 0, ctx, UNMARSHALL);
169
170 /* create and send a MSRPC command with api SPOOLSS_ENUMPORTS */
171
172 DEBUG(5,("SPOOLSS Enum Ports (Server: %s level: %d)\n", srv_name, level));
173
174 make_spoolss_q_enumports(&q_o, "", level, buffer, offered);
175
176 /* turn parameters into data stream */
177 if (spoolss_io_q_enumports("", &q_o, &buf, 0) &&
178 rpc_con_pipe_req(con, SPOOLSS_ENUMPORTS, &buf, &rbuf))
179 {
180 prs_mem_free(&buf );
181 ZERO_STRUCT(r_o);
182
183 prs_switch_type(&buffer->prs, UNMARSHALL);
184 prs_set_offset(&buffer->prs, 0);
185 r_o.buffer=buffer;
186
187 if(new_spoolss_io_r_enumports("", &r_o, &rbuf, 0))
188 {
189 if (r_o.status != NT_STATUS_NOPROBLEMO)
190 {
191 DEBUG(3,("SPOOLSS_ENUMPORTS: %s\n", get_nt_error_msg(r_o.status)));
192 }
193
194 *needed=r_o.needed;
195 *returned=r_o.returned;
196 }
197 }
198
199 prs_mem_free(&rbuf);
200 prs_mem_free(&buf );
201
202 cli_connection_unlink(con);
203
204 return r_o.status;
205 }
206
207 /****************************************************************************
208 do a SPOOLSS Enum Jobs
209 ****************************************************************************/
210 uint32 spoolss_enum_jobs(const POLICY_HND *hnd, uint32 firstjob, uint32 numofjobs,
211 uint32 level, NEW_BUFFER *buffer, uint32 offered,
212 uint32 *needed, uint32 *returned)
213 {
214 prs_struct rbuf;
215 prs_struct buf;
216 SPOOL_Q_ENUMJOBS q_o;
217 SPOOL_R_ENUMJOBS r_o;
218 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
219
220 if (hnd == NULL)
221 return NT_STATUS_INVALID_PARAMETER;
222
223 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
224 prs_init(&rbuf, 0, ctx, UNMARSHALL);
225
226 /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
227
228 DEBUG(5,("SPOOLSS Enum Jobs level: %d)\n", level));
229
230 make_spoolss_q_enumjobs(&q_o, hnd, firstjob, numofjobs, level, buffer, offered);
231
232 /* turn parameters into data stream */
233 if (spoolss_io_q_enumjobs("", &q_o, &buf, 0) &&
234 rpc_hnd_pipe_req(hnd, SPOOLSS_ENUMJOBS, &buf, &rbuf))
235 {
236 ZERO_STRUCT(r_o);
237 prs_mem_free(&buf );
238
239 r_o.buffer=buffer;
240
241 if(spoolss_io_r_enumjobs("", &r_o, &rbuf, 0))
242 {
243 if (r_o.status != NT_STATUS_NOPROBLEMO)
244 {
245 DEBUG(3,("SPOOLSS_ENUMJOBS: %s\n", get_nt_error_msg(r_o.status)));
246 }
247 *needed=r_o.needed;
248 *returned=r_o.returned;
249 }
250 }
251
252 prs_mem_free(&rbuf);
253 prs_mem_free(&buf );
254
255 return r_o.status;
256 }
257
258 /***************************************************************************
259 do a SPOOLSS Enum printer datas
260 ****************************************************************************/
261 uint32 spoolss_enum_printerdata(const POLICY_HND *hnd, uint32 idx,
262 uint32 *valuelen, uint16 *value, uint32 *rvaluelen,
263 uint32 *type, uint32 *datalen, uint8 *data,
264 uint32 *rdatalen)
265 {
266 prs_struct rbuf;
267 prs_struct buf;
268 SPOOL_Q_ENUMPRINTERDATA q_o;
269 SPOOL_R_ENUMPRINTERDATA r_o;
270 TALLOC_CTX *mem_ctx = NULL;
271
272 if (hnd == NULL)
273 return NT_STATUS_INVALID_PARAMETER;
274
275 if ((mem_ctx=talloc_init()) == NULL)
276 {
277 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
278 return False;
279 }
280 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
281 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
282
283 /* create and send a MSRPC command with api SPOOLSS_ENUMPRINTERDATA*/
284
285 DEBUG(4,("SPOOLSS Enum Printer data\n"));
286
287 make_spoolss_q_enumprinterdata(&q_o, hnd, idx, *valuelen, *datalen);
288
289 /* turn parameters into data stream */
290 if (spoolss_io_q_enumprinterdata("", &q_o, &buf, 0) &&
291 rpc_hnd_pipe_req(hnd, SPOOLSS_ENUMPRINTERDATA, &buf, &rbuf))
292 {
293 ZERO_STRUCT(r_o);
294 prs_mem_free(&buf );
295
296 r_o.data=data;
297 r_o.value=value;
298
299 if(spoolss_io_r_enumprinterdata("", &r_o, &rbuf, 0))
300 {
301 if (r_o.status != NT_STATUS_NOPROBLEMO)
302 {
303 DEBUG(3,("SPOOLSS_ENUMPRINTERDATA: %s\n", get_nt_error_msg(r_o.status)));
304 }
305
306 *valuelen=r_o.valuesize;
307 *rvaluelen=r_o.realvaluesize;
308 *type=r_o.type;
309 *datalen=r_o.datasize;
310 *rdatalen=r_o.realdatasize;
311
312 }
313 }
314
315 prs_mem_free(&rbuf);
316 prs_mem_free(&buf );
317 if (mem_ctx)
318 talloc_destroy(mem_ctx);
319
320 return r_o.status;
321 }
322
323 /****************************************************************************
324 do a SPOOLSS Enum printer datas
325 ****************************************************************************/
326 uint32 spoolss_getprinter(const POLICY_HND *hnd, uint32 level,
327 NEW_BUFFER *buffer, uint32 offered,
328 uint32 *needed)
329 {
330 prs_struct rbuf;
331 prs_struct buf;
332 SPOOL_Q_GETPRINTER q_o;
333 SPOOL_R_GETPRINTER r_o;
334 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
335
336 if (hnd == NULL)
337 return NT_STATUS_INVALID_PARAMETER;
338
339 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
340 prs_init(&rbuf, 0, ctx, UNMARSHALL);
341
342 /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
343
344 DEBUG(5,("SPOOLSS Enum Printer data)\n"));
345
346 make_spoolss_q_getprinter(&q_o, hnd, level, buffer, offered);
347
348 /* turn parameters into data stream */
349 if (spoolss_io_q_getprinter("", &q_o, &buf, 0) &&
350 rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTER, &buf, &rbuf))
351 {
352 ZERO_STRUCT(r_o);
353 prs_mem_free(&buf );
354
355 prs_switch_type(&buffer->prs, UNMARSHALL);
356 prs_set_offset(&buffer->prs, 0);
357 r_o.buffer=buffer;
358
359 if(!spoolss_io_r_getprinter("", &r_o, &rbuf, 0))
360 {
361 if (r_o.status != NT_STATUS_NOPROBLEMO)
362 {
363 DEBUG(3,("SPOOLSS_GETPRINTER: %s\n", get_nt_error_msg(r_o.status)));
364 }
365 *needed=r_o.needed;
366 }
367 }
368
369 prs_mem_free(&rbuf);
370 prs_mem_free(&buf );
371
372 return r_o.status;
373 }
374
375 /****************************************************************************
376 do a SPOOLSS Enum printer driver
377 ****************************************************************************/
378 uint32 spoolss_getprinterdriver(const POLICY_HND *hnd,
379 const char *environment, uint32 level,
380 NEW_BUFFER *buffer, uint32 offered,
381 uint32 *needed)
382 {
383 prs_struct rbuf;
384 prs_struct buf;
385 SPOOL_Q_GETPRINTERDRIVER2 q_o;
386 SPOOL_R_GETPRINTERDRIVER2 r_o;
387 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
388
389 if (hnd == NULL)
390 return NT_STATUS_INVALID_PARAMETER;
391
392 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
393 prs_init(&rbuf, 0, ctx, UNMARSHALL);
394
395 /* create and send a MSRPC command with api SPOOLSS_ENUMJOBS */
396
397 DEBUG(5,("SPOOLSS Enum Printer driver)\n"));
398
399 make_spoolss_q_getprinterdriver2(&q_o, hnd, environment, level, 2, 0, buffer, offered);
400
401 /* turn parameters into data stream */
402 if (spoolss_io_q_getprinterdriver2("", &q_o, &buf, 0) &&
403 rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTERDRIVER2, &buf, &rbuf))
404 {
405 ZERO_STRUCT(r_o);
406 prs_mem_free(&buf );
407
408 prs_switch_type(&buffer->prs, UNMARSHALL);
409 prs_set_offset(&buffer->prs, 0);
410 r_o.buffer=buffer;
411
412 if(spoolss_io_r_getprinterdriver2("", &r_o, &rbuf, 0))
413 {
414 if (r_o.status != NT_STATUS_NOPROBLEMO)
415 {
416 DEBUG(3,("SPOOLSS_GETPRINTERDRIVER2: %s\n", get_nt_error_msg(r_o.status)));
417 }
418
419 *needed=r_o.needed;
420 }
421 }
422
423 prs_mem_free(&rbuf);
424 prs_mem_free(&buf );
425
426 return r_o.status;
427 }
428
429
430
431 /****************************************************************************
432 do a SPOOLSS Open Printer Ex
433 ****************************************************************************/
434 BOOL spoolss_open_printer_ex( const char *printername,
435 const char *datatype, uint32 access_required,
436 const char *station, const char *username,
437 POLICY_HND *hnd)
438 {
439 prs_struct rbuf;
440 prs_struct buf;
441 SPOOL_Q_OPEN_PRINTER_EX q_o;
442 BOOL valid_pol = False;
443 fstring srv_name;
444 char *s = NULL;
445 struct cli_connection *con = NULL;
446 TALLOC_CTX *mem_ctx = NULL;
447
448 memset(srv_name, 0, sizeof(srv_name));
449 fstrcpy(srv_name, printername);
450
451 s = strchr_m(&srv_name[2], '\\');
452 if (s != NULL)
453 *s = '\0';
454
455 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
456 return False;
457
458 if (hnd == NULL)
459 return False;
460
461 if ((mem_ctx=talloc_init()) == NULL)
462 {
463 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
464 return False;
465 }
466 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
467 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
468
469 /* create and send a MSRPC command with api SPOOLSS_OPENPRINTEREX */
470
471 DEBUG(5,("SPOOLSS Open Printer Ex\n"));
472
473 make_spoolss_q_open_printer_ex(&q_o, printername, datatype,
474 access_required, station, username);
475
476 /* turn parameters into data stream */
477 if (spoolss_io_q_open_printer_ex("", &q_o, &buf, 0) &&
478 rpc_con_pipe_req(con, SPOOLSS_OPENPRINTEREX, &buf, &rbuf))
479 {
480 SPOOL_R_OPEN_PRINTER_EX r_o;
481 BOOL p = True;
482
483 spoolss_io_r_open_printer_ex("", &r_o, &rbuf, 0);
484
485 if (prs_offset(&rbuf)!= 0 && r_o.status != 0)
486 {
487 /* report error code */
488 DEBUG(3,("SPOOLSS_OPENPRINTEREX: %s\n", get_nt_error_msg(r_o.status)));
489 p = False;
490 }
491
492 if (p)
493 {
494 /* ok, at last: we're happy. return the policy handle */
495 *hnd = r_o.handle;
496
497 /* associate the handle returned with the current
498 state of the clienjt connection */
499 valid_pol = RpcHndList_set_connection(hnd, con);
500
501 }
502 }
503
504 prs_mem_free(&rbuf);
505 prs_mem_free(&buf );
506 if (mem_ctx)
507 talloc_destroy(mem_ctx);
508
509 return valid_pol;
510 }
511
512 /****************************************************************************
513 do a SPOOLSS AddPrinterEx()
514 **ALWAYS** uses as PRINTER_INFO level 2 struct
515 ****************************************************************************/
516 BOOL spoolss_addprinterex(POLICY_HND *hnd, const char* srv_name, PRINTER_INFO_2 *info2)
517 {
518 prs_struct rbuf;
519 prs_struct buf;
520 SPOOL_Q_ADDPRINTEREX q_o;
521 SPOOL_R_ADDPRINTEREX r_o;
522 struct cli_connection *con = NULL;
523 TALLOC_CTX *mem_ctx = NULL;
524 fstring the_client_name;
525 BOOL valid_pol = True;
526
527
528
529 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
530 return NT_STATUS_ACCESS_DENIED;
531
532 if (hnd == NULL)
533 return NT_STATUS_INVALID_PARAMETER;
534
535 if ((mem_ctx=talloc_init()) == NULL)
536 {
537 DEBUG(0,("spoolss_addprinterex: talloc_init() failed!\n"));
538 return NT_STATUS_ACCESS_DENIED;
539 }
540 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
541 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
542
543 /* create and send a MSRPC command with api SPOOLSS_ENUMPORTS */
544 DEBUG(5,("SPOOLSS Add Printer Ex (Server: %s)\n", srv_name));
545
546 fstrcpy(the_client_name, "\\\\");
547 fstrcat(the_client_name, con->pCli_state->desthost);
548 strupper(the_client_name);
549
550
551 make_spoolss_q_addprinterex(mem_ctx, &q_o, srv_name, the_client_name,
552 /* "Administrator", */
553 con->pCli_state->user_name,
554 2, info2);
555
556 /* turn parameters into data stream and send the request */
557 if (spoolss_io_q_addprinterex("", &q_o, &buf, 0) &&
558 rpc_con_pipe_req(con, SPOOLSS_ADDPRINTEREX, &buf, &rbuf))
559 {
560 ZERO_STRUCT(r_o);
561
562 if(spoolss_io_r_addprinterex("", &r_o, &rbuf, 0))
563 {
564 if (r_o.status != NT_STATUS_NOPROBLEMO)
565 {
566 /* report error code */
567 DEBUG(3,("SPOOLSS_ADDPRINTEREX: %s\n", get_nt_error_msg(r_o.status)));
568 valid_pol = False;
569 }
570 }
571
572 if (valid_pol)
573 {
574 /* ok, at last: we're happy. return the policy handle */
575 copy_policy_hnd( hnd, &r_o.handle);
576
577 /* associate the handle returned with the current
578 state of the clienjt connection */
579 RpcHndList_set_connection(hnd, con);
580 }
581 }
582
583
584 prs_mem_free(&rbuf);
585 prs_mem_free(&buf );
586
587 if (mem_ctx)
588 talloc_destroy(mem_ctx);
589
590 return valid_pol;
591 }
592
593 /****************************************************************************
594 do a SPOOL Close
595 ****************************************************************************/
596 BOOL spoolss_closeprinter(POLICY_HND *hnd)
597 {
598 prs_struct rbuf;
599 prs_struct buf;
600 SPOOL_Q_CLOSEPRINTER q_c;
601 BOOL valid_close = False;
602 TALLOC_CTX *mem_ctx = NULL;
603
604 if (hnd == NULL)
605 return False;
606
607 /* create and send a MSRPC command with api SPOOLSS_CLOSEPRINTER */
608 if ((mem_ctx=talloc_init()) == NULL)
609 {
610 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
611 return False;
612 }
613 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
614 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
615
616 DEBUG(4,("SPOOL Close Printer\n"));
617
618 /* store the parameters */
619 make_spoolss_q_closeprinter(&q_c, hnd);
620
621 /* turn parameters into data stream */
622 if (spoolss_io_q_closeprinter("", &q_c, &buf, 0) &&
623 rpc_hnd_pipe_req(hnd, SPOOLSS_CLOSEPRINTER, &buf, &rbuf))
624 {
625 SPOOL_R_CLOSEPRINTER r_c;
626
627 spoolss_io_r_closeprinter("", &r_c, &rbuf, 0);
628
629 if (prs_offset(&rbuf)!=0 && r_c.status != 0)
630 {
631 /* report error code */
632 DEBUG(3,("SPOOL_CLOSEPRINTER: %s\n", get_nt_error_msg(r_c.status)));
633 }
634 else
635 valid_close = True;
636 }
637
638 prs_mem_free(&rbuf);
639 prs_mem_free(&buf );
640 if (mem_ctx)
641 talloc_destroy(mem_ctx);
642
643 /* disassociate with the cli_connection */
644 RpcHndList_del_connection(hnd);
645
646 return valid_close;
647 }
648
649 /****************************************************************************
650 do a SPOOLSS Get printer datas
651 ****************************************************************************/
652 uint32 spoolss_getprinterdata(const POLICY_HND *hnd, const UNISTR2 *valuename,
653 uint32 in_size,
654 uint32 *type,
655 uint32 *out_size,
656 uint8 *data,
657 uint32 *needed)
658 {
659 prs_struct rbuf;
660 prs_struct buf;
661 SPOOL_Q_GETPRINTERDATA q_o;
662 SPOOL_R_GETPRINTERDATA r_o;
663 TALLOC_CTX *mem_ctx = NULL;
664
665 if (hnd == NULL)
666 return NT_STATUS_INVALID_PARAMETER;
667
668 if ((mem_ctx=talloc_init()) == NULL)
669 {
670 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
671 return False;
672 }
673 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
674 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
675
676 /* create and send a MSRPC command with api SPOOLSS_GETPRINTERDATA */
677
678 DEBUG(5,("SPOOLSS Get Printer data)\n"));
679
680 make_spoolss_q_getprinterdata(&q_o, hnd,(UNISTR2 *)valuename, in_size);
681
682 /* turn parameters into data stream */
683 if (spoolss_io_q_getprinterdata("", &q_o, &buf, 0) &&
684 rpc_hnd_pipe_req(hnd, SPOOLSS_GETPRINTERDATA, &buf, &rbuf))
685 {
686 ZERO_STRUCT(r_o);
687 prs_mem_free(&buf );
688
689 r_o.data=data;
690
691 if(spoolss_io_r_getprinterdata("", &r_o, &rbuf, 0))
692 {
693 if (r_o.status != NT_STATUS_NOPROBLEMO)
694 {
695 DEBUG(3,("SPOOLSS_GETPRINTERDATA: %s\n", get_nt_error_msg(r_o.status)));
696 }
697
698 *type=r_o.type;
699 *out_size=r_o.size;
700 *needed=r_o.needed;
701 }
702 }
703
704 prs_mem_free(&rbuf);
705 prs_mem_free(&buf );
706
707 return r_o.status;
708 }
709
710 /****************************************************************************
711 do a SPOOLSS Get Printer Driver Direcotry
712 ****************************************************************************/
713 uint32 spoolss_getprinterdriverdir(fstring srv_name, fstring env_name, uint32 level,
714 NEW_BUFFER *buffer, uint32 offered,
715 uint32 *needed)
716 {
717 prs_struct rbuf;
718 prs_struct buf;
719 SPOOL_Q_GETPRINTERDRIVERDIR q_o;
720 SPOOL_R_GETPRINTERDRIVERDIR r_o;
721 TALLOC_CTX *ctx = prs_get_mem_context(&buffer->prs);
722
723 struct cli_connection *con = NULL;
724
725 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
726 return False;
727
728 prs_init(&buf, MAX_PDU_FRAG_LEN, ctx, MARSHALL);
729 prs_init(&rbuf, 0, ctx, UNMARSHALL);
730
731 /* create and send a MSRPC command with api SPOOLSS_ENUM_PRINTERS */
732
733 DEBUG(5,("SPOOLSS GetPrinterDriverDir (Server: %s Env: %s level: %d)\n",
734 srv_name, env_name, level));
735
736 make_spoolss_q_getprinterdriverdir(&q_o, srv_name, env_name, level,
737 buffer, offered);
738
739 /* turn parameters into data stream */
740 if (spoolss_io_q_getprinterdriverdir("", &q_o, &buf, 0) &&
741 rpc_con_pipe_req(con, SPOOLSS_GETPRINTERDRIVERDIRECTORY, &buf, &rbuf))
742 {
743 prs_mem_free(&buf );
744 ZERO_STRUCT(r_o);
745
746 prs_switch_type(&buffer->prs, UNMARSHALL);
747 prs_set_offset(&buffer->prs, 0);
748 r_o.buffer=buffer;
749
750 if(spoolss_io_r_getprinterdriverdir("", &r_o, &rbuf, 0))
751 {
752 if (r_o.status != NT_STATUS_NOPROBLEMO)
753 {
754 DEBUG(3,("SPOOLSS_GETPRINTERDRIVERDIRECTORY: %s\n", get_nt_error_msg(r_o.status)));
755 }
756
757 *needed=r_o.needed;
758 }
759 }
760
761 prs_mem_free(&rbuf);
762 prs_mem_free(&buf );
763
764 cli_connection_unlink(con);
765
766 return r_o.status;
767 }
768
769 /******************************************************************************
770 AddPrinterDriver()
771 *****************************************************************************/
772 uint32 spoolss_addprinterdriver(const char *srv_name, uint32 level, PRINTER_DRIVER_CTR *info)
773 {
774 prs_struct rbuf;
775 prs_struct buf;
776 SPOOL_Q_ADDPRINTERDRIVER q_o;
777 SPOOL_R_ADDPRINTERDRIVER r_o;
778 TALLOC_CTX *mem_ctx = NULL;
779 struct cli_connection *con = NULL;
780
781 if (!cli_connection_init(srv_name, PIPE_SPOOLSS, &con))
782 return False;
783
784 if ((mem_ctx=talloc_init()) == NULL)
785 {
786 DEBUG(0,("msrpc_spoolss_enum_jobs: talloc_init failed!\n"));
787 return False;
788 }
789 prs_init(&buf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
790 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
791
792 /* make the ADDPRINTERDRIVER PDU */
793 make_spoolss_q_addprinterdriver(mem_ctx, &q_o, srv_name, level, info);
794
795 /* turn the data into an io stream */
796 if (spoolss_io_q_addprinterdriver("", &q_o, &buf, 0) &&
797 rpc_con_pipe_req(con, SPOOLSS_ADDPRINTERDRIVER, &buf, &rbuf))
798 {
799 ZERO_STRUCT(r_o);
800
801 if(spoolss_io_r_addprinterdriver("", &r_o, &rbuf, 0))
802 {
803 if (r_o.status != NT_STATUS_NOPROBLEMO)
804 {
805 /* report error code */
806 DEBUG(3,("SPOOLSS_ADDPRINTERDRIVER: %s\n", get_nt_error_msg(r_o.status)));
807 }
808 }
809 }
810
811
812 prs_mem_free(&rbuf);
813 prs_mem_free(&buf );
814
815 if (mem_ctx)
816 talloc_destroy(mem_ctx);
817
818 return r_o.status;
819
820 }
821
822
Samba GIT mirror