source: trunk/server/source3/registry/reg_backend_printing.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 8.8 KB
Line 
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
37struct 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
55static 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
83static 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
100static 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
117static 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
134static 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
156static 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
178static 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
207static 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
223static 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
239static 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
258static 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
275struct 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};
Note: See TracBrowser for help on using the repository browser.