import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / rpc_server / srv_reg.c
1 /*
2  *  Unix SMB/CIFS implementation.
3  *  RPC Pipe client / server routines
4  *  Copyright (C) Andrew Tridgell              1992-1997,
5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
6  *  Copyright (C) Paul Ashton                       1997,
7  *  Copyright (C) Marc Jacobsen                     2000,
8  *  Copyright (C) Jeremy Allison                    2001,
9  *  Copyright (C) Gerald Carter                     2002,
10  *  Copyright (C) Jim McDonough <jmcd@us.ibm.com>   2003.
11  *
12  *  This program is free software; you can redistribute it and/or modify
13  *  it under the terms of the GNU General Public License as published by
14  *  the Free Software Foundation; either version 2 of the License, or
15  *  (at your option) any later version.
16  *  
17  *  This program is distributed in the hope that it will be useful,
18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  *  GNU General Public License for more details.
21  *  
22  *  You should have received a copy of the GNU General Public License
23  *  along with this program; if not, write to the Free Software
24  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25  */
26
27 /* This is the interface for the registry functions. */
28
29 #include "includes.h"
30
31 #undef DBGC_CLASS
32 #define DBGC_CLASS DBGC_RPC_SRV
33
34 /*******************************************************************
35  api_reg_close
36  ********************************************************************/
37
38 static BOOL api_reg_close(pipes_struct *p)
39 {
40         REG_Q_CLOSE q_u;
41         REG_R_CLOSE r_u;
42         prs_struct *data = &p->in_data.data;
43         prs_struct *rdata = &p->out_data.rdata;
44
45         ZERO_STRUCT(q_u);
46         ZERO_STRUCT(r_u);
47
48         /* grab the reg unknown 1 */
49         if(!reg_io_q_close("", &q_u, data, 0))
50                 return False;
51
52         r_u.status = _reg_close(p, &q_u, &r_u);
53
54         if(!reg_io_r_close("", &r_u, rdata, 0))
55                 return False;
56
57         return True;
58 }
59
60 /*******************************************************************
61  api_reg_open_khlm
62  ********************************************************************/
63
64 static BOOL api_reg_open_hklm(pipes_struct *p)
65 {
66         REG_Q_OPEN_HKLM q_u;
67         REG_R_OPEN_HKLM r_u;
68         prs_struct *data = &p->in_data.data;
69         prs_struct *rdata = &p->out_data.rdata;
70
71         ZERO_STRUCT(q_u);
72         ZERO_STRUCT(r_u);
73
74         /* grab the reg open */
75         if(!reg_io_q_open_hklm("", &q_u, data, 0))
76                 return False;
77
78         r_u.status = _reg_open_hklm(p, &q_u, &r_u);
79
80         if(!reg_io_r_open_hklm("", &r_u, rdata, 0))
81                 return False;
82
83         return True;
84 }
85
86 /*******************************************************************
87  api_reg_open_khu
88  ********************************************************************/
89
90 static BOOL api_reg_open_hku(pipes_struct *p)
91 {
92         REG_Q_OPEN_HKU q_u;
93         REG_R_OPEN_HKU r_u;
94         prs_struct *data = &p->in_data.data;
95         prs_struct *rdata = &p->out_data.rdata;
96
97         ZERO_STRUCT(q_u);
98         ZERO_STRUCT(r_u);
99
100         /* grab the reg open */
101         if(!reg_io_q_open_hku("", &q_u, data, 0))
102                 return False;
103
104         r_u.status = _reg_open_hku(p, &q_u, &r_u);
105
106         if(!reg_io_r_open_hku("", &r_u, rdata, 0))
107                 return False;
108
109         return True;
110 }
111
112 /*******************************************************************
113  api_reg_open_khcr
114  ********************************************************************/
115
116 static BOOL api_reg_open_hkcr(pipes_struct *p)
117 {
118         REG_Q_OPEN_HKCR q_u;
119         REG_R_OPEN_HKCR r_u;
120         prs_struct *data = &p->in_data.data;
121         prs_struct *rdata = &p->out_data.rdata;
122
123         ZERO_STRUCT(q_u);
124         ZERO_STRUCT(r_u);
125
126         /* grab the reg open */
127         if(!reg_io_q_open_hkcr("", &q_u, data, 0))
128                 return False;
129
130         r_u.status = _reg_open_hkcr(p, &q_u, &r_u);
131
132         if(!reg_io_r_open_hkcr("", &r_u, rdata, 0))
133                 return False;
134
135         return True;
136 }
137
138
139 /*******************************************************************
140  api_reg_open_entry
141  ********************************************************************/
142
143 static BOOL api_reg_open_entry(pipes_struct *p)
144 {
145         REG_Q_OPEN_ENTRY q_u;
146         REG_R_OPEN_ENTRY r_u;
147         prs_struct *data = &p->in_data.data;
148         prs_struct *rdata = &p->out_data.rdata;
149
150         ZERO_STRUCT(q_u);
151         ZERO_STRUCT(r_u);
152
153         /* grab the reg open entry */
154         if(!reg_io_q_open_entry("", &q_u, data, 0))
155                 return False;
156
157         /* construct reply. */
158         r_u.status = _reg_open_entry(p, &q_u, &r_u);
159
160         if(!reg_io_r_open_entry("", &r_u, rdata, 0))
161                 return False;
162
163         return True;
164 }
165
166 /*******************************************************************
167  api_reg_info
168  ********************************************************************/
169
170 static BOOL api_reg_info(pipes_struct *p)
171 {
172         REG_Q_INFO q_u;
173         REG_R_INFO r_u;
174         prs_struct *data = &p->in_data.data;
175         prs_struct *rdata = &p->out_data.rdata;
176
177         ZERO_STRUCT(q_u);
178         ZERO_STRUCT(r_u);
179
180         /* grab the reg unknown 0x11*/
181         if(!reg_io_q_info("", &q_u, data, 0))
182                 return False;
183
184         r_u.status = _reg_info(p, &q_u, &r_u);
185
186         if(!reg_io_r_info("", &r_u, rdata, 0))
187                 return False;
188
189         return True;
190 }
191
192 /*******************************************************************
193  api_reg_shutdown
194  ********************************************************************/
195
196 static BOOL api_reg_shutdown(pipes_struct *p)
197 {
198         REG_Q_SHUTDOWN q_u;
199         REG_R_SHUTDOWN r_u;
200         prs_struct *data = &p->in_data.data;
201         prs_struct *rdata = &p->out_data.rdata;
202
203         ZERO_STRUCT(q_u);
204         ZERO_STRUCT(r_u);
205
206         /* grab the reg shutdown */
207         if(!reg_io_q_shutdown("", &q_u, data, 0))
208                 return False;
209
210         r_u.status = _reg_shutdown(p, &q_u, &r_u);
211
212         if(!reg_io_r_shutdown("", &r_u, rdata, 0))
213                 return False;
214
215         return True;
216 }
217
218 /*******************************************************************
219  api_reg_abort_shutdown
220  ********************************************************************/
221
222 static BOOL api_reg_abort_shutdown(pipes_struct *p)
223 {
224         REG_Q_ABORT_SHUTDOWN q_u;
225         REG_R_ABORT_SHUTDOWN r_u;
226         prs_struct *data = &p->in_data.data;
227         prs_struct *rdata = &p->out_data.rdata;
228
229         ZERO_STRUCT(q_u);
230         ZERO_STRUCT(r_u);
231
232         /* grab the reg shutdown */
233         if(!reg_io_q_abort_shutdown("", &q_u, data, 0))
234                 return False;
235
236         r_u.status = _reg_abort_shutdown(p, &q_u, &r_u);
237
238         if(!reg_io_r_abort_shutdown("", &r_u, rdata, 0))
239                 return False;
240
241         return True;
242 }
243
244
245 /*******************************************************************
246  api_reg_query_key
247  ********************************************************************/
248
249 static BOOL api_reg_query_key(pipes_struct *p)
250 {
251         REG_Q_QUERY_KEY q_u;
252         REG_R_QUERY_KEY r_u;
253         prs_struct *data = &p->in_data.data;
254         prs_struct *rdata = &p->out_data.rdata;
255
256         ZERO_STRUCT(q_u);
257         ZERO_STRUCT(r_u);
258
259         if(!reg_io_q_query_key("", &q_u, data, 0))
260                 return False;
261
262         r_u.status = _reg_query_key(p, &q_u, &r_u);
263
264         if(!reg_io_r_query_key("", &r_u, rdata, 0))
265                 return False;
266
267         return True;
268 }
269
270 /*******************************************************************
271  api_reg_unknown_1a
272  ********************************************************************/
273
274 static BOOL api_reg_unknown_1a(pipes_struct *p)
275 {
276         REG_Q_UNKNOWN_1A q_u;
277         REG_R_UNKNOWN_1A r_u;
278         prs_struct *data = &p->in_data.data;
279         prs_struct *rdata = &p->out_data.rdata;
280
281         ZERO_STRUCT(q_u);
282         ZERO_STRUCT(r_u);
283
284         if(!reg_io_q_unknown_1a("", &q_u, data, 0))
285                 return False;
286
287         r_u.status = _reg_unknown_1a(p, &q_u, &r_u);
288
289         if(!reg_io_r_unknown_1a("", &r_u, rdata, 0))
290                 return False;
291
292         return True;
293 }
294
295 /*******************************************************************
296  api_reg_enum_key
297  ********************************************************************/
298
299 static BOOL api_reg_enum_key(pipes_struct *p)
300 {
301         REG_Q_ENUM_KEY q_u;
302         REG_R_ENUM_KEY r_u;
303         prs_struct *data = &p->in_data.data;
304         prs_struct *rdata = &p->out_data.rdata;
305
306         ZERO_STRUCT(q_u);
307         ZERO_STRUCT(r_u);
308
309         if(!reg_io_q_enum_key("", &q_u, data, 0))
310                 return False;
311
312         r_u.status = _reg_enum_key(p, &q_u, &r_u);
313
314         if(!reg_io_r_enum_key("", &r_u, rdata, 0))
315                 return False;
316
317         return True;
318 }
319
320 /*******************************************************************
321  api_reg_enum_value
322  ********************************************************************/
323
324 static BOOL api_reg_enum_value(pipes_struct *p)
325 {
326         REG_Q_ENUM_VALUE q_u;
327         REG_R_ENUM_VALUE r_u;
328         prs_struct *data = &p->in_data.data;
329         prs_struct *rdata = &p->out_data.rdata;
330
331         ZERO_STRUCT(q_u);
332         ZERO_STRUCT(r_u);
333
334         if(!reg_io_q_enum_val("", &q_u, data, 0))
335                 return False;
336                 
337         r_u.status = _reg_enum_value(p, &q_u, &r_u);
338
339         if(!reg_io_r_enum_val("", &r_u, rdata, 0))
340                 return False;
341
342         return True;
343 }
344
345 /*******************************************************************
346  api_reg_save_key
347  ********************************************************************/
348
349 static BOOL api_reg_save_key(pipes_struct *p)
350 {
351         REG_Q_SAVE_KEY q_u;
352         REG_R_SAVE_KEY r_u;
353         prs_struct *data = &p->in_data.data;
354         prs_struct *rdata = &p->out_data.rdata;
355
356         ZERO_STRUCT(q_u);
357         ZERO_STRUCT(r_u);
358
359         if(!reg_io_q_save_key("", &q_u, data, 0))
360                 return False;
361                 
362         r_u.status = _reg_save_key(p, &q_u, &r_u);
363
364         if(!reg_io_r_save_key("", &r_u, rdata, 0))
365                 return False;
366
367         return True;
368 }
369
370 /*******************************************************************
371  array of \PIPE\reg operations
372  ********************************************************************/
373
374 static struct api_struct api_reg_cmds[] =
375 {
376       { "REG_CLOSE"              , REG_CLOSE              , api_reg_close            },
377       { "REG_OPEN_ENTRY"         , REG_OPEN_ENTRY         , api_reg_open_entry       },
378       { "REG_OPEN_HKCR"          , REG_OPEN_HKCR          , api_reg_open_hkcr        },
379       { "REG_OPEN_HKLM"          , REG_OPEN_HKLM          , api_reg_open_hklm        },
380       { "REG_OPEN_HKU"           , REG_OPEN_HKU           , api_reg_open_hku         },
381       { "REG_ENUM_KEY"           , REG_ENUM_KEY           , api_reg_enum_key         },
382       { "REG_ENUM_VALUE"         , REG_ENUM_VALUE         , api_reg_enum_value       },
383       { "REG_QUERY_KEY"          , REG_QUERY_KEY          , api_reg_query_key        },
384       { "REG_INFO"               , REG_INFO               , api_reg_info             },
385       { "REG_SHUTDOWN"           , REG_SHUTDOWN           , api_reg_shutdown         },
386       { "REG_ABORT_SHUTDOWN"     , REG_ABORT_SHUTDOWN     , api_reg_abort_shutdown   },
387       { "REG_UNKNOWN_1A"         , REG_UNKNOWN_1A         , api_reg_unknown_1a       },
388       { "REG_SAVE_KEY"           , REG_SAVE_KEY           , api_reg_save_key         }
389 };
390
391 void reg_get_pipe_fns( struct api_struct **fns, int *n_fns )
392 {
393         *fns = api_reg_cmds;
394         *n_fns = sizeof(api_reg_cmds) / sizeof(struct api_struct);
395 }
396     
397 NTSTATUS rpc_reg_init(void)
398 {
399
400   return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "winreg", "winreg", api_reg_cmds,
401                                     sizeof(api_reg_cmds) / sizeof(struct api_struct));
402 }