gpg: Try to use the passphrase from the primary for --quick-addkey.
[gnupg.git] / common / w32-reg.c
1 /* w32-reg.c -  MS-Windows Registry access
2  * Copyright (C) 1999, 2002, 2007 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify it
7  * under the terms of either
8  *
9  *   - the GNU Lesser General Public License as published by the Free
10  *     Software Foundation; either version 3 of the License, or (at
11  *     your option) any later version.
12  *
13  * or
14  *
15  *   - the GNU General Public License as published by the Free
16  *     Software Foundation; either version 2 of the License, or (at
17  *     your option) any later version.
18  *
19  * or both in parallel, as here.
20  *
21  * GnuPG is distributed in the hope that it will be useful, but
22  * WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * General Public License for more details.
25  *
26  * You should have received a copies of the GNU General Public License
27  * and the GNU Lesser General Public License along with this program;
28  * if not, see <http://www.gnu.org/licenses/>.
29  */
30
31 #include <config.h>
32 #ifdef HAVE_W32_SYSTEM
33  /* This module is only used in this environment */
34
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <stdarg.h>
39 #ifdef HAVE_WINSOCK2_H
40 # include <winsock2.h>
41 #endif
42 #include <windows.h>
43
44 #include "util.h"
45 #include "common-defs.h"
46 #include "utf8conv.h"
47 #include "w32help.h"
48
49
50 static HKEY
51 get_root_key(const char *root)
52 {
53   HKEY root_key;
54
55   if (!root)
56     root_key = HKEY_CURRENT_USER;
57   else if (!strcmp( root, "HKEY_CLASSES_ROOT" ) )
58     root_key = HKEY_CLASSES_ROOT;
59   else if (!strcmp( root, "HKEY_CURRENT_USER" ) )
60     root_key = HKEY_CURRENT_USER;
61   else if (!strcmp( root, "HKEY_LOCAL_MACHINE" ) )
62     root_key = HKEY_LOCAL_MACHINE;
63   else if (!strcmp( root, "HKEY_USERS" ) )
64     root_key = HKEY_USERS;
65   else if (!strcmp( root, "HKEY_PERFORMANCE_DATA" ) )
66     root_key = HKEY_PERFORMANCE_DATA;
67   else if (!strcmp( root, "HKEY_CURRENT_CONFIG" ) )
68     root_key = HKEY_CURRENT_CONFIG;
69   else
70     return NULL;
71
72   return root_key;
73 }
74
75
76 /* Return a string from the Win32 Registry or NULL in case of error.
77    Caller must release the return value.  A NULL for root is an alias
78    for HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE in turn.  */
79 char *
80 read_w32_registry_string (const char *root, const char *dir, const char *name)
81 {
82 #ifdef HAVE_W32CE_SYSTEM
83   HKEY root_key, key_handle;
84   DWORD n1, nbytes, type;
85   char *result = NULL;
86   wchar_t *wdir, *wname;
87
88   if ( !(root_key = get_root_key(root) ) )
89     return NULL;
90
91   wdir = utf8_to_wchar (dir);
92   if (!wdir)
93     return NULL;
94
95   if (RegOpenKeyEx (root_key, wdir, 0, KEY_READ, &key_handle) )
96     {
97       if (root)
98         {
99           xfree (wdir);
100           return NULL; /* No need for a RegClose, so return immediately. */
101         }
102       /* It seems to be common practise to fall back to HKLM. */
103       if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, wdir, 0, KEY_READ, &key_handle) )
104         {
105           xfree (wdir);
106           return NULL; /* Still no need for a RegClose. */
107         }
108     }
109   xfree (wdir);
110
111   if (name)
112     {
113       wname = utf8_to_wchar (name);
114       if (!wname)
115         goto leave;
116     }
117   else
118     wname = NULL;
119
120   nbytes = 2;
121   if (RegQueryValueEx (key_handle, wname, 0, NULL, NULL, &nbytes))
122     goto leave;
123   result = xtrymalloc ((n1=nbytes+2));
124   if (!result)
125     goto leave;
126   if (RegQueryValueEx (key_handle, wname, 0, &type, result, &n1))
127     {
128       xfree (result);
129       result = NULL;
130       goto leave;
131     }
132   result[nbytes] = 0;   /* Make sure it is a string.  */
133   result[nbytes+1] = 0;
134   if (type == REG_SZ || type == REG_EXPAND_SZ)
135     {
136       wchar_t *tmp = (void*)result;
137       result = wchar_to_utf8 (tmp);
138       xfree (tmp);
139     }
140
141  leave:
142   xfree (wname);
143   RegCloseKey (key_handle);
144   return result;
145 #else /*!HAVE_W32CE_SYSTEM*/
146   HKEY root_key, key_handle;
147   DWORD n1, nbytes, type;
148   char *result = NULL;
149
150   if ( !(root_key = get_root_key(root) ) )
151     return NULL;
152
153   if (RegOpenKeyEx (root_key, dir, 0, KEY_READ, &key_handle) )
154     {
155       if (root)
156         return NULL; /* No need for a RegClose, so return immediately. */
157       /* It seems to be common practise to fall back to HKLM. */
158       if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, dir, 0, KEY_READ, &key_handle) )
159         return NULL; /* Still no need for a RegClose. */
160     }
161
162   nbytes = 1;
163   if (RegQueryValueEx( key_handle, name, 0, NULL, NULL, &nbytes ) )
164     goto leave;
165   result = xtrymalloc ((n1=nbytes+1));
166   if (!result)
167     goto leave;
168   if (RegQueryValueEx( key_handle, name, 0, &type, result, &n1 ))
169     {
170       xfree (result);
171       result = NULL;
172       goto leave;
173     }
174   result[nbytes] = 0; /* Make sure it is a string.  */
175   if (type == REG_EXPAND_SZ && strchr (result, '%'))
176     {
177       char *tmp;
178
179       n1 += 1000;
180       tmp = xtrymalloc (n1+1);
181       if (!tmp)
182         goto leave;
183       nbytes = ExpandEnvironmentStrings (result, tmp, n1);
184       if (nbytes && nbytes > n1)
185         {
186           xfree (tmp);
187           n1 = nbytes;
188           tmp = xtrymalloc (n1 + 1);
189           if (!tmp)
190             goto leave;
191           nbytes = ExpandEnvironmentStrings (result, tmp, n1);
192           if (nbytes && nbytes > n1)
193             {
194               /* Oops - truncated, better don't expand at all.  */
195               xfree (tmp);
196               goto leave;
197             }
198           tmp[nbytes] = 0;
199           xfree (result);
200           result = tmp;
201         }
202       else if (nbytes)
203         {
204           /* Okay, reduce the length.  */
205           tmp[nbytes] = 0;
206           xfree (result);
207           result = xtrymalloc (strlen (tmp)+1);
208           if (!result)
209             result = tmp;
210             else
211               {
212                 strcpy (result, tmp);
213                 xfree (tmp);
214               }
215         }
216       else
217         {
218           /* Error - don't expand.  */
219           xfree (tmp);
220         }
221     }
222
223  leave:
224   RegCloseKey (key_handle);
225   return result;
226 #endif /*!HAVE_W32CE_SYSTEM*/
227 }
228
229
230 #endif /*HAVE_W32_SYSTEM*/