Python code coverage for PC/_winreg.c

#	count	content
1	n/a	/*
2	n/a	_winreg.c
3	n/a
4	n/a	Windows Registry access module for Python.
5	n/a
6	n/a	* Simple registry access written by Mark Hammond in win32api
7	n/a	module circa 1995.
8	n/a	* Bill Tutt expanded the support significantly not long after.
9	n/a	* Numerous other people have submitted patches since then.
10	n/a	* Ripped from win32api module 03-Feb-2000 by Mark Hammond, and
11	n/a	basic Unicode support added.
12	n/a
13	n/a	*/
14	n/a
15	n/a	#include "Python.h"
16	n/a	#include "structmember.h"
17	n/a	#include "malloc.h" /* for alloca */
18	n/a	#include "windows.h"
19	n/a
20	n/a	static BOOL PyHKEY_AsHKEY(PyObject ob, HKEY pRes, BOOL bNoneOK);
21	n/a	static PyObject *PyHKEY_FromHKEY(HKEY h);
22	n/a	static BOOL PyHKEY_Close(PyObject *obHandle);
23	n/a
24	n/a	static char errNotAHandle[] = "Object is not a handle";
25	n/a
26	n/a	/* The win32api module reports the function name that failed,
27	n/a	but this concept is not in the Python core.
28	n/a	Hopefully it will one day, and in the meantime I don't
29	n/a	want to lose this info...
30	n/a	*/
31	n/a	#define PyErr_SetFromWindowsErrWithFunction(rc, fnname) \
32	n/a	PyErr_SetFromWindowsErr(rc)
33	n/a
34	n/a	/* Forward declares */
35	n/a
36	n/a	/* Doc strings */
37	n/a	PyDoc_STRVAR(module_doc,
38	n/a	"This module provides access to the Windows registry API.\n"
39	n/a	"\n"
40	n/a	"Functions:\n"
41	n/a	"\n"
42	n/a	"CloseKey() - Closes a registry key.\n"
43	n/a	"ConnectRegistry() - Establishes a connection to a predefined registry handle\n"
44	n/a	" on another computer.\n"
45	n/a	"CreateKey() - Creates the specified key, or opens it if it already exists.\n"
46	n/a	"DeleteKey() - Deletes the specified key.\n"
47	n/a	"DeleteValue() - Removes a named value from the specified registry key.\n"
48	n/a	"EnumKey() - Enumerates subkeys of the specified open registry key.\n"
49	n/a	"EnumValue() - Enumerates values of the specified open registry key.\n"
50	n/a	"ExpandEnvironmentStrings() - Expand the env strings in a REG_EXPAND_SZ string.\n"
51	n/a	"FlushKey() - Writes all the attributes of the specified key to the registry.\n"
52	n/a	"LoadKey() - Creates a subkey under HKEY_USER or HKEY_LOCAL_MACHINE and stores\n"
53	n/a	" registration information from a specified file into that subkey.\n"
54	n/a	"OpenKey() - Alias for <om win32api.RegOpenKeyEx>\n"
55	n/a	"OpenKeyEx() - Opens the specified key.\n"
56	n/a	"QueryValue() - Retrieves the value associated with the unnamed value for a\n"
57	n/a	" specified key in the registry.\n"
58	n/a	"QueryValueEx() - Retrieves the type and data for a specified value name\n"
59	n/a	" associated with an open registry key.\n"
60	n/a	"QueryInfoKey() - Returns information about the specified key.\n"
61	n/a	"SaveKey() - Saves the specified key, and all its subkeys a file.\n"
62	n/a	"SetValue() - Associates a value with a specified key.\n"
63	n/a	"SetValueEx() - Stores data in the value field of an open registry key.\n"
64	n/a	"\n"
65	n/a	"Special objects:\n"
66	n/a	"\n"
67	n/a	"HKEYType -- type object for HKEY objects\n"
68	n/a	"error -- exception raised for Win32 errors\n"
69	n/a	"\n"
70	n/a	"Integer constants:\n"
71	n/a	"Many constants are defined - see the documentation for each function\n"
72	n/a	"to see what constants are used, and where.");
73	n/a
74	n/a
75	n/a	PyDoc_STRVAR(CloseKey_doc,
76	n/a	"CloseKey(hkey) - Closes a previously opened registry key.\n"
77	n/a	"\n"
78	n/a	"The hkey argument specifies a previously opened key.\n"
79	n/a	"\n"
80	n/a	"Note that if the key is not closed using this method, it will be\n"
81	n/a	"closed when the hkey object is destroyed by Python.");
82	n/a
83	n/a	PyDoc_STRVAR(ConnectRegistry_doc,
84	n/a	"key = ConnectRegistry(computer_name, key) - "
85	n/a	"Establishes a connection to a predefined registry handle on another computer.\n"
86	n/a	"\n"
87	n/a	"computer_name is the name of the remote computer, of the form \\\\computername.\n"
88	n/a	" If None, the local computer is used.\n"
89	n/a	"key is the predefined handle to connect to.\n"
90	n/a	"\n"
91	n/a	"The return value is the handle of the opened key.\n"
92	n/a	"If the function fails, a WindowsError exception is raised.");
93	n/a
94	n/a	PyDoc_STRVAR(CreateKey_doc,
95	n/a	"key = CreateKey(key, sub_key) - Creates or opens the specified key.\n"
96	n/a	"\n"
97	n/a	"key is an already open key, or one of the predefined HKEY_* constants\n"
98	n/a	"sub_key is a string that names the key this method opens or creates.\n"
99	n/a	" If key is one of the predefined keys, sub_key may be None. In that case,\n"
100	n/a	" the handle returned is the same key handle passed in to the function.\n"
101	n/a	"\n"
102	n/a	"If the key already exists, this function opens the existing key\n"
103	n/a	"\n"
104	n/a	"The return value is the handle of the opened key.\n"
105	n/a	"If the function fails, an exception is raised.");
106	n/a
107	n/a	PyDoc_STRVAR(CreateKeyEx_doc,
108	n/a	"key = CreateKeyEx(key, sub_key, res, sam) - Creates or opens the specified key.\n"
109	n/a	"\n"
110	n/a	"key is an already open key, or one of the predefined HKEY_* constants\n"
111	n/a	"sub_key is a string that names the key this method opens or creates.\n"
112	n/a	"res is a reserved integer, and must be zero. Default is zero.\n"
113	n/a	"sam is an integer that specifies an access mask that describes the desired\n"
114	n/a	" If key is one of the predefined keys, sub_key may be None. In that case,\n"
115	n/a	" the handle returned is the same key handle passed in to the function.\n"
116	n/a	"\n"
117	n/a	"If the key already exists, this function opens the existing key\n"
118	n/a	"\n"
119	n/a	"The return value is the handle of the opened key.\n"
120	n/a	"If the function fails, an exception is raised.");
121	n/a
122	n/a	PyDoc_STRVAR(DeleteKey_doc,
123	n/a	"DeleteKey(key, sub_key) - Deletes the specified key.\n"
124	n/a	"\n"
125	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
126	n/a	"sub_key is a string that must be a subkey of the key identified by the key parameter.\n"
127	n/a	" This value must not be None, and the key may not have subkeys.\n"
128	n/a	"\n"
129	n/a	"This method can not delete keys with subkeys.\n"
130	n/a	"\n"
131	n/a	"If the method succeeds, the entire key, including all of its values,\n"
132	n/a	"is removed. If the method fails, a WindowsError exception is raised.");
133	n/a
134	n/a	PyDoc_STRVAR(DeleteKeyEx_doc,
135	n/a	"DeleteKeyEx(key, sub_key, sam, res) - Deletes the specified key.\n"
136	n/a	"\n"
137	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
138	n/a	"sub_key is a string that must be a subkey of the key identified by the key parameter.\n"
139	n/a	"res is a reserved integer, and must be zero. Default is zero.\n"
140	n/a	"sam is an integer that specifies an access mask that describes the desired\n"
141	n/a	" This value must not be None, and the key may not have subkeys.\n"
142	n/a	"\n"
143	n/a	"This method can not delete keys with subkeys.\n"
144	n/a	"\n"
145	n/a	"If the method succeeds, the entire key, including all of its values,\n"
146	n/a	"is removed. If the method fails, a WindowsError exception is raised.\n"
147	n/a	"On unsupported Windows versions, NotImplementedError is raised.");
148	n/a
149	n/a	PyDoc_STRVAR(DeleteValue_doc,
150	n/a	"DeleteValue(key, value) - Removes a named value from a registry key.\n"
151	n/a	"\n"
152	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
153	n/a	"value is a string that identifies the value to remove.");
154	n/a
155	n/a	PyDoc_STRVAR(EnumKey_doc,
156	n/a	"string = EnumKey(key, index) - Enumerates subkeys of an open registry key.\n"
157	n/a	"\n"
158	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
159	n/a	"index is an integer that identifies the index of the key to retrieve.\n"
160	n/a	"\n"
161	n/a	"The function retrieves the name of one subkey each time it is called.\n"
162	n/a	"It is typically called repeatedly until a WindowsError exception is\n"
163	n/a	"raised, indicating no more values are available.");
164	n/a
165	n/a	PyDoc_STRVAR(EnumValue_doc,
166	n/a	"tuple = EnumValue(key, index) - Enumerates values of an open registry key.\n"
167	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
168	n/a	"index is an integer that identifies the index of the value to retrieve.\n"
169	n/a	"\n"
170	n/a	"The function retrieves the name of one subkey each time it is called.\n"
171	n/a	"It is typically called repeatedly, until a WindowsError exception\n"
172	n/a	"is raised, indicating no more values.\n"
173	n/a	"\n"
174	n/a	"The result is a tuple of 3 items:\n"
175	n/a	"value_name is a string that identifies the value.\n"
176	n/a	"value_data is an object that holds the value data, and whose type depends\n"
177	n/a	" on the underlying registry type.\n"
178	n/a	"data_type is an integer that identifies the type of the value data.");
179	n/a
180	n/a	PyDoc_STRVAR(ExpandEnvironmentStrings_doc,
181	n/a	"string = ExpandEnvironmentStrings(string) - Expand environment vars.\n");
182	n/a
183	n/a	PyDoc_STRVAR(FlushKey_doc,
184	n/a	"FlushKey(key) - Writes all the attributes of a key to the registry.\n"
185	n/a	"\n"
186	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
187	n/a	"\n"
188	n/a	"It is not necessary to call RegFlushKey to change a key.\n"
189	n/a	"Registry changes are flushed to disk by the registry using its lazy flusher.\n"
190	n/a	"Registry changes are also flushed to disk at system shutdown.\n"
191	n/a	"Unlike CloseKey(), the FlushKey() method returns only when all the data has\n"
192	n/a	"been written to the registry.\n"
193	n/a	"An application should only call FlushKey() if it requires absolute certainty that registry changes are on disk.\n"
194	n/a	"If you don't know whether a FlushKey() call is required, it probably isn't.");
195	n/a
196	n/a	PyDoc_STRVAR(LoadKey_doc,
197	n/a	"LoadKey(key, sub_key, file_name) - Creates a subkey under the specified key\n"
198	n/a	"and stores registration information from a specified file into that subkey.\n"
199	n/a	"\n"
200	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
201	n/a	"sub_key is a string that identifies the sub_key to load\n"
202	n/a	"file_name is the name of the file to load registry data from.\n"
203	n/a	" This file must have been created with the SaveKey() function.\n"
204	n/a	" Under the file allocation table (FAT) file system, the filename may not\n"
205	n/a	"have an extension.\n"
206	n/a	"\n"
207	n/a	"A call to LoadKey() fails if the calling process does not have the\n"
208	n/a	"SE_RESTORE_PRIVILEGE privilege.\n"
209	n/a	"\n"
210	n/a	"If key is a handle returned by ConnectRegistry(), then the path specified\n"
211	n/a	"in fileName is relative to the remote computer.\n"
212	n/a	"\n"
213	n/a	"The docs imply key must be in the HKEY_USER or HKEY_LOCAL_MACHINE tree");
214	n/a
215	n/a	PyDoc_STRVAR(OpenKey_doc,
216	n/a	"key = OpenKey(key, sub_key, res = 0, sam = KEY_READ) - Opens the specified key.\n"
217	n/a	"\n"
218	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
219	n/a	"sub_key is a string that identifies the sub_key to open\n"
220	n/a	"res is a reserved integer, and must be zero. Default is zero.\n"
221	n/a	"sam is an integer that specifies an access mask that describes the desired\n"
222	n/a	" security access for the key. Default is KEY_READ\n"
223	n/a	"\n"
224	n/a	"The result is a new handle to the specified key\n"
225	n/a	"If the function fails, a WindowsError exception is raised.");
226	n/a
227	n/a	PyDoc_STRVAR(OpenKeyEx_doc, "See OpenKey()");
228	n/a
229	n/a	PyDoc_STRVAR(QueryInfoKey_doc,
230	n/a	"tuple = QueryInfoKey(key) - Returns information about a key.\n"
231	n/a	"\n"
232	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
233	n/a	"\n"
234	n/a	"The result is a tuple of 3 items:"
235	n/a	"An integer that identifies the number of sub keys this key has.\n"
236	n/a	"An integer that identifies the number of values this key has.\n"
237	n/a	"A long integer that identifies when the key was last modified (if available)\n"
238	n/a	" as 100's of nanoseconds since Jan 1, 1600.");
239	n/a
240	n/a	PyDoc_STRVAR(QueryValue_doc,
241	n/a	"string = QueryValue(key, sub_key) - retrieves the unnamed value for a key.\n"
242	n/a	"\n"
243	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
244	n/a	"sub_key is a string that holds the name of the subkey with which the value\n"
245	n/a	" is associated. If this parameter is None or empty, the function retrieves\n"
246	n/a	" the value set by the SetValue() method for the key identified by key."
247	n/a	"\n"
248	n/a	"Values in the registry have name, type, and data components. This method\n"
249	n/a	"retrieves the data for a key's first value that has a NULL name.\n"
250	n/a	"But the underlying API call doesn't return the type, Lame Lame Lame, DONT USE THIS!!!");
251	n/a
252	n/a	PyDoc_STRVAR(QueryValueEx_doc,
253	n/a	"value,type_id = QueryValueEx(key, value_name) - Retrieves the type and data for a specified value name associated with an open registry key.\n"
254	n/a	"\n"
255	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
256	n/a	"value_name is a string indicating the value to query");
257	n/a
258	n/a	PyDoc_STRVAR(SaveKey_doc,
259	n/a	"SaveKey(key, file_name) - Saves the specified key, and all its subkeys to the specified file.\n"
260	n/a	"\n"
261	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
262	n/a	"file_name is the name of the file to save registry data to.\n"
263	n/a	" This file cannot already exist. If this filename includes an extension,\n"
264	n/a	" it cannot be used on file allocation table (FAT) file systems by the\n"
265	n/a	" LoadKey(), ReplaceKey() or RestoreKey() methods.\n"
266	n/a	"\n"
267	n/a	"If key represents a key on a remote computer, the path described by\n"
268	n/a	"file_name is relative to the remote computer.\n"
269	n/a	"The caller of this method must possess the SeBackupPrivilege security privilege.\n"
270	n/a	"This function passes NULL for security_attributes to the API.");
271	n/a
272	n/a	PyDoc_STRVAR(SetValue_doc,
273	n/a	"SetValue(key, sub_key, type, value) - Associates a value with a specified key.\n"
274	n/a	"\n"
275	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
276	n/a	"sub_key is a string that names the subkey with which the value is associated.\n"
277	n/a	"type is an integer that specifies the type of the data. Currently this\n"
278	n/a	" must be REG_SZ, meaning only strings are supported.\n"
279	n/a	"value is a string that specifies the new value.\n"
280	n/a	"\n"
281	n/a	"If the key specified by the sub_key parameter does not exist, the SetValue\n"
282	n/a	"function creates it.\n"
283	n/a	"\n"
284	n/a	"Value lengths are limited by available memory. Long values (more than\n"
285	n/a	"2048 bytes) should be stored as files with the filenames stored in \n"
286	n/a	"the configuration registry. This helps the registry perform efficiently.\n"
287	n/a	"\n"
288	n/a	"The key identified by the key parameter must have been opened with\n"
289	n/a	"KEY_SET_VALUE access.");
290	n/a
291	n/a	PyDoc_STRVAR(SetValueEx_doc,
292	n/a	"SetValueEx(key, value_name, reserved, type, value) - Stores data in the value field of an open registry key.\n"
293	n/a	"\n"
294	n/a	"key is an already open key, or any one of the predefined HKEY_* constants.\n"
295	n/a	"value_name is a string containing the name of the value to set, or None\n"
296	n/a	"type is an integer that specifies the type of the data. This should be one of:\n"
297	n/a	" REG_BINARY -- Binary data in any form.\n"
298	n/a	" REG_DWORD -- A 32-bit number.\n"
299	n/a	" REG_DWORD_LITTLE_ENDIAN -- A 32-bit number in little-endian format.\n"
300	n/a	" REG_DWORD_BIG_ENDIAN -- A 32-bit number in big-endian format.\n"
301	n/a	" REG_EXPAND_SZ -- A null-terminated string that contains unexpanded references\n"
302	n/a	" to environment variables (for example, %PATH%).\n"
303	n/a	" REG_LINK -- A Unicode symbolic link.\n"
304	n/a	" REG_MULTI_SZ -- An sequence of null-terminated strings, terminated by\n"
305	n/a	" two null characters. Note that Python handles this\n"
306	n/a	" termination automatically.\n"
307	n/a	" REG_NONE -- No defined value type.\n"
308	n/a	" REG_RESOURCE_LIST -- A device-driver resource list.\n"
309	n/a	" REG_SZ -- A null-terminated string.\n"
310	n/a	"reserved can be anything - zero is always passed to the API.\n"
311	n/a	"value is a string that specifies the new value.\n"
312	n/a	"\n"
313	n/a	"This method can also set additional value and type information for the\n"
314	n/a	"specified key. The key identified by the key parameter must have been\n"
315	n/a	"opened with KEY_SET_VALUE access.\n"
316	n/a	"\n"
317	n/a	"To open the key, use the CreateKeyEx() or OpenKeyEx() methods.\n"
318	n/a	"\n"
319	n/a	"Value lengths are limited by available memory. Long values (more than\n"
320	n/a	"2048 bytes) should be stored as files with the filenames stored in \n"
321	n/a	"the configuration registry. This helps the registry perform efficiently.");
322	n/a
323	n/a	PyDoc_STRVAR(DisableReflectionKey_doc,
324	n/a	"Disables registry reflection for 32-bit processes running on a 64-bit\n"
325	n/a	"Operating System. Will generally raise NotImplemented if executed on\n"
326	n/a	"a 32-bit Operating System.\n"
327	n/a	"If the key is not on the reflection list, the function succeeds but has no effect.\n"
328	n/a	"Disabling reflection for a key does not affect reflection of any subkeys.");
329	n/a
330	n/a	PyDoc_STRVAR(EnableReflectionKey_doc,
331	n/a	"Restores registry reflection for the specified disabled key.\n"
332	n/a	"Will generally raise NotImplemented if executed on a 32-bit Operating System.\n"
333	n/a	"Restoring reflection for a key does not affect reflection of any subkeys.");
334	n/a
335	n/a	PyDoc_STRVAR(QueryReflectionKey_doc,
336	n/a	"bool = QueryReflectionKey(hkey) - Determines the reflection state for the specified key.\n"
337	n/a	"Will generally raise NotImplemented if executed on a 32-bit Operating System.\n");
338	n/a
339	n/a	/* PyHKEY docstrings */
340	n/a	PyDoc_STRVAR(PyHKEY_doc,
341	n/a	"PyHKEY Object - A Python object, representing a win32 registry key.\n"
342	n/a	"\n"
343	n/a	"This object wraps a Windows HKEY object, automatically closing it when\n"
344	n/a	"the object is destroyed. To guarantee cleanup, you can call either\n"
345	n/a	"the Close() method on the PyHKEY, or the CloseKey() method.\n"
346	n/a	"\n"
347	n/a	"All functions which accept a handle object also accept an integer - \n"
348	n/a	"however, use of the handle object is encouraged.\n"
349	n/a	"\n"
350	n/a	"Functions:\n"
351	n/a	"Close() - Closes the underlying handle.\n"
352	n/a	"Detach() - Returns the integer Win32 handle, detaching it from the object\n"
353	n/a	"\n"
354	n/a	"Properties:\n"
355	n/a	"handle - The integer Win32 handle.\n"
356	n/a	"\n"
357	n/a	"Operations:\n"
358	n/a	"__nonzero__ - Handles with an open object return true, otherwise false.\n"
359	n/a	"__int__ - Converting a handle to an integer returns the Win32 handle.\n"
360	n/a	"__cmp__ - Handle objects are compared using the handle value.");
361	n/a
362	n/a
363	n/a	PyDoc_STRVAR(PyHKEY_Close_doc,
364	n/a	"key.Close() - Closes the underlying Windows handle.\n"
365	n/a	"\n"
366	n/a	"If the handle is already closed, no error is raised.");
367	n/a
368	n/a	PyDoc_STRVAR(PyHKEY_Detach_doc,
369	n/a	"int = key.Detach() - Detaches the Windows handle from the handle object.\n"
370	n/a	"\n"
371	n/a	"The result is the value of the handle before it is detached. If the\n"
372	n/a	"handle is already detached, this will return zero.\n"
373	n/a	"\n"
374	n/a	"After calling this function, the handle is effectively invalidated,\n"
375	n/a	"but the handle is not closed. You would call this function when you\n"
376	n/a	"need the underlying win32 handle to exist beyond the lifetime of the\n"
377	n/a	"handle object.\n"
378	n/a	"On 64 bit windows, the result of this function is a long integer");
379	n/a
380	n/a
381	n/a	/************************************************************************
382	n/a
383	n/a	The PyHKEY object definition
384	n/a
385	n/a	************************************************************************/
386	n/a	typedef struct {
387	n/a	PyObject_VAR_HEAD
388	n/a	HKEY hkey;
389	n/a	} PyHKEYObject;
390	n/a
391	n/a	#define PyHKEY_Check(op) ((op)->ob_type == &PyHKEY_Type)
392	n/a
393	n/a	static char *failMsg = "bad operand type";
394	n/a
395	n/a	static PyObject *
396	n/a	PyHKEY_unaryFailureFunc(PyObject *ob)
397	n/a	{
398	n/a	PyErr_SetString(PyExc_TypeError, failMsg);
399	n/a	return NULL;
400	n/a	}
401	n/a	static PyObject *
402	n/a	PyHKEY_binaryFailureFunc(PyObject ob1, PyObject ob2)
403	n/a	{
404	n/a	PyErr_SetString(PyExc_TypeError, failMsg);
405	n/a	return NULL;
406	n/a	}
407	n/a	static PyObject *
408	n/a	PyHKEY_ternaryFailureFunc(PyObject ob1, PyObject ob2, PyObject *ob3)
409	n/a	{
410	n/a	PyErr_SetString(PyExc_TypeError, failMsg);
411	n/a	return NULL;
412	n/a	}
413	n/a
414	n/a	static void
415	n/a	PyHKEY_deallocFunc(PyObject *ob)
416	n/a	{
417	n/a	/* Can not call PyHKEY_Close, as the ob->tp_type
418	n/a	has already been cleared, thus causing the type
419	n/a	check to fail!
420	n/a	*/
421	n/a	PyHKEYObject obkey = (PyHKEYObject )ob;
422	n/a	if (obkey->hkey)
423	n/a	RegCloseKey((HKEY)obkey->hkey);
424	n/a	PyObject_DEL(ob);
425	n/a	}
426	n/a
427	n/a	static int
428	n/a	PyHKEY_nonzeroFunc(PyObject *ob)
429	n/a	{
430	n/a	return ((PyHKEYObject *)ob)->hkey != 0;
431	n/a	}
432	n/a
433	n/a	static PyObject *
434	n/a	PyHKEY_intFunc(PyObject *ob)
435	n/a	{
436	n/a	PyHKEYObject pyhkey = (PyHKEYObject )ob;
437	n/a	return PyLong_FromVoidPtr(pyhkey->hkey);
438	n/a	}
439	n/a
440	n/a	static int
441	n/a	PyHKEY_printFunc(PyObject ob, FILE fp, int flags)
442	n/a	{
443	n/a	PyHKEYObject pyhkey = (PyHKEYObject )ob;
444	n/a	fprintf(fp, "<PyHKEY at %p (%p)>",
445	n/a	ob, pyhkey->hkey);
446	n/a	return 0;
447	n/a	}
448	n/a
449	n/a	static PyObject *
450	n/a	PyHKEY_strFunc(PyObject *ob)
451	n/a	{
452	n/a	PyHKEYObject pyhkey = (PyHKEYObject )ob;
453	n/a	return PyString_FromFormat("<PyHKEY:%p>", pyhkey->hkey);
454	n/a	}
455	n/a
456	n/a	static int
457	n/a	PyHKEY_compareFunc(PyObject ob1, PyObject ob2)
458	n/a	{
459	n/a	PyHKEYObject pyhkey1 = (PyHKEYObject )ob1;
460	n/a	PyHKEYObject pyhkey2 = (PyHKEYObject )ob2;
461	n/a	return pyhkey1 == pyhkey2 ? 0 :
462	n/a	(pyhkey1 < pyhkey2 ? -1 : 1);
463	n/a	}
464	n/a
465	n/a	static long
466	n/a	PyHKEY_hashFunc(PyObject *ob)
467	n/a	{
468	n/a	/* Just use the address.
469	n/a	XXX - should we use the handle value?
470	n/a	*/
471	n/a	return _Py_HashPointer(ob);
472	n/a	}
473	n/a
474	n/a
475	n/a	static PyNumberMethods PyHKEY_NumberMethods =
476	n/a	{
477	n/a	PyHKEY_binaryFailureFunc, /* nb_add */
478	n/a	PyHKEY_binaryFailureFunc, /* nb_subtract */
479	n/a	PyHKEY_binaryFailureFunc, /* nb_multiply */
480	n/a	PyHKEY_binaryFailureFunc, /* nb_divide */
481	n/a	PyHKEY_binaryFailureFunc, /* nb_remainder */
482	n/a	PyHKEY_binaryFailureFunc, /* nb_divmod */
483	n/a	PyHKEY_ternaryFailureFunc, /* nb_power */
484	n/a	PyHKEY_unaryFailureFunc, /* nb_negative */
485	n/a	PyHKEY_unaryFailureFunc, /* nb_positive */
486	n/a	PyHKEY_unaryFailureFunc, /* nb_absolute */
487	n/a	PyHKEY_nonzeroFunc, /* nb_nonzero */
488	n/a	PyHKEY_unaryFailureFunc, /* nb_invert */
489	n/a	PyHKEY_binaryFailureFunc, /* nb_lshift */
490	n/a	PyHKEY_binaryFailureFunc, /* nb_rshift */
491	n/a	PyHKEY_binaryFailureFunc, /* nb_and */
492	n/a	PyHKEY_binaryFailureFunc, /* nb_xor */
493	n/a	PyHKEY_binaryFailureFunc, /* nb_or */
494	n/a	0, /* nb_coerce (allowed to be zero) */
495	n/a	PyHKEY_intFunc, /* nb_int */
496	n/a	PyHKEY_unaryFailureFunc, /* nb_long */
497	n/a	PyHKEY_unaryFailureFunc, /* nb_float */
498	n/a	PyHKEY_unaryFailureFunc, /* nb_oct */
499	n/a	PyHKEY_unaryFailureFunc, /* nb_hex */
500	n/a	};
501	n/a
502	n/a	static PyObject PyHKEY_CloseMethod(PyObject self, PyObject *args);
503	n/a	static PyObject PyHKEY_DetachMethod(PyObject self, PyObject *args);
504	n/a	static PyObject PyHKEY_Enter(PyObject self);
505	n/a	static PyObject PyHKEY_Exit(PyObject self, PyObject *args);
506	n/a
507	n/a	static struct PyMethodDef PyHKEY_methods[] = {
508	n/a	{"Close", PyHKEY_CloseMethod, METH_VARARGS, PyHKEY_Close_doc},
509	n/a	{"Detach", PyHKEY_DetachMethod, METH_VARARGS, PyHKEY_Detach_doc},
510	n/a	{"__enter__", (PyCFunction)PyHKEY_Enter, METH_NOARGS, NULL},
511	n/a	{"__exit__", PyHKEY_Exit, METH_VARARGS, NULL},
512	n/a	{NULL}
513	n/a	};
514	n/a
515	n/a	static PyMemberDef PyHKEY_memberlist[] = {
516	n/a	{"handle", T_PYSSIZET, offsetof(PyHKEYObject, hkey), READONLY},
517	n/a	{NULL} /* Sentinel */
518	n/a	};
519	n/a
520	n/a	/* The type itself */
521	n/a	PyTypeObject PyHKEY_Type =
522	n/a	{
523	n/a	PyVarObject_HEAD_INIT(0, 0) /* fill in type at module init */
524	n/a	"PyHKEY",
525	n/a	sizeof(PyHKEYObject),
526	n/a	0,
527	n/a	PyHKEY_deallocFunc, /* tp_dealloc */
528	n/a	PyHKEY_printFunc, /* tp_print */
529	n/a	0, /* tp_getattr */
530	n/a	0, /* tp_setattr */
531	n/a	PyHKEY_compareFunc, /* tp_compare */
532	n/a	0, /* tp_repr */
533	n/a	&PyHKEY_NumberMethods, /* tp_as_number */
534	n/a	0, /* tp_as_sequence */
535	n/a	0, /* tp_as_mapping */
536	n/a	PyHKEY_hashFunc, /* tp_hash */
537	n/a	0, /* tp_call */
538	n/a	PyHKEY_strFunc, /* tp_str */
539	n/a	0, /* tp_getattro */
540	n/a	0, /* tp_setattro */
541	n/a	0, /* tp_as_buffer */
542	n/a	Py_TPFLAGS_DEFAULT, /* tp_flags */
543	n/a	PyHKEY_doc, /* tp_doc */
544	n/a	0, /* tp_traverse */
545	n/a	0, /* tp_clear */
546	n/a	0, /* tp_richcompare */
547	n/a	0, /* tp_weaklistoffset */
548	n/a	0, /* tp_iter */
549	n/a	0, /* tp_iternext */
550	n/a	PyHKEY_methods, /* tp_methods */
551	n/a	PyHKEY_memberlist, /* tp_members */
552	n/a	};
553	n/a
554	n/a	/************************************************************************
555	n/a
556	n/a	The PyHKEY object methods
557	n/a
558	n/a	************************************************************************/
559	n/a	static PyObject *
560	n/a	PyHKEY_CloseMethod(PyObject self, PyObject args)
561	n/a	{
562	n/a	if (!PyArg_ParseTuple(args, ":Close"))
563	n/a	return NULL;
564	n/a	if (!PyHKEY_Close(self))
565	n/a	return NULL;
566	n/a	Py_INCREF(Py_None);
567	n/a	return Py_None;
568	n/a	}
569	n/a
570	n/a	static PyObject *
571	n/a	PyHKEY_DetachMethod(PyObject self, PyObject args)
572	n/a	{
573	n/a	void* ret;
574	n/a	PyHKEYObject pThis = (PyHKEYObject )self;
575	n/a	if (!PyArg_ParseTuple(args, ":Detach"))
576	n/a	return NULL;
577	n/a	ret = (void*)pThis->hkey;
578	n/a	pThis->hkey = 0;
579	n/a	return PyLong_FromVoidPtr(ret);
580	n/a	}
581	n/a
582	n/a	static PyObject *
583	n/a	PyHKEY_Enter(PyObject *self)
584	n/a	{
585	n/a	Py_XINCREF(self);
586	n/a	return self;
587	n/a	}
588	n/a
589	n/a	static PyObject *
590	n/a	PyHKEY_Exit(PyObject self, PyObject args)
591	n/a	{
592	n/a	if (!PyHKEY_Close(self))
593	n/a	return NULL;
594	n/a	Py_RETURN_NONE;
595	n/a	}
596	n/a
597	n/a
598	n/a	/************************************************************************
599	n/a	The public PyHKEY API (well, not public yet :-)
600	n/a	************************************************************************/
601	n/a	PyObject *
602	n/a	PyHKEY_New(HKEY hInit)
603	n/a	{
604	n/a	PyHKEYObject *key = PyObject_NEW(PyHKEYObject, &PyHKEY_Type);
605	n/a	if (key)
606	n/a	key->hkey = hInit;
607	n/a	return (PyObject *)key;
608	n/a	}
609	n/a
610	n/a	BOOL
611	n/a	PyHKEY_Close(PyObject *ob_handle)
612	n/a	{
613	n/a	LONG rc;
614	n/a	PyHKEYObject *key;
615	n/a
616	n/a	if (!PyHKEY_Check(ob_handle)) {
617	n/a	PyErr_SetString(PyExc_TypeError, "bad operand type");
618	n/a	return FALSE;
619	n/a	}
620	n/a	key = (PyHKEYObject *)ob_handle;
621	n/a	rc = key->hkey ? RegCloseKey((HKEY)key->hkey) : ERROR_SUCCESS;
622	n/a	key->hkey = 0;
623	n/a	if (rc != ERROR_SUCCESS)
624	n/a	PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");
625	n/a	return rc == ERROR_SUCCESS;
626	n/a	}
627	n/a
628	n/a	BOOL
629	n/a	PyHKEY_AsHKEY(PyObject ob, HKEY pHANDLE, BOOL bNoneOK)
630	n/a	{
631	n/a	if (ob == Py_None) {
632	n/a	if (!bNoneOK) {
633	n/a	PyErr_SetString(
634	n/a	PyExc_TypeError,
635	n/a	"None is not a valid HKEY in this context");
636	n/a	return FALSE;
637	n/a	}
638	n/a	*pHANDLE = (HKEY)0;
639	n/a	}
640	n/a	else if (PyHKEY_Check(ob)) {
641	n/a	PyHKEYObject pH = (PyHKEYObject )ob;
642	n/a	*pHANDLE = pH->hkey;
643	n/a	}
644	n/a	else if (PyInt_Check(ob) \|\| PyLong_Check(ob)) {
645	n/a	/* We also support integers */
646	n/a	PyErr_Clear();
647	n/a	*pHANDLE = (HKEY)PyLong_AsVoidPtr(ob);
648	n/a	if (PyErr_Occurred())
649	n/a	return FALSE;
650	n/a	}
651	n/a	else {
652	n/a	PyErr_SetString(
653	n/a	PyExc_TypeError,
654	n/a	"The object is not a PyHKEY object");
655	n/a	return FALSE;
656	n/a	}
657	n/a	return TRUE;
658	n/a	}
659	n/a
660	n/a	PyObject *
661	n/a	PyHKEY_FromHKEY(HKEY h)
662	n/a	{
663	n/a	PyHKEYObject *op;
664	n/a
665	n/a	/* Inline PyObject_New */
666	n/a	op = (PyHKEYObject *) PyObject_MALLOC(sizeof(PyHKEYObject));
667	n/a	if (op == NULL)
668	n/a	return PyErr_NoMemory();
669	n/a	PyObject_INIT(op, &PyHKEY_Type);
670	n/a	op->hkey = h;
671	n/a	return (PyObject *)op;
672	n/a	}
673	n/a
674	n/a
675	n/a	/************************************************************************
676	n/a	The module methods
677	n/a	************************************************************************/
678	n/a	BOOL
679	n/a	PyWinObject_CloseHKEY(PyObject *obHandle)
680	n/a	{
681	n/a	BOOL ok;
682	n/a	if (PyHKEY_Check(obHandle)) {
683	n/a	ok = PyHKEY_Close(obHandle);
684	n/a	}
685	n/a	#if SIZEOF_LONG >= SIZEOF_HKEY
686	n/a	else if (PyInt_Check(obHandle)) {
687	n/a	long rc = RegCloseKey((HKEY)PyInt_AsLong(obHandle));
688	n/a	ok = (rc == ERROR_SUCCESS);
689	n/a	if (!ok)
690	n/a	PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");
691	n/a	}
692	n/a	#else
693	n/a	else if (PyLong_Check(obHandle)) {
694	n/a	long rc = RegCloseKey((HKEY)PyLong_AsVoidPtr(obHandle));
695	n/a	ok = (rc == ERROR_SUCCESS);
696	n/a	if (!ok)
697	n/a	PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");
698	n/a	}
699	n/a	#endif
700	n/a	else {
701	n/a	PyErr_SetString(
702	n/a	PyExc_TypeError,
703	n/a	"A handle must be a HKEY object or an integer");
704	n/a	return FALSE;
705	n/a	}
706	n/a	return ok;
707	n/a	}
708	n/a
709	n/a
710	n/a	/*
711	n/a	Private Helper functions for the registry interfaces
712	n/a
713	n/a	** Note that fixupMultiSZ and countString have both had changes
714	n/a	** made to support "incorrect strings". The registry specification
715	n/a	** calls for strings to be terminated with 2 null bytes. It seems
716	n/a	** some commercial packages install strings which don't conform,
717	n/a	** causing this code to fail - however, "regedit" etc still work
718	n/a	** with these strings (ie only we don't!).
719	n/a	*/
720	n/a	static void
721	n/a	fixupMultiSZ(char *str, char data, int len)
722	n/a	{
723	n/a	char *P;
724	n/a	int i;
725	n/a	char *Q;
726	n/a
727	n/a	Q = data + len;
728	n/a	for (P = data, i = 0; P < Q && *P != '\0'; P++, i++) {
729	n/a	str[i] = P;
730	n/a	for(; *P != '\0'; P++)
731	n/a	;
732	n/a	}
733	n/a	}
734	n/a
735	n/a	static int
736	n/a	countStrings(char *data, int len)
737	n/a	{
738	n/a	int strings;
739	n/a	char *P;
740	n/a	char *Q = data + len;
741	n/a
742	n/a	for (P = data, strings = 0; P < Q && *P != '\0'; P++, strings++)
743	n/a	for (; P < Q && *P != '\0'; P++)
744	n/a	;
745	n/a	return strings;
746	n/a	}
747	n/a
748	n/a	/* Convert PyObject into Registry data.
749	n/a	Allocates space as needed. */
750	n/a	static BOOL
751	n/a	Py2Reg(PyObject value, DWORD typ, BYTE retDataBuf, DWORD retDataSize)
752	n/a	{
753	n/a	Py_ssize_t i,j;
754	n/a	switch (typ) {
755	n/a	case REG_DWORD:
756	n/a	if (value != Py_None && !PyInt_Check(value))
757	n/a	return FALSE;
758	n/a	retDataBuf = (BYTE )PyMem_NEW(DWORD, 1);
759	n/a	if (*retDataBuf==NULL){
760	n/a	PyErr_NoMemory();
761	n/a	return FALSE;
762	n/a	}
763	n/a	*retDataSize = sizeof(DWORD);
764	n/a	if (value == Py_None) {
765	n/a	DWORD zero = 0;
766	n/a	memcpy(*retDataBuf, &zero, sizeof(DWORD));
767	n/a	}
768	n/a	else
769	n/a	memcpy(*retDataBuf,
770	n/a	&PyInt_AS_LONG((PyIntObject *)value),
771	n/a	sizeof(DWORD));
772	n/a	break;
773	n/a	case REG_SZ:
774	n/a	case REG_EXPAND_SZ:
775	n/a	{
776	n/a	int need_decref = 0;
777	n/a	if (value == Py_None)
778	n/a	*retDataSize = 1;
779	n/a	else {
780	n/a	if (PyUnicode_Check(value)) {
781	n/a	value = PyUnicode_AsEncodedString(
782	n/a	value,
783	n/a	"mbcs",
784	n/a	NULL);
785	n/a	if (value==NULL)
786	n/a	return FALSE;
787	n/a	need_decref = 1;
788	n/a	}
789	n/a	if (!PyString_Check(value))
790	n/a	return FALSE;
791	n/a	*retDataSize = 1 + strlen(
792	n/a	PyString_AS_STRING(
793	n/a	(PyStringObject *)value));
794	n/a	}
795	n/a	retDataBuf = (BYTE )PyMem_NEW(DWORD, *retDataSize);
796	n/a	if (*retDataBuf==NULL){
797	n/a	PyErr_NoMemory();
798	n/a	return FALSE;
799	n/a	}
800	n/a	if (value == Py_None)
801	n/a	strcpy((char )retDataBuf, "");
802	n/a	else
803	n/a	strcpy((char )retDataBuf,
804	n/a	PyString_AS_STRING(
805	n/a	(PyStringObject *)value));
806	n/a	if (need_decref)
807	n/a	Py_DECREF(value);
808	n/a	break;
809	n/a	}
810	n/a	case REG_MULTI_SZ:
811	n/a	{
812	n/a	DWORD size = 0;
813	n/a	char *P;
814	n/a	PyObject **obs = NULL;
815	n/a
816	n/a	if (value == Py_None)
817	n/a	i = 0;
818	n/a	else {
819	n/a	if (!PyList_Check(value))
820	n/a	return FALSE;
821	n/a	i = PyList_Size(value);
822	n/a	}
823	n/a	obs = malloc(sizeof(PyObject ) i);
824	n/a	memset(obs, 0, sizeof(PyObject ) i);
825	n/a	for (j = 0; j < i; j++)
826	n/a	{
827	n/a	PyObject *t;
828	n/a	t = PyList_GET_ITEM(
829	n/a	(PyListObject *)value,j);
830	n/a	if (PyString_Check(t)) {
831	n/a	obs[j] = t;
832	n/a	Py_INCREF(t);
833	n/a	} else if (PyUnicode_Check(t)) {
834	n/a	obs[j] = PyUnicode_AsEncodedString(
835	n/a	t,
836	n/a	"mbcs",
837	n/a	NULL);
838	n/a	if (obs[j]==NULL)
839	n/a	goto reg_multi_fail;
840	n/a	} else
841	n/a	goto reg_multi_fail;
842	n/a	size += 1 + strlen(
843	n/a	PyString_AS_STRING(
844	n/a	(PyStringObject *)obs[j]));
845	n/a	}
846	n/a
847	n/a	*retDataSize = size + 1;
848	n/a	retDataBuf = (BYTE )PyMem_NEW(char,
849	n/a	*retDataSize);
850	n/a	if (*retDataBuf==NULL){
851	n/a	PyErr_NoMemory();
852	n/a	goto reg_multi_fail;
853	n/a	}
854	n/a	P = (char )retDataBuf;
855	n/a
856	n/a	for (j = 0; j < i; j++)
857	n/a	{
858	n/a	PyObject *t;
859	n/a	t = obs[j];
860	n/a	strcpy(P,
861	n/a	PyString_AS_STRING(
862	n/a	(PyStringObject *)t));
863	n/a	P += 1 + strlen(
864	n/a	PyString_AS_STRING(
865	n/a	(PyStringObject *)t));
866	n/a	Py_DECREF(obs[j]);
867	n/a	}
868	n/a	/* And doubly-terminate the list... */
869	n/a	*P = '\0';
870	n/a	free(obs);
871	n/a	break;
872	n/a	reg_multi_fail:
873	n/a	if (obs) {
874	n/a	for (j = 0; j < i; j++)
875	n/a	Py_XDECREF(obs[j]);
876	n/a
877	n/a	free(obs);
878	n/a	}
879	n/a	return FALSE;
880	n/a	}
881	n/a	case REG_BINARY:
882	n/a	/* ALSO handle ALL unknown data types here. Even if we can't
883	n/a	support it natively, we should handle the bits. */
884	n/a	default:
885	n/a	if (value == Py_None)
886	n/a	*retDataSize = 0;
887	n/a	else {
888	n/a	void *src_buf;
889	n/a	PyBufferProcs *pb = value->ob_type->tp_as_buffer;
890	n/a	if (pb==NULL) {
891	n/a	PyErr_Format(PyExc_TypeError,
892	n/a	"Objects of type '%s' can not "
893	n/a	"be used as binary registry values",
894	n/a	value->ob_type->tp_name);
895	n/a	return FALSE;
896	n/a	}
897	n/a	retDataSize = (pb->bf_getreadbuffer)(value, 0, &src_buf);
898	n/a	retDataBuf = (BYTE )PyMem_NEW(char,
899	n/a	*retDataSize);
900	n/a	if (*retDataBuf==NULL){
901	n/a	PyErr_NoMemory();
902	n/a	return FALSE;
903	n/a	}
904	n/a	memcpy(retDataBuf, src_buf, retDataSize);
905	n/a	}
906	n/a	break;
907	n/a	}
908	n/a	return TRUE;
909	n/a	}
910	n/a
911	n/a	/* Convert Registry data into PyObject*/
912	n/a	static PyObject *
913	n/a	Reg2Py(char *retDataBuf, DWORD retDataSize, DWORD typ)
914	n/a	{
915	n/a	PyObject *obData;
916	n/a
917	n/a	switch (typ) {
918	n/a	case REG_DWORD:
919	n/a	if (retDataSize == 0)
920	n/a	obData = Py_BuildValue("i", 0);
921	n/a	else
922	n/a	obData = Py_BuildValue("i",
923	n/a	(int )retDataBuf);
924	n/a	break;
925	n/a	case REG_SZ:
926	n/a	case REG_EXPAND_SZ:
927	n/a	/* retDataBuf may or may not have a trailing NULL in
928	n/a	the buffer. */
929	n/a	if (retDataSize && retDataBuf[retDataSize-1] == '\0')
930	n/a	--retDataSize;
931	n/a	if (retDataSize ==0)
932	n/a	retDataBuf = "";
933	n/a	obData = PyUnicode_DecodeMBCS(retDataBuf,
934	n/a	retDataSize,
935	n/a	NULL);
936	n/a	break;
937	n/a	case REG_MULTI_SZ:
938	n/a	if (retDataSize == 0)
939	n/a	obData = PyList_New(0);
940	n/a	else
941	n/a	{
942	n/a	int index = 0;
943	n/a	int s = countStrings(retDataBuf, retDataSize);
944	n/a	char str = (char )malloc(sizeof(char )s);
945	n/a	if (str == NULL)
946	n/a	return PyErr_NoMemory();
947	n/a
948	n/a	fixupMultiSZ(str, retDataBuf, retDataSize);
949	n/a	obData = PyList_New(s);
950	n/a	if (obData == NULL)
951	n/a	return NULL;
952	n/a	for (index = 0; index < s; index++)
953	n/a	{
954	n/a	size_t len = _mbstrlen(str[index]);
955	n/a	if (len > INT_MAX) {
956	n/a	PyErr_SetString(PyExc_OverflowError,
957	n/a	"registry string is too long for a Python string");
958	n/a	Py_DECREF(obData);
959	n/a	return NULL;
960	n/a	}
961	n/a	PyList_SetItem(obData,
962	n/a	index,
963	n/a	PyUnicode_DecodeMBCS(
964	n/a	(const char *)str[index],
965	n/a	(int)len,
966	n/a	NULL)
967	n/a	);
968	n/a	}
969	n/a	free(str);
970	n/a
971	n/a	break;
972	n/a	}
973	n/a	case REG_BINARY:
974	n/a	/* ALSO handle ALL unknown data types here. Even if we can't
975	n/a	support it natively, we should handle the bits. */
976	n/a	default:
977	n/a	if (retDataSize == 0) {
978	n/a	Py_INCREF(Py_None);
979	n/a	obData = Py_None;
980	n/a	}
981	n/a	else
982	n/a	obData = Py_BuildValue("s#",
983	n/a	(char *)retDataBuf,
984	n/a	retDataSize);
985	n/a	break;
986	n/a	}
987	n/a	if (obData == NULL)
988	n/a	return NULL;
989	n/a	else
990	n/a	return obData;
991	n/a	}
992	n/a
993	n/a	/* The Python methods */
994	n/a
995	n/a	static PyObject *
996	n/a	PyCloseKey(PyObject self, PyObject args)
997	n/a	{
998	n/a	PyObject *obKey;
999	n/a	if (!PyArg_ParseTuple(args, "O:CloseKey", &obKey))
1000	n/a	return NULL;
1001	n/a	if (!PyHKEY_Close(obKey))
1002	n/a	return NULL;
1003	n/a	Py_INCREF(Py_None);
1004	n/a	return Py_None;
1005	n/a	}
1006	n/a
1007	n/a	static PyObject *
1008	n/a	PyConnectRegistry(PyObject self, PyObject args)
1009	n/a	{
1010	n/a	HKEY hKey;
1011	n/a	PyObject *obKey;
1012	n/a	char *szCompName = NULL;
1013	n/a	HKEY retKey;
1014	n/a	long rc;
1015	n/a	if (!PyArg_ParseTuple(args, "zO:ConnectRegistry", &szCompName, &obKey))
1016	n/a	return NULL;
1017	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1018	n/a	return NULL;
1019	n/a	Py_BEGIN_ALLOW_THREADS
1020	n/a	rc = RegConnectRegistry(szCompName, hKey, &retKey);
1021	n/a	Py_END_ALLOW_THREADS
1022	n/a	if (rc != ERROR_SUCCESS)
1023	n/a	return PyErr_SetFromWindowsErrWithFunction(rc,
1024	n/a	"ConnectRegistry");
1025	n/a	return PyHKEY_FromHKEY(retKey);
1026	n/a	}
1027	n/a
1028	n/a	static PyObject *
1029	n/a	PyCreateKey(PyObject self, PyObject args)
1030	n/a	{
1031	n/a	HKEY hKey;
1032	n/a	PyObject *obKey;
1033	n/a	char *subKey;
1034	n/a	HKEY retKey;
1035	n/a	long rc;
1036	n/a	if (!PyArg_ParseTuple(args, "Oz:CreateKey", &obKey, &subKey))
1037	n/a	return NULL;
1038	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1039	n/a	return NULL;
1040	n/a	rc = RegCreateKey(hKey, subKey, &retKey);
1041	n/a	if (rc != ERROR_SUCCESS)
1042	n/a	return PyErr_SetFromWindowsErrWithFunction(rc, "CreateKey");
1043	n/a	return PyHKEY_FromHKEY(retKey);
1044	n/a	}
1045	n/a
1046	n/a	static PyObject *
1047	n/a	PyCreateKeyEx(PyObject self, PyObject args)
1048	n/a	{
1049	n/a	HKEY hKey;
1050	n/a	PyObject *obKey;
1051	n/a	char *subKey;
1052	n/a	HKEY retKey;
1053	n/a	int res = 0;
1054	n/a	REGSAM sam = KEY_WRITE;
1055	n/a	long rc;
1056	n/a	if (!PyArg_ParseTuple(args, "Oz\|ii:CreateKeyEx", &obKey, &subKey,
1057	n/a	&res, &sam))
1058	n/a	return NULL;
1059	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1060	n/a	return NULL;
1061	n/a
1062	n/a	rc = RegCreateKeyEx(hKey, subKey, res, NULL, (DWORD)NULL,
1063	n/a	sam, NULL, &retKey, NULL);
1064	n/a	if (rc != ERROR_SUCCESS)
1065	n/a	return PyErr_SetFromWindowsErrWithFunction(rc, "CreateKeyEx");
1066	n/a	return PyHKEY_FromHKEY(retKey);
1067	n/a	}
1068	n/a
1069	n/a	static PyObject *
1070	n/a	PyDeleteKey(PyObject self, PyObject args)
1071	n/a	{
1072	n/a	HKEY hKey;
1073	n/a	PyObject *obKey;
1074	n/a	char *subKey;
1075	n/a	long rc;
1076	n/a	if (!PyArg_ParseTuple(args, "Os:DeleteKey", &obKey, &subKey))
1077	n/a	return NULL;
1078	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1079	n/a	return NULL;
1080	n/a	rc = RegDeleteKey(hKey, subKey );
1081	n/a	if (rc != ERROR_SUCCESS)
1082	n/a	return PyErr_SetFromWindowsErrWithFunction(rc, "RegDeleteKey");
1083	n/a	Py_INCREF(Py_None);
1084	n/a	return Py_None;
1085	n/a	}
1086	n/a
1087	n/a	static PyObject *
1088	n/a	PyDeleteKeyEx(PyObject self, PyObject args)
1089	n/a	{
1090	n/a	HKEY hKey;
1091	n/a	PyObject *obKey;
1092	n/a	HMODULE hMod;
1093	n/a	typedef LONG (WINAPI RDKEFunc)(HKEY, const char, REGSAM, int);
1094	n/a	RDKEFunc pfn = NULL;
1095	n/a	char *subKey;
1096	n/a	long rc;
1097	n/a	int res = 0;
1098	n/a	REGSAM sam = KEY_WOW64_64KEY;
1099	n/a
1100	n/a	if (!PyArg_ParseTuple(args, "Os\|ii:DeleteKeyEx",
1101	n/a	&obKey, &subKey, &sam, &res))
1102	n/a	return NULL;
1103	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1104	n/a	return NULL;
1105	n/a
1106	n/a	/* Only available on 64bit platforms, so we must load it
1107	n/a	dynamically. */
1108	n/a	hMod = GetModuleHandle("advapi32.dll");
1109	n/a	if (hMod)
1110	n/a	pfn = (RDKEFunc)GetProcAddress(hMod,
1111	n/a	"RegDeleteKeyExA");
1112	n/a	if (!pfn) {
1113	n/a	PyErr_SetString(PyExc_NotImplementedError,
1114	n/a	"not implemented on this platform");
1115	n/a	return NULL;
1116	n/a	}
1117	n/a	Py_BEGIN_ALLOW_THREADS
1118	n/a	rc = (*pfn)(hKey, subKey, sam, res);
1119	n/a	Py_END_ALLOW_THREADS
1120	n/a
1121	n/a	if (rc != ERROR_SUCCESS)
1122	n/a	return PyErr_SetFromWindowsErrWithFunction(rc, "RegDeleteKeyEx");
1123	n/a	Py_INCREF(Py_None);
1124	n/a	return Py_None;
1125	n/a	}
1126	n/a
1127	n/a	static PyObject *
1128	n/a	PyDeleteValue(PyObject self, PyObject args)
1129	n/a	{
1130	n/a	HKEY hKey;
1131	n/a	PyObject *obKey;
1132	n/a	char *subKey;
1133	n/a	long rc;
1134	n/a	if (!PyArg_ParseTuple(args, "Oz:DeleteValue", &obKey, &subKey))
1135	n/a	return NULL;
1136	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1137	n/a	return NULL;
1138	n/a	Py_BEGIN_ALLOW_THREADS
1139	n/a	rc = RegDeleteValue(hKey, subKey);
1140	n/a	Py_END_ALLOW_THREADS
1141	n/a	if (rc !=ERROR_SUCCESS)
1142	n/a	return PyErr_SetFromWindowsErrWithFunction(rc,
1143	n/a	"RegDeleteValue");
1144	n/a	Py_INCREF(Py_None);
1145	n/a	return Py_None;
1146	n/a	}
1147	n/a
1148	n/a	static PyObject *
1149	n/a	PyEnumKey(PyObject self, PyObject args)
1150	n/a	{
1151	n/a	HKEY hKey;
1152	n/a	PyObject *obKey;
1153	n/a	int index;
1154	n/a	long rc;
1155	n/a	PyObject *retStr;
1156	n/a
1157	n/a	/* The Windows docs claim that the max key name length is 255
1158	n/a	* characters, plus a terminating nul character. However,
1159	n/a	* empirical testing demonstrates that it is possible to
1160	n/a	* create a 256 character key that is missing the terminating
1161	n/a	* nul. RegEnumKeyEx requires a 257 character buffer to
1162	n/a	* retrieve such a key name. */
1163	n/a	char tmpbuf[257];
1164	n/a	DWORD len = sizeof(tmpbuf); /* includes NULL terminator */
1165	n/a
1166	n/a	if (!PyArg_ParseTuple(args, "Oi:EnumKey", &obKey, &index))
1167	n/a	return NULL;
1168	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1169	n/a	return NULL;
1170	n/a
1171	n/a	Py_BEGIN_ALLOW_THREADS
1172	n/a	rc = RegEnumKeyEx(hKey, index, tmpbuf, &len, NULL, NULL, NULL, NULL);
1173	n/a	Py_END_ALLOW_THREADS
1174	n/a	if (rc != ERROR_SUCCESS)
1175	n/a	return PyErr_SetFromWindowsErrWithFunction(rc, "RegEnumKeyEx");
1176	n/a
1177	n/a	retStr = PyString_FromStringAndSize(tmpbuf, len);
1178	n/a	return retStr; /* can be NULL */
1179	n/a	}
1180	n/a
1181	n/a	static PyObject *
1182	n/a	PyEnumValue(PyObject self, PyObject args)
1183	n/a	{
1184	n/a	HKEY hKey;
1185	n/a	PyObject *obKey;
1186	n/a	int index;
1187	n/a	long rc;
1188	n/a	char *retValueBuf;
1189	n/a	char *retDataBuf;
1190	n/a	char *tmpBuf;
1191	n/a	DWORD retValueSize, bufValueSize;
1192	n/a	DWORD retDataSize, bufDataSize;
1193	n/a	DWORD typ;
1194	n/a	PyObject *obData;
1195	n/a	PyObject *retVal;
1196	n/a
1197	n/a	if (!PyArg_ParseTuple(args, "Oi:EnumValue", &obKey, &index))
1198	n/a	return NULL;
1199	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1200	n/a	return NULL;
1201	n/a
1202	n/a	if ((rc = RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL,
1203	n/a	NULL,
1204	n/a	&retValueSize, &retDataSize, NULL, NULL))
1205	n/a	!= ERROR_SUCCESS)
1206	n/a	return PyErr_SetFromWindowsErrWithFunction(rc,
1207	n/a	"RegQueryInfoKey");
1208	n/a	++retValueSize; /* include null terminators */
1209	n/a	++retDataSize;
1210	n/a	bufDataSize = retDataSize;
1211	n/a	bufValueSize = retValueSize;
1212	n/a	retValueBuf = (char *)PyMem_Malloc(retValueSize);
1213	n/a	if (retValueBuf == NULL)
1214	n/a	return PyErr_NoMemory();
1215	n/a	retDataBuf = (char *)PyMem_Malloc(retDataSize);
1216	n/a	if (retDataBuf == NULL) {
1217	n/a	PyMem_Free(retValueBuf);
1218	n/a	return PyErr_NoMemory();
1219	n/a	}
1220	n/a
1221	n/a	while (1) {
1222	n/a	Py_BEGIN_ALLOW_THREADS
1223	n/a	rc = RegEnumValue(hKey,
1224	n/a	index,
1225	n/a	retValueBuf,
1226	n/a	&retValueSize,
1227	n/a	NULL,
1228	n/a	&typ,
1229	n/a	(BYTE *)retDataBuf,
1230	n/a	&retDataSize);
1231	n/a	Py_END_ALLOW_THREADS
1232	n/a
1233	n/a	if (rc != ERROR_MORE_DATA)
1234	n/a	break;
1235	n/a
1236	n/a	bufDataSize *= 2;
1237	n/a	tmpBuf = (char *)PyMem_Realloc(retDataBuf, bufDataSize);
1238	n/a	if (tmpBuf == NULL) {
1239	n/a	PyErr_NoMemory();
1240	n/a	retVal = NULL;
1241	n/a	goto fail;
1242	n/a	}
1243	n/a	retDataBuf = tmpBuf;
1244	n/a	retDataSize = bufDataSize;
1245	n/a	retValueSize = bufValueSize;
1246	n/a	}
1247	n/a
1248	n/a	if (rc != ERROR_SUCCESS) {
1249	n/a	retVal = PyErr_SetFromWindowsErrWithFunction(rc,
1250	n/a	"PyRegEnumValue");
1251	n/a	goto fail;
1252	n/a	}
1253	n/a	obData = Reg2Py(retDataBuf, retDataSize, typ);
1254	n/a	if (obData == NULL) {
1255	n/a	retVal = NULL;
1256	n/a	goto fail;
1257	n/a	}
1258	n/a	retVal = Py_BuildValue("sOi", retValueBuf, obData, typ);
1259	n/a	Py_DECREF(obData);
1260	n/a	fail:
1261	n/a	PyMem_Free(retValueBuf);
1262	n/a	PyMem_Free(retDataBuf);
1263	n/a	return retVal;
1264	n/a	}
1265	n/a
1266	n/a	static PyObject *
1267	n/a	PyExpandEnvironmentStrings(PyObject self, PyObject args)
1268	n/a	{
1269	n/a	Py_UNICODE *retValue = NULL;
1270	n/a	Py_UNICODE *src;
1271	n/a	DWORD retValueSize;
1272	n/a	DWORD rc;
1273	n/a	PyObject *o;
1274	n/a
1275	n/a	if (!PyArg_ParseTuple(args, "u:ExpandEnvironmentStrings", &src))
1276	n/a	return NULL;
1277	n/a
1278	n/a	retValueSize = ExpandEnvironmentStringsW(src, retValue, 0);
1279	n/a	if (retValueSize == 0) {
1280	n/a	return PyErr_SetFromWindowsErrWithFunction(retValueSize,
1281	n/a	"ExpandEnvironmentStrings");
1282	n/a	}
1283	n/a	retValue = (Py_UNICODE )PyMem_Malloc(retValueSize sizeof(Py_UNICODE));
1284	n/a	if (retValue == NULL) {
1285	n/a	return PyErr_NoMemory();
1286	n/a	}
1287	n/a
1288	n/a	rc = ExpandEnvironmentStringsW(src, retValue, retValueSize);
1289	n/a	if (rc == 0) {
1290	n/a	PyMem_Free(retValue);
1291	n/a	return PyErr_SetFromWindowsErrWithFunction(retValueSize,
1292	n/a	"ExpandEnvironmentStrings");
1293	n/a	}
1294	n/a	o = PyUnicode_FromUnicode(retValue, wcslen(retValue));
1295	n/a	PyMem_Free(retValue);
1296	n/a	return o;
1297	n/a	}
1298	n/a
1299	n/a	static PyObject *
1300	n/a	PyFlushKey(PyObject self, PyObject args)
1301	n/a	{
1302	n/a	HKEY hKey;
1303	n/a	PyObject *obKey;
1304	n/a	long rc;
1305	n/a	if (!PyArg_ParseTuple(args, "O:FlushKey", &obKey))
1306	n/a	return NULL;
1307	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1308	n/a	return NULL;
1309	n/a	Py_BEGIN_ALLOW_THREADS
1310	n/a	rc = RegFlushKey(hKey);
1311	n/a	Py_END_ALLOW_THREADS
1312	n/a	if (rc != ERROR_SUCCESS)
1313	n/a	return PyErr_SetFromWindowsErrWithFunction(rc, "RegFlushKey");
1314	n/a	Py_INCREF(Py_None);
1315	n/a	return Py_None;
1316	n/a	}
1317	n/a	static PyObject *
1318	n/a	PyLoadKey(PyObject self, PyObject args)
1319	n/a	{
1320	n/a	HKEY hKey;
1321	n/a	PyObject *obKey;
1322	n/a	char *subKey;
1323	n/a	char *fileName;
1324	n/a
1325	n/a	long rc;
1326	n/a	if (!PyArg_ParseTuple(args, "Oss:LoadKey", &obKey, &subKey, &fileName))
1327	n/a	return NULL;
1328	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1329	n/a	return NULL;
1330	n/a	Py_BEGIN_ALLOW_THREADS
1331	n/a	rc = RegLoadKey(hKey, subKey, fileName );
1332	n/a	Py_END_ALLOW_THREADS
1333	n/a	if (rc != ERROR_SUCCESS)
1334	n/a	return PyErr_SetFromWindowsErrWithFunction(rc, "RegLoadKey");
1335	n/a	Py_INCREF(Py_None);
1336	n/a	return Py_None;
1337	n/a	}
1338	n/a
1339	n/a	static PyObject *
1340	n/a	PyOpenKey(PyObject self, PyObject args)
1341	n/a	{
1342	n/a	HKEY hKey;
1343	n/a	PyObject *obKey;
1344	n/a
1345	n/a	char *subKey;
1346	n/a	int res = 0;
1347	n/a	HKEY retKey;
1348	n/a	long rc;
1349	n/a	REGSAM sam = KEY_READ;
1350	n/a	if (!PyArg_ParseTuple(args, "Oz\|ii:OpenKey", &obKey, &subKey,
1351	n/a	&res, &sam))
1352	n/a	return NULL;
1353	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1354	n/a	return NULL;
1355	n/a
1356	n/a	Py_BEGIN_ALLOW_THREADS
1357	n/a	rc = RegOpenKeyEx(hKey, subKey, res, sam, &retKey);
1358	n/a	Py_END_ALLOW_THREADS
1359	n/a	if (rc != ERROR_SUCCESS)
1360	n/a	return PyErr_SetFromWindowsErrWithFunction(rc, "RegOpenKeyEx");
1361	n/a	return PyHKEY_FromHKEY(retKey);
1362	n/a	}
1363	n/a
1364	n/a
1365	n/a	static PyObject *
1366	n/a	PyQueryInfoKey(PyObject self, PyObject args)
1367	n/a	{
1368	n/a	HKEY hKey;
1369	n/a	PyObject *obKey;
1370	n/a	long rc;
1371	n/a	DWORD nSubKeys, nValues;
1372	n/a	FILETIME ft;
1373	n/a	LARGE_INTEGER li;
1374	n/a	PyObject *l;
1375	n/a	PyObject *ret;
1376	n/a	if (!PyArg_ParseTuple(args, "O:QueryInfoKey", &obKey))
1377	n/a	return NULL;
1378	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1379	n/a	return NULL;
1380	n/a	if ((rc = RegQueryInfoKey(hKey, NULL, NULL, 0, &nSubKeys, NULL, NULL,
1381	n/a	&nValues, NULL, NULL, NULL, &ft))
1382	n/a	!= ERROR_SUCCESS)
1383	n/a	return PyErr_SetFromWindowsErrWithFunction(rc, "RegQueryInfoKey");
1384	n/a	li.LowPart = ft.dwLowDateTime;
1385	n/a	li.HighPart = ft.dwHighDateTime;
1386	n/a	l = PyLong_FromLongLong(li.QuadPart);
1387	n/a	if (l == NULL)
1388	n/a	return NULL;
1389	n/a	ret = Py_BuildValue("iiO", nSubKeys, nValues, l);
1390	n/a	Py_DECREF(l);
1391	n/a	return ret;
1392	n/a	}
1393	n/a
1394	n/a	static PyObject *
1395	n/a	PyQueryValue(PyObject self, PyObject args)
1396	n/a	{
1397	n/a	HKEY hKey;
1398	n/a	PyObject *obKey;
1399	n/a	char *subKey;
1400	n/a	long rc;
1401	n/a	PyObject *retStr;
1402	n/a	char *retBuf;
1403	n/a	DWORD bufSize = 0;
1404	n/a	DWORD retSize = 0;
1405	n/a	char *tmp;
1406	n/a
1407	n/a	if (!PyArg_ParseTuple(args, "Oz:QueryValue", &obKey, &subKey))
1408	n/a	return NULL;
1409	n/a
1410	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1411	n/a	return NULL;
1412	n/a
1413	n/a	rc = RegQueryValue(hKey, subKey, NULL, &retSize);
1414	n/a	if (rc == ERROR_MORE_DATA)
1415	n/a	retSize = 256;
1416	n/a	else if (rc != ERROR_SUCCESS)
1417	n/a	return PyErr_SetFromWindowsErrWithFunction(rc,
1418	n/a	"RegQueryValue");
1419	n/a
1420	n/a	bufSize = retSize;
1421	n/a	retBuf = (char *) PyMem_Malloc(bufSize);
1422	n/a	if (retBuf == NULL)
1423	n/a	return PyErr_NoMemory();
1424	n/a
1425	n/a	while (1) {
1426	n/a	retSize = bufSize;
1427	n/a	rc = RegQueryValue(hKey, subKey, retBuf, &retSize);
1428	n/a	if (rc != ERROR_MORE_DATA)
1429	n/a	break;
1430	n/a
1431	n/a	bufSize *= 2;
1432	n/a	tmp = (char *) PyMem_Realloc(retBuf, bufSize);
1433	n/a	if (tmp == NULL) {
1434	n/a	PyMem_Free(retBuf);
1435	n/a	return PyErr_NoMemory();
1436	n/a	}
1437	n/a	retBuf = tmp;
1438	n/a	}
1439	n/a
1440	n/a	if (rc != ERROR_SUCCESS) {
1441	n/a	PyMem_Free(retBuf);
1442	n/a	return PyErr_SetFromWindowsErrWithFunction(rc,
1443	n/a	"RegQueryValue");
1444	n/a	}
1445	n/a
1446	n/a	if (retBuf[retSize-1] == '\x00')
1447	n/a	retSize--;
1448	n/a	retStr = PyString_FromStringAndSize(retBuf, retSize);
1449	n/a	if (retStr == NULL) {
1450	n/a	PyMem_Free(retBuf);
1451	n/a	return NULL;
1452	n/a	}
1453	n/a	return retStr;
1454	n/a	}
1455	n/a
1456	n/a	static PyObject *
1457	n/a	PyQueryValueEx(PyObject self, PyObject args)
1458	n/a	{
1459	n/a	HKEY hKey;
1460	n/a	PyObject *obKey;
1461	n/a	char *valueName;
1462	n/a
1463	n/a	long rc;
1464	n/a	char retBuf, tmp;
1465	n/a	DWORD bufSize = 0, retSize;
1466	n/a	DWORD typ;
1467	n/a	PyObject *obData;
1468	n/a	PyObject *result;
1469	n/a
1470	n/a	if (!PyArg_ParseTuple(args, "Oz:QueryValueEx", &obKey, &valueName))
1471	n/a	return NULL;
1472	n/a
1473	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1474	n/a	return NULL;
1475	n/a
1476	n/a	rc = RegQueryValueEx(hKey, valueName, NULL, NULL, NULL, &bufSize);
1477	n/a	if (rc == ERROR_MORE_DATA)
1478	n/a	bufSize = 256;
1479	n/a	else if (rc != ERROR_SUCCESS)
1480	n/a	return PyErr_SetFromWindowsErrWithFunction(rc,
1481	n/a	"RegQueryValueEx");
1482	n/a	retBuf = (char *)PyMem_Malloc(bufSize);
1483	n/a	if (retBuf == NULL)
1484	n/a	return PyErr_NoMemory();
1485	n/a
1486	n/a	while (1) {
1487	n/a	retSize = bufSize;
1488	n/a	rc = RegQueryValueEx(hKey, valueName, NULL, &typ,
1489	n/a	(BYTE *)retBuf, &retSize);
1490	n/a	if (rc != ERROR_MORE_DATA)
1491	n/a	break;
1492	n/a
1493	n/a	bufSize *= 2;
1494	n/a	tmp = (char *) PyMem_Realloc(retBuf, bufSize);
1495	n/a	if (tmp == NULL) {
1496	n/a	PyMem_Free(retBuf);
1497	n/a	return PyErr_NoMemory();
1498	n/a	}
1499	n/a	retBuf = tmp;
1500	n/a	}
1501	n/a
1502	n/a	if (rc != ERROR_SUCCESS) {
1503	n/a	PyMem_Free(retBuf);
1504	n/a	return PyErr_SetFromWindowsErrWithFunction(rc,
1505	n/a	"RegQueryValueEx");
1506	n/a	}
1507	n/a	obData = Reg2Py(retBuf, bufSize, typ);
1508	n/a	PyMem_Free((void *)retBuf);
1509	n/a	if (obData == NULL)
1510	n/a	return NULL;
1511	n/a	result = Py_BuildValue("Oi", obData, typ);
1512	n/a	Py_DECREF(obData);
1513	n/a	return result;
1514	n/a	}
1515	n/a
1516	n/a
1517	n/a	static PyObject *
1518	n/a	PySaveKey(PyObject self, PyObject args)
1519	n/a	{
1520	n/a	HKEY hKey;
1521	n/a	PyObject *obKey;
1522	n/a	char *fileName;
1523	n/a	LPSECURITY_ATTRIBUTES pSA = NULL;
1524	n/a
1525	n/a	long rc;
1526	n/a	if (!PyArg_ParseTuple(args, "Os:SaveKey", &obKey, &fileName))
1527	n/a	return NULL;
1528	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1529	n/a	return NULL;
1530	n/a	/* One day we may get security into the core?
1531	n/a	if (!PyWinObject_AsSECURITY_ATTRIBUTES(obSA, &pSA, TRUE))
1532	n/a	return NULL;
1533	n/a	*/
1534	n/a	Py_BEGIN_ALLOW_THREADS
1535	n/a	rc = RegSaveKey(hKey, fileName, pSA );
1536	n/a	Py_END_ALLOW_THREADS
1537	n/a	if (rc != ERROR_SUCCESS)
1538	n/a	return PyErr_SetFromWindowsErrWithFunction(rc, "RegSaveKey");
1539	n/a	Py_INCREF(Py_None);
1540	n/a	return Py_None;
1541	n/a	}
1542	n/a
1543	n/a	static PyObject *
1544	n/a	PySetValue(PyObject self, PyObject args)
1545	n/a	{
1546	n/a	HKEY hKey;
1547	n/a	PyObject *obKey;
1548	n/a	char *subKey;
1549	n/a	char *str;
1550	n/a	DWORD typ;
1551	n/a	DWORD len;
1552	n/a	long rc;
1553	n/a	PyObject *obStrVal;
1554	n/a	PyObject *obSubKey;
1555	n/a	if (!PyArg_ParseTuple(args, "OOiO:SetValue",
1556	n/a	&obKey,
1557	n/a	&obSubKey,
1558	n/a	&typ,
1559	n/a	&obStrVal))
1560	n/a	return NULL;
1561	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1562	n/a	return NULL;
1563	n/a	if (typ != REG_SZ) {
1564	n/a	PyErr_SetString(PyExc_TypeError,
1565	n/a	"Type must be _winreg.REG_SZ");
1566	n/a	return NULL;
1567	n/a	}
1568	n/a	/* XXX - need Unicode support */
1569	n/a	str = PyString_AsString(obStrVal);
1570	n/a	if (str == NULL)
1571	n/a	return NULL;
1572	n/a	len = PyString_Size(obStrVal);
1573	n/a	if (obSubKey == Py_None)
1574	n/a	subKey = NULL;
1575	n/a	else {
1576	n/a	subKey = PyString_AsString(obSubKey);
1577	n/a	if (subKey == NULL)
1578	n/a	return NULL;
1579	n/a	}
1580	n/a	Py_BEGIN_ALLOW_THREADS
1581	n/a	rc = RegSetValue(hKey, subKey, REG_SZ, str, len+1);
1582	n/a	Py_END_ALLOW_THREADS
1583	n/a	if (rc != ERROR_SUCCESS)
1584	n/a	return PyErr_SetFromWindowsErrWithFunction(rc, "RegSetValue");
1585	n/a	Py_INCREF(Py_None);
1586	n/a	return Py_None;
1587	n/a	}
1588	n/a
1589	n/a	static PyObject *
1590	n/a	PySetValueEx(PyObject self, PyObject args)
1591	n/a	{
1592	n/a	HKEY hKey;
1593	n/a	PyObject *obKey;
1594	n/a	char *valueName;
1595	n/a	PyObject *obRes;
1596	n/a	PyObject *value;
1597	n/a	BYTE *data;
1598	n/a	DWORD len;
1599	n/a	DWORD typ;
1600	n/a
1601	n/a	LONG rc;
1602	n/a
1603	n/a	if (!PyArg_ParseTuple(args, "OzOiO:SetValueEx",
1604	n/a	&obKey,
1605	n/a	&valueName,
1606	n/a	&obRes,
1607	n/a	&typ,
1608	n/a	&value))
1609	n/a	return NULL;
1610	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1611	n/a	return NULL;
1612	n/a	if (!Py2Reg(value, typ, &data, &len))
1613	n/a	{
1614	n/a	if (!PyErr_Occurred())
1615	n/a	PyErr_SetString(PyExc_ValueError,
1616	n/a	"Could not convert the data to the specified type.");
1617	n/a	return NULL;
1618	n/a	}
1619	n/a	Py_BEGIN_ALLOW_THREADS
1620	n/a	rc = RegSetValueEx(hKey, valueName, 0, typ, data, len);
1621	n/a	Py_END_ALLOW_THREADS
1622	n/a	PyMem_DEL(data);
1623	n/a	if (rc != ERROR_SUCCESS)
1624	n/a	return PyErr_SetFromWindowsErrWithFunction(rc,
1625	n/a	"RegSetValueEx");
1626	n/a	Py_INCREF(Py_None);
1627	n/a	return Py_None;
1628	n/a	}
1629	n/a
1630	n/a	static PyObject *
1631	n/a	PyDisableReflectionKey(PyObject self, PyObject args)
1632	n/a	{
1633	n/a	HKEY hKey;
1634	n/a	PyObject *obKey;
1635	n/a	HMODULE hMod;
1636	n/a	typedef LONG (WINAPI *RDRKFunc)(HKEY);
1637	n/a	RDRKFunc pfn = NULL;
1638	n/a	LONG rc;
1639	n/a
1640	n/a	if (!PyArg_ParseTuple(args, "O:DisableReflectionKey", &obKey))
1641	n/a	return NULL;
1642	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1643	n/a	return NULL;
1644	n/a
1645	n/a	/* Only available on 64bit platforms, so we must load it
1646	n/a	dynamically. */
1647	n/a	hMod = GetModuleHandle("advapi32.dll");
1648	n/a	if (hMod)
1649	n/a	pfn = (RDRKFunc)GetProcAddress(hMod,
1650	n/a	"RegDisableReflectionKey");
1651	n/a	if (!pfn) {
1652	n/a	PyErr_SetString(PyExc_NotImplementedError,
1653	n/a	"not implemented on this platform");
1654	n/a	return NULL;
1655	n/a	}
1656	n/a	Py_BEGIN_ALLOW_THREADS
1657	n/a	rc = (*pfn)(hKey);
1658	n/a	Py_END_ALLOW_THREADS
1659	n/a	if (rc != ERROR_SUCCESS)
1660	n/a	return PyErr_SetFromWindowsErrWithFunction(rc,
1661	n/a	"RegDisableReflectionKey");
1662	n/a	Py_INCREF(Py_None);
1663	n/a	return Py_None;
1664	n/a	}
1665	n/a
1666	n/a	static PyObject *
1667	n/a	PyEnableReflectionKey(PyObject self, PyObject args)
1668	n/a	{
1669	n/a	HKEY hKey;
1670	n/a	PyObject *obKey;
1671	n/a	HMODULE hMod;
1672	n/a	typedef LONG (WINAPI *RERKFunc)(HKEY);
1673	n/a	RERKFunc pfn = NULL;
1674	n/a	LONG rc;
1675	n/a
1676	n/a	if (!PyArg_ParseTuple(args, "O:EnableReflectionKey", &obKey))
1677	n/a	return NULL;
1678	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1679	n/a	return NULL;
1680	n/a
1681	n/a	/* Only available on 64bit platforms, so we must load it
1682	n/a	dynamically. */
1683	n/a	hMod = GetModuleHandle("advapi32.dll");
1684	n/a	if (hMod)
1685	n/a	pfn = (RERKFunc)GetProcAddress(hMod,
1686	n/a	"RegEnableReflectionKey");
1687	n/a	if (!pfn) {
1688	n/a	PyErr_SetString(PyExc_NotImplementedError,
1689	n/a	"not implemented on this platform");
1690	n/a	return NULL;
1691	n/a	}
1692	n/a	Py_BEGIN_ALLOW_THREADS
1693	n/a	rc = (*pfn)(hKey);
1694	n/a	Py_END_ALLOW_THREADS
1695	n/a	if (rc != ERROR_SUCCESS)
1696	n/a	return PyErr_SetFromWindowsErrWithFunction(rc,
1697	n/a	"RegEnableReflectionKey");
1698	n/a	Py_INCREF(Py_None);
1699	n/a	return Py_None;
1700	n/a	}
1701	n/a
1702	n/a	static PyObject *
1703	n/a	PyQueryReflectionKey(PyObject self, PyObject args)
1704	n/a	{
1705	n/a	HKEY hKey;
1706	n/a	PyObject *obKey;
1707	n/a	HMODULE hMod;
1708	n/a	typedef LONG (WINAPI RQRKFunc)(HKEY, BOOL );
1709	n/a	RQRKFunc pfn = NULL;
1710	n/a	BOOL result;
1711	n/a	LONG rc;
1712	n/a
1713	n/a	if (!PyArg_ParseTuple(args, "O:QueryReflectionKey", &obKey))
1714	n/a	return NULL;
1715	n/a	if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1716	n/a	return NULL;
1717	n/a
1718	n/a	/* Only available on 64bit platforms, so we must load it
1719	n/a	dynamically. */
1720	n/a	hMod = GetModuleHandle("advapi32.dll");
1721	n/a	if (hMod)
1722	n/a	pfn = (RQRKFunc)GetProcAddress(hMod,
1723	n/a	"RegQueryReflectionKey");
1724	n/a	if (!pfn) {
1725	n/a	PyErr_SetString(PyExc_NotImplementedError,
1726	n/a	"not implemented on this platform");
1727	n/a	return NULL;
1728	n/a	}
1729	n/a	Py_BEGIN_ALLOW_THREADS
1730	n/a	rc = (*pfn)(hKey, &result);
1731	n/a	Py_END_ALLOW_THREADS
1732	n/a	if (rc != ERROR_SUCCESS)
1733	n/a	return PyErr_SetFromWindowsErrWithFunction(rc,
1734	n/a	"RegQueryReflectionKey");
1735	n/a	return PyBool_FromLong(result);
1736	n/a	}
1737	n/a
1738	n/a	static struct PyMethodDef winreg_methods[] = {
1739	n/a	{"CloseKey", PyCloseKey, METH_VARARGS, CloseKey_doc},
1740	n/a	{"ConnectRegistry", PyConnectRegistry, METH_VARARGS, ConnectRegistry_doc},
1741	n/a	{"CreateKey", PyCreateKey, METH_VARARGS, CreateKey_doc},
1742	n/a	{"CreateKeyEx", PyCreateKeyEx, METH_VARARGS, CreateKeyEx_doc},
1743	n/a	{"DeleteKey", PyDeleteKey, METH_VARARGS, DeleteKey_doc},
1744	n/a	{"DeleteKeyEx", PyDeleteKeyEx, METH_VARARGS, DeleteKeyEx_doc},
1745	n/a	{"DeleteValue", PyDeleteValue, METH_VARARGS, DeleteValue_doc},
1746	n/a	{"DisableReflectionKey", PyDisableReflectionKey, METH_VARARGS, DisableReflectionKey_doc},
1747	n/a	{"EnableReflectionKey", PyEnableReflectionKey, METH_VARARGS, EnableReflectionKey_doc},
1748	n/a	{"EnumKey", PyEnumKey, METH_VARARGS, EnumKey_doc},
1749	n/a	{"EnumValue", PyEnumValue, METH_VARARGS, EnumValue_doc},
1750	n/a	{"ExpandEnvironmentStrings", PyExpandEnvironmentStrings, METH_VARARGS,
1751	n/a	ExpandEnvironmentStrings_doc },
1752	n/a	{"FlushKey", PyFlushKey, METH_VARARGS, FlushKey_doc},
1753	n/a	{"LoadKey", PyLoadKey, METH_VARARGS, LoadKey_doc},
1754	n/a	{"OpenKey", PyOpenKey, METH_VARARGS, OpenKey_doc},
1755	n/a	{"OpenKeyEx", PyOpenKey, METH_VARARGS, OpenKeyEx_doc},
1756	n/a	{"QueryValue", PyQueryValue, METH_VARARGS, QueryValue_doc},
1757	n/a	{"QueryValueEx", PyQueryValueEx, METH_VARARGS, QueryValueEx_doc},
1758	n/a	{"QueryInfoKey", PyQueryInfoKey, METH_VARARGS, QueryInfoKey_doc},
1759	n/a	{"QueryReflectionKey",PyQueryReflectionKey,METH_VARARGS, QueryReflectionKey_doc},
1760	n/a	{"SaveKey", PySaveKey, METH_VARARGS, SaveKey_doc},
1761	n/a	{"SetValue", PySetValue, METH_VARARGS, SetValue_doc},
1762	n/a	{"SetValueEx", PySetValueEx, METH_VARARGS, SetValueEx_doc},
1763	n/a	NULL,
1764	n/a	};
1765	n/a
1766	n/a	static void
1767	n/a	insint(PyObject * d, char * name, long value)
1768	n/a	{
1769	n/a	PyObject *v = PyInt_FromLong(value);
1770	n/a	if (!v \|\| PyDict_SetItemString(d, name, v))
1771	n/a	PyErr_Clear();
1772	n/a	Py_XDECREF(v);
1773	n/a	}
1774	n/a
1775	n/a	#define ADD_INT(val) insint(d, #val, val)
1776	n/a
1777	n/a	static void
1778	n/a	inskey(PyObject * d, char * name, HKEY key)
1779	n/a	{
1780	n/a	PyObject *v = PyLong_FromVoidPtr(key);
1781	n/a	if (!v \|\| PyDict_SetItemString(d, name, v))
1782	n/a	PyErr_Clear();
1783	n/a	Py_XDECREF(v);
1784	n/a	}
1785	n/a
1786	n/a	#define ADD_KEY(val) inskey(d, #val, val)
1787	n/a
1788	n/a	PyMODINIT_FUNC init_winreg(void)
1789	n/a	{
1790	n/a	PyObject m, d;
1791	n/a	m = Py_InitModule3("_winreg", winreg_methods, module_doc);
1792	n/a	if (m == NULL)
1793	n/a	return;
1794	n/a	d = PyModule_GetDict(m);
1795	n/a	if (PyType_Ready(&PyHKEY_Type) < 0)
1796	n/a	return;
1797	n/a	PyHKEY_Type.tp_doc = PyHKEY_doc;
1798	n/a	Py_INCREF(&PyHKEY_Type);
1799	n/a	if (PyDict_SetItemString(d, "HKEYType",
1800	n/a	(PyObject *)&PyHKEY_Type) != 0)
1801	n/a	return;
1802	n/a	Py_INCREF(PyExc_WindowsError);
1803	n/a	if (PyDict_SetItemString(d, "error",
1804	n/a	PyExc_WindowsError) != 0)
1805	n/a	return;
1806	n/a
1807	n/a	/* Add the relevant constants */
1808	n/a	ADD_KEY(HKEY_CLASSES_ROOT);
1809	n/a	ADD_KEY(HKEY_CURRENT_USER);
1810	n/a	ADD_KEY(HKEY_LOCAL_MACHINE);
1811	n/a	ADD_KEY(HKEY_USERS);
1812	n/a	ADD_KEY(HKEY_PERFORMANCE_DATA);
1813	n/a	#ifdef HKEY_CURRENT_CONFIG
1814	n/a	ADD_KEY(HKEY_CURRENT_CONFIG);
1815	n/a	#endif
1816	n/a	#ifdef HKEY_DYN_DATA
1817	n/a	ADD_KEY(HKEY_DYN_DATA);
1818	n/a	#endif
1819	n/a	ADD_INT(KEY_QUERY_VALUE);
1820	n/a	ADD_INT(KEY_SET_VALUE);
1821	n/a	ADD_INT(KEY_CREATE_SUB_KEY);
1822	n/a	ADD_INT(KEY_ENUMERATE_SUB_KEYS);
1823	n/a	ADD_INT(KEY_NOTIFY);
1824	n/a	ADD_INT(KEY_CREATE_LINK);
1825	n/a	ADD_INT(KEY_READ);
1826	n/a	ADD_INT(KEY_WRITE);
1827	n/a	ADD_INT(KEY_EXECUTE);
1828	n/a	ADD_INT(KEY_ALL_ACCESS);
1829	n/a	#ifdef KEY_WOW64_64KEY
1830	n/a	ADD_INT(KEY_WOW64_64KEY);
1831	n/a	#endif
1832	n/a	#ifdef KEY_WOW64_32KEY
1833	n/a	ADD_INT(KEY_WOW64_32KEY);
1834	n/a	#endif
1835	n/a	ADD_INT(REG_OPTION_RESERVED);
1836	n/a	ADD_INT(REG_OPTION_NON_VOLATILE);
1837	n/a	ADD_INT(REG_OPTION_VOLATILE);
1838	n/a	ADD_INT(REG_OPTION_CREATE_LINK);
1839	n/a	ADD_INT(REG_OPTION_BACKUP_RESTORE);
1840	n/a	ADD_INT(REG_OPTION_OPEN_LINK);
1841	n/a	ADD_INT(REG_LEGAL_OPTION);
1842	n/a	ADD_INT(REG_CREATED_NEW_KEY);
1843	n/a	ADD_INT(REG_OPENED_EXISTING_KEY);
1844	n/a	ADD_INT(REG_WHOLE_HIVE_VOLATILE);
1845	n/a	ADD_INT(REG_REFRESH_HIVE);
1846	n/a	ADD_INT(REG_NO_LAZY_FLUSH);
1847	n/a	ADD_INT(REG_NOTIFY_CHANGE_NAME);
1848	n/a	ADD_INT(REG_NOTIFY_CHANGE_ATTRIBUTES);
1849	n/a	ADD_INT(REG_NOTIFY_CHANGE_LAST_SET);
1850	n/a	ADD_INT(REG_NOTIFY_CHANGE_SECURITY);
1851	n/a	ADD_INT(REG_LEGAL_CHANGE_FILTER);
1852	n/a	ADD_INT(REG_NONE);
1853	n/a	ADD_INT(REG_SZ);
1854	n/a	ADD_INT(REG_EXPAND_SZ);
1855	n/a	ADD_INT(REG_BINARY);
1856	n/a	ADD_INT(REG_DWORD);
1857	n/a	ADD_INT(REG_DWORD_LITTLE_ENDIAN);
1858	n/a	ADD_INT(REG_DWORD_BIG_ENDIAN);
1859	n/a	ADD_INT(REG_LINK);
1860	n/a	ADD_INT(REG_MULTI_SZ);
1861	n/a	ADD_INT(REG_RESOURCE_LIST);
1862	n/a	ADD_INT(REG_FULL_RESOURCE_DESCRIPTOR);
1863	n/a	ADD_INT(REG_RESOURCE_REQUIREMENTS_LIST);
1864	n/a	}
1865	n/a