source: trunk/server/source3/rpc_client/cli_winreg_int.c@ 745

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

Samba Server: updated trunk to 3.6.0
File size: 7.9 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 *
4 * WINREG internal client routines
5 *
6 * Copyright (c) 2011 Andreas Schneider <[email protected]>
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 3 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, see <http://www.gnu.org/licenses/>.
20 */
21
22#include "includes.h"
23#include "include/registry.h"
24#include "librpc/gen_ndr/ndr_winreg_c.h"
25#include "rpc_client/cli_winreg_int.h"
26#include "rpc_server/rpc_ncacn_np.h"
27
28/**
29 * Split path into hive name and subkeyname
30 * normalizations performed:
31 * - if the path contains no '\\' characters,
32 * assume that the legacy format of using '/'
33 * as a separator is used and convert '/' to '\\'
34 * - strip trailing '\\' chars
35 */
36static WERROR _split_hive_key(TALLOC_CTX *mem_ctx,
37 const char *path,
38 char **hivename,
39 char **subkeyname)
40{
41 char *p;
42 const char *tmp_subkeyname;
43
44 if ((path == NULL) || (hivename == NULL) || (subkeyname == NULL)) {
45 return WERR_INVALID_PARAM;
46 }
47
48 if (strlen(path) == 0) {
49 return WERR_INVALID_PARAM;
50 }
51
52 if (strchr(path, '\\') == NULL) {
53 *hivename = talloc_string_sub(mem_ctx, path, "/", "\\");
54 } else {
55 *hivename = talloc_strdup(mem_ctx, path);
56 }
57
58 if (*hivename == NULL) {
59 return WERR_NOMEM;
60 }
61
62 /* strip trailing '\\' chars */
63 p = strrchr(*hivename, '\\');
64 while ((p != NULL) && (p[1] == '\0')) {
65 *p = '\0';
66 p = strrchr(*hivename, '\\');
67 }
68
69 p = strchr(*hivename, '\\');
70
71 if ((p == NULL) || (*p == '\0')) {
72 /* just the hive - no subkey given */
73 tmp_subkeyname = "";
74 } else {
75 *p = '\0';
76 tmp_subkeyname = p+1;
77 }
78 *subkeyname = talloc_strdup(mem_ctx, tmp_subkeyname);
79 if (*subkeyname == NULL) {
80 return WERR_NOMEM;
81 }
82
83 return WERR_OK;
84}
85
86static NTSTATUS _winreg_int_openkey(TALLOC_CTX *mem_ctx,
87 const struct auth_serversupplied_info *session_info,
88 struct messaging_context *msg_ctx,
89 struct dcerpc_binding_handle **h,
90 uint32_t reg_type,
91 const char *key,
92 bool create_key,
93 uint32_t access_mask,
94 struct policy_handle *hive_handle,
95 struct policy_handle *key_handle,
96 WERROR *pwerr)
97{
98 static struct client_address client_id;
99 struct dcerpc_binding_handle *binding_handle;
100 struct winreg_String wkey, wkeyclass;
101 NTSTATUS status;
102 WERROR result = WERR_OK;
103
104 strlcpy(client_id.addr, "127.0.0.1", sizeof(client_id.addr));
105 client_id.name = "127.0.0.1";
106
107 status = rpcint_binding_handle(mem_ctx,
108 &ndr_table_winreg,
109 &client_id,
110 session_info,
111 msg_ctx,
112 &binding_handle);
113 if (!NT_STATUS_IS_OK(status)) {
114 DEBUG(0, ("dcerpc_winreg_int_openkey: Could not connect to winreg pipe: %s\n",
115 nt_errstr(status)));
116 return status;
117 }
118
119 switch (reg_type) {
120 case HKEY_LOCAL_MACHINE:
121 status = dcerpc_winreg_OpenHKLM(binding_handle,
122 mem_ctx,
123 NULL,
124 access_mask,
125 hive_handle,
126 &result);
127 break;
128 case HKEY_CLASSES_ROOT:
129 status = dcerpc_winreg_OpenHKCR(binding_handle,
130 mem_ctx,
131 NULL,
132 access_mask,
133 hive_handle,
134 &result);
135 break;
136 case HKEY_USERS:
137 status = dcerpc_winreg_OpenHKU(binding_handle,
138 mem_ctx,
139 NULL,
140 access_mask,
141 hive_handle,
142 &result);
143 break;
144 case HKEY_CURRENT_USER:
145 status = dcerpc_winreg_OpenHKCU(binding_handle,
146 mem_ctx,
147 NULL,
148 access_mask,
149 hive_handle,
150 &result);
151 break;
152 case HKEY_PERFORMANCE_DATA:
153 status = dcerpc_winreg_OpenHKPD(binding_handle,
154 mem_ctx,
155 NULL,
156 access_mask,
157 hive_handle,
158 &result);
159 break;
160 default:
161 result = WERR_INVALID_PARAMETER;
162 status = NT_STATUS_OK;
163 }
164 if (!NT_STATUS_IS_OK(status)) {
165 talloc_free(binding_handle);
166 return status;
167 }
168 if (!W_ERROR_IS_OK(result)) {
169 talloc_free(binding_handle);
170 *pwerr = result;
171 return status;
172 }
173
174 ZERO_STRUCT(wkey);
175 wkey.name = key;
176
177 if (create_key) {
178 enum winreg_CreateAction action = REG_ACTION_NONE;
179
180 ZERO_STRUCT(wkeyclass);
181 wkeyclass.name = "";
182
183 status = dcerpc_winreg_CreateKey(binding_handle,
184 mem_ctx,
185 hive_handle,
186 wkey,
187 wkeyclass,
188 0,
189 access_mask,
190 NULL,
191 key_handle,
192 &action,
193 &result);
194 switch (action) {
195 case REG_ACTION_NONE:
196 DEBUG(8, ("dcerpc_winreg_int_openkey: createkey"
197 " did nothing -- huh?\n"));
198 break;
199 case REG_CREATED_NEW_KEY:
200 DEBUG(8, ("dcerpc_winreg_int_openkey: createkey"
201 " created %s\n", key));
202 break;
203 case REG_OPENED_EXISTING_KEY:
204 DEBUG(8, ("dcerpc_winreg_int_openkey: createkey"
205 " opened existing %s\n", key));
206 break;
207 }
208 } else {
209 status = dcerpc_winreg_OpenKey(binding_handle,
210 mem_ctx,
211 hive_handle,
212 wkey,
213 0,
214 access_mask,
215 key_handle,
216 &result);
217 }
218 if (!NT_STATUS_IS_OK(status)) {
219 talloc_free(binding_handle);
220 return status;
221 }
222 if (!W_ERROR_IS_OK(result)) {
223 talloc_free(binding_handle);
224 *pwerr = result;
225 return status;
226 }
227
228 *h = binding_handle;
229
230 return status;
231}
232
233NTSTATUS dcerpc_winreg_int_openkey(TALLOC_CTX *mem_ctx,
234 const struct auth_serversupplied_info *server_info,
235 struct messaging_context *msg_ctx,
236 struct dcerpc_binding_handle **h,
237 const char *key,
238 bool create_key,
239 uint32_t access_mask,
240 struct policy_handle *hive_handle,
241 struct policy_handle *key_handle,
242 WERROR *pwerr)
243{
244 char *hivename = NULL;
245 char *subkey = NULL;
246 uint32_t reg_type;
247 WERROR result;
248
249 result = _split_hive_key(mem_ctx, key, &hivename, &subkey);
250 if (!W_ERROR_IS_OK(result)) {
251 *pwerr = result;
252 return NT_STATUS_OK;
253 }
254
255 if (strequal(hivename, "HKLM") ||
256 strequal(hivename, "HKEY_LOCAL_MACHINE")) {
257 reg_type = HKEY_LOCAL_MACHINE;
258 } else if (strequal(hivename, "HKCR") ||
259 strequal(hivename, "HKEY_CLASSES_ROOT")) {
260 reg_type = HKEY_CLASSES_ROOT;
261 } else if (strequal(hivename, "HKU") ||
262 strequal(hivename, "HKEY_USERS")) {
263 reg_type = HKEY_USERS;
264 } else if (strequal(hivename, "HKCU") ||
265 strequal(hivename, "HKEY_CURRENT_USER")) {
266 reg_type = HKEY_CURRENT_USER;
267 } else if (strequal(hivename, "HKPD") ||
268 strequal(hivename, "HKEY_PERFORMANCE_DATA")) {
269 reg_type = HKEY_PERFORMANCE_DATA;
270 } else {
271 DEBUG(10,("dcerpc_winreg_int_openkey: unrecognised hive key %s\n",
272 key));
273 *pwerr = WERR_INVALID_PARAMETER;
274 return NT_STATUS_OK;
275 }
276
277 return _winreg_int_openkey(mem_ctx,
278 server_info,
279 msg_ctx,
280 h,
281 reg_type,
282 key,
283 create_key,
284 access_mask,
285 hive_handle,
286 key_handle,
287 pwerr);
288}
289
290NTSTATUS dcerpc_winreg_int_hklm_openkey(TALLOC_CTX *mem_ctx,
291 const struct auth_serversupplied_info *server_info,
292 struct messaging_context *msg_ctx,
293 struct dcerpc_binding_handle **h,
294 const char *key,
295 bool create_key,
296 uint32_t access_mask,
297 struct policy_handle *hive_handle,
298 struct policy_handle *key_handle,
299 WERROR *pwerr)
300{
301 return _winreg_int_openkey(mem_ctx,
302 server_info,
303 msg_ctx,
304 h,
305 HKEY_LOCAL_MACHINE,
306 key,
307 create_key,
308 access_mask,
309 hive_handle,
310 key_handle,
311 pwerr);
312}
313
314/* vim: set ts=8 sw=8 noet cindent syntax=c.doxygen: */
Note: See TracBrowser for help on using the repository browser.