r24665: Close file handles properly.
[sfrench/samba-autobuild/.git] / source4 / lib / registry / rpc.c
1 /*
2    Samba Unix/Linux SMB implementation
3    RPC backend for the registry library
4    Copyright (C) 2003-2007 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 3 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, see <http://www.gnu.org/licenses/>.  */
18  
19 #include "includes.h"
20 #include "registry.h"
21 #include "librpc/gen_ndr/ndr_winreg_c.h"
22
23 struct rpc_key {
24         struct registry_key key;
25         struct policy_handle pol;
26         struct dcerpc_pipe *pipe;
27
28         uint32_t num_values;
29         uint32_t num_subkeys;
30         uint32_t max_valnamelen;
31         uint32_t max_valdatalen;
32 };
33
34 struct rpc_registry_context {
35         struct registry_context context;
36         struct dcerpc_pipe *pipe;
37 };
38
39 static struct registry_operations reg_backend_rpc;
40
41 /**
42  * This is the RPC backend for the registry library.
43  */
44
45 static void init_winreg_String(struct winreg_String *name, const char *s)
46 {
47         name->name = s;
48 }
49
50
51 #define openhive(u) static WERROR open_ ## u(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *hnd) \
52 { \
53         struct winreg_Open ## u r; \
54         NTSTATUS status; \
55         \
56         r.in.system_name = NULL; \
57         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED; \
58         r.out.handle = hnd;\
59         \
60         status = dcerpc_winreg_Open ## u(p, mem_ctx, &r); \
61         if (NT_STATUS_IS_ERR(status)) {\
62                 DEBUG(0,("Error executing open\n"));\
63                 return ntstatus_to_werror(status);\
64         }\
65 \
66         return r.out.result;\
67 }
68
69 openhive(HKLM)
70 openhive(HKCU)
71 openhive(HKPD)
72 openhive(HKU)
73 openhive(HKCR)
74 openhive(HKDD)
75 openhive(HKCC)
76
77 static struct {
78         uint32_t hkey;
79         WERROR (*open) (struct dcerpc_pipe *p, TALLOC_CTX *, struct policy_handle *h);
80 } known_hives[] = {
81         { HKEY_LOCAL_MACHINE, open_HKLM },
82         { HKEY_CURRENT_USER, open_HKCU },
83         { HKEY_CLASSES_ROOT, open_HKCR },
84         { HKEY_PERFORMANCE_DATA, open_HKPD },
85         { HKEY_USERS, open_HKU },
86         { HKEY_DYN_DATA, open_HKDD },
87         { HKEY_CURRENT_CONFIG, open_HKCC },
88         { 0, NULL }
89 };
90
91 static WERROR rpc_query_key(const struct registry_key *k);
92
93 static WERROR rpc_get_predefined_key(struct registry_context *ctx, 
94                                                                          uint32_t hkey_type, 
95                                                                          struct registry_key **k)
96 {
97         int n;
98         struct rpc_registry_context *rctx = talloc_get_type(ctx, 
99                                                                                                 struct rpc_registry_context);
100         struct rpc_key *mykeydata;
101
102         for(n = 0; known_hives[n].hkey; n++) {
103                 if(known_hives[n].hkey == hkey_type) 
104                         break;
105         }
106         
107         if (known_hives[n].open == NULL)  {
108                 DEBUG(1, ("No such hive %d\n", hkey_type));
109                 return WERR_NO_MORE_ITEMS;
110         }
111
112         mykeydata = talloc(ctx, struct rpc_key);
113         mykeydata->pipe = rctx->pipe;
114         mykeydata->num_values = -1;
115         mykeydata->num_subkeys = -1;
116         return known_hives[n].open(mykeydata->pipe, *k, &(mykeydata->pol));
117 }
118
119 #if 0
120 static WERROR rpc_key_put_rpc_data(TALLOC_CTX *mem_ctx, struct registry_key *k)
121 {
122     struct winreg_OpenKey r;
123         struct rpc_key_data *mykeydata;
124
125         k->backend_data = mykeydata = talloc(mem_ctx, struct rpc_key_data);
126         mykeydata->num_values = -1;
127         mykeydata->num_subkeys = -1;
128
129         /* Then, open the handle using the hive */
130
131         memset(&r, 0, sizeof(struct winreg_OpenKey));
132     r.in.handle = &(((struct rpc_key_data *)k->hive->root->backend_data)->pol);
133     init_winreg_String(&r.in.keyname, k->path);
134     r.in.unknown = 0x00000000;
135     r.in.access_mask = 0x02000000;
136     r.out.handle = &mykeydata->pol;
137
138     dcerpc_winreg_OpenKey((struct dcerpc_pipe *)k->hive->backend_data, mem_ctx, &r);
139
140         return r.out.result;
141 }
142 #endif
143
144 static WERROR rpc_open_key(TALLOC_CTX *mem_ctx, struct registry_key *h, 
145                                                    const char *name, struct registry_key **key)
146 {
147         struct rpc_key *mykeydata = talloc_get_type(h, struct rpc_key),
148                                    *newkeydata;
149     struct winreg_OpenKey r;
150
151         mykeydata = talloc(mem_ctx, struct rpc_key);
152
153         /* Then, open the handle using the hive */
154         memset(&r, 0, sizeof(struct winreg_OpenKey));
155     r.in.parent_handle = &mykeydata->pol;
156     init_winreg_String(&r.in.keyname, name);
157     r.in.unknown = 0x00000000;
158     r.in.access_mask = 0x02000000;
159     r.out.handle = &newkeydata->pol;
160
161     dcerpc_winreg_OpenKey(mykeydata->pipe, mem_ctx, &r);
162
163         return r.out.result;
164 }
165
166 static WERROR rpc_get_value_by_index(TALLOC_CTX *mem_ctx, 
167                                                                          const struct registry_key *parent, 
168                                                                          uint32_t n, 
169                                                                          const char **value_name,
170                                                                          uint32_t *type,
171                                                                          DATA_BLOB *data)
172 {
173         struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
174         WERROR error;
175         struct winreg_EnumValue r;
176         uint32_t len1, zero = 0;
177         NTSTATUS status;
178         struct winreg_StringBuf name;
179         uint8_t u8;
180         
181         if (mykeydata->num_values == -1) {
182                 error = rpc_query_key(parent);
183                 if(!W_ERROR_IS_OK(error)) return error;
184         }
185
186         len1 = mykeydata->max_valdatalen;
187         
188         name.length = 0;
189         name.size   = mykeydata->max_valnamelen * 2;
190         name.name   = "";
191
192         r.in.handle = &mykeydata->pol;
193         r.in.enum_index = n;
194         r.in.name = &name;
195         r.in.type = type;
196         r.in.value = &u8;
197         r.in.length = &zero;
198         r.in.size = &len1;
199         r.out.name = &name;
200         
201         status = dcerpc_winreg_EnumValue(mykeydata->pipe, mem_ctx, &r);
202         if(NT_STATUS_IS_ERR(status)) {
203                 DEBUG(0, ("Error in EnumValue: %s\n", nt_errstr(status)));
204                 return WERR_GENERAL_FAILURE;
205         }
206         
207         if(NT_STATUS_IS_OK(status) && 
208            W_ERROR_IS_OK(r.out.result) && r.out.length) {
209                 *value_name = talloc_strdup(mem_ctx, r.out.name->name);
210                 *data = data_blob_talloc(mem_ctx, r.out.value, *r.out.length);
211                 return WERR_OK;
212         }
213         
214         return r.out.result;
215 }
216
217 static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx, 
218                                                                           const struct registry_key *parent, 
219                                                                           uint32_t n, 
220                                                                           const char **name,
221                                                                           const char **keyclass,
222                                                                           NTTIME *last_changed_time)
223 {
224         struct winreg_EnumKey r;
225         struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
226         NTSTATUS status;
227         struct winreg_StringBuf namebuf, classbuf;
228         NTTIME change_time = 0;
229
230         namebuf.length = 0;
231         namebuf.size   = 1024;
232         namebuf.name   = NULL;
233         classbuf.length = 0;
234         classbuf.size   = 0;
235         classbuf.name   = NULL;
236
237         r.in.handle = &mykeydata->pol;
238         r.in.enum_index = n;
239         r.in.name = &namebuf;
240         r.in.keyclass = &classbuf;
241         r.in.last_changed_time = &change_time;
242         r.out.name = &namebuf;
243
244         status = dcerpc_winreg_EnumKey(mykeydata->pipe, mem_ctx, &r);
245         if(NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result)) {
246                 *name = talloc_strdup(mem_ctx, r.out.name->name);
247                 *keyclass = talloc_strdup(mem_ctx, r.out.keyclass->name);
248                 *last_changed_time = *r.out.last_changed_time;
249         }
250
251         return r.out.result;
252 }
253
254 static WERROR rpc_add_key(TALLOC_CTX *mem_ctx, 
255                                                   struct registry_key *parent, const char *name, 
256                                                   const char *key_class,
257                                                   struct security_descriptor *sec, 
258                                                   struct registry_key **key)
259 {
260         NTSTATUS status;
261         struct winreg_CreateKey r;
262         struct rpc_key *parentkd = talloc_get_type(parent, struct rpc_key);
263         struct rpc_key *rpck = talloc(mem_ctx, struct rpc_key);
264
265         init_winreg_String(&r.in.name, name);
266         init_winreg_String(&r.in.keyclass, NULL);
267
268         r.in.handle = &parentkd->pol;
269         r.out.new_handle = &rpck->pol;
270         r.in.options = 0;
271         r.in.access_mask = SEC_STD_ALL;
272         r.in.secdesc = NULL;
273
274         status = dcerpc_winreg_CreateKey(parentkd->pipe, mem_ctx, &r);
275
276     if (!NT_STATUS_IS_OK(status)) {
277                 talloc_free(rpck);
278         DEBUG(1, ("CreateKey failed - %s\n", nt_errstr(status)));
279         return ntstatus_to_werror(status);
280     }
281
282         if (W_ERROR_IS_OK(r.out.result)) {
283                 rpck->pipe = talloc_reference(rpck, parentkd->pipe);
284                 *key = (struct registry_key *)rpck;
285         }
286
287         return r.out.result;
288 }
289
290 static WERROR rpc_query_key(const struct registry_key *k)
291 {
292     NTSTATUS status;
293     struct winreg_QueryInfoKey r;
294     struct rpc_key *mykeydata = talloc_get_type(k, struct rpc_key);
295         TALLOC_CTX *mem_ctx = talloc_init("query_key");
296
297         r.in.classname = talloc(mem_ctx, struct winreg_String);
298     init_winreg_String(r.in.classname, NULL);
299     r.in.handle = &mykeydata->pol;
300         
301     status = dcerpc_winreg_QueryInfoKey(mykeydata->pipe, mem_ctx, &r);
302         talloc_free(mem_ctx);
303
304     if (!NT_STATUS_IS_OK(status)) {
305         DEBUG(1, ("QueryInfoKey failed - %s\n", nt_errstr(status)));
306         return ntstatus_to_werror(status);
307     }
308                                                                                                        
309     if (W_ERROR_IS_OK(r.out.result)) {
310                 mykeydata->num_subkeys = *r.out.num_subkeys;
311                 mykeydata->num_values = *r.out.num_values;
312                 mykeydata->max_valnamelen = *r.out.max_valnamelen;
313                 mykeydata->max_valdatalen = *r.out.max_valbufsize;
314         } 
315
316         return r.out.result;
317 }
318
319 static WERROR rpc_del_key(struct registry_key *parent, const char *name)
320 {
321         NTSTATUS status;
322         struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
323         struct winreg_DeleteKey r;
324         TALLOC_CTX *mem_ctx = talloc_init("del_key");
325         
326     r.in.handle = &mykeydata->pol;
327     init_winreg_String(&r.in.key, name);
328  
329     status = dcerpc_winreg_DeleteKey(mykeydata->pipe, mem_ctx, &r);
330
331         talloc_free(mem_ctx);
332
333         return r.out.result;
334 }
335
336 static WERROR rpc_get_info(TALLOC_CTX *mem_ctx, const struct registry_key *key,
337                                                    const char **classname, 
338                                                    uint32_t *numsubkeys,
339                                                    uint32_t *numvalue)
340 {
341         struct rpc_key *mykeydata = talloc_get_type(key, struct rpc_key);
342         WERROR error;
343                 
344         if(mykeydata->num_values == -1) {
345                 error = rpc_query_key(key);
346                 if(!W_ERROR_IS_OK(error)) return error;
347         }
348                         
349         /* FIXME: *classname = talloc_strdup(mem_ctx, mykeydata->classname); */
350         *numvalue = mykeydata->num_values;
351         *numsubkeys = mykeydata->num_subkeys;
352         return WERR_OK;
353 }
354
355 static struct registry_operations reg_backend_rpc = {
356         .name = "rpc",
357         .open_key = rpc_open_key,
358         .enum_key = rpc_get_subkey_by_index,
359         .enum_value = rpc_get_value_by_index,
360         .create_key = rpc_add_key,
361         .delete_key = rpc_del_key,
362         .get_key_info = rpc_get_info,
363 };
364
365 _PUBLIC_ WERROR reg_open_remote(struct registry_context **ctx, 
366                                                                 struct auth_session_info *session_info, 
367                                                                 struct cli_credentials *credentials, 
368                                                                 const char *location, struct event_context *ev)
369 {
370         NTSTATUS status;
371         struct dcerpc_pipe *p;
372         struct rpc_registry_context *rctx;
373
374         dcerpc_init();
375
376         rctx = talloc(NULL, struct rpc_registry_context);
377
378         /* Default to local smbd if no connection is specified */
379         if (!location) {
380                 location = talloc_strdup(ctx, "ncalrpc:");
381         }
382
383         status = dcerpc_pipe_connect(*ctx /* TALLOC_CTX */, 
384                                      &p, location, 
385                                          &ndr_table_winreg,
386                                      credentials, ev);
387         rctx->pipe = p;
388
389         if(NT_STATUS_IS_ERR(status)) {
390                 DEBUG(1, ("Unable to open '%s': %s\n", location, nt_errstr(status)));
391                 talloc_free(*ctx);
392                 *ctx = NULL;
393                 return ntstatus_to_werror(status);
394         }
395
396         *ctx = (struct registry_context *)rctx;
397
398         return WERR_OK;
399 }