blob: b39411a8ca910aa430ee6046ac7c803bdd46bf7c [file] [log] [blame]
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001/*
Fred Drake270e19b2000-06-29 16:14:14 +00002 _winreg.c
Guido van Rossum9f3712c2000-03-28 20:37:15 +00003
4 Windows Registry access module for Python.
5
6 * Simple registry access written by Mark Hammond in win32api
7 module circa 1995.
8 * Bill Tutt expanded the support significantly not long after.
9 * Numerous other people have submitted patches since then.
10 * Ripped from win32api module 03-Feb-2000 by Mark Hammond, and
11 basic Unicode support added.
12
13*/
14
15#include "windows.h"
16#include "Python.h"
17#include "structmember.h"
18#include "malloc.h" /* for alloca */
19
20static BOOL PyHKEY_AsHKEY(PyObject *ob, HKEY *pRes, BOOL bNoneOK);
21static PyObject *PyHKEY_FromHKEY(HKEY h);
22static BOOL PyHKEY_Close(PyObject *obHandle);
23
24static char errNotAHandle[] = "Object is not a handle";
25
26/* The win32api module reports the function name that failed,
27 but this concept is not in the Python core.
28 Hopefully it will one day, and in the meantime I dont
29 want to lose this info...
30*/
31#define PyErr_SetFromWindowsErrWithFunction(rc, fnname) \
32 PyErr_SetFromWindowsErr(rc)
33
34/* Forward declares */
35
36/* Doc strings */
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000037PyDoc_STRVAR(module_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +000038"This module provides access to the Windows registry API.\n"
39"\n"
40"Functions:\n"
41"\n"
42"CloseKey() - Closes a registry key.\n"
43"ConnectRegistry() - Establishes a connection to a predefined registry handle\n"
44" on another computer.\n"
45"CreateKey() - Creates the specified key, or opens it if it already exists.\n"
46"DeleteKey() - Deletes the specified key.\n"
47"DeleteValue() - Removes a named value from the specified registry key.\n"
48"EnumKey() - Enumerates subkeys of the specified open registry key.\n"
49"EnumValue() - Enumerates values of the specified open registry key.\n"
50"FlushKey() - Writes all the attributes of the specified key to the registry.\n"
51"LoadKey() - Creates a subkey under HKEY_USER or HKEY_LOCAL_MACHINE and stores\n"
52" registration information from a specified file into that subkey.\n"
53"OpenKey() - Alias for <om win32api.RegOpenKeyEx>\n"
54"OpenKeyEx() - Opens the specified key.\n"
55"QueryValue() - Retrieves the value associated with the unnamed value for a\n"
56" specified key in the registry.\n"
57"QueryValueEx() - Retrieves the type and data for a specified value name\n"
58" associated with an open registry key.\n"
59"QueryInfoKey() - Returns information about the specified key.\n"
60"SaveKey() - Saves the specified key, and all its subkeys a file.\n"
61"SetValue() - Associates a value with a specified key.\n"
62"SetValueEx() - Stores data in the value field of an open registry key.\n"
63"\n"
64"Special objects:\n"
65"\n"
66"HKEYType -- type object for HKEY objects\n"
67"error -- exception raised for Win32 errors\n"
68"\n"
69"Integer constants:\n"
70"Many constants are defined - see the documentation for each function\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000071"to see what constants are used, and where.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +000072
73
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000074PyDoc_STRVAR(CloseKey_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +000075"CloseKey(hkey) - Closes a previously opened registry key.\n"
76"\n"
77"The hkey argument specifies a previously opened key.\n"
78"\n"
79"Note that if the key is not closed using this method, it will be\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000080"closed when the hkey object is destroyed by Python.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +000081
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000082PyDoc_STRVAR(ConnectRegistry_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +000083"key = ConnectRegistry(computer_name, key) - "
84"Establishes a connection to a predefined registry handle on another computer.\n"
85"\n"
86"computer_name is the name of the remote computer, of the form \\\\computername.\n"
87" If None, the local computer is used.\n"
88"key is the predefined handle to connect to.\n"
89"\n"
90"The return value is the handle of the opened key.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000091"If the function fails, an EnvironmentError exception is raised.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +000092
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000093PyDoc_STRVAR(CreateKey_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +000094"key = CreateKey(key, sub_key) - Creates or opens the specified key.\n"
95"\n"
96"key is an already open key, or one of the predefined HKEY_* constants\n"
97"sub_key is a string that names the key this method opens or creates.\n"
98" If key is one of the predefined keys, sub_key may be None. In that case,\n"
99" the handle returned is the same key handle passed in to the function.\n"
100"\n"
101"If the key already exists, this function opens the existing key\n"
102"\n"
103"The return value is the handle of the opened key.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000104"If the function fails, an exception is raised.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000105
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000106PyDoc_STRVAR(DeleteKey_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000107"DeleteKey(key, sub_key) - Deletes the specified key.\n"
108"\n"
109"key is an already open key, or any one of the predefined HKEY_* constants.\n"
110"sub_key is a string that must be a subkey of the key identified by the key parameter.\n"
111" This value must not be None, and the key may not have subkeys.\n"
112"\n"
113"This method can not delete keys with subkeys.\n"
114"\n"
115"If the method succeeds, the entire key, including all of its values,\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000116"is removed. If the method fails, an EnvironmentError exception is raised.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000117
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000118PyDoc_STRVAR(DeleteValue_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000119"DeleteValue(key, value) - Removes a named value from a registry key.\n"
120"\n"
121"key is an already open key, or any one of the predefined HKEY_* constants.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000122"value is a string that identifies the value to remove.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000123
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000124PyDoc_STRVAR(EnumKey_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000125"string = EnumKey(key, index) - Enumerates subkeys of an open registry key.\n"
126"\n"
127"key is an already open key, or any one of the predefined HKEY_* constants.\n"
128"index is an integer that identifies the index of the key to retrieve.\n"
129"\n"
130"The function retrieves the name of one subkey each time it is called.\n"
Mark Hammondb422f952000-06-09 06:01:47 +0000131"It is typically called repeatedly until an EnvironmentError exception is\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000132"raised, indicating no more values are available.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000133
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000134PyDoc_STRVAR(EnumValue_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000135"tuple = EnumValue(key, index) - Enumerates values of an open registry key.\n"
136"key is an already open key, or any one of the predefined HKEY_* constants.\n"
137"index is an integer that identifies the index of the value to retrieve.\n"
138"\n"
139"The function retrieves the name of one subkey each time it is called.\n"
Mark Hammondb422f952000-06-09 06:01:47 +0000140"It is typically called repeatedly, until an EnvironmentError exception\n"
141"is raised, indicating no more values.\n"
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000142"\n"
143"The result is a tuple of 3 items:\n"
144"value_name is a string that identifies the value.\n"
145"value_data is an object that holds the value data, and whose type depends\n"
146" on the underlying registry type.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000147"data_type is an integer that identifies the type of the value data.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000148
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000149PyDoc_STRVAR(FlushKey_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000150"FlushKey(key) - Writes all the attributes of a key to the registry.\n"
151"\n"
152"key is an already open key, or any one of the predefined HKEY_* constants.\n"
153"\n"
154"It is not necessary to call RegFlushKey to change a key.\n"
155"Registry changes are flushed to disk by the registry using its lazy flusher.\n"
156"Registry changes are also flushed to disk at system shutdown.\n"
157"Unlike CloseKey(), the FlushKey() method returns only when all the data has\n"
158"been written to the registry.\n"
159"An application should only call FlushKey() if it requires absolute certainty that registry changes are on disk.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000160"If you don't know whether a FlushKey() call is required, it probably isn't.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000161
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000162PyDoc_STRVAR(LoadKey_doc,
Mark Hammondb422f952000-06-09 06:01:47 +0000163"LoadKey(key, sub_key, file_name) - Creates a subkey under the specified key\n"
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000164"and stores registration information from a specified file into that subkey.\n"
165"\n"
166"key is an already open key, or any one of the predefined HKEY_* constants.\n"
167"sub_key is a string that identifies the sub_key to load\n"
168"file_name is the name of the file to load registry data from.\n"
169" This file must have been created with the SaveKey() function.\n"
170" Under the file allocation table (FAT) file system, the filename may not\n"
171"have an extension.\n"
172"\n"
173"A call to LoadKey() fails if the calling process does not have the\n"
174"SE_RESTORE_PRIVILEGE privilege.\n"
175"\n"
176"If key is a handle returned by ConnectRegistry(), then the path specified\n"
177"in fileName is relative to the remote computer.\n"
178"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000179"The docs imply key must be in the HKEY_USER or HKEY_LOCAL_MACHINE tree");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000180
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000181PyDoc_STRVAR(OpenKey_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000182"key = OpenKey(key, sub_key, res = 0, sam = KEY_READ) - Opens the specified key.\n"
183"\n"
184"key is an already open key, or any one of the predefined HKEY_* constants.\n"
185"sub_key is a string that identifies the sub_key to open\n"
186"res is a reserved integer, and must be zero. Default is zero.\n"
187"sam is an integer that specifies an access mask that describes the desired\n"
188" security access for the key. Default is KEY_READ\n"
189"\n"
190"The result is a new handle to the specified key\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000191"If the function fails, an EnvironmentError exception is raised.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000192
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000193PyDoc_STRVAR(OpenKeyEx_doc, "See OpenKey()");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000194
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000195PyDoc_STRVAR(QueryInfoKey_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000196"tuple = QueryInfoKey(key) - Returns information about a key.\n"
197"\n"
198"key is an already open key, or any one of the predefined HKEY_* constants.\n"
199"\n"
200"The result is a tuple of 3 items:"
201"An integer that identifies the number of sub keys this key has.\n"
202"An integer that identifies the number of values this key has.\n"
203"A long integer that identifies when the key was last modified (if available)\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000204" as 100's of nanoseconds since Jan 1, 1600.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000205
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000206PyDoc_STRVAR(QueryValue_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000207"string = QueryValue(key, sub_key) - retrieves the unnamed value for a key.\n"
208"\n"
209"key is an already open key, or any one of the predefined HKEY_* constants.\n"
Mark Hammondb422f952000-06-09 06:01:47 +0000210"sub_key is a string that holds the name of the subkey with which the value\n"
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000211" is associated. If this parameter is None or empty, the function retrieves\n"
212" the value set by the SetValue() method for the key identified by key."
213"\n"
214"Values in the registry have name, type, and data components. This method\n"
215"retrieves the data for a key's first value that has a NULL name.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000216"But the underlying API call doesn't return the type, Lame Lame Lame, DONT USE THIS!!!");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000217
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000218PyDoc_STRVAR(QueryValueEx_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000219"value,type_id = QueryValueEx(key, value_name) - Retrieves the type and data for a specified value name associated with an open registry key.\n"
220"\n"
221"key is an already open key, or any one of the predefined HKEY_* constants.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000222"value_name is a string indicating the value to query");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000223
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000224PyDoc_STRVAR(SaveKey_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000225"SaveKey(key, file_name) - Saves the specified key, and all its subkeys to the specified file.\n"
226"\n"
227"key is an already open key, or any one of the predefined HKEY_* constants.\n"
228"file_name is the name of the file to save registry data to.\n"
229" This file cannot already exist. If this filename includes an extension,\n"
230" it cannot be used on file allocation table (FAT) file systems by the\n"
231" LoadKey(), ReplaceKey() or RestoreKey() methods.\n"
232"\n"
233"If key represents a key on a remote computer, the path described by\n"
234"file_name is relative to the remote computer.\n"
235"The caller of this method must possess the SeBackupPrivilege security privilege.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000236"This function passes NULL for security_attributes to the API.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000237
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000238PyDoc_STRVAR(SetValue_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000239"SetValue(key, sub_key, type, value) - Associates a value with a specified key.\n"
240"\n"
241"key is an already open key, or any one of the predefined HKEY_* constants.\n"
242"sub_key is a string that names the subkey with which the value is associated.\n"
243"type is an integer that specifies the type of the data. Currently this\n"
244" must be REG_SZ, meaning only strings are supported.\n"
245"value is a string that specifies the new value.\n"
246"\n"
247"If the key specified by the sub_key parameter does not exist, the SetValue\n"
248"function creates it.\n"
249"\n"
250"Value lengths are limited by available memory. Long values (more than\n"
251"2048 bytes) should be stored as files with the filenames stored in \n"
252"the configuration registry. This helps the registry perform efficiently.\n"
253"\n"
254"The key identified by the key parameter must have been opened with\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000255"KEY_SET_VALUE access.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000256
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000257PyDoc_STRVAR(SetValueEx_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000258"SetValueEx(key, value_name, reserved, type, value) - Stores data in the value field of an open registry key.\n"
259"\n"
260"key is an already open key, or any one of the predefined HKEY_* constants.\n"
Mark Hammondc9083b62003-01-15 23:38:15 +0000261"value_name is a string containing the name of the value to set, or None\n"
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000262"type is an integer that specifies the type of the data. This should be one of:\n"
263" REG_BINARY -- Binary data in any form.\n"
264" REG_DWORD -- A 32-bit number.\n"
265" REG_DWORD_LITTLE_ENDIAN -- A 32-bit number in little-endian format.\n"
266" REG_DWORD_BIG_ENDIAN -- A 32-bit number in big-endian format.\n"
267" REG_EXPAND_SZ -- A null-terminated string that contains unexpanded references\n"
268" to environment variables (for example, %PATH%).\n"
269" REG_LINK -- A Unicode symbolic link.\n"
Mark Hammondb422f952000-06-09 06:01:47 +0000270" REG_MULTI_SZ -- An sequence of null-terminated strings, terminated by\n"
271" two null characters. Note that Python handles this\n"
272" termination automatically.\n"
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000273" REG_NONE -- No defined value type.\n"
274" REG_RESOURCE_LIST -- A device-driver resource list.\n"
275" REG_SZ -- A null-terminated string.\n"
276"reserved can be anything - zero is always passed to the API.\n"
277"value is a string that specifies the new value.\n"
278"\n"
279"This method can also set additional value and type information for the\n"
280"specified key. The key identified by the key parameter must have been\n"
281"opened with KEY_SET_VALUE access.\n"
282"\n"
283"To open the key, use the CreateKeyEx() or OpenKeyEx() methods.\n"
284"\n"
285"Value lengths are limited by available memory. Long values (more than\n"
286"2048 bytes) should be stored as files with the filenames stored in \n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000287"the configuration registry. This helps the registry perform efficiently.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000288
289/* PyHKEY docstrings */
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000290PyDoc_STRVAR(PyHKEY_doc,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000291"PyHKEY Object - A Python object, representing a win32 registry key.\n"
292"\n"
Mark Hammondb422f952000-06-09 06:01:47 +0000293"This object wraps a Windows HKEY object, automatically closing it when\n"
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000294"the object is destroyed. To guarantee cleanup, you can call either\n"
295"the Close() method on the PyHKEY, or the CloseKey() method.\n"
296"\n"
297"All functions which accept a handle object also accept an integer - \n"
298"however, use of the handle object is encouraged.\n"
299"\n"
300"Functions:\n"
301"Close() - Closes the underlying handle.\n"
302"Detach() - Returns the integer Win32 handle, detaching it from the object\n"
303"\n"
304"Properties:\n"
305"handle - The integer Win32 handle.\n"
306"\n"
307"Operations:\n"
308"__nonzero__ - Handles with an open object return true, otherwise false.\n"
309"__int__ - Converting a handle to an integer returns the Win32 handle.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000310"__cmp__ - Handle objects are compared using the handle value.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000311
312
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000313PyDoc_STRVAR(PyHKEY_Close_doc,
Mark Hammondb422f952000-06-09 06:01:47 +0000314"key.Close() - Closes the underlying Windows handle.\n"
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000315"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000316"If the handle is already closed, no error is raised.");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000317
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000318PyDoc_STRVAR(PyHKEY_Detach_doc,
Mark Hammondb422f952000-06-09 06:01:47 +0000319"int = key.Detach() - Detaches the Windows handle from the handle object.\n"
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000320"\n"
321"The result is the value of the handle before it is detached. If the\n"
322"handle is already detached, this will return zero.\n"
323"\n"
324"After calling this function, the handle is effectively invalidated,\n"
325"but the handle is not closed. You would call this function when you\n"
326"need the underlying win32 handle to exist beyond the lifetime of the\n"
Mark Hammondb422f952000-06-09 06:01:47 +0000327"handle object.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000328"On 64 bit windows, the result of this function is a long integer");
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000329
330
331/************************************************************************
332
333 The PyHKEY object definition
334
335************************************************************************/
336typedef struct {
337 PyObject_VAR_HEAD
338 HKEY hkey;
339} PyHKEYObject;
340
341#define PyHKEY_Check(op) ((op)->ob_type == &PyHKEY_Type)
342
343static char *failMsg = "bad operand type";
344
345static PyObject *
346PyHKEY_unaryFailureFunc(PyObject *ob)
347{
348 PyErr_SetString(PyExc_TypeError, failMsg);
349 return NULL;
350}
351static PyObject *
352PyHKEY_binaryFailureFunc(PyObject *ob1, PyObject *ob2)
353{
354 PyErr_SetString(PyExc_TypeError, failMsg);
355 return NULL;
356}
357static PyObject *
358PyHKEY_ternaryFailureFunc(PyObject *ob1, PyObject *ob2, PyObject *ob3)
359{
360 PyErr_SetString(PyExc_TypeError, failMsg);
361 return NULL;
362}
363
364static void
365PyHKEY_deallocFunc(PyObject *ob)
366{
367 /* Can not call PyHKEY_Close, as the ob->tp_type
368 has already been cleared, thus causing the type
369 check to fail!
370 */
371 PyHKEYObject *obkey = (PyHKEYObject *)ob;
372 if (obkey->hkey)
373 RegCloseKey((HKEY)obkey->hkey);
Guido van Rossumb18618d2000-05-03 23:44:39 +0000374 PyObject_DEL(ob);
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000375}
376
377static int
378PyHKEY_nonzeroFunc(PyObject *ob)
379{
380 return ((PyHKEYObject *)ob)->hkey != 0;
381}
382
383static PyObject *
384PyHKEY_intFunc(PyObject *ob)
385{
386 PyHKEYObject *pyhkey = (PyHKEYObject *)ob;
387 return PyLong_FromVoidPtr(pyhkey->hkey);
388}
389
390static int
391PyHKEY_printFunc(PyObject *ob, FILE *fp, int flags)
392{
393 PyHKEYObject *pyhkey = (PyHKEYObject *)ob;
394 char resBuf[160];
395 wsprintf(resBuf, "<PyHKEY at %p (%p)>",
396 ob, pyhkey->hkey);
397 fputs(resBuf, fp);
398 return 0;
399}
400
401static PyObject *
402PyHKEY_strFunc(PyObject *ob)
403{
404 PyHKEYObject *pyhkey = (PyHKEYObject *)ob;
405 char resBuf[160];
406 wsprintf(resBuf, "<PyHKEY:%p>", pyhkey->hkey);
407 return PyString_FromString(resBuf);
408}
409
410static int
411PyHKEY_compareFunc(PyObject *ob1, PyObject *ob2)
412{
413 PyHKEYObject *pyhkey1 = (PyHKEYObject *)ob1;
414 PyHKEYObject *pyhkey2 = (PyHKEYObject *)ob2;
415 return pyhkey1 == pyhkey2 ? 0 :
416 (pyhkey1 < pyhkey2 ? -1 : 1);
417}
418
419static long
420PyHKEY_hashFunc(PyObject *ob)
421{
422 /* Just use the address.
423 XXX - should we use the handle value?
424 */
Fred Drake13634cf2000-06-29 19:17:04 +0000425 return _Py_HashPointer(ob);
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000426}
427
428
429static PyNumberMethods PyHKEY_NumberMethods =
430{
431 PyHKEY_binaryFailureFunc, /* nb_add */
432 PyHKEY_binaryFailureFunc, /* nb_subtract */
433 PyHKEY_binaryFailureFunc, /* nb_multiply */
434 PyHKEY_binaryFailureFunc, /* nb_divide */
435 PyHKEY_binaryFailureFunc, /* nb_remainder */
436 PyHKEY_binaryFailureFunc, /* nb_divmod */
437 PyHKEY_ternaryFailureFunc, /* nb_power */
438 PyHKEY_unaryFailureFunc, /* nb_negative */
439 PyHKEY_unaryFailureFunc, /* nb_positive */
440 PyHKEY_unaryFailureFunc, /* nb_absolute */
441 PyHKEY_nonzeroFunc, /* nb_nonzero */
442 PyHKEY_unaryFailureFunc, /* nb_invert */
443 PyHKEY_binaryFailureFunc, /* nb_lshift */
444 PyHKEY_binaryFailureFunc, /* nb_rshift */
445 PyHKEY_binaryFailureFunc, /* nb_and */
446 PyHKEY_binaryFailureFunc, /* nb_xor */
447 PyHKEY_binaryFailureFunc, /* nb_or */
448 0, /* nb_coerce (allowed to be zero) */
449 PyHKEY_intFunc, /* nb_int */
450 PyHKEY_unaryFailureFunc, /* nb_long */
451 PyHKEY_unaryFailureFunc, /* nb_float */
452 PyHKEY_unaryFailureFunc, /* nb_oct */
453 PyHKEY_unaryFailureFunc, /* nb_hex */
454};
455
456
457/* fwd declare __getattr__ */
Tim Petersc3d12ac2005-12-24 06:03:06 +0000458static PyObject *PyHKEY_getattr(PyObject *self, const char *name);
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000459
460/* The type itself */
461PyTypeObject PyHKEY_Type =
462{
463 PyObject_HEAD_INIT(0) /* fill in type at module init */
464 0,
465 "PyHKEY",
466 sizeof(PyHKEYObject),
467 0,
468 PyHKEY_deallocFunc, /* tp_dealloc */
469 PyHKEY_printFunc, /* tp_print */
470 PyHKEY_getattr, /* tp_getattr */
471 0, /* tp_setattr */
472 PyHKEY_compareFunc, /* tp_compare */
473 0, /* tp_repr */
474 &PyHKEY_NumberMethods, /* tp_as_number */
475 0, /* tp_as_sequence */
476 0, /* tp_as_mapping */
477 PyHKEY_hashFunc, /* tp_hash */
478 0, /* tp_call */
479 PyHKEY_strFunc, /* tp_str */
480 0, /* tp_getattro */
481 0, /* tp_setattro */
482 0, /* tp_as_buffer */
483 0, /* tp_flags */
484 PyHKEY_doc, /* tp_doc */
485};
486
487#define OFF(e) offsetof(PyHKEYObject, e)
488
489static struct memberlist PyHKEY_memberlist[] = {
490 {"handle", T_INT, OFF(hkey)},
491 {NULL} /* Sentinel */
492};
493
494/************************************************************************
495
496 The PyHKEY object methods
497
498************************************************************************/
499static PyObject *
500PyHKEY_CloseMethod(PyObject *self, PyObject *args)
501{
502 if (!PyArg_ParseTuple(args, ":Close"))
503 return NULL;
504 if (!PyHKEY_Close(self))
505 return NULL;
506 Py_INCREF(Py_None);
507 return Py_None;
508}
509
510static PyObject *
511PyHKEY_DetachMethod(PyObject *self, PyObject *args)
512{
513 void* ret;
514 PyHKEYObject *pThis = (PyHKEYObject *)self;
515 if (!PyArg_ParseTuple(args, ":Detach"))
516 return NULL;
517 ret = (void*)pThis->hkey;
518 pThis->hkey = 0;
519 return PyLong_FromVoidPtr(ret);
520}
521
522static struct PyMethodDef PyHKEY_methods[] = {
Neal Norwitz031829d2002-03-31 14:37:44 +0000523 {"Close", PyHKEY_CloseMethod, METH_VARARGS, PyHKEY_Close_doc},
524 {"Detach", PyHKEY_DetachMethod, METH_VARARGS, PyHKEY_Detach_doc},
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000525 {NULL}
526};
527
528/*static*/ PyObject *
Tim Petersc3d12ac2005-12-24 06:03:06 +0000529PyHKEY_getattr(PyObject *self, const char *name)
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000530{
531 PyObject *res;
532
533 res = Py_FindMethod(PyHKEY_methods, self, name);
534 if (res != NULL)
535 return res;
536 PyErr_Clear();
537 if (strcmp(name, "handle") == 0)
538 return PyLong_FromVoidPtr(((PyHKEYObject *)self)->hkey);
539 return PyMember_Get((char *)self, PyHKEY_memberlist, name);
540}
541
542/************************************************************************
543 The public PyHKEY API (well, not public yet :-)
544************************************************************************/
545PyObject *
546PyHKEY_New(HKEY hInit)
547{
548 PyHKEYObject *key = PyObject_NEW(PyHKEYObject, &PyHKEY_Type);
549 if (key)
550 key->hkey = hInit;
551 return (PyObject *)key;
552}
553
554BOOL
555PyHKEY_Close(PyObject *ob_handle)
556{
557 LONG rc;
558 PyHKEYObject *key;
559
560 if (!PyHKEY_Check(ob_handle)) {
561 PyErr_SetString(PyExc_TypeError, "bad operand type");
562 return FALSE;
563 }
564 key = (PyHKEYObject *)ob_handle;
565 rc = key->hkey ? RegCloseKey((HKEY)key->hkey) : ERROR_SUCCESS;
566 key->hkey = 0;
567 if (rc != ERROR_SUCCESS)
568 PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");
569 return rc == ERROR_SUCCESS;
570}
571
572BOOL
573PyHKEY_AsHKEY(PyObject *ob, HKEY *pHANDLE, BOOL bNoneOK)
574{
575 if (ob == Py_None) {
576 if (!bNoneOK) {
577 PyErr_SetString(
578 PyExc_TypeError,
579 "None is not a valid HKEY in this context");
580 return FALSE;
581 }
582 *pHANDLE = (HKEY)0;
583 }
584 else if (PyHKEY_Check(ob)) {
585 PyHKEYObject *pH = (PyHKEYObject *)ob;
586 *pHANDLE = pH->hkey;
587 }
588 else if (PyInt_Check(ob) || PyLong_Check(ob)) {
589 /* We also support integers */
590 PyErr_Clear();
591 *pHANDLE = (HKEY)PyLong_AsVoidPtr(ob);
592 if (PyErr_Occurred())
593 return FALSE;
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000594 }
595 else {
596 PyErr_SetString(
597 PyExc_TypeError,
598 "The object is not a PyHKEY object");
599 return FALSE;
600 }
601 return TRUE;
602}
603
604PyObject *
605PyHKEY_FromHKEY(HKEY h)
606{
Guido van Rossumb18618d2000-05-03 23:44:39 +0000607 PyHKEYObject *op;
608
Guido van Rossume3a8e7e2002-08-19 19:26:42 +0000609 /* Inline PyObject_New */
Guido van Rossumb18618d2000-05-03 23:44:39 +0000610 op = (PyHKEYObject *) PyObject_MALLOC(sizeof(PyHKEYObject));
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000611 if (op == NULL)
612 return PyErr_NoMemory();
Guido van Rossumb18618d2000-05-03 23:44:39 +0000613 PyObject_INIT(op, &PyHKEY_Type);
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000614 op->hkey = h;
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000615 return (PyObject *)op;
616}
617
618
619/************************************************************************
620 The module methods
621************************************************************************/
622BOOL
623PyWinObject_CloseHKEY(PyObject *obHandle)
624{
625 BOOL ok;
626 if (PyHKEY_Check(obHandle)) {
627 ok = PyHKEY_Close(obHandle);
628 }
Fred Drake25e17262000-06-30 17:48:51 +0000629#if SIZEOF_LONG >= SIZEOF_HKEY
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000630 else if (PyInt_Check(obHandle)) {
631 long rc = RegCloseKey((HKEY)PyInt_AsLong(obHandle));
632 ok = (rc == ERROR_SUCCESS);
633 if (!ok)
634 PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");
635 }
Fred Drake25e17262000-06-30 17:48:51 +0000636#else
637 else if (PyLong_Check(obHandle)) {
638 long rc = RegCloseKey((HKEY)PyLong_AsVoidPtr(obHandle));
639 ok = (rc == ERROR_SUCCESS);
640 if (!ok)
641 PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");
642 }
643#endif
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000644 else {
645 PyErr_SetString(
646 PyExc_TypeError,
647 "A handle must be a HKEY object or an integer");
648 return FALSE;
649 }
650 return ok;
651}
652
653
654/*
655 Private Helper functions for the registry interfaces
656
657** Note that fixupMultiSZ and countString have both had changes
658** made to support "incorrect strings". The registry specification
659** calls for strings to be terminated with 2 null bytes. It seems
Thomas Wouters7e474022000-07-16 12:04:32 +0000660** some commercial packages install strings which dont conform,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000661** causing this code to fail - however, "regedit" etc still work
662** with these strings (ie only we dont!).
663*/
664static void
665fixupMultiSZ(char **str, char *data, int len)
666{
667 char *P;
668 int i;
669 char *Q;
670
671 Q = data + len;
672 for (P = data, i = 0; P < Q && *P != '\0'; P++, i++) {
673 str[i] = P;
674 for(; *P != '\0'; P++)
675 ;
676 }
677}
678
679static int
680countStrings(char *data, int len)
681{
682 int strings;
683 char *P;
684 char *Q = data + len;
685
686 for (P = data, strings = 0; P < Q && *P != '\0'; P++, strings++)
687 for (; P < Q && *P != '\0'; P++)
688 ;
689 return strings;
690}
691
692/* Convert PyObject into Registry data.
693 Allocates space as needed. */
694static BOOL
695Py2Reg(PyObject *value, DWORD typ, BYTE **retDataBuf, DWORD *retDataSize)
696{
697 int i,j;
698 switch (typ) {
699 case REG_DWORD:
700 if (value != Py_None && !PyInt_Check(value))
701 return FALSE;
702 *retDataBuf = (BYTE *)PyMem_NEW(DWORD, sizeof(DWORD));
703 if (*retDataBuf==NULL){
704 PyErr_NoMemory();
705 return FALSE;
706 }
707 *retDataSize = sizeof(DWORD);
708 if (value == Py_None) {
709 DWORD zero = 0;
710 memcpy(*retDataBuf, &zero, sizeof(DWORD));
711 }
712 else
713 memcpy(*retDataBuf,
714 &PyInt_AS_LONG((PyIntObject *)value),
715 sizeof(DWORD));
716 break;
717 case REG_SZ:
718 case REG_EXPAND_SZ:
719 {
720 int need_decref = 0;
721 if (value == Py_None)
722 *retDataSize = 1;
723 else {
724 if (PyUnicode_Check(value)) {
725 value = PyUnicode_AsEncodedString(
726 value,
727 "mbcs",
728 NULL);
729 if (value==NULL)
730 return FALSE;
731 need_decref = 1;
732 }
733 if (!PyString_Check(value))
734 return FALSE;
735 *retDataSize = 1 + strlen(
736 PyString_AS_STRING(
737 (PyStringObject *)value));
738 }
739 *retDataBuf = (BYTE *)PyMem_NEW(DWORD, *retDataSize);
740 if (*retDataBuf==NULL){
741 PyErr_NoMemory();
742 return FALSE;
743 }
744 if (value == Py_None)
745 strcpy((char *)*retDataBuf, "");
746 else
747 strcpy((char *)*retDataBuf,
748 PyString_AS_STRING(
749 (PyStringObject *)value));
750 if (need_decref)
751 Py_DECREF(value);
752 break;
753 }
754 case REG_MULTI_SZ:
755 {
756 DWORD size = 0;
757 char *P;
758 PyObject **obs = NULL;
759
760 if (value == Py_None)
761 i = 0;
762 else {
763 if (!PyList_Check(value))
764 return FALSE;
765 i = PyList_Size(value);
766 }
767 obs = malloc(sizeof(PyObject *) * i);
768 memset(obs, 0, sizeof(PyObject *) * i);
769 for (j = 0; j < i; j++)
770 {
771 PyObject *t;
772 t = PyList_GET_ITEM(
773 (PyListObject *)value,j);
774 if (PyString_Check(t)) {
775 obs[j] = t;
776 Py_INCREF(t);
777 } else if (PyUnicode_Check(t)) {
778 obs[j] = PyUnicode_AsEncodedString(
779 t,
780 "mbcs",
781 NULL);
782 if (obs[j]==NULL)
783 goto reg_multi_fail;
784 } else
785 goto reg_multi_fail;
786 size += 1 + strlen(
787 PyString_AS_STRING(
788 (PyStringObject *)obs[j]));
789 }
790
791 *retDataSize = size + 1;
792 *retDataBuf = (BYTE *)PyMem_NEW(char,
793 *retDataSize);
794 if (*retDataBuf==NULL){
795 PyErr_NoMemory();
796 goto reg_multi_fail;
797 }
798 P = (char *)*retDataBuf;
799
800 for (j = 0; j < i; j++)
801 {
802 PyObject *t;
803 t = obs[j];
804 strcpy(P,
805 PyString_AS_STRING(
806 (PyStringObject *)t));
807 P += 1 + strlen(
808 PyString_AS_STRING(
809 (PyStringObject *)t));
810 Py_DECREF(obs[j]);
811 }
812 /* And doubly-terminate the list... */
813 *P = '\0';
814 free(obs);
815 break;
816 reg_multi_fail:
817 if (obs) {
818 for (j = 0; j < i; j++)
819 Py_XDECREF(obs[j]);
820
821 free(obs);
822 }
823 return FALSE;
824 }
825 case REG_BINARY:
826 /* ALSO handle ALL unknown data types here. Even if we can't
827 support it natively, we should handle the bits. */
828 default:
829 if (value == Py_None)
830 *retDataSize = 0;
831 else {
Mark Hammond4e80bb52000-07-28 03:44:41 +0000832 void *src_buf;
833 PyBufferProcs *pb = value->ob_type->tp_as_buffer;
834 if (pb==NULL) {
Tim Peters313fcd42006-02-19 04:05:39 +0000835 PyErr_Format(PyExc_TypeError,
Mark Hammond4e80bb52000-07-28 03:44:41 +0000836 "Objects of type '%s' can not "
Tim Peters313fcd42006-02-19 04:05:39 +0000837 "be used as binary registry values",
Mark Hammond4e80bb52000-07-28 03:44:41 +0000838 value->ob_type->tp_name);
839 return FALSE;
840 }
841 *retDataSize = (*pb->bf_getreadbuffer)(value, 0, &src_buf);
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000842 *retDataBuf = (BYTE *)PyMem_NEW(char,
843 *retDataSize);
844 if (*retDataBuf==NULL){
845 PyErr_NoMemory();
846 return FALSE;
847 }
Mark Hammond4e80bb52000-07-28 03:44:41 +0000848 memcpy(*retDataBuf, src_buf, *retDataSize);
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000849 }
850 break;
851 }
852 return TRUE;
853}
854
855/* Convert Registry data into PyObject*/
856static PyObject *
857Reg2Py(char *retDataBuf, DWORD retDataSize, DWORD typ)
858{
859 PyObject *obData;
860
861 switch (typ) {
862 case REG_DWORD:
863 if (retDataSize == 0)
864 obData = Py_BuildValue("i", 0);
865 else
866 obData = Py_BuildValue("i",
867 *(int *)retDataBuf);
868 break;
869 case REG_SZ:
870 case REG_EXPAND_SZ:
871 /* retDataBuf may or may not have a trailing NULL in
872 the buffer. */
873 if (retDataSize && retDataBuf[retDataSize-1] == '\0')
874 --retDataSize;
875 if (retDataSize ==0)
876 retDataBuf = "";
877 obData = PyUnicode_DecodeMBCS(retDataBuf,
878 retDataSize,
879 NULL);
880 break;
881 case REG_MULTI_SZ:
882 if (retDataSize == 0)
883 obData = PyList_New(0);
884 else
885 {
886 int index = 0;
887 int s = countStrings(retDataBuf, retDataSize);
888 char **str = (char **)malloc(sizeof(char *)*s);
889 if (str == NULL)
890 return PyErr_NoMemory();
891
892 fixupMultiSZ(str, retDataBuf, retDataSize);
893 obData = PyList_New(s);
Fred Drake25e17262000-06-30 17:48:51 +0000894 if (obData == NULL)
895 return NULL;
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000896 for (index = 0; index < s; index++)
897 {
Fred Drake25e17262000-06-30 17:48:51 +0000898 size_t len = _mbstrlen(str[index]);
899 if (len > INT_MAX) {
900 PyErr_SetString(PyExc_OverflowError,
901 "registry string is too long for a Python string");
902 Py_DECREF(obData);
903 return NULL;
904 }
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000905 PyList_SetItem(obData,
906 index,
907 PyUnicode_DecodeMBCS(
908 (const char *)str[index],
Fred Drake25e17262000-06-30 17:48:51 +0000909 (int)len,
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000910 NULL)
911 );
912 }
913 free(str);
914
915 break;
916 }
917 case REG_BINARY:
918 /* ALSO handle ALL unknown data types here. Even if we can't
919 support it natively, we should handle the bits. */
920 default:
921 if (retDataSize == 0) {
922 Py_INCREF(Py_None);
923 obData = Py_None;
924 }
925 else
926 obData = Py_BuildValue("s#",
927 (char *)retDataBuf,
928 retDataSize);
929 break;
930 }
931 if (obData == NULL)
932 return NULL;
933 else
934 return obData;
935}
936
937/* The Python methods */
938
939static PyObject *
940PyCloseKey(PyObject *self, PyObject *args)
941{
942 PyObject *obKey;
943 if (!PyArg_ParseTuple(args, "O:CloseKey", &obKey))
944 return NULL;
945 if (!PyHKEY_Close(obKey))
946 return NULL;
947 Py_INCREF(Py_None);
948 return Py_None;
949}
950
951static PyObject *
952PyConnectRegistry(PyObject *self, PyObject *args)
953{
954 HKEY hKey;
955 PyObject *obKey;
956 char *szCompName = NULL;
957 HKEY retKey;
958 long rc;
959 if (!PyArg_ParseTuple(args, "zO:ConnectRegistry", &szCompName, &obKey))
960 return NULL;
961 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
962 return NULL;
Martin v. Löwisbda0dde2006-07-24 10:26:33 +0000963 Py_BEGIN_ALLOW_THREADS
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000964 rc = RegConnectRegistry(szCompName, hKey, &retKey);
Martin v. Löwisbda0dde2006-07-24 10:26:33 +0000965 Py_END_ALLOW_THREADS
Guido van Rossum9f3712c2000-03-28 20:37:15 +0000966 if (rc != ERROR_SUCCESS)
967 return PyErr_SetFromWindowsErrWithFunction(rc,
968 "ConnectRegistry");
969 return PyHKEY_FromHKEY(retKey);
970}
971
972static PyObject *
973PyCreateKey(PyObject *self, PyObject *args)
974{
975 HKEY hKey;
976 PyObject *obKey;
977 char *subKey;
978 HKEY retKey;
979 long rc;
980 if (!PyArg_ParseTuple(args, "Oz:CreateKey", &obKey, &subKey))
981 return NULL;
982 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
983 return NULL;
984 rc = RegCreateKey(hKey, subKey, &retKey);
985 if (rc != ERROR_SUCCESS)
986 return PyErr_SetFromWindowsErrWithFunction(rc, "CreateKey");
987 return PyHKEY_FromHKEY(retKey);
988}
989
990static PyObject *
991PyDeleteKey(PyObject *self, PyObject *args)
992{
993 HKEY hKey;
994 PyObject *obKey;
995 char *subKey;
996 long rc;
997 if (!PyArg_ParseTuple(args, "Os:DeleteKey", &obKey, &subKey))
998 return NULL;
999 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1000 return NULL;
1001 rc = RegDeleteKey(hKey, subKey );
1002 if (rc != ERROR_SUCCESS)
1003 return PyErr_SetFromWindowsErrWithFunction(rc, "RegDeleteKey");
1004 Py_INCREF(Py_None);
1005 return Py_None;
1006}
1007
1008static PyObject *
1009PyDeleteValue(PyObject *self, PyObject *args)
1010{
1011 HKEY hKey;
1012 PyObject *obKey;
1013 char *subKey;
1014 long rc;
1015 if (!PyArg_ParseTuple(args, "Oz:DeleteValue", &obKey, &subKey))
1016 return NULL;
1017 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1018 return NULL;
1019 Py_BEGIN_ALLOW_THREADS
1020 rc = RegDeleteValue(hKey, subKey);
1021 Py_END_ALLOW_THREADS
1022 if (rc !=ERROR_SUCCESS)
1023 return PyErr_SetFromWindowsErrWithFunction(rc,
1024 "RegDeleteValue");
1025 Py_INCREF(Py_None);
1026 return Py_None;
1027}
1028
1029static PyObject *
1030PyEnumKey(PyObject *self, PyObject *args)
1031{
1032 HKEY hKey;
1033 PyObject *obKey;
1034 int index;
1035 long rc;
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001036 PyObject *retStr;
Georg Brandl9a928e72006-02-18 23:35:11 +00001037 char tmpbuf[256]; /* max key name length is 255 */
Georg Brandlb2699b22006-02-18 23:44:24 +00001038 DWORD len = sizeof(tmpbuf); /* includes NULL terminator */
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001039
1040 if (!PyArg_ParseTuple(args, "Oi:EnumKey", &obKey, &index))
1041 return NULL;
1042 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1043 return NULL;
Tim Peters313fcd42006-02-19 04:05:39 +00001044
Georg Brandl9a928e72006-02-18 23:35:11 +00001045 Py_BEGIN_ALLOW_THREADS
1046 rc = RegEnumKeyEx(hKey, index, tmpbuf, &len, NULL, NULL, NULL, NULL);
1047 Py_END_ALLOW_THREADS
1048 if (rc != ERROR_SUCCESS)
1049 return PyErr_SetFromWindowsErrWithFunction(rc, "RegEnumKeyEx");
Tim Peters313fcd42006-02-19 04:05:39 +00001050
Georg Brandl9a928e72006-02-18 23:35:11 +00001051 retStr = PyString_FromStringAndSize(tmpbuf, len);
1052 return retStr; /* can be NULL */
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001053}
1054
1055static PyObject *
1056PyEnumValue(PyObject *self, PyObject *args)
1057{
1058 HKEY hKey;
1059 PyObject *obKey;
1060 int index;
1061 long rc;
1062 char *retValueBuf;
1063 char *retDataBuf;
1064 DWORD retValueSize;
1065 DWORD retDataSize;
1066 DWORD typ;
1067 PyObject *obData;
1068 PyObject *retVal;
1069
1070 if (!PyArg_ParseTuple(args, "Oi:EnumValue", &obKey, &index))
1071 return NULL;
1072 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1073 return NULL;
1074
1075 if ((rc = RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL,
1076 NULL,
1077 &retValueSize, &retDataSize, NULL, NULL))
1078 != ERROR_SUCCESS)
1079 return PyErr_SetFromWindowsErrWithFunction(rc,
1080 "RegQueryInfoKey");
1081 ++retValueSize; /* include null terminators */
1082 ++retDataSize;
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001083 retValueBuf = (char *)PyMem_Malloc(retValueSize);
1084 if (retValueBuf == NULL)
1085 return PyErr_NoMemory();
1086 retDataBuf = (char *)PyMem_Malloc(retDataSize);
1087 if (retDataBuf == NULL) {
1088 PyMem_Free(retValueBuf);
1089 return PyErr_NoMemory();
1090 }
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001091
1092 Py_BEGIN_ALLOW_THREADS
1093 rc = RegEnumValue(hKey,
1094 index,
1095 retValueBuf,
1096 &retValueSize,
1097 NULL,
1098 &typ,
1099 (BYTE *)retDataBuf,
1100 &retDataSize);
1101 Py_END_ALLOW_THREADS
1102
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001103 if (rc != ERROR_SUCCESS) {
1104 retVal = PyErr_SetFromWindowsErrWithFunction(rc,
1105 "PyRegEnumValue");
1106 goto fail;
1107 }
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001108 obData = Reg2Py(retDataBuf, retDataSize, typ);
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001109 if (obData == NULL) {
1110 retVal = NULL;
1111 goto fail;
1112 }
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001113 retVal = Py_BuildValue("sOi", retValueBuf, obData, typ);
1114 Py_DECREF(obData);
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001115 fail:
1116 PyMem_Free(retValueBuf);
1117 PyMem_Free(retDataBuf);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001118 return retVal;
1119}
1120
1121static PyObject *
1122PyFlushKey(PyObject *self, PyObject *args)
1123{
1124 HKEY hKey;
1125 PyObject *obKey;
1126 long rc;
1127 if (!PyArg_ParseTuple(args, "O:FlushKey", &obKey))
1128 return NULL;
1129 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1130 return NULL;
1131 Py_BEGIN_ALLOW_THREADS
1132 rc = RegFlushKey(hKey);
1133 Py_END_ALLOW_THREADS
1134 if (rc != ERROR_SUCCESS)
1135 return PyErr_SetFromWindowsErrWithFunction(rc, "RegFlushKey");
1136 Py_INCREF(Py_None);
1137 return Py_None;
1138}
1139static PyObject *
1140PyLoadKey(PyObject *self, PyObject *args)
1141{
1142 HKEY hKey;
1143 PyObject *obKey;
1144 char *subKey;
1145 char *fileName;
1146
1147 long rc;
1148 if (!PyArg_ParseTuple(args, "Oss:LoadKey", &obKey, &subKey, &fileName))
1149 return NULL;
1150 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1151 return NULL;
1152 Py_BEGIN_ALLOW_THREADS
1153 rc = RegLoadKey(hKey, subKey, fileName );
1154 Py_END_ALLOW_THREADS
1155 if (rc != ERROR_SUCCESS)
1156 return PyErr_SetFromWindowsErrWithFunction(rc, "RegLoadKey");
1157 Py_INCREF(Py_None);
1158 return Py_None;
1159}
1160
1161static PyObject *
1162PyOpenKey(PyObject *self, PyObject *args)
1163{
1164 HKEY hKey;
1165 PyObject *obKey;
1166
1167 char *subKey;
1168 int res = 0;
1169 HKEY retKey;
1170 long rc;
1171 REGSAM sam = KEY_READ;
1172 if (!PyArg_ParseTuple(args, "Oz|ii:OpenKey", &obKey, &subKey,
1173 &res, &sam))
1174 return NULL;
1175 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1176 return NULL;
1177
1178 Py_BEGIN_ALLOW_THREADS
1179 rc = RegOpenKeyEx(hKey, subKey, res, sam, &retKey);
1180 Py_END_ALLOW_THREADS
1181 if (rc != ERROR_SUCCESS)
1182 return PyErr_SetFromWindowsErrWithFunction(rc, "RegOpenKeyEx");
1183 return PyHKEY_FromHKEY(retKey);
1184}
1185
1186
1187static PyObject *
1188PyQueryInfoKey(PyObject *self, PyObject *args)
1189{
1190 HKEY hKey;
1191 PyObject *obKey;
1192 long rc;
1193 DWORD nSubKeys, nValues;
1194 FILETIME ft;
1195 LARGE_INTEGER li;
1196 PyObject *l;
1197 PyObject *ret;
1198 if (!PyArg_ParseTuple(args, "O:QueryInfoKey", &obKey))
1199 return NULL;
1200 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1201 return NULL;
1202 if ((rc = RegQueryInfoKey(hKey, NULL, NULL, 0, &nSubKeys, NULL, NULL,
1203 &nValues, NULL, NULL, NULL, &ft))
1204 != ERROR_SUCCESS)
1205 return PyErr_SetFromWindowsErrWithFunction(rc, "RegQueryInfoKey");
1206 li.LowPart = ft.dwLowDateTime;
1207 li.HighPart = ft.dwHighDateTime;
1208 l = PyLong_FromLongLong(li.QuadPart);
1209 if (l == NULL)
1210 return NULL;
1211 ret = Py_BuildValue("iiO", nSubKeys, nValues, l);
1212 Py_DECREF(l);
1213 return ret;
1214}
1215
1216static PyObject *
1217PyQueryValue(PyObject *self, PyObject *args)
1218{
1219 HKEY hKey;
1220 PyObject *obKey;
1221 char *subKey;
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001222 long rc;
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001223 PyObject *retStr;
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001224 char *retBuf;
1225 long bufSize = 0;
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001226
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001227 if (!PyArg_ParseTuple(args, "Oz:QueryValue", &obKey, &subKey))
1228 return NULL;
1229
1230 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1231 return NULL;
1232 if ((rc = RegQueryValue(hKey, subKey, NULL, &bufSize))
1233 != ERROR_SUCCESS)
1234 return PyErr_SetFromWindowsErrWithFunction(rc,
1235 "RegQueryValue");
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001236 retStr = PyString_FromStringAndSize(NULL, bufSize);
1237 if (retStr == NULL)
1238 return NULL;
1239 retBuf = PyString_AS_STRING(retStr);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001240 if ((rc = RegQueryValue(hKey, subKey, retBuf, &bufSize))
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001241 != ERROR_SUCCESS) {
1242 Py_DECREF(retStr);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001243 return PyErr_SetFromWindowsErrWithFunction(rc,
1244 "RegQueryValue");
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001245 }
1246 _PyString_Resize(&retStr, strlen(retBuf));
1247 return retStr;
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001248}
1249
1250static PyObject *
1251PyQueryValueEx(PyObject *self, PyObject *args)
1252{
1253 HKEY hKey;
1254 PyObject *obKey;
1255 char *valueName;
1256
1257 long rc;
1258 char *retBuf;
1259 DWORD bufSize = 0;
1260 DWORD typ;
1261 PyObject *obData;
1262 PyObject *result;
1263
1264 if (!PyArg_ParseTuple(args, "Oz:QueryValueEx", &obKey, &valueName))
1265 return NULL;
1266
1267 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1268 return NULL;
1269 if ((rc = RegQueryValueEx(hKey, valueName,
1270 NULL, NULL, NULL,
1271 &bufSize))
1272 != ERROR_SUCCESS)
1273 return PyErr_SetFromWindowsErrWithFunction(rc,
1274 "RegQueryValueEx");
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001275 retBuf = (char *)PyMem_Malloc(bufSize);
1276 if (retBuf == NULL)
1277 return PyErr_NoMemory();
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001278 if ((rc = RegQueryValueEx(hKey, valueName, NULL,
1279 &typ, (BYTE *)retBuf, &bufSize))
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001280 != ERROR_SUCCESS) {
1281 PyMem_Free(retBuf);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001282 return PyErr_SetFromWindowsErrWithFunction(rc,
1283 "RegQueryValueEx");
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001284 }
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001285 obData = Reg2Py(retBuf, bufSize, typ);
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001286 PyMem_Free((void *)retBuf);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001287 if (obData == NULL)
1288 return NULL;
1289 result = Py_BuildValue("Oi", obData, typ);
1290 Py_DECREF(obData);
1291 return result;
1292}
1293
1294
1295static PyObject *
1296PySaveKey(PyObject *self, PyObject *args)
1297{
1298 HKEY hKey;
1299 PyObject *obKey;
1300 char *fileName;
1301 LPSECURITY_ATTRIBUTES pSA = NULL;
1302
1303 long rc;
1304 if (!PyArg_ParseTuple(args, "Os:SaveKey", &obKey, &fileName))
1305 return NULL;
1306 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1307 return NULL;
1308/* One day we may get security into the core?
1309 if (!PyWinObject_AsSECURITY_ATTRIBUTES(obSA, &pSA, TRUE))
1310 return NULL;
1311*/
1312 Py_BEGIN_ALLOW_THREADS
1313 rc = RegSaveKey(hKey, fileName, pSA );
1314 Py_END_ALLOW_THREADS
1315 if (rc != ERROR_SUCCESS)
1316 return PyErr_SetFromWindowsErrWithFunction(rc, "RegSaveKey");
1317 Py_INCREF(Py_None);
1318 return Py_None;
1319}
1320
1321static PyObject *
1322PySetValue(PyObject *self, PyObject *args)
1323{
1324 HKEY hKey;
1325 PyObject *obKey;
1326 char *subKey;
1327 char *str;
1328 DWORD typ;
1329 DWORD len;
1330 long rc;
1331 PyObject *obStrVal;
1332 PyObject *obSubKey;
1333 if (!PyArg_ParseTuple(args, "OOiO:SetValue",
1334 &obKey,
1335 &obSubKey,
1336 &typ,
1337 &obStrVal))
1338 return NULL;
1339 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1340 return NULL;
1341 if (typ != REG_SZ) {
1342 PyErr_SetString(PyExc_TypeError,
Thomas Hellere1d18f52002-12-20 20:13:35 +00001343 "Type must be _winreg.REG_SZ");
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001344 return NULL;
1345 }
1346 /* XXX - need Unicode support */
1347 str = PyString_AsString(obStrVal);
1348 if (str == NULL)
1349 return NULL;
1350 len = PyString_Size(obStrVal);
1351 if (obSubKey == Py_None)
1352 subKey = NULL;
1353 else {
1354 subKey = PyString_AsString(obSubKey);
1355 if (subKey == NULL)
1356 return NULL;
1357 }
1358 Py_BEGIN_ALLOW_THREADS
1359 rc = RegSetValue(hKey, subKey, REG_SZ, str, len+1);
1360 Py_END_ALLOW_THREADS
1361 if (rc != ERROR_SUCCESS)
1362 return PyErr_SetFromWindowsErrWithFunction(rc, "RegSetValue");
1363 Py_INCREF(Py_None);
1364 return Py_None;
1365}
1366
1367static PyObject *
1368PySetValueEx(PyObject *self, PyObject *args)
1369{
1370 HKEY hKey;
1371 PyObject *obKey;
1372 char *valueName;
1373 PyObject *obRes;
1374 PyObject *value;
1375 BYTE *data;
1376 DWORD len;
1377 DWORD typ;
1378
1379 LONG rc;
1380
1381 if (!PyArg_ParseTuple(args, "OzOiO:SetValueEx",
1382 &obKey,
1383 &valueName,
1384 &obRes,
1385 &typ,
1386 &value))
1387 return NULL;
1388 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1389 return NULL;
1390 if (!Py2Reg(value, typ, &data, &len))
1391 {
1392 if (!PyErr_Occurred())
1393 PyErr_SetString(PyExc_ValueError,
1394 "Could not convert the data to the specified type.");
1395 return NULL;
1396 }
1397 Py_BEGIN_ALLOW_THREADS
1398 rc = RegSetValueEx(hKey, valueName, 0, typ, data, len);
1399 Py_END_ALLOW_THREADS
Guido van Rossumb18618d2000-05-03 23:44:39 +00001400 PyMem_DEL(data);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001401 if (rc != ERROR_SUCCESS)
1402 return PyErr_SetFromWindowsErrWithFunction(rc,
1403 "RegSetValueEx");
1404 Py_INCREF(Py_None);
1405 return Py_None;
1406}
1407
1408static struct PyMethodDef winreg_methods[] = {
Neal Norwitz031829d2002-03-31 14:37:44 +00001409 {"CloseKey", PyCloseKey, METH_VARARGS, CloseKey_doc},
1410 {"ConnectRegistry", PyConnectRegistry, METH_VARARGS, ConnectRegistry_doc},
1411 {"CreateKey", PyCreateKey, METH_VARARGS, CreateKey_doc},
1412 {"DeleteKey", PyDeleteKey, METH_VARARGS, DeleteKey_doc},
1413 {"DeleteValue", PyDeleteValue, METH_VARARGS, DeleteValue_doc},
1414 {"EnumKey", PyEnumKey, METH_VARARGS, EnumKey_doc},
1415 {"EnumValue", PyEnumValue, METH_VARARGS, EnumValue_doc},
1416 {"FlushKey", PyFlushKey, METH_VARARGS, FlushKey_doc},
1417 {"LoadKey", PyLoadKey, METH_VARARGS, LoadKey_doc},
1418 {"OpenKey", PyOpenKey, METH_VARARGS, OpenKey_doc},
1419 {"OpenKeyEx", PyOpenKey, METH_VARARGS, OpenKeyEx_doc},
1420 {"QueryValue", PyQueryValue, METH_VARARGS, QueryValue_doc},
1421 {"QueryValueEx", PyQueryValueEx, METH_VARARGS, QueryValueEx_doc},
1422 {"QueryInfoKey", PyQueryInfoKey, METH_VARARGS, QueryInfoKey_doc},
1423 {"SaveKey", PySaveKey, METH_VARARGS, SaveKey_doc},
1424 {"SetValue", PySetValue, METH_VARARGS, SetValue_doc},
1425 {"SetValueEx", PySetValueEx, METH_VARARGS, SetValueEx_doc},
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001426 NULL,
1427};
1428
1429static void
1430insint(PyObject * d, char * name, long value)
1431{
1432 PyObject *v = PyInt_FromLong(value);
1433 if (!v || PyDict_SetItemString(d, name, v))
1434 PyErr_Clear();
1435 Py_XDECREF(v);
1436}
1437
1438#define ADD_INT(val) insint(d, #val, val)
1439
1440static void
1441inskey(PyObject * d, char * name, HKEY key)
1442{
1443 PyObject *v = PyLong_FromVoidPtr(key);
1444 if (!v || PyDict_SetItemString(d, name, v))
1445 PyErr_Clear();
1446 Py_XDECREF(v);
1447}
1448
1449#define ADD_KEY(val) inskey(d, #val, val)
1450
Mark Hammond8235ea12002-07-19 06:55:41 +00001451PyMODINIT_FUNC init_winreg(void)
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001452{
1453 PyObject *m, *d;
Fred Drake270e19b2000-06-29 16:14:14 +00001454 m = Py_InitModule3("_winreg", winreg_methods, module_doc);
Neal Norwitz1ac754f2006-01-19 06:09:39 +00001455 if (m == NULL)
1456 return;
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001457 d = PyModule_GetDict(m);
1458 PyHKEY_Type.ob_type = &PyType_Type;
1459 PyHKEY_Type.tp_doc = PyHKEY_doc;
1460 Py_INCREF(&PyHKEY_Type);
1461 if (PyDict_SetItemString(d, "HKEYType",
1462 (PyObject *)&PyHKEY_Type) != 0)
1463 return;
1464 Py_INCREF(PyExc_WindowsError);
1465 if (PyDict_SetItemString(d, "error",
1466 PyExc_WindowsError) != 0)
1467 return;
1468
1469 /* Add the relevant constants */
1470 ADD_KEY(HKEY_CLASSES_ROOT);
1471 ADD_KEY(HKEY_CURRENT_USER);
1472 ADD_KEY(HKEY_LOCAL_MACHINE);
1473 ADD_KEY(HKEY_USERS);
1474 ADD_KEY(HKEY_PERFORMANCE_DATA);
1475#ifdef HKEY_CURRENT_CONFIG
1476 ADD_KEY(HKEY_CURRENT_CONFIG);
1477#endif
1478#ifdef HKEY_DYN_DATA
1479 ADD_KEY(HKEY_DYN_DATA);
1480#endif
1481 ADD_INT(KEY_QUERY_VALUE);
1482 ADD_INT(KEY_SET_VALUE);
1483 ADD_INT(KEY_CREATE_SUB_KEY);
1484 ADD_INT(KEY_ENUMERATE_SUB_KEYS);
1485 ADD_INT(KEY_NOTIFY);
1486 ADD_INT(KEY_CREATE_LINK);
1487 ADD_INT(KEY_READ);
1488 ADD_INT(KEY_WRITE);
1489 ADD_INT(KEY_EXECUTE);
1490 ADD_INT(KEY_ALL_ACCESS);
1491 ADD_INT(REG_OPTION_RESERVED);
1492 ADD_INT(REG_OPTION_NON_VOLATILE);
1493 ADD_INT(REG_OPTION_VOLATILE);
1494 ADD_INT(REG_OPTION_CREATE_LINK);
1495 ADD_INT(REG_OPTION_BACKUP_RESTORE);
1496 ADD_INT(REG_OPTION_OPEN_LINK);
1497 ADD_INT(REG_LEGAL_OPTION);
1498 ADD_INT(REG_CREATED_NEW_KEY);
1499 ADD_INT(REG_OPENED_EXISTING_KEY);
1500 ADD_INT(REG_WHOLE_HIVE_VOLATILE);
1501 ADD_INT(REG_REFRESH_HIVE);
1502 ADD_INT(REG_NO_LAZY_FLUSH);
1503 ADD_INT(REG_NOTIFY_CHANGE_NAME);
1504 ADD_INT(REG_NOTIFY_CHANGE_ATTRIBUTES);
1505 ADD_INT(REG_NOTIFY_CHANGE_LAST_SET);
1506 ADD_INT(REG_NOTIFY_CHANGE_SECURITY);
1507 ADD_INT(REG_LEGAL_CHANGE_FILTER);
1508 ADD_INT(REG_NONE);
1509 ADD_INT(REG_SZ);
1510 ADD_INT(REG_EXPAND_SZ);
1511 ADD_INT(REG_BINARY);
1512 ADD_INT(REG_DWORD);
1513 ADD_INT(REG_DWORD_LITTLE_ENDIAN);
1514 ADD_INT(REG_DWORD_BIG_ENDIAN);
1515 ADD_INT(REG_LINK);
1516 ADD_INT(REG_MULTI_SZ);
1517 ADD_INT(REG_RESOURCE_LIST);
1518 ADD_INT(REG_FULL_RESOURCE_DESCRIPTOR);
1519 ADD_INT(REG_RESOURCE_REQUIREMENTS_LIST);
1520}
1521