core.sys.windows.winreg source code

1 /**
2  * Windows API header module
3  *
4  * Translated from MinGW Windows headers
5  *
6  * Authors: Stewart Gordon
7  * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
8  * Source: $(DRUNTIMESRC core/sys/windows/_winreg.d)
9  */
10 module core.sys.windows.winreg;
11 version (Windows):
12 
13 version (ANSI) {} else version = Unicode;
14 pragma(lib, "advapi32");
15 
16 import core.sys.windows.w32api, core.sys.windows.winbase, core.sys.windows.windef;
17 
18 enum : HKEY { // for some reason, DMD errors if I don't give all the values explicitly
19     HKEY_CLASSES_ROOT        = cast(HKEY) 0x80000000,
20     HKEY_CURRENT_USER        = cast(HKEY) 0x80000001,
21     HKEY_LOCAL_MACHINE       = cast(HKEY) 0x80000002,
22     HKEY_USERS               = cast(HKEY) 0x80000003,
23     HKEY_PERFORMANCE_DATA    = cast(HKEY) 0x80000004,
24     HKEY_CURRENT_CONFIG      = cast(HKEY) 0x80000005,
25     HKEY_DYN_DATA            = cast(HKEY) 0x80000006,
26     HKEY_PERFORMANCE_TEXT    = cast(HKEY) 0x80000050,
27     HKEY_PERFORMANCE_NLSTEXT = cast(HKEY) 0x80000060,
28 }
29 
30 //enum : DWORD {
31 //    REG_OPTION_NON_VOLATILE,
32 //    REG_OPTION_VOLATILE
33 //}
34 
35 enum : DWORD {
36     REG_CREATED_NEW_KEY = 1,
37     REG_OPENED_EXISTING_KEY
38 }
39 
40 enum : DWORD {
41     REG_NONE                       = 0,
42     REG_SZ,
43     REG_EXPAND_SZ,
44     REG_BINARY,
45     REG_DWORD_LITTLE_ENDIAN,
46     REG_DWORD                      = REG_DWORD_LITTLE_ENDIAN,
47     REG_DWORD_BIG_ENDIAN,
48     REG_LINK,
49     REG_MULTI_SZ,
50     REG_RESOURCE_LIST,
51     REG_FULL_RESOURCE_DESCRIPTOR,
52     REG_RESOURCE_REQUIREMENTS_LIST,
53     REG_QWORD_LITTLE_ENDIAN,
54     REG_QWORD                      = REG_QWORD_LITTLE_ENDIAN
55 }
56 
57 enum DWORD
58     REG_NOTIFY_CHANGE_NAME       = 1,
59     REG_NOTIFY_CHANGE_ATTRIBUTES = 2,
60     REG_NOTIFY_CHANGE_LAST_SET   = 4,
61     REG_NOTIFY_CHANGE_SECURITY   = 8;
62 
63 alias ACCESS_MASK REGSAM;
64 
65 struct VALENTA {
66     LPSTR ve_valuename;
67     DWORD ve_valuelen;
68     DWORD_PTR ve_valueptr;
69     DWORD ve_type;
70 }
71 alias VALENTA* PVALENTA;
72 
73 struct VALENTW {
74     LPWSTR ve_valuename;
75     DWORD  ve_valuelen;
76     DWORD_PTR ve_valueptr;
77     DWORD  ve_type;
78 }
79 alias VALENTW* PVALENTW;
80 
81 // RRF - Registry Routine Flags (for RegGetValue)
82 static if (_WIN32_WINNT >= 0x600) {
83     enum : DWORD {
84         RRF_RT_REG_NONE      = 0x00000001,
85         RRF_RT_REG_SZ        = 0x00000002,
86         RRF_RT_REG_EXPAND_SZ = 0x00000004,
87         RRF_RT_REG_BINARY    = 0x00000008,
88         RRF_RT_REG_DWORD     = 0x00000010,
89         RRF_RT_REG_MULTI_SZ  = 0x00000020,
90         RRF_RT_REG_QWORD     = 0x00000040,
91         RRF_RT_DWORD         = RRF_RT_REG_BINARY | RRF_RT_REG_DWORD,
92         RRF_RT_QWORD         = RRF_RT_REG_BINARY | RRF_RT_REG_QWORD,
93         RRF_RT_ANY           = 0x0000FFFF,
94         RRF_NOEXPAND         = 0x10000000,
95         RRF_ZEROONFAILURE    = 0x20000000
96     }
97 }
98 
99 extern (Windows) nothrow @nogc {
100     LONG RegCloseKey(const scope HKEY);
101     LONG RegConnectRegistryA(LPCSTR, HKEY, PHKEY);
102     LONG RegConnectRegistryW(LPCWSTR, HKEY, PHKEY);
103     LONG RegCreateKeyExA(const scope HKEY, LPCSTR, DWORD, LPSTR, DWORD, REGSAM,
104       LPSECURITY_ATTRIBUTES, PHKEY, PDWORD);
105     LONG RegCreateKeyExW(const scope HKEY, LPCWSTR, DWORD, LPWSTR, DWORD, REGSAM,
106       LPSECURITY_ATTRIBUTES, PHKEY, PDWORD);
107     LONG RegDeleteKeyA(const scope HKEY, LPCSTR);
108     LONG RegDeleteKeyW(const scope HKEY, LPCWSTR);
109     LONG RegDeleteValueA(const scope HKEY, LPCSTR);
110     LONG RegDeleteValueW(const scope HKEY, LPCWSTR);
111     LONG RegEnumKeyExA(const scope HKEY, DWORD, LPSTR, PDWORD, PDWORD, LPSTR, PDWORD,
112       PFILETIME);
113     LONG RegEnumKeyExW(const scope HKEY, DWORD, LPWSTR, PDWORD, PDWORD, LPWSTR, PDWORD,
114       PFILETIME);
115     LONG RegEnumValueA(const scope HKEY, DWORD, LPSTR, PDWORD, PDWORD, PDWORD, LPBYTE,
116       PDWORD);
117     LONG RegEnumValueW(const scope HKEY, DWORD, LPWSTR, PDWORD, PDWORD, PDWORD, LPBYTE,
118       PDWORD);
119     LONG RegFlushKey(const scope HKEY);
120     LONG RegLoadKeyA(const scope HKEY, LPCSTR, LPCSTR);
121     LONG RegLoadKeyW(const scope HKEY, LPCWSTR, LPCWSTR);
122     LONG RegOpenKeyExA(const scope HKEY, LPCSTR, DWORD, REGSAM, PHKEY);
123     LONG RegOpenKeyExW(const scope HKEY, LPCWSTR, DWORD, REGSAM, PHKEY);
124     LONG RegQueryInfoKeyA(const scope HKEY, LPSTR, PDWORD, PDWORD, PDWORD, PDWORD,
125       PDWORD, PDWORD, PDWORD, PDWORD, PDWORD, PFILETIME);
126     LONG RegQueryInfoKeyW(const scope HKEY, LPWSTR, PDWORD, PDWORD, PDWORD, PDWORD,
127       PDWORD, PDWORD, PDWORD, PDWORD, PDWORD, PFILETIME);
128     LONG RegQueryMultipleValuesA(const scope HKEY, PVALENTA, DWORD, LPSTR, LPDWORD);
129     LONG RegQueryMultipleValuesW(const scope HKEY, PVALENTW, DWORD, LPWSTR, LPDWORD);
130     LONG RegQueryValueExA(const scope HKEY, LPCSTR, LPDWORD, LPDWORD, /*LPBYTE*/LPVOID, LPDWORD);
131     LONG RegQueryValueExW(const scope HKEY, LPCWSTR, LPDWORD, LPDWORD, /*LPBYTE*/LPVOID, LPDWORD);
132     LONG RegReplaceKeyA(const scope HKEY, LPCSTR, LPCSTR, LPCSTR);
133     LONG RegReplaceKeyW(const scope HKEY, LPCWSTR, LPCWSTR, LPCWSTR);
134     LONG RegSaveKeyA(const scope HKEY, LPCSTR, LPSECURITY_ATTRIBUTES);
135     LONG RegSaveKeyW(const scope HKEY, LPCWSTR, LPSECURITY_ATTRIBUTES);
136     LONG RegSetKeySecurity(const scope HKEY, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
137     LONG RegSetValueExA(const scope HKEY, LPCSTR, DWORD, DWORD, const(BYTE)*, DWORD);
138     LONG RegSetValueExW(const scope HKEY, LPCWSTR, DWORD, DWORD, const(BYTE)*, DWORD);
139     LONG RegUnLoadKeyA(const scope HKEY, LPCSTR);
140     LONG RegUnLoadKeyW(const scope HKEY, LPCWSTR);
141     LONG RegNotifyChangeKeyValue(const scope HKEY, BOOL, DWORD, HANDLE, BOOL);
142 
143     BOOL AbortSystemShutdownA(LPCSTR);
144     BOOL AbortSystemShutdownW(LPCWSTR);
145     BOOL InitiateSystemShutdownA(LPSTR, LPSTR, DWORD, BOOL, BOOL);
146     BOOL InitiateSystemShutdownW(LPWSTR, LPWSTR, DWORD, BOOL, BOOL);
147     LONG RegGetKeySecurity(const scope HKEY, SECURITY_INFORMATION,
148       PSECURITY_DESCRIPTOR, PDWORD);
149     LONG RegRestoreKeyA(const scope HKEY, LPCSTR, DWORD);
150     LONG RegRestoreKeyW(const scope HKEY, LPCWSTR, DWORD);
151     LONG RegSetKeySecurity(const scope HKEY, SECURITY_INFORMATION,
152       PSECURITY_DESCRIPTOR);
153 
154     static if (_WIN32_WINNT >= 0x500) {
155         LONG RegDisablePredefinedCache();
156         LONG RegOpenCurrentUser(REGSAM, PHKEY);
157         LONG RegOpenUserClassesRoot(HANDLE, DWORD, REGSAM, PHKEY);
158     }
159 
160     static if (_WIN32_WINNT >= 0x501) {
161         LONG RegSaveKeyExA(const scope HKEY, LPCSTR, LPSECURITY_ATTRIBUTES, DWORD);
162         LONG RegSaveKeyExW(const scope HKEY, LPCWSTR, LPSECURITY_ATTRIBUTES, DWORD);
163     }
164 
165     static if (_WIN32_WINNT >= 0x600) {
166         LONG RegGetValueA(const scope HKEY hkey, LPCSTR lpSubKey, LPCSTR lpValue,
167           DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData);
168         LONG RegGetValueW(const scope HKEY hkey, LPCWSTR lpSubKey, LPCWSTR lpValue,
169           DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData);
170     }
171 
172     //deprecated {
173         LONG RegCreateKeyA(const scope HKEY, LPCSTR, PHKEY);
174         LONG RegCreateKeyW(const scope HKEY, LPCWSTR, PHKEY);
175         LONG RegEnumKeyA(const scope HKEY, DWORD, LPSTR, DWORD);
176         LONG RegEnumKeyW(const scope HKEY, DWORD, LPWSTR, DWORD);
177         LONG RegOpenKeyA(const scope HKEY, LPCSTR, PHKEY);
178         LONG RegOpenKeyW(const scope HKEY, LPCWSTR, PHKEY);
179         LONG RegQueryValueA(const scope HKEY, LPCSTR, LPSTR, PLONG);
180         LONG RegQueryValueW(const scope HKEY, LPCWSTR, LPWSTR, PLONG);
181         LONG RegSetValueA(const scope HKEY, LPCSTR, DWORD, LPCSTR, DWORD);
182         LONG RegSetValueW(const scope HKEY, LPCWSTR, DWORD, LPCWSTR, DWORD);
183     //}
184 }
185 
186 version (Unicode) {
187     alias VALENTW VALENT;
188     alias RegConnectRegistryW RegConnectRegistry;
189     alias RegCreateKeyExW RegCreateKeyEx;
190     alias RegDeleteKeyW RegDeleteKey;
191     alias RegDeleteValueW RegDeleteValue;
192     alias RegEnumKeyExW RegEnumKeyEx;
193     alias RegEnumValueW RegEnumValue;
194     alias RegLoadKeyW RegLoadKey;
195     alias RegOpenKeyExW RegOpenKeyEx;
196     alias RegQueryInfoKeyW RegQueryInfoKey;
197     alias RegQueryMultipleValuesW RegQueryMultipleValues;
198     alias RegQueryValueExW RegQueryValueEx;
199     alias RegReplaceKeyW RegReplaceKey;
200     alias RegSaveKeyW RegSaveKey;
201     alias RegSetValueExW RegSetValueEx;
202     alias RegUnLoadKeyW RegUnLoadKey;
203 
204     alias AbortSystemShutdownW AbortSystemShutdown;
205     alias InitiateSystemShutdownW InitiateSystemShutdown;
206     alias RegRestoreKeyW RegRestoreKey;
207     static if (_WIN32_WINNT >= 0x501) {
208         alias RegSaveKeyExA RegSaveKeyEx;
209     }
210     static if (_WIN32_WINNT >= 0x600) {
211         alias RegGetValueW RegGetValue;
212     }
213     //deprecated {
214         alias RegCreateKeyW RegCreateKey;
215         alias RegEnumKeyW RegEnumKey;
216         alias RegOpenKeyW RegOpenKey;
217         alias RegQueryValueW RegQueryValue;
218         alias RegSetValueW RegSetValue;
219     //}
220 } else {
221     alias VALENTA VALENT;
222     alias RegConnectRegistryA RegConnectRegistry;
223     alias RegCreateKeyExA RegCreateKeyEx;
224     alias RegDeleteKeyA RegDeleteKey;
225     alias RegDeleteValueA RegDeleteValue;
226     alias RegEnumKeyExA RegEnumKeyEx;
227     alias RegEnumValueA RegEnumValue;
228     alias RegLoadKeyA RegLoadKey;
229     alias RegOpenKeyExA RegOpenKeyEx;
230     alias RegQueryInfoKeyA RegQueryInfoKey;
231     alias RegQueryMultipleValuesA RegQueryMultipleValues;
232     alias RegQueryValueExA RegQueryValueEx;
233     alias RegReplaceKeyA RegReplaceKey;
234     alias RegSaveKeyA RegSaveKey;
235     alias RegSetValueExA RegSetValueEx;
236     alias RegUnLoadKeyA RegUnLoadKey;
237     alias AbortSystemShutdownA AbortSystemShutdown;
238     alias InitiateSystemShutdownA InitiateSystemShutdown;
239     alias RegRestoreKeyW RegRestoreKey;
240     static if (_WIN32_WINNT >= 0x501) {
241         alias RegSaveKeyExA RegSaveKeyEx;
242     }
243     static if (_WIN32_WINNT >= 0x600) {
244         alias RegGetValueA RegGetValue;
245     }
246     //deprecated {
247         alias RegCreateKeyA RegCreateKey;
248         alias RegEnumKeyA RegEnumKey;
249         alias RegOpenKeyA RegOpenKey;
250         alias RegQueryValueA RegQueryValue;
251         alias RegSetValueA RegSetValue;
252     //}
253 }
254 
255 alias VALENT* PVALENT;