s3-registry: remove some unused headers.
[amitay/samba.git] / source3 / registry / reg_backend_printing.c
1 /*
2  *  Unix SMB/CIFS implementation.
3  *  Virtual Windows Registry Layer
4  *  Copyright (C) Gerald Carter                     2002-2005
5  *  Copyright (c) Andreas Schneider <asn@samba.org> 2010
6  *
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License as published by
9  *  the Free Software Foundation; either version 3 of the License, or
10  *  (at your option) any later version.
11  *
12  *  This program is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *  GNU General Public License for more details.
16  *
17  *  You should have received a copy of the GNU General Public License
18  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /* Implementation of registry virtual views for printing information */
22
23 #include "includes.h"
24 #include "registry.h"
25 #include "reg_util_internal.h"
26 #include "reg_backend_db.h"
27
28 #undef DBGC_CLASS
29 #define DBGC_CLASS DBGC_REGISTRY
30
31 /* registry paths used in the print_registry[] */
32 #define KEY_CONTROL_PRINTERS    "HKLM\\SYSTEM\\CURRENTCONTROLSET\\CONTROL\\PRINT\\PRINTERS"
33 #define KEY_WINNT_PRINTERS      "HKLM\\SOFTWARE\\MICROSOFT\\WINDOWS NT\\CURRENTVERSION\\PRINT\\PRINTERS"
34
35 /* callback table for various registry paths below the ones we service in this module */
36
37 struct reg_dyn_tree {
38         /* full key path in normalized form */
39         const char *path;
40
41         /* callbscks for fetch/store operations */
42         int ( *fetch_subkeys) ( const char *path, struct regsubkey_ctr *subkeys );
43         bool (*store_subkeys) ( const char *path, struct regsubkey_ctr *subkeys );
44         int  (*fetch_values)  ( const char *path, struct regval_ctr *values );
45         bool (*store_values)  ( const char *path, struct regval_ctr *values );
46 };
47
48 /*********************************************************************
49  *********************************************************************
50  ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/PRINTERS"
51  ** "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT/PRINTERS"
52  *********************************************************************
53  *********************************************************************/
54
55 static char *create_printer_registry_path(TALLOC_CTX *mem_ctx, const char *key) {
56         char *path;
57         char *subkey = NULL;
58
59         path = talloc_strdup(mem_ctx, key);
60         if (path == NULL) {
61                 return NULL;
62         }
63
64         path = normalize_reg_path(mem_ctx, path);
65         if (path == NULL) {
66                 return NULL;
67         }
68
69         if (strncmp(path, KEY_CONTROL_PRINTERS, strlen(KEY_CONTROL_PRINTERS)) == 0) {
70                 subkey = reg_remaining_path(mem_ctx, key + strlen(KEY_CONTROL_PRINTERS));
71                 if (subkey == NULL) {
72                         return NULL;
73                 }
74                 return talloc_asprintf(mem_ctx, "%s\\%s", KEY_WINNT_PRINTERS, subkey);
75         }
76
77         return NULL;
78 }
79
80 /*********************************************************************
81  *********************************************************************/
82
83 static int key_printers_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
84 {
85         TALLOC_CTX *ctx = talloc_tos();
86         char *printers_key;
87
88         printers_key = create_printer_registry_path(ctx, key);
89         if (printers_key == NULL) {
90                 /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
91                 return regdb_fetch_keys(KEY_WINNT_PRINTERS, subkeys);
92         }
93
94         return regdb_fetch_keys(printers_key, subkeys);
95 }
96
97 /**********************************************************************
98  *********************************************************************/
99
100 static bool key_printers_store_keys( const char *key, struct regsubkey_ctr *subkeys )
101 {
102         TALLOC_CTX *ctx = talloc_tos();
103         char *printers_key;
104
105         printers_key = create_printer_registry_path(ctx, key);
106         if (printers_key == NULL) {
107                 /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
108                 return regdb_store_keys(KEY_WINNT_PRINTERS, subkeys);
109         }
110
111         return regdb_store_keys(printers_key, subkeys);
112 }
113
114 /**********************************************************************
115  *********************************************************************/
116
117 static int key_printers_fetch_values(const char *key, struct regval_ctr *values)
118 {
119         TALLOC_CTX *ctx = talloc_tos();
120         char *printers_key;
121
122         printers_key = create_printer_registry_path(ctx, key);
123         if (printers_key == NULL) {
124                 /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
125                 return regdb_fetch_values(KEY_WINNT_PRINTERS, values);
126         }
127
128         return regdb_fetch_values(printers_key, values);
129 }
130
131 /**********************************************************************
132  *********************************************************************/
133
134 static bool key_printers_store_values(const char *key, struct regval_ctr *values)
135 {
136         TALLOC_CTX *ctx = talloc_tos();
137         char *printers_key;
138
139         printers_key = create_printer_registry_path(ctx, key);
140         if (printers_key == NULL) {
141                 /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
142                 return regdb_store_values(KEY_WINNT_PRINTERS, values);
143         }
144
145         return regdb_store_values(printers_key, values);
146 }
147
148 /**********************************************************************
149  *********************************************************************
150  ** Structure to hold dispatch table of ops for various printer keys.
151  ** Make sure to always store deeper keys along the same path first so
152  ** we ge a more specific match.
153  *********************************************************************
154  *********************************************************************/
155
156 static struct reg_dyn_tree print_registry[] = {
157 { KEY_CONTROL_PRINTERS,
158         &key_printers_fetch_keys,
159         &key_printers_store_keys,
160         &key_printers_fetch_values,
161         &key_printers_store_values },
162
163 { NULL, NULL, NULL, NULL, NULL }
164 };
165
166
167 /**********************************************************************
168  *********************************************************************
169  ** Main reg_printing interface functions
170  *********************************************************************
171  *********************************************************************/
172
173 /***********************************************************************
174  Lookup a key in the print_registry table, returning its index.
175  -1 on failure
176  **********************************************************************/
177
178 static int match_registry_path(const char *key)
179 {
180         int i;
181         char *path = NULL;
182         TALLOC_CTX *ctx = talloc_tos();
183
184         if ( !key )
185                 return -1;
186
187         path = talloc_strdup(ctx, key);
188         if (!path) {
189                 return -1;
190         }
191         path = normalize_reg_path(ctx, path);
192         if (!path) {
193                 return -1;
194         }
195
196         for ( i=0; print_registry[i].path; i++ ) {
197                 if (strncmp( path, print_registry[i].path, strlen(print_registry[i].path) ) == 0 )
198                         return i;
199         }
200
201         return -1;
202 }
203
204 /***********************************************************************
205  **********************************************************************/
206
207 static int regprint_fetch_reg_keys( const char *key, struct regsubkey_ctr *subkeys )
208 {
209         int i = match_registry_path( key );
210
211         if ( i == -1 )
212                 return -1;
213
214         if ( !print_registry[i].fetch_subkeys )
215                 return -1;
216
217         return print_registry[i].fetch_subkeys( key, subkeys );
218 }
219
220 /**********************************************************************
221  *********************************************************************/
222
223 static bool regprint_store_reg_keys( const char *key, struct regsubkey_ctr *subkeys )
224 {
225         int i = match_registry_path( key );
226
227         if ( i == -1 )
228                 return False;
229
230         if ( !print_registry[i].store_subkeys )
231                 return False;
232
233         return print_registry[i].store_subkeys( key, subkeys );
234 }
235
236 /**********************************************************************
237  *********************************************************************/
238
239 static int regprint_fetch_reg_values(const char *key, struct regval_ctr *values)
240 {
241         int i = match_registry_path( key );
242
243         if ( i == -1 )
244                 return -1;
245
246         /* return 0 values by default since we know the key had
247            to exist because the client opened a handle */
248
249         if ( !print_registry[i].fetch_values )
250                 return 0;
251
252         return print_registry[i].fetch_values( key, values );
253 }
254
255 /**********************************************************************
256  *********************************************************************/
257
258 static bool regprint_store_reg_values(const char *key, struct regval_ctr *values)
259 {
260         int i = match_registry_path( key );
261
262         if ( i == -1 )
263                 return False;
264
265         if ( !print_registry[i].store_values )
266                 return False;
267
268         return print_registry[i].store_values( key, values );
269 }
270
271 /*
272  * Table of function pointers for accessing printing data
273  */
274
275 struct registry_ops printing_ops = {
276         .fetch_subkeys = regprint_fetch_reg_keys,
277         .fetch_values = regprint_fetch_reg_values,
278         .store_subkeys = regprint_store_reg_keys,
279         .store_values = regprint_store_reg_values,
280 };