messaging: Do POOL_USAGE via a socket
[samba.git] / source3 / rpc_server / spoolss / srv_spoolss_util.c
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 }