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