1 /*
2 * Unix SMB/CIFS implementation.
3 *
4 * SPOOLSS RPC Pipe server / winreg client routines
5 *
6 * Copyright (c) 2010 Andreas Schneider <asn@samba.org>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "rpc_server/rpc_ncacn_np.h"
24 #include "../lib/tsocket/tsocket.h"
25 #include "../librpc/gen_ndr/ndr_spoolss.h"
26 #include "../librpc/gen_ndr/ndr_winreg.h"
27 #include "srv_spoolss_util.h"
28 #include "rpc_client/cli_winreg_spoolss.h"
29
winreg_printer_binding_handle(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,struct dcerpc_binding_handle ** winreg_binding_handle)30 WERROR winreg_printer_binding_handle(TALLOC_CTX *mem_ctx,
31 const struct auth_session_info *session_info,
32 struct messaging_context *msg_ctx,
33 struct dcerpc_binding_handle **winreg_binding_handle)
34 {
35 struct tsocket_address *local;
36 NTSTATUS status;
37 int rc;
38
39 rc = tsocket_address_inet_from_strings(mem_ctx,
40 "ip",
41 "127.0.0.1",
42 0,
43 &local);
44 if (rc < 0) {
45 return WERR_NOT_ENOUGH_MEMORY;
46 }
47
48 status = rpcint_binding_handle(mem_ctx,
49 &ndr_table_winreg,
50 local,
51 NULL,
52 session_info,
53 msg_ctx,
54 winreg_binding_handle);
55 talloc_free(local);
56 if (!NT_STATUS_IS_OK(status)) {
57 DEBUG(0, ("winreg_printer_binding_handle: Could not connect to winreg pipe: %s\n",
58 nt_errstr(status)));
59 return ntstatus_to_werror(status);
60 }
61
62 return WERR_OK;
63 }
64
winreg_delete_printer_key_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * printer,const char * key)65 WERROR winreg_delete_printer_key_internal(TALLOC_CTX *mem_ctx,
66 const struct auth_session_info *session_info,
67 struct messaging_context *msg_ctx,
68 const char *printer,
69 const char *key)
70 {
71 WERROR result;
72 struct dcerpc_binding_handle *b;
73 TALLOC_CTX *tmp_ctx;
74
75 tmp_ctx = talloc_stackframe();
76 if (tmp_ctx == NULL) {
77 return WERR_NOT_ENOUGH_MEMORY;
78 }
79
80 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
81 if (!W_ERROR_IS_OK(result)) {
82 talloc_free(tmp_ctx);
83 return result;
84 }
85
86 result = winreg_delete_printer_key(tmp_ctx,
87 b,
88 printer,
89 key);
90
91 talloc_free(tmp_ctx);
92 return result;
93 }
94
winreg_printer_update_changeid_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * printer)95 WERROR winreg_printer_update_changeid_internal(TALLOC_CTX *mem_ctx,
96 const struct auth_session_info *session_info,
97 struct messaging_context *msg_ctx,
98 const char *printer)
99 {
100 WERROR result;
101 struct dcerpc_binding_handle *b;
102 TALLOC_CTX *tmp_ctx;
103
104 tmp_ctx = talloc_stackframe();
105 if (tmp_ctx == NULL) {
106 return WERR_NOT_ENOUGH_MEMORY;
107 }
108
109 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
110 if (!W_ERROR_IS_OK(result)) {
111 talloc_free(tmp_ctx);
112 return result;
113 }
114
115 result = winreg_printer_update_changeid(mem_ctx,
116 b,
117 printer);
118
119 talloc_free(tmp_ctx);
120 return result;
121 }
122
winreg_printer_get_changeid_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * printer,uint32_t * pchangeid)123 WERROR winreg_printer_get_changeid_internal(TALLOC_CTX *mem_ctx,
124 const struct auth_session_info *session_info,
125 struct messaging_context *msg_ctx,
126 const char *printer,
127 uint32_t *pchangeid)
128 {
129 WERROR result;
130 struct dcerpc_binding_handle *b;
131 TALLOC_CTX *tmp_ctx;
132
133 tmp_ctx = talloc_stackframe();
134 if (tmp_ctx == NULL) {
135 return WERR_NOT_ENOUGH_MEMORY;
136 }
137
138 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
139 if (!W_ERROR_IS_OK(result)) {
140 talloc_free(tmp_ctx);
141 return result;
142 }
143
144 result = winreg_printer_get_changeid(mem_ctx,
145 b,
146 printer,
147 pchangeid);
148
149 talloc_free(tmp_ctx);
150 return result;
151 }
152
winreg_get_printer_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * printer,struct spoolss_PrinterInfo2 ** pinfo2)153 WERROR winreg_get_printer_internal(TALLOC_CTX *mem_ctx,
154 const struct auth_session_info *session_info,
155 struct messaging_context *msg_ctx,
156 const char *printer,
157 struct spoolss_PrinterInfo2 **pinfo2)
158 {
159 WERROR result;
160 struct dcerpc_binding_handle *b;
161 TALLOC_CTX *tmp_ctx;
162
163 tmp_ctx = talloc_stackframe();
164 if (tmp_ctx == NULL) {
165 return WERR_NOT_ENOUGH_MEMORY;
166 }
167
168 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
169 if (!W_ERROR_IS_OK(result)) {
170 talloc_free(tmp_ctx);
171 return result;
172 }
173
174 result = winreg_get_printer(mem_ctx,
175 b,
176 printer,
177 pinfo2);
178
179 talloc_free(tmp_ctx);
180 return result;
181 }
182
winreg_create_printer_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * sharename)183 WERROR winreg_create_printer_internal(TALLOC_CTX *mem_ctx,
184 const struct auth_session_info *session_info,
185 struct messaging_context *msg_ctx,
186 const char *sharename)
187 {
188 WERROR result;
189 struct dcerpc_binding_handle *b;
190 TALLOC_CTX *tmp_ctx;
191
192 tmp_ctx = talloc_stackframe();
193 if (tmp_ctx == NULL) {
194 return WERR_NOT_ENOUGH_MEMORY;
195 }
196
197 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
198 if (!W_ERROR_IS_OK(result)) {
199 talloc_free(tmp_ctx);
200 return result;
201 }
202
203 result = winreg_create_printer(mem_ctx,
204 b,
205 sharename);
206
207 talloc_free(tmp_ctx);
208 return result;
209 }
210
winreg_update_printer_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * sharename,uint32_t info2_mask,struct spoolss_SetPrinterInfo2 * info2,struct spoolss_DeviceMode * devmode,struct security_descriptor * secdesc)211 WERROR winreg_update_printer_internal(TALLOC_CTX *mem_ctx,
212 const struct auth_session_info *session_info,
213 struct messaging_context *msg_ctx,
214 const char *sharename,
215 uint32_t info2_mask,
216 struct spoolss_SetPrinterInfo2 *info2,
217 struct spoolss_DeviceMode *devmode,
218 struct security_descriptor *secdesc)
219 {
220 WERROR result;
221 struct dcerpc_binding_handle *b;
222 TALLOC_CTX *tmp_ctx;
223
224 tmp_ctx = talloc_stackframe();
225 if (tmp_ctx == NULL) {
226 return WERR_NOT_ENOUGH_MEMORY;
227 }
228
229 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
230 if (!W_ERROR_IS_OK(result)) {
231 talloc_free(tmp_ctx);
232 return result;
233 }
234
235 result = winreg_update_printer(mem_ctx,
236 b,
237 sharename,
238 info2_mask,
239 info2,
240 devmode,
241 secdesc);
242
243 talloc_free(tmp_ctx);
244 return result;
245 }
246
winreg_set_printer_dataex_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * printer,const char * key,const char * value,enum winreg_Type type,uint8_t * data,uint32_t data_size)247 WERROR winreg_set_printer_dataex_internal(TALLOC_CTX *mem_ctx,
248 const struct auth_session_info *session_info,
249 struct messaging_context *msg_ctx,
250 const char *printer,
251 const char *key,
252 const char *value,
253 enum winreg_Type type,
254 uint8_t *data,
255 uint32_t data_size)
256 {
257 WERROR result;
258 struct dcerpc_binding_handle *b;
259 TALLOC_CTX *tmp_ctx;
260
261 tmp_ctx = talloc_stackframe();
262 if (tmp_ctx == NULL) {
263 return WERR_NOT_ENOUGH_MEMORY;
264 }
265
266 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
267 if (!W_ERROR_IS_OK(result)) {
268 talloc_free(tmp_ctx);
269 return result;
270 }
271
272 result = winreg_set_printer_dataex(mem_ctx,
273 b,
274 printer,
275 key,
276 value,
277 type,
278 data,
279 data_size);
280
281 talloc_free(tmp_ctx);
282 return result;
283 }
284
winreg_enum_printer_dataex_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * printer,const char * key,uint32_t * pnum_values,struct spoolss_PrinterEnumValues ** penum_values)285 WERROR winreg_enum_printer_dataex_internal(TALLOC_CTX *mem_ctx,
286 const struct auth_session_info *session_info,
287 struct messaging_context *msg_ctx,
288 const char *printer,
289 const char *key,
290 uint32_t *pnum_values,
291 struct spoolss_PrinterEnumValues **penum_values)
292 {
293 WERROR result;
294 struct dcerpc_binding_handle *b;
295 TALLOC_CTX *tmp_ctx;
296
297 tmp_ctx = talloc_stackframe();
298 if (tmp_ctx == NULL) {
299 return WERR_NOT_ENOUGH_MEMORY;
300 }
301
302 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
303 if (!W_ERROR_IS_OK(result)) {
304 talloc_free(tmp_ctx);
305 return result;
306 }
307
308 result = winreg_enum_printer_dataex(mem_ctx,
309 b,
310 printer,
311 key,
312 pnum_values,
313 penum_values);
314
315 talloc_free(tmp_ctx);
316 return result;
317 }
318
winreg_get_printer_dataex_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * printer,const char * key,const char * value,enum winreg_Type * type,uint8_t ** data,uint32_t * data_size)319 WERROR winreg_get_printer_dataex_internal(TALLOC_CTX *mem_ctx,
320 const struct auth_session_info *session_info,
321 struct messaging_context *msg_ctx,
322 const char *printer,
323 const char *key,
324 const char *value,
325 enum winreg_Type *type,
326 uint8_t **data,
327 uint32_t *data_size)
328 {
329 WERROR result;
330 struct dcerpc_binding_handle *b;
331 TALLOC_CTX *tmp_ctx;
332
333 tmp_ctx = talloc_stackframe();
334 if (tmp_ctx == NULL) {
335 return WERR_NOT_ENOUGH_MEMORY;
336 }
337
338 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
339 if (!W_ERROR_IS_OK(result)) {
340 talloc_free(tmp_ctx);
341 return result;
342 }
343
344 result = winreg_get_printer_dataex(mem_ctx,
345 b,
346 printer,
347 key,
348 value,
349 type,
350 data,
351 data_size);
352
353 talloc_free(tmp_ctx);
354 return result;
355 }
356
winreg_delete_printer_dataex_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * printer,const char * key,const char * value)357 WERROR winreg_delete_printer_dataex_internal(TALLOC_CTX *mem_ctx,
358 const struct auth_session_info *session_info,
359 struct messaging_context *msg_ctx,
360 const char *printer,
361 const char *key,
362 const char *value)
363 {
364 WERROR result;
365 struct dcerpc_binding_handle *b;
366 TALLOC_CTX *tmp_ctx;
367
368 tmp_ctx = talloc_stackframe();
369 if (tmp_ctx == NULL) {
370 return WERR_NOT_ENOUGH_MEMORY;
371 }
372
373 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
374 if (!W_ERROR_IS_OK(result)) {
375 talloc_free(tmp_ctx);
376 return result;
377 }
378
379 result = winreg_delete_printer_dataex(mem_ctx,
380 b,
381 printer,
382 key,
383 value);
384
385 talloc_free(tmp_ctx);
386 return result;
387 }
388
winreg_get_driver_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * architecture,const char * driver_name,uint32_t driver_version,struct spoolss_DriverInfo8 ** _info8)389 WERROR winreg_get_driver_internal(TALLOC_CTX *mem_ctx,
390 const struct auth_session_info *session_info,
391 struct messaging_context *msg_ctx,
392 const char *architecture,
393 const char *driver_name,
394 uint32_t driver_version,
395 struct spoolss_DriverInfo8 **_info8)
396 {
397 WERROR result;
398 struct dcerpc_binding_handle *b;
399 TALLOC_CTX *tmp_ctx;
400
401 tmp_ctx = talloc_stackframe();
402 if (tmp_ctx == NULL) {
403 return WERR_NOT_ENOUGH_MEMORY;
404 }
405
406 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
407 if (!W_ERROR_IS_OK(result)) {
408 talloc_free(tmp_ctx);
409 return result;
410 }
411
412 result = winreg_get_driver(mem_ctx,
413 b,
414 architecture,
415 driver_name,
416 driver_version,
417 _info8);
418
419 talloc_free(tmp_ctx);
420 return result;
421 }
422
winreg_get_driver_list_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * architecture,uint32_t version,uint32_t * num_drivers,const char *** drivers_p)423 WERROR winreg_get_driver_list_internal(TALLOC_CTX *mem_ctx,
424 const struct auth_session_info *session_info,
425 struct messaging_context *msg_ctx,
426 const char *architecture,
427 uint32_t version,
428 uint32_t *num_drivers,
429 const char ***drivers_p)
430 {
431 WERROR result;
432 struct dcerpc_binding_handle *b;
433 TALLOC_CTX *tmp_ctx;
434
435 tmp_ctx = talloc_stackframe();
436 if (tmp_ctx == NULL) {
437 return WERR_NOT_ENOUGH_MEMORY;
438 }
439
440 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
441 if (!W_ERROR_IS_OK(result)) {
442 talloc_free(tmp_ctx);
443 return result;
444 }
445
446 result = winreg_get_driver_list(mem_ctx,
447 b,
448 architecture,
449 version,
450 num_drivers,
451 drivers_p);
452
453 talloc_free(tmp_ctx);
454 return result;
455 }
456
winreg_del_driver_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,struct spoolss_DriverInfo8 * info8,uint32_t version)457 WERROR winreg_del_driver_internal(TALLOC_CTX *mem_ctx,
458 const struct auth_session_info *session_info,
459 struct messaging_context *msg_ctx,
460 struct spoolss_DriverInfo8 *info8,
461 uint32_t version)
462 {
463 WERROR result;
464 struct dcerpc_binding_handle *b;
465 TALLOC_CTX *tmp_ctx;
466
467 tmp_ctx = talloc_stackframe();
468 if (tmp_ctx == NULL) {
469 return WERR_NOT_ENOUGH_MEMORY;
470 }
471
472 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
473 if (!W_ERROR_IS_OK(result)) {
474 talloc_free(tmp_ctx);
475 return result;
476 }
477
478 result = winreg_del_driver(mem_ctx,
479 b,
480 info8,
481 version);
482
483 talloc_free(tmp_ctx);
484 return result;
485 }
486
winreg_add_driver_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,struct spoolss_AddDriverInfoCtr * r,const char ** driver_name,uint32_t * driver_version)487 WERROR winreg_add_driver_internal(TALLOC_CTX *mem_ctx,
488 const struct auth_session_info *session_info,
489 struct messaging_context *msg_ctx,
490 struct spoolss_AddDriverInfoCtr *r,
491 const char **driver_name,
492 uint32_t *driver_version)
493 {
494 WERROR result;
495 struct dcerpc_binding_handle *b;
496 TALLOC_CTX *tmp_ctx;
497
498 tmp_ctx = talloc_stackframe();
499 if (tmp_ctx == NULL) {
500 return WERR_NOT_ENOUGH_MEMORY;
501 }
502
503 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
504 if (!W_ERROR_IS_OK(result)) {
505 talloc_free(tmp_ctx);
506 return result;
507 }
508
509 result = winreg_add_driver(mem_ctx,
510 b,
511 r,
512 driver_name,
513 driver_version);
514
515 talloc_free(tmp_ctx);
516 return result;
517 }
518
winreg_get_core_driver_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * architecture,const struct GUID * core_driver_guid,struct spoolss_CorePrinterDriver ** core_printer_driver)519 WERROR winreg_get_core_driver_internal(TALLOC_CTX *mem_ctx,
520 const struct auth_session_info *session_info,
521 struct messaging_context *msg_ctx,
522 const char *architecture,
523 const struct GUID *core_driver_guid,
524 struct spoolss_CorePrinterDriver **core_printer_driver)
525 {
526 WERROR result;
527 struct dcerpc_binding_handle *b;
528 TALLOC_CTX *tmp_ctx;
529
530 tmp_ctx = talloc_stackframe();
531 if (tmp_ctx == NULL) {
532 return WERR_NOT_ENOUGH_MEMORY;
533 }
534
535 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
536 if (!W_ERROR_IS_OK(result)) {
537 talloc_free(tmp_ctx);
538 return result;
539 }
540
541 result = winreg_get_core_driver(mem_ctx,
542 b,
543 architecture,
544 core_driver_guid,
545 core_printer_driver);
546
547 talloc_free(tmp_ctx);
548 return result;
549 }
550
winreg_add_core_driver_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * architecture,const struct spoolss_CorePrinterDriver * core_printer_driver)551 WERROR winreg_add_core_driver_internal(TALLOC_CTX *mem_ctx,
552 const struct auth_session_info *session_info,
553 struct messaging_context *msg_ctx,
554 const char *architecture,
555 const struct spoolss_CorePrinterDriver *core_printer_driver)
556 {
557 WERROR result;
558 struct dcerpc_binding_handle *b;
559 TALLOC_CTX *tmp_ctx;
560
561 tmp_ctx = talloc_stackframe();
562 if (tmp_ctx == NULL) {
563 return WERR_NOT_ENOUGH_MEMORY;
564 }
565
566 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
567 if (!W_ERROR_IS_OK(result)) {
568 talloc_free(tmp_ctx);
569 return result;
570 }
571
572 result = winreg_add_core_driver(mem_ctx,
573 b,
574 architecture,
575 core_printer_driver);
576
577 talloc_free(tmp_ctx);
578 return result;
579 }
580
winreg_add_driver_package_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * package_id,const char * architecture,const char * driver_store_path,const char * cab_path)581 WERROR winreg_add_driver_package_internal(TALLOC_CTX *mem_ctx,
582 const struct auth_session_info *session_info,
583 struct messaging_context *msg_ctx,
584 const char *package_id,
585 const char *architecture,
586 const char *driver_store_path,
587 const char *cab_path)
588 {
589 WERROR result;
590 struct dcerpc_binding_handle *b;
591 TALLOC_CTX *tmp_ctx;
592
593 tmp_ctx = talloc_stackframe();
594 if (tmp_ctx == NULL) {
595 return WERR_NOT_ENOUGH_MEMORY;
596 }
597
598 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
599 if (!W_ERROR_IS_OK(result)) {
600 talloc_free(tmp_ctx);
601 return result;
602 }
603
604 result = winreg_add_driver_package(mem_ctx,
605 b,
606 package_id,
607 architecture,
608 driver_store_path,
609 cab_path);
610
611 talloc_free(tmp_ctx);
612 return result;
613 }
614
winreg_get_driver_package_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * package_id,const char * architecture,const char ** driver_store_path,const char ** cab_path)615 WERROR winreg_get_driver_package_internal(TALLOC_CTX *mem_ctx,
616 const struct auth_session_info *session_info,
617 struct messaging_context *msg_ctx,
618 const char *package_id,
619 const char *architecture,
620 const char **driver_store_path,
621 const char **cab_path)
622 {
623 WERROR result;
624 struct dcerpc_binding_handle *b;
625 TALLOC_CTX *tmp_ctx;
626
627 tmp_ctx = talloc_stackframe();
628 if (tmp_ctx == NULL) {
629 return WERR_NOT_ENOUGH_MEMORY;
630 }
631
632 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
633 if (!W_ERROR_IS_OK(result)) {
634 talloc_free(tmp_ctx);
635 return result;
636 }
637
638 result = winreg_get_driver_package(mem_ctx,
639 b,
640 package_id,
641 architecture,
642 driver_store_path,
643 cab_path);
644
645 talloc_free(tmp_ctx);
646 return result;
647 }
648
winreg_del_driver_package_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * package_id,const char * architecture)649 WERROR winreg_del_driver_package_internal(TALLOC_CTX *mem_ctx,
650 const struct auth_session_info *session_info,
651 struct messaging_context *msg_ctx,
652 const char *package_id,
653 const char *architecture)
654 {
655 WERROR result;
656 struct dcerpc_binding_handle *b;
657 TALLOC_CTX *tmp_ctx;
658
659 tmp_ctx = talloc_stackframe();
660 if (tmp_ctx == NULL) {
661 return WERR_NOT_ENOUGH_MEMORY;
662 }
663
664 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
665 if (!W_ERROR_IS_OK(result)) {
666 talloc_free(tmp_ctx);
667 return result;
668 }
669
670 result = winreg_del_driver_package(mem_ctx,
671 b,
672 package_id,
673 architecture);
674
675 talloc_free(tmp_ctx);
676 return result;
677 }
678
winreg_get_printer_secdesc_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * sharename,struct spoolss_security_descriptor ** psecdesc)679 WERROR winreg_get_printer_secdesc_internal(TALLOC_CTX *mem_ctx,
680 const struct auth_session_info *session_info,
681 struct messaging_context *msg_ctx,
682 const char *sharename,
683 struct spoolss_security_descriptor **psecdesc)
684 {
685 WERROR result;
686 struct dcerpc_binding_handle *b;
687 TALLOC_CTX *tmp_ctx;
688
689 tmp_ctx = talloc_stackframe();
690 if (tmp_ctx == NULL) {
691 return WERR_NOT_ENOUGH_MEMORY;
692 }
693
694 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
695 if (!W_ERROR_IS_OK(result)) {
696 talloc_free(tmp_ctx);
697 return result;
698 }
699
700 result = winreg_get_printer_secdesc(mem_ctx,
701 b,
702 sharename,
703 psecdesc);
704
705 talloc_free(tmp_ctx);
706 return result;
707 }
708
winreg_set_printer_secdesc_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * sharename,const struct spoolss_security_descriptor * secdesc)709 WERROR winreg_set_printer_secdesc_internal(TALLOC_CTX *mem_ctx,
710 const struct auth_session_info *session_info,
711 struct messaging_context *msg_ctx,
712 const char *sharename,
713 const struct spoolss_security_descriptor *secdesc)
714 {
715 WERROR result;
716 struct dcerpc_binding_handle *b;
717 TALLOC_CTX *tmp_ctx;
718
719 tmp_ctx = talloc_stackframe();
720 if (tmp_ctx == NULL) {
721 return WERR_NOT_ENOUGH_MEMORY;
722 }
723
724 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
725 if (!W_ERROR_IS_OK(result)) {
726 talloc_free(tmp_ctx);
727 return result;
728 }
729
730 result = winreg_set_printer_secdesc(mem_ctx,
731 b,
732 sharename,
733 secdesc);
734
735 talloc_free(tmp_ctx);
736 return result;
737 }
738
winreg_printer_enumforms1_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,uint32_t * pnum_info,union spoolss_FormInfo ** pinfo)739 WERROR winreg_printer_enumforms1_internal(TALLOC_CTX *mem_ctx,
740 const struct auth_session_info *session_info,
741 struct messaging_context *msg_ctx,
742 uint32_t *pnum_info,
743 union spoolss_FormInfo **pinfo)
744 {
745 WERROR result;
746 struct dcerpc_binding_handle *b;
747 TALLOC_CTX *tmp_ctx;
748
749 tmp_ctx = talloc_stackframe();
750 if (tmp_ctx == NULL) {
751 return WERR_NOT_ENOUGH_MEMORY;
752 }
753
754 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
755 if (!W_ERROR_IS_OK(result)) {
756 talloc_free(tmp_ctx);
757 return result;
758 }
759
760 result = winreg_printer_enumforms1(mem_ctx,
761 b,
762 pnum_info,
763 pinfo);
764
765 talloc_free(tmp_ctx);
766 return result;
767 }
768
winreg_printer_getform1_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * form_name,struct spoolss_FormInfo1 * r)769 WERROR winreg_printer_getform1_internal(TALLOC_CTX *mem_ctx,
770 const struct auth_session_info *session_info,
771 struct messaging_context *msg_ctx,
772 const char *form_name,
773 struct spoolss_FormInfo1 *r)
774 {
775 WERROR result;
776 struct dcerpc_binding_handle *b;
777 TALLOC_CTX *tmp_ctx;
778
779 tmp_ctx = talloc_stackframe();
780 if (tmp_ctx == NULL) {
781 return WERR_NOT_ENOUGH_MEMORY;
782 }
783
784 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
785 if (!W_ERROR_IS_OK(result)) {
786 talloc_free(tmp_ctx);
787 return result;
788 }
789
790 result = winreg_printer_getform1(mem_ctx,
791 b,
792 form_name,
793 r);
794
795 talloc_free(tmp_ctx);
796 return result;
797 }
798
winreg_printer_addform1_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,struct spoolss_AddFormInfo1 * form)799 WERROR winreg_printer_addform1_internal(TALLOC_CTX *mem_ctx,
800 const struct auth_session_info *session_info,
801 struct messaging_context *msg_ctx,
802 struct spoolss_AddFormInfo1 *form)
803 {
804 WERROR result;
805 struct dcerpc_binding_handle *b;
806 TALLOC_CTX *tmp_ctx;
807
808 tmp_ctx = talloc_stackframe();
809 if (tmp_ctx == NULL) {
810 return WERR_NOT_ENOUGH_MEMORY;
811 }
812
813 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
814 if (!W_ERROR_IS_OK(result)) {
815 talloc_free(tmp_ctx);
816 return result;
817 }
818
819 result = winreg_printer_addform1(mem_ctx,
820 b,
821 form);
822
823 talloc_free(tmp_ctx);
824 return result;
825 }
826
winreg_printer_setform1_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * form_name,struct spoolss_AddFormInfo1 * form)827 WERROR winreg_printer_setform1_internal(TALLOC_CTX *mem_ctx,
828 const struct auth_session_info *session_info,
829 struct messaging_context *msg_ctx,
830 const char *form_name,
831 struct spoolss_AddFormInfo1 *form)
832 {
833 WERROR result;
834 struct dcerpc_binding_handle *b;
835 TALLOC_CTX *tmp_ctx;
836
837 tmp_ctx = talloc_stackframe();
838 if (tmp_ctx == NULL) {
839 return WERR_NOT_ENOUGH_MEMORY;
840 }
841
842 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
843 if (!W_ERROR_IS_OK(result)) {
844 talloc_free(tmp_ctx);
845 return result;
846 }
847
848 result = winreg_printer_setform1(mem_ctx,
849 b,
850 form_name,
851 form);
852
853 talloc_free(tmp_ctx);
854 return result;
855 }
856
winreg_printer_deleteform1_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * form_name)857 WERROR winreg_printer_deleteform1_internal(TALLOC_CTX *mem_ctx,
858 const struct auth_session_info *session_info,
859 struct messaging_context *msg_ctx,
860 const char *form_name)
861 {
862 WERROR result;
863 struct dcerpc_binding_handle *b;
864 TALLOC_CTX *tmp_ctx;
865
866 tmp_ctx = talloc_stackframe();
867 if (tmp_ctx == NULL) {
868 return WERR_NOT_ENOUGH_MEMORY;
869 }
870
871 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
872 if (!W_ERROR_IS_OK(result)) {
873 talloc_free(tmp_ctx);
874 return result;
875 }
876
877 result = winreg_printer_deleteform1(mem_ctx,
878 b,
879 form_name);
880
881 talloc_free(tmp_ctx);
882 return result;
883 }
884
winreg_enum_printer_key_internal(TALLOC_CTX * mem_ctx,const struct auth_session_info * session_info,struct messaging_context * msg_ctx,const char * printer,const char * key,uint32_t * pnum_subkeys,const char *** psubkeys)885 WERROR winreg_enum_printer_key_internal(TALLOC_CTX *mem_ctx,
886 const struct auth_session_info *session_info,
887 struct messaging_context *msg_ctx,
888 const char *printer,
889 const char *key,
890 uint32_t *pnum_subkeys,
891 const char ***psubkeys)
892 {
893 WERROR result;
894 struct dcerpc_binding_handle *b;
895 TALLOC_CTX *tmp_ctx;
896
897 tmp_ctx = talloc_stackframe();
898 if (tmp_ctx == NULL) {
899 return WERR_NOT_ENOUGH_MEMORY;
900 }
901
902 result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
903 if (!W_ERROR_IS_OK(result)) {
904 talloc_free(tmp_ctx);
905 return result;
906 }
907
908 result = winreg_enum_printer_key(mem_ctx,
909 b,
910 printer,
911 key,
912 pnum_subkeys,
913 psubkeys);
914
915 talloc_free(tmp_ctx);
916 return result;
917 }
918