r128: Another registry update. Changes:
[ira/wip.git] / source4 / rpc_server / winreg / rpc_winreg.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    endpoint server for the winreg pipe
5
6    Copyright (C) Jelmer Vernooij 2004
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 2 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, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24
25 /**
26  * General notes for the current implementation:
27  * 
28  * - All hives are currently openened as subkeys of one single registry file 
29  *   (e.g. HKCR from \HKEY_CURRENT_USER, etc). This might be changed in 
30  *   the future and we might want to make it possible to configure 
31  *   what registries are behind which hives (e.g. 
32  *      \HKEY_CURRENT_USER -> gconf,
33  *      \HKEY_LOCAL_MACHINE -> tdb,
34  *      etc
35  */
36
37 enum handle_types { HTYPE_REGKEY, HTYPE_REGVAL };
38
39 struct _privatedata {
40         REG_HANDLE *registry;
41 };
42
43
44 /* this function is called when the client disconnects the endpoint */
45 static void winreg_unbind(struct dcesrv_connection *dc, const struct dcesrv_interface *di) 
46 {
47         struct _privatedata *data = dc->private;
48         if (data) reg_free(data->registry);
49 }
50
51 static NTSTATUS winreg_bind(struct dcesrv_call_state *dc, const struct dcesrv_interface *di) 
52 {
53         struct _privatedata *data;
54         WERROR error;
55         data = talloc(dc->conn->mem_ctx, sizeof(struct _privatedata));
56         error = reg_open("dir", "/tmp/reg", "", &data->registry);
57         if(!W_ERROR_IS_OK(error)) return werror_to_ntstatus(error);
58         dc->conn->private = data;
59         return NT_STATUS_OK;
60 }
61
62 #define DCESRV_INTERFACE_WINREG_BIND winreg_bind
63 #define DCESRV_INTERFACE_WINREG_UNBIND winreg_unbind
64
65 #define func_winreg_OpenHive(k,n) static NTSTATUS winreg_Open ## k (struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct winreg_Open ## k *r) \
66 { \
67         struct _privatedata *data = dce_call->conn->private; \
68         REG_KEY *root/* = reg_get_root(data->registry)*/; \
69         REG_KEY *k/* = reg_open_key(root, n)*/; \
70 \
71         if(!k) { \
72                 r->out.result = WERR_BADFILE; \
73         } else { \
74                 struct dcesrv_handle *h = dcesrv_handle_new(dce_call->conn, HTYPE_REGKEY); \
75                 h->data = k; \
76                 r->out.handle = &h->wire_handle; \
77         } \
78 \
79         r->out.result = WERR_OK; \
80 \
81         return NT_STATUS_OK; \
82 }
83
84 func_winreg_OpenHive(HKCR,"\\HKEY_CLASSES_ROOT")
85 func_winreg_OpenHive(HKCU,"\\HKEY_CURRENT_USER")
86 func_winreg_OpenHive(HKLM,"\\HKEY_LOCAL_MACHINE")
87 func_winreg_OpenHive(HKPD,"\\HKEY_PERFORMANCE_DATA")
88 func_winreg_OpenHive(HKU,"\\HKEY_USERS")
89 func_winreg_OpenHive(HKCC,"\\HKEY_CC")
90 func_winreg_OpenHive(HKDD,"\\HKEY_DD")
91 func_winreg_OpenHive(HKPT,"\\HKEY_PT")
92 func_winreg_OpenHive(HKPN,"\\HKEY_PN")
93
94 /* 
95   winreg_CloseKey 
96 */
97 static NTSTATUS winreg_CloseKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
98                        struct winreg_CloseKey *r)
99 {
100         struct dcesrv_handle *h = dcesrv_handle_fetch(dce_call->conn, r->in.handle, HTYPE_REGKEY);
101         if(!h) {
102                 return NT_STATUS_INVALID_HANDLE;
103         }
104
105         reg_key_free((REG_KEY *)h->data);
106         dcesrv_handle_destroy(dce_call->conn, h);
107
108         return NT_STATUS_OK;
109 }
110
111
112 /* 
113   winreg_CreateKey 
114 */
115 static NTSTATUS winreg_CreateKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
116                        struct winreg_CreateKey *r)
117 {
118         struct dcesrv_handle *h = dcesrv_handle_fetch(dce_call->conn, r->in.handle, HTYPE_REGKEY);
119         WERROR error;
120         REG_KEY *parent;
121         if(!h) {
122                 return NT_STATUS_INVALID_HANDLE;
123         }
124
125         parent = h->data;
126         error = reg_key_add_name_recursive(parent, r->in.key.name);
127         if(W_ERROR_IS_OK(error)) {
128                 struct dcesrv_handle *newh = dcesrv_handle_new(dce_call->conn, HTYPE_REGKEY);
129                 error = reg_open_key(parent, r->in.key.name, (REG_KEY **)&newh->data);
130                 if(W_ERROR_IS_OK(error)) r->out.handle = &newh->wire_handle;
131                 else dcesrv_handle_destroy(dce_call->conn, newh);
132         }
133
134         r->out.result = error;
135
136         return NT_STATUS_OK;
137 }
138
139
140 /* 
141   winreg_DeleteKey 
142 */
143 static NTSTATUS winreg_DeleteKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
144                        struct winreg_DeleteKey *r)
145 {
146         struct dcesrv_handle *h = dcesrv_handle_fetch(dce_call->conn, r->in.handle, HTYPE_REGKEY);
147         REG_KEY *parent, *key;
148         WERROR error;
149         if(!h) {
150                 return NT_STATUS_INVALID_HANDLE;
151         }
152
153         parent = h->data;
154         r->out.result = reg_open_key(parent, r->in.key.name, &key);
155         if(W_ERROR_IS_OK(r->out.result)) {
156                 r->out.result = reg_key_del(key);
157         }
158         return NT_STATUS_OK;
159 }
160
161
162 /* 
163   winreg_DeleteValue 
164 */
165 static NTSTATUS winreg_DeleteValue(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
166                        struct winreg_DeleteValue *r)
167 {
168         return NT_STATUS_NOT_IMPLEMENTED;
169 }
170
171
172 /* 
173   winreg_EnumKey 
174 */
175 static NTSTATUS winreg_EnumKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
176                        struct winreg_EnumKey *r)
177 {
178         struct dcesrv_handle *h = dcesrv_handle_fetch(dce_call->conn, r->in.handle, HTYPE_REGKEY);
179         REG_KEY *key;
180         if(!h) {
181                 return NT_STATUS_INVALID_HANDLE;
182         }
183
184         key = h->data;
185         
186         return NT_STATUS_NOT_IMPLEMENTED;
187 }
188
189
190 /* 
191   winreg_EnumValue 
192 */
193 static NTSTATUS winreg_EnumValue(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
194                        struct winreg_EnumValue *r)
195 {
196         return NT_STATUS_NOT_IMPLEMENTED;
197 }
198
199
200 /* 
201   winreg_FlushKey 
202 */
203 static NTSTATUS winreg_FlushKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
204                        struct winreg_FlushKey *r)
205 {
206         return NT_STATUS_NOT_IMPLEMENTED;
207 }
208
209
210 /* 
211   winreg_GetKeySecurity 
212 */
213 static NTSTATUS winreg_GetKeySecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
214                        struct winreg_GetKeySecurity *r)
215 {
216         return NT_STATUS_NOT_IMPLEMENTED;
217 }
218
219
220 /* 
221   winreg_LoadKey 
222 */
223 static NTSTATUS winreg_LoadKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
224                        struct winreg_LoadKey *r)
225 {
226         return NT_STATUS_NOT_IMPLEMENTED;
227 }
228
229
230 /* 
231   winreg_NotifyChangeKeyValue 
232 */
233 static NTSTATUS winreg_NotifyChangeKeyValue(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
234                        struct winreg_NotifyChangeKeyValue *r)
235 {
236         return NT_STATUS_NOT_IMPLEMENTED;
237 }
238
239
240 /* 
241   winreg_OpenKey 
242 */
243 static NTSTATUS winreg_OpenKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
244                        struct winreg_OpenKey *r)
245 {
246         struct dcesrv_handle *h = dcesrv_handle_fetch(dce_call->conn, r->in.handle, HTYPE_REGKEY);
247         REG_KEY *k, *subkey;
248         if(!h) {
249                 return NT_STATUS_INVALID_HANDLE;
250         }
251
252         k = h->data;
253
254
255         r->out.result = reg_open_key(k, r->in.keyname.name, &subkey);
256         if(W_ERROR_IS_OK(r->out.result)) {
257                 struct dcesrv_handle *newh = dcesrv_handle_new(dce_call->conn, HTYPE_REGKEY); 
258                 h->data = subkey; 
259                 r->out.handle = &h->wire_handle; 
260         }
261         
262         return NT_STATUS_OK;
263 }
264
265
266 /* 
267   winreg_QueryInfoKey 
268 */
269 static NTSTATUS winreg_QueryInfoKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
270                        struct winreg_QueryInfoKey *r)
271 {
272         return NT_STATUS_NOT_IMPLEMENTED;
273 }
274
275
276 /* 
277   winreg_QueryValue 
278 */
279 static NTSTATUS winreg_QueryValue(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
280                        struct winreg_QueryValue *r)
281 {
282         return NT_STATUS_NOT_IMPLEMENTED;
283 }
284
285
286 /* 
287   winreg_ReplaceKey 
288 */
289 static NTSTATUS winreg_ReplaceKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
290                        struct winreg_ReplaceKey *r)
291 {
292         return NT_STATUS_NOT_IMPLEMENTED;
293 }
294
295
296 /* 
297   winreg_RestoreKey 
298 */
299 static NTSTATUS winreg_RestoreKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
300                        struct winreg_RestoreKey *r)
301 {
302         return NT_STATUS_NOT_IMPLEMENTED;
303 }
304
305
306 /* 
307   winreg_SaveKey 
308 */
309 static NTSTATUS winreg_SaveKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
310                        struct winreg_SaveKey *r)
311 {
312         return NT_STATUS_NOT_IMPLEMENTED;
313 }
314
315
316 /* 
317   winreg_SetKeySecurity 
318 */
319 static NTSTATUS winreg_SetKeySecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
320                        struct winreg_SetKeySecurity *r)
321 {
322         return NT_STATUS_NOT_IMPLEMENTED;
323 }
324
325
326 /* 
327   winreg_SetValue 
328 */
329 static NTSTATUS winreg_SetValue(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
330                        struct winreg_SetValue *r)
331 {
332         return NT_STATUS_NOT_IMPLEMENTED;
333 }
334
335
336 /* 
337   winreg_UnLoadKey 
338 */
339 static NTSTATUS winreg_UnLoadKey(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
340                        struct winreg_UnLoadKey *r)
341 {
342         return NT_STATUS_NOT_IMPLEMENTED;
343 }
344
345
346 /* 
347   winreg_InitiateSystemShutdown 
348 */
349 static NTSTATUS winreg_InitiateSystemShutdown(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
350                        struct winreg_InitiateSystemShutdown *r)
351 {
352         return NT_STATUS_NOT_IMPLEMENTED;
353 }
354
355
356 /* 
357   winreg_AbortSystemShutdown 
358 */
359 static NTSTATUS winreg_AbortSystemShutdown(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
360                        struct winreg_AbortSystemShutdown *r)
361 {
362         return NT_STATUS_NOT_IMPLEMENTED;
363 }
364
365
366 /* 
367   winreg_GetVersion 
368 */
369 static NTSTATUS winreg_GetVersion(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
370                        struct winreg_GetVersion *r)
371 {
372         return NT_STATUS_NOT_IMPLEMENTED;
373 }
374
375
376 /* 
377   winreg_QueryMultipleValues 
378 */
379 static NTSTATUS winreg_QueryMultipleValues(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
380                        struct winreg_QueryMultipleValues *r)
381 {
382         return NT_STATUS_NOT_IMPLEMENTED;
383 }
384
385
386 /* 
387   winreg_InitiateSystemShutdownEx 
388 */
389 static NTSTATUS winreg_InitiateSystemShutdownEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
390                        struct winreg_InitiateSystemShutdownEx *r)
391 {
392         return NT_STATUS_NOT_IMPLEMENTED;
393 }
394
395
396 /* 
397   winreg_SaveKeyEx 
398 */
399 static NTSTATUS winreg_SaveKeyEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
400                        struct winreg_SaveKeyEx *r)
401 {
402         return NT_STATUS_NOT_IMPLEMENTED;
403 }
404
405
406 /* 
407   winreg_QueryMultipleValues2 
408 */
409 static NTSTATUS winreg_QueryMultipleValues2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
410                        struct winreg_QueryMultipleValues2 *r)
411 {
412         return NT_STATUS_NOT_IMPLEMENTED;
413 }
414
415
416 /* include the generated boilerplate */
417 #include "librpc/gen_ndr/ndr_winreg_s.c"