r3323: more warning reductions
[bbaumbach/samba-autobuild/.git] / source4 / lib / registry / reg_backend_rpc / reg_backend_rpc.c
1 /*
2    Samba Unix/Linux SMB implementation
3    RPC backend for the registry library
4    Copyright (C) 2003-2004 Jelmer Vernooij, jelmer@samba.org
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
19  
20 #include "includes.h"
21
22 /**
23  * This is the RPC backend for the registry library.
24  */
25
26 static void init_winreg_String(struct winreg_String *name, const char *s)
27 {
28     name->name = s;
29     if (s) {
30         name->name_len = 2 * (strlen_m(s) + 1);
31         name->name_size = name->name_len;
32     } else {
33         name->name_len = 0;
34         name->name_size = 0;
35     }
36 }
37
38
39 #define openhive(u) static WERROR open_ ## u(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *hnd) \
40 { \
41         struct winreg_Open ## u r; \
42         struct winreg_OpenUnknown unknown; \
43         NTSTATUS status; \
44         \
45         unknown.unknown0 = 0x84e0; \
46         unknown.unknown1 = 0x0000; \
47         r.in.unknown = &unknown; \
48         r.in.access_required = SEC_RIGHTS_MAXIMUM_ALLOWED; \
49         r.out.handle = hnd;\
50         \
51         status = dcerpc_winreg_Open ## u(p, mem_ctx, &r); \
52         if (NT_STATUS_IS_ERR(status)) {\
53                 DEBUG(0,("Error executing open\n"));\
54                 return ntstatus_to_werror(status);\
55         }\
56 \
57         return r.out.result;\
58 }
59
60 openhive(HKLM)
61 openhive(HKCU)
62 openhive(HKPD)
63 openhive(HKU)
64 openhive(HKCR)
65
66 struct rpc_key_data {
67         struct policy_handle pol;
68         int num_subkeys;
69         int num_values;
70         int max_valnamelen;
71         int max_valdatalen;
72 };
73
74 struct {
75         const char *name;
76         WERROR (*open) (struct dcerpc_pipe *p, TALLOC_CTX *, struct policy_handle *h);
77 } known_hives[] = {
78 { "HKEY_LOCAL_MACHINE", open_HKLM },
79 { "HKEY_CURRENT_USER", open_HKCU },
80 { "HKEY_CLASSES_ROOT", open_HKCR },
81 { "HKEY_PERFORMANCE_DATA", open_HKPD },
82 { "HKEY_USERS", open_HKU },
83 { NULL, NULL }
84 };
85
86 static WERROR rpc_query_key(struct registry_key *k);
87
88 WERROR rpc_list_hives (TALLOC_CTX *mem_ctx, const char *location, const char *credentials, char ***hives)
89 {
90         int i = 0;
91         *hives = talloc_p(mem_ctx, char *);
92         for(i = 0; known_hives[i].name; i++) {
93                 *hives = talloc_realloc_p(mem_ctx, *hives, char *, i+2);
94                 (*hives)[i] = talloc_strdup(mem_ctx, known_hives[i].name);
95         }
96         (*hives)[i] = NULL;
97         return WERR_OK;
98 }
99
100 static WERROR rpc_open_hive(TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **k)
101 {
102         NTSTATUS status;
103         char *user;
104         char *pass;
105         struct rpc_key_data *mykeydata;
106         struct dcerpc_pipe *p;
107         int n;
108
109         if (!h->credentials) return WERR_INVALID_PARAM;
110
111         /* Default to local smbd if no connection is specified */
112         if (!h->location) {
113                 h->location = talloc_strdup(mem_ctx, "ncalrpc:");
114         }
115
116         user = talloc_strdup(mem_ctx, h->credentials);
117         pass = strchr(user, '%');
118         if (pass) {
119                 pass = strdup(pass+1);
120         } else {
121                 pass = strdup("");
122         }
123
124         status = dcerpc_pipe_connect(&p, h->location, 
125                                      DCERPC_WINREG_UUID,
126                                      DCERPC_WINREG_VERSION,
127                                      lp_workgroup(),
128                                      user, pass);
129         free(pass);
130
131         h->backend_data = p;
132
133         if(NT_STATUS_IS_ERR(status)) return ntstatus_to_werror(status);
134
135         for(n = 0; known_hives[n].name; n++) 
136         {
137                 if(!strcmp(known_hives[n].name, h->backend_hivename)) break;
138         }
139         
140         if(!known_hives[n].name) return WERR_NO_MORE_ITEMS;
141         
142         *k = talloc_p(mem_ctx, struct registry_key);
143         (*k)->backend_data = mykeydata = talloc_p(mem_ctx, struct rpc_key_data);
144         mykeydata->num_values = -1;
145         mykeydata->num_subkeys = -1;
146         return known_hives[n].open((struct dcerpc_pipe *)h->backend_data, *k, &(mykeydata->pol));
147 }
148
149 #if 0
150 static WERROR rpc_key_put_rpc_data(TALLOC_CTX *mem_ctx, struct registry_key *k)
151 {
152     struct winreg_OpenKey r;
153         struct rpc_key_data *mykeydata;
154
155         k->backend_data = mykeydata = talloc_p(mem_ctx, struct rpc_key_data);
156         mykeydata->num_values = -1;
157         mykeydata->num_subkeys = -1;
158
159         /* Then, open the handle using the hive */
160
161         memset(&r, 0, sizeof(struct winreg_OpenKey));
162     r.in.handle = &(((struct rpc_key_data *)k->hive->root->backend_data)->pol);
163     init_winreg_String(&r.in.keyname, k->path);
164     r.in.unknown = 0x00000000;
165     r.in.access_mask = 0x02000000;
166     r.out.handle = &mykeydata->pol;
167
168     dcerpc_winreg_OpenKey((struct dcerpc_pipe *)k->hive->backend_data, mem_ctx, &r);
169
170         return r.out.result;
171 }
172 #endif
173
174 static WERROR rpc_open_rel_key(TALLOC_CTX *mem_ctx, struct registry_key *h, const char *name, struct registry_key **key)
175 {
176         struct rpc_key_data *mykeydata;
177     struct winreg_OpenKey r;
178
179         *key = talloc_p(mem_ctx, struct registry_key);
180         (*key)->name = talloc_strdup(mem_ctx, name);
181
182         (*key)->backend_data = mykeydata = talloc_p(mem_ctx, struct rpc_key_data);
183         mykeydata->num_values = -1;
184         mykeydata->num_subkeys = -1;
185
186         /* Then, open the handle using the hive */
187
188         memset(&r, 0, sizeof(struct winreg_OpenKey));
189     r.in.handle = &(((struct rpc_key_data *)h->backend_data)->pol);
190     init_winreg_String(&r.in.keyname, name);
191     r.in.unknown = 0x00000000;
192     r.in.access_mask = 0x02000000;
193     r.out.handle = &mykeydata->pol;
194
195     dcerpc_winreg_OpenKey((struct dcerpc_pipe *)(h->hive->backend_data), mem_ctx, &r);
196
197         return r.out.result;
198 }
199
200 static WERROR rpc_open_key(TALLOC_CTX *mem_ctx, struct registry_hive *h, const char *name, struct registry_key **key)
201 {
202         return rpc_open_rel_key(mem_ctx, h->root, name, key);
203 }
204
205 static WERROR rpc_get_value_by_index(TALLOC_CTX *mem_ctx, struct registry_key *parent, int n, struct registry_value **value)  
206 {
207         struct rpc_key_data *mykeydata = parent->backend_data;
208         WERROR error;
209         struct winreg_EnumValue r;
210         uint32 type, len1, len2 = 0;
211         struct EnumValueIn buf_name, buf_val;
212         NTSTATUS status;
213         
214         if(mykeydata->num_values == -1) {
215                 error = rpc_query_key(parent);
216                 if(!W_ERROR_IS_OK(error)) return error;
217         }
218
219         len1 = mykeydata->max_valdatalen;
220         
221         r.in.handle = &mykeydata->pol;
222         r.in.enum_index = n;
223         r.in.name_in.len = 0;
224         r.in.name_in.max_len = mykeydata->max_valnamelen * 2;
225         buf_name.max_len = mykeydata->max_valnamelen;
226         buf_name.offset = 0;
227         buf_name.len = 0;
228         r.in.name_in.buffer = &buf_name;
229         r.in.type = &type;
230         buf_val.max_len = mykeydata->max_valdatalen;
231         buf_val.offset = 0;
232         buf_val.len = 0;
233         r.in.value_in = &buf_val;
234         r.in.value_len1 = &len1;
235         r.in.value_len2 = &len2;
236         r.out.type = &type;
237
238         
239         status = dcerpc_winreg_EnumValue((struct dcerpc_pipe *)parent->hive->backend_data, mem_ctx, &r);
240         if(NT_STATUS_IS_ERR(status)) {
241                 DEBUG(0, ("Error in EnumValue: %s\n", nt_errstr(status)));
242                 return WERR_GENERAL_FAILURE;
243         }
244         
245         if(NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result)) {
246                 *value = talloc_p(mem_ctx, struct registry_value);
247                 (*value)->parent = parent;
248                 (*value)->name = talloc_strdup(mem_ctx, r.out.name_out.name);
249                 (*value)->data_type = type;
250                 (*value)->data_len = r.out.value_out->buffer.length;
251                 (*value)->data_blk = talloc_memdup(mem_ctx, r.out.value_out->buffer.data, r.out.value_out->buffer.length);
252                 return WERR_OK;
253         }
254         
255         return r.out.result;
256 }
257
258 static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx, struct registry_key *parent, int n, struct registry_key **subkey) 
259 {
260         struct winreg_EnumKey r;
261         struct winreg_EnumKeyNameRequest keyname;
262         struct winreg_String classname;
263         struct winreg_Time tm;
264         struct rpc_key_data *mykeydata = parent->backend_data;
265         NTSTATUS status;
266
267         r.in.handle = &mykeydata->pol;
268         keyname.unknown = 0x0000020a;
269         init_winreg_String(&keyname.key_name, NULL);
270         init_winreg_String(&classname, NULL);
271         r.in.in_name = &keyname;
272         r.in.class = &classname;
273         tm.low = tm.high = 0x7fffffff;
274         r.in.last_changed_time = &tm;
275
276         r.in.enum_index = n;
277         r.in.unknown = r.out.unknown = 0x0414;
278         r.in.key_name_len = r.out.key_name_len = 0;
279         status = dcerpc_winreg_EnumKey((struct dcerpc_pipe *)parent->hive->backend_data, mem_ctx, &r);
280         if(NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result)) {
281                         return rpc_open_rel_key(mem_ctx, parent, talloc_strdup(mem_ctx, r.out.out_name->name), subkey);
282         }
283
284         return r.out.result;
285 }
286
287 static WERROR rpc_add_key(TALLOC_CTX *mem_ctx, struct registry_key *parent, const char *name, uint32_t access_mask, SEC_DESC *sec, struct registry_key **key)
288 {
289         return WERR_NOT_SUPPORTED;
290 }
291
292 static WERROR rpc_query_key(struct registry_key *k)
293 {
294     NTSTATUS status;
295     struct winreg_QueryInfoKey r;
296     struct rpc_key_data *mykeydata = k->backend_data;
297         TALLOC_CTX *mem_ctx = talloc_init("query_key");
298
299     init_winreg_String(&r.in.class, NULL);
300     r.in.handle = &mykeydata->pol;
301         
302     status = dcerpc_winreg_QueryInfoKey((struct dcerpc_pipe *)(k->hive->backend_data), mem_ctx, &r);
303         talloc_destroy(mem_ctx);
304
305     if (!NT_STATUS_IS_OK(status)) {
306         DEBUG(1, ("QueryInfoKey failed - %s\n", nt_errstr(status)));
307         return ntstatus_to_werror(status);
308     }
309                                                                                                        
310     if (W_ERROR_IS_OK(r.out.result)) {
311                 mykeydata->num_subkeys = r.out.num_subkeys;
312                 mykeydata->num_values = r.out.num_values;
313                 mykeydata->max_valnamelen = r.out.max_valnamelen;
314                 mykeydata->max_valdatalen = r.out.max_valbufsize;
315         } 
316
317         return r.out.result;
318 }
319
320 static WERROR rpc_del_key(struct registry_key *k)
321 {
322         NTSTATUS status;
323         struct rpc_key_data *mykeydata = k->backend_data;
324         struct winreg_DeleteKey r;
325         struct registry_key *parent;
326         WERROR error;
327         TALLOC_CTX *mem_ctx = talloc_init("del_key");
328         
329         error = reg_key_get_parent(mem_ctx, k, &parent);
330         if(!W_ERROR_IS_OK(error)) { 
331                 talloc_destroy(mem_ctx); 
332                 return error; 
333         }
334
335         mykeydata = parent->backend_data;
336
337     r.in.handle = &mykeydata->pol;
338     init_winreg_String(&r.in.key, k->name);
339  
340     status = dcerpc_winreg_DeleteKey((struct dcerpc_pipe *)k->hive->backend_data, mem_ctx, &r);
341
342         talloc_destroy(mem_ctx);
343
344         return r.out.result;
345 }
346
347 static WERROR rpc_num_values(struct registry_key *key, int *count) {
348         struct rpc_key_data *mykeydata = key->backend_data;
349         WERROR error;
350                 
351         if(mykeydata->num_values == -1) {
352                 error = rpc_query_key(key);
353                 if(!W_ERROR_IS_OK(error)) return error;
354         }
355                         
356         *count = mykeydata->num_values;
357         return WERR_OK;
358 }
359
360 static WERROR rpc_num_subkeys(struct registry_key *key, int *count) {
361         struct rpc_key_data *mykeydata = key->backend_data;
362         WERROR error;
363
364         if(mykeydata->num_subkeys == -1) {
365                 error = rpc_query_key(key);
366                 if(!W_ERROR_IS_OK(error)) return error;
367         }
368                         
369         *count = mykeydata->num_subkeys;
370         return WERR_OK;
371 }
372
373 static struct registry_operations reg_backend_rpc = {
374         .name = "rpc",
375         .open_hive = rpc_open_hive,
376         .open_key = rpc_open_key,
377         .get_subkey_by_index = rpc_get_subkey_by_index,
378         .get_value_by_index = rpc_get_value_by_index,
379         .add_key = rpc_add_key,
380         .del_key = rpc_del_key,
381         .num_subkeys = rpc_num_subkeys,
382         .num_values = rpc_num_values,
383         .list_available_hives = rpc_list_hives,
384 };
385
386 NTSTATUS registry_rpc_init(void)
387 {
388         return register_backend("registry", &reg_backend_rpc);
389 }