blob: a20b09a4ee038ce0ce426e5ce100d8cd02ffbd3e [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__ */
458static PyObject *PyHKEY_getattr(PyObject *self, char *name);
459
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 *
529PyHKEY_getattr(PyObject *self, char *name)
530{
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) {
835 PyErr_Format(PyExc_TypeError,
836 "Objects of type '%s' can not "
837 "be used as binary registry values",
838 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;
963 rc = RegConnectRegistry(szCompName, hKey, &retKey);
964 if (rc != ERROR_SUCCESS)
965 return PyErr_SetFromWindowsErrWithFunction(rc,
966 "ConnectRegistry");
967 return PyHKEY_FromHKEY(retKey);
968}
969
970static PyObject *
971PyCreateKey(PyObject *self, PyObject *args)
972{
973 HKEY hKey;
974 PyObject *obKey;
975 char *subKey;
976 HKEY retKey;
977 long rc;
978 if (!PyArg_ParseTuple(args, "Oz:CreateKey", &obKey, &subKey))
979 return NULL;
980 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
981 return NULL;
982 rc = RegCreateKey(hKey, subKey, &retKey);
983 if (rc != ERROR_SUCCESS)
984 return PyErr_SetFromWindowsErrWithFunction(rc, "CreateKey");
985 return PyHKEY_FromHKEY(retKey);
986}
987
988static PyObject *
989PyDeleteKey(PyObject *self, PyObject *args)
990{
991 HKEY hKey;
992 PyObject *obKey;
993 char *subKey;
994 long rc;
995 if (!PyArg_ParseTuple(args, "Os:DeleteKey", &obKey, &subKey))
996 return NULL;
997 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
998 return NULL;
999 rc = RegDeleteKey(hKey, subKey );
1000 if (rc != ERROR_SUCCESS)
1001 return PyErr_SetFromWindowsErrWithFunction(rc, "RegDeleteKey");
1002 Py_INCREF(Py_None);
1003 return Py_None;
1004}
1005
1006static PyObject *
1007PyDeleteValue(PyObject *self, PyObject *args)
1008{
1009 HKEY hKey;
1010 PyObject *obKey;
1011 char *subKey;
1012 long rc;
1013 if (!PyArg_ParseTuple(args, "Oz:DeleteValue", &obKey, &subKey))
1014 return NULL;
1015 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1016 return NULL;
1017 Py_BEGIN_ALLOW_THREADS
1018 rc = RegDeleteValue(hKey, subKey);
1019 Py_END_ALLOW_THREADS
1020 if (rc !=ERROR_SUCCESS)
1021 return PyErr_SetFromWindowsErrWithFunction(rc,
1022 "RegDeleteValue");
1023 Py_INCREF(Py_None);
1024 return Py_None;
1025}
1026
1027static PyObject *
1028PyEnumKey(PyObject *self, PyObject *args)
1029{
1030 HKEY hKey;
1031 PyObject *obKey;
1032 int index;
1033 long rc;
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001034 PyObject *retStr;
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001035 char *retBuf;
1036 DWORD len;
1037
1038 if (!PyArg_ParseTuple(args, "Oi:EnumKey", &obKey, &index))
1039 return NULL;
1040 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1041 return NULL;
1042
1043 if ((rc = RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, &len,
1044 NULL, NULL, NULL, NULL, NULL, NULL))
1045 != ERROR_SUCCESS)
1046 return PyErr_SetFromWindowsErrWithFunction(rc,
1047 "RegQueryInfoKey");
1048 ++len; /* include null terminator */
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001049 retStr = PyString_FromStringAndSize(NULL, len);
1050 if (retStr == NULL)
1051 return NULL;
1052 retBuf = PyString_AS_STRING(retStr);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001053
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001054 if ((rc = RegEnumKey(hKey, index, retBuf, len)) != ERROR_SUCCESS) {
1055 Py_DECREF(retStr);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001056 return PyErr_SetFromWindowsErrWithFunction(rc, "RegEnumKey");
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001057 }
1058 _PyString_Resize(&retStr, strlen(retBuf));
1059 return retStr;
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001060}
1061
1062static PyObject *
1063PyEnumValue(PyObject *self, PyObject *args)
1064{
1065 HKEY hKey;
1066 PyObject *obKey;
1067 int index;
1068 long rc;
1069 char *retValueBuf;
1070 char *retDataBuf;
1071 DWORD retValueSize;
1072 DWORD retDataSize;
1073 DWORD typ;
1074 PyObject *obData;
1075 PyObject *retVal;
1076
1077 if (!PyArg_ParseTuple(args, "Oi:EnumValue", &obKey, &index))
1078 return NULL;
1079 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1080 return NULL;
1081
1082 if ((rc = RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL,
1083 NULL,
1084 &retValueSize, &retDataSize, NULL, NULL))
1085 != ERROR_SUCCESS)
1086 return PyErr_SetFromWindowsErrWithFunction(rc,
1087 "RegQueryInfoKey");
1088 ++retValueSize; /* include null terminators */
1089 ++retDataSize;
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001090 retValueBuf = (char *)PyMem_Malloc(retValueSize);
1091 if (retValueBuf == NULL)
1092 return PyErr_NoMemory();
1093 retDataBuf = (char *)PyMem_Malloc(retDataSize);
1094 if (retDataBuf == NULL) {
1095 PyMem_Free(retValueBuf);
1096 return PyErr_NoMemory();
1097 }
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001098
1099 Py_BEGIN_ALLOW_THREADS
1100 rc = RegEnumValue(hKey,
1101 index,
1102 retValueBuf,
1103 &retValueSize,
1104 NULL,
1105 &typ,
1106 (BYTE *)retDataBuf,
1107 &retDataSize);
1108 Py_END_ALLOW_THREADS
1109
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001110 if (rc != ERROR_SUCCESS) {
1111 retVal = PyErr_SetFromWindowsErrWithFunction(rc,
1112 "PyRegEnumValue");
1113 goto fail;
1114 }
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001115 obData = Reg2Py(retDataBuf, retDataSize, typ);
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001116 if (obData == NULL) {
1117 retVal = NULL;
1118 goto fail;
1119 }
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001120 retVal = Py_BuildValue("sOi", retValueBuf, obData, typ);
1121 Py_DECREF(obData);
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001122 fail:
1123 PyMem_Free(retValueBuf);
1124 PyMem_Free(retDataBuf);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001125 return retVal;
1126}
1127
1128static PyObject *
1129PyFlushKey(PyObject *self, PyObject *args)
1130{
1131 HKEY hKey;
1132 PyObject *obKey;
1133 long rc;
1134 if (!PyArg_ParseTuple(args, "O:FlushKey", &obKey))
1135 return NULL;
1136 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1137 return NULL;
1138 Py_BEGIN_ALLOW_THREADS
1139 rc = RegFlushKey(hKey);
1140 Py_END_ALLOW_THREADS
1141 if (rc != ERROR_SUCCESS)
1142 return PyErr_SetFromWindowsErrWithFunction(rc, "RegFlushKey");
1143 Py_INCREF(Py_None);
1144 return Py_None;
1145}
1146static PyObject *
1147PyLoadKey(PyObject *self, PyObject *args)
1148{
1149 HKEY hKey;
1150 PyObject *obKey;
1151 char *subKey;
1152 char *fileName;
1153
1154 long rc;
1155 if (!PyArg_ParseTuple(args, "Oss:LoadKey", &obKey, &subKey, &fileName))
1156 return NULL;
1157 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1158 return NULL;
1159 Py_BEGIN_ALLOW_THREADS
1160 rc = RegLoadKey(hKey, subKey, fileName );
1161 Py_END_ALLOW_THREADS
1162 if (rc != ERROR_SUCCESS)
1163 return PyErr_SetFromWindowsErrWithFunction(rc, "RegLoadKey");
1164 Py_INCREF(Py_None);
1165 return Py_None;
1166}
1167
1168static PyObject *
1169PyOpenKey(PyObject *self, PyObject *args)
1170{
1171 HKEY hKey;
1172 PyObject *obKey;
1173
1174 char *subKey;
1175 int res = 0;
1176 HKEY retKey;
1177 long rc;
1178 REGSAM sam = KEY_READ;
1179 if (!PyArg_ParseTuple(args, "Oz|ii:OpenKey", &obKey, &subKey,
1180 &res, &sam))
1181 return NULL;
1182 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1183 return NULL;
1184
1185 Py_BEGIN_ALLOW_THREADS
1186 rc = RegOpenKeyEx(hKey, subKey, res, sam, &retKey);
1187 Py_END_ALLOW_THREADS
1188 if (rc != ERROR_SUCCESS)
1189 return PyErr_SetFromWindowsErrWithFunction(rc, "RegOpenKeyEx");
1190 return PyHKEY_FromHKEY(retKey);
1191}
1192
1193
1194static PyObject *
1195PyQueryInfoKey(PyObject *self, PyObject *args)
1196{
1197 HKEY hKey;
1198 PyObject *obKey;
1199 long rc;
1200 DWORD nSubKeys, nValues;
1201 FILETIME ft;
1202 LARGE_INTEGER li;
1203 PyObject *l;
1204 PyObject *ret;
1205 if (!PyArg_ParseTuple(args, "O:QueryInfoKey", &obKey))
1206 return NULL;
1207 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1208 return NULL;
1209 if ((rc = RegQueryInfoKey(hKey, NULL, NULL, 0, &nSubKeys, NULL, NULL,
1210 &nValues, NULL, NULL, NULL, &ft))
1211 != ERROR_SUCCESS)
1212 return PyErr_SetFromWindowsErrWithFunction(rc, "RegQueryInfoKey");
1213 li.LowPart = ft.dwLowDateTime;
1214 li.HighPart = ft.dwHighDateTime;
1215 l = PyLong_FromLongLong(li.QuadPart);
1216 if (l == NULL)
1217 return NULL;
1218 ret = Py_BuildValue("iiO", nSubKeys, nValues, l);
1219 Py_DECREF(l);
1220 return ret;
1221}
1222
1223static PyObject *
1224PyQueryValue(PyObject *self, PyObject *args)
1225{
1226 HKEY hKey;
1227 PyObject *obKey;
1228 char *subKey;
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001229 long rc;
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001230 PyObject *retStr;
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001231 char *retBuf;
1232 long bufSize = 0;
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001233
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001234 if (!PyArg_ParseTuple(args, "Oz:QueryValue", &obKey, &subKey))
1235 return NULL;
1236
1237 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1238 return NULL;
1239 if ((rc = RegQueryValue(hKey, subKey, NULL, &bufSize))
1240 != ERROR_SUCCESS)
1241 return PyErr_SetFromWindowsErrWithFunction(rc,
1242 "RegQueryValue");
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001243 retStr = PyString_FromStringAndSize(NULL, bufSize);
1244 if (retStr == NULL)
1245 return NULL;
1246 retBuf = PyString_AS_STRING(retStr);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001247 if ((rc = RegQueryValue(hKey, subKey, retBuf, &bufSize))
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001248 != ERROR_SUCCESS) {
1249 Py_DECREF(retStr);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001250 return PyErr_SetFromWindowsErrWithFunction(rc,
1251 "RegQueryValue");
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001252 }
1253 _PyString_Resize(&retStr, strlen(retBuf));
1254 return retStr;
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001255}
1256
1257static PyObject *
1258PyQueryValueEx(PyObject *self, PyObject *args)
1259{
1260 HKEY hKey;
1261 PyObject *obKey;
1262 char *valueName;
1263
1264 long rc;
1265 char *retBuf;
1266 DWORD bufSize = 0;
1267 DWORD typ;
1268 PyObject *obData;
1269 PyObject *result;
1270
1271 if (!PyArg_ParseTuple(args, "Oz:QueryValueEx", &obKey, &valueName))
1272 return NULL;
1273
1274 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1275 return NULL;
1276 if ((rc = RegQueryValueEx(hKey, valueName,
1277 NULL, NULL, NULL,
1278 &bufSize))
1279 != ERROR_SUCCESS)
1280 return PyErr_SetFromWindowsErrWithFunction(rc,
1281 "RegQueryValueEx");
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001282 retBuf = (char *)PyMem_Malloc(bufSize);
1283 if (retBuf == NULL)
1284 return PyErr_NoMemory();
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001285 if ((rc = RegQueryValueEx(hKey, valueName, NULL,
1286 &typ, (BYTE *)retBuf, &bufSize))
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001287 != ERROR_SUCCESS) {
1288 PyMem_Free(retBuf);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001289 return PyErr_SetFromWindowsErrWithFunction(rc,
1290 "RegQueryValueEx");
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001291 }
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001292 obData = Reg2Py(retBuf, bufSize, typ);
Guido van Rossuma6a38ad2003-11-30 22:01:43 +00001293 PyMem_Free((void *)retBuf);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001294 if (obData == NULL)
1295 return NULL;
1296 result = Py_BuildValue("Oi", obData, typ);
1297 Py_DECREF(obData);
1298 return result;
1299}
1300
1301
1302static PyObject *
1303PySaveKey(PyObject *self, PyObject *args)
1304{
1305 HKEY hKey;
1306 PyObject *obKey;
1307 char *fileName;
1308 LPSECURITY_ATTRIBUTES pSA = NULL;
1309
1310 long rc;
1311 if (!PyArg_ParseTuple(args, "Os:SaveKey", &obKey, &fileName))
1312 return NULL;
1313 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1314 return NULL;
1315/* One day we may get security into the core?
1316 if (!PyWinObject_AsSECURITY_ATTRIBUTES(obSA, &pSA, TRUE))
1317 return NULL;
1318*/
1319 Py_BEGIN_ALLOW_THREADS
1320 rc = RegSaveKey(hKey, fileName, pSA );
1321 Py_END_ALLOW_THREADS
1322 if (rc != ERROR_SUCCESS)
1323 return PyErr_SetFromWindowsErrWithFunction(rc, "RegSaveKey");
1324 Py_INCREF(Py_None);
1325 return Py_None;
1326}
1327
1328static PyObject *
1329PySetValue(PyObject *self, PyObject *args)
1330{
1331 HKEY hKey;
1332 PyObject *obKey;
1333 char *subKey;
1334 char *str;
1335 DWORD typ;
1336 DWORD len;
1337 long rc;
1338 PyObject *obStrVal;
1339 PyObject *obSubKey;
1340 if (!PyArg_ParseTuple(args, "OOiO:SetValue",
1341 &obKey,
1342 &obSubKey,
1343 &typ,
1344 &obStrVal))
1345 return NULL;
1346 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1347 return NULL;
1348 if (typ != REG_SZ) {
1349 PyErr_SetString(PyExc_TypeError,
Thomas Hellere1d18f52002-12-20 20:13:35 +00001350 "Type must be _winreg.REG_SZ");
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001351 return NULL;
1352 }
1353 /* XXX - need Unicode support */
1354 str = PyString_AsString(obStrVal);
1355 if (str == NULL)
1356 return NULL;
1357 len = PyString_Size(obStrVal);
1358 if (obSubKey == Py_None)
1359 subKey = NULL;
1360 else {
1361 subKey = PyString_AsString(obSubKey);
1362 if (subKey == NULL)
1363 return NULL;
1364 }
1365 Py_BEGIN_ALLOW_THREADS
1366 rc = RegSetValue(hKey, subKey, REG_SZ, str, len+1);
1367 Py_END_ALLOW_THREADS
1368 if (rc != ERROR_SUCCESS)
1369 return PyErr_SetFromWindowsErrWithFunction(rc, "RegSetValue");
1370 Py_INCREF(Py_None);
1371 return Py_None;
1372}
1373
1374static PyObject *
1375PySetValueEx(PyObject *self, PyObject *args)
1376{
1377 HKEY hKey;
1378 PyObject *obKey;
1379 char *valueName;
1380 PyObject *obRes;
1381 PyObject *value;
1382 BYTE *data;
1383 DWORD len;
1384 DWORD typ;
1385
1386 LONG rc;
1387
1388 if (!PyArg_ParseTuple(args, "OzOiO:SetValueEx",
1389 &obKey,
1390 &valueName,
1391 &obRes,
1392 &typ,
1393 &value))
1394 return NULL;
1395 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1396 return NULL;
1397 if (!Py2Reg(value, typ, &data, &len))
1398 {
1399 if (!PyErr_Occurred())
1400 PyErr_SetString(PyExc_ValueError,
1401 "Could not convert the data to the specified type.");
1402 return NULL;
1403 }
1404 Py_BEGIN_ALLOW_THREADS
1405 rc = RegSetValueEx(hKey, valueName, 0, typ, data, len);
1406 Py_END_ALLOW_THREADS
Guido van Rossumb18618d2000-05-03 23:44:39 +00001407 PyMem_DEL(data);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001408 if (rc != ERROR_SUCCESS)
1409 return PyErr_SetFromWindowsErrWithFunction(rc,
1410 "RegSetValueEx");
1411 Py_INCREF(Py_None);
1412 return Py_None;
1413}
1414
1415static struct PyMethodDef winreg_methods[] = {
Neal Norwitz031829d2002-03-31 14:37:44 +00001416 {"CloseKey", PyCloseKey, METH_VARARGS, CloseKey_doc},
1417 {"ConnectRegistry", PyConnectRegistry, METH_VARARGS, ConnectRegistry_doc},
1418 {"CreateKey", PyCreateKey, METH_VARARGS, CreateKey_doc},
1419 {"DeleteKey", PyDeleteKey, METH_VARARGS, DeleteKey_doc},
1420 {"DeleteValue", PyDeleteValue, METH_VARARGS, DeleteValue_doc},
1421 {"EnumKey", PyEnumKey, METH_VARARGS, EnumKey_doc},
1422 {"EnumValue", PyEnumValue, METH_VARARGS, EnumValue_doc},
1423 {"FlushKey", PyFlushKey, METH_VARARGS, FlushKey_doc},
1424 {"LoadKey", PyLoadKey, METH_VARARGS, LoadKey_doc},
1425 {"OpenKey", PyOpenKey, METH_VARARGS, OpenKey_doc},
1426 {"OpenKeyEx", PyOpenKey, METH_VARARGS, OpenKeyEx_doc},
1427 {"QueryValue", PyQueryValue, METH_VARARGS, QueryValue_doc},
1428 {"QueryValueEx", PyQueryValueEx, METH_VARARGS, QueryValueEx_doc},
1429 {"QueryInfoKey", PyQueryInfoKey, METH_VARARGS, QueryInfoKey_doc},
1430 {"SaveKey", PySaveKey, METH_VARARGS, SaveKey_doc},
1431 {"SetValue", PySetValue, METH_VARARGS, SetValue_doc},
1432 {"SetValueEx", PySetValueEx, METH_VARARGS, SetValueEx_doc},
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001433 NULL,
1434};
1435
1436static void
1437insint(PyObject * d, char * name, long value)
1438{
1439 PyObject *v = PyInt_FromLong(value);
1440 if (!v || PyDict_SetItemString(d, name, v))
1441 PyErr_Clear();
1442 Py_XDECREF(v);
1443}
1444
1445#define ADD_INT(val) insint(d, #val, val)
1446
1447static void
1448inskey(PyObject * d, char * name, HKEY key)
1449{
1450 PyObject *v = PyLong_FromVoidPtr(key);
1451 if (!v || PyDict_SetItemString(d, name, v))
1452 PyErr_Clear();
1453 Py_XDECREF(v);
1454}
1455
1456#define ADD_KEY(val) inskey(d, #val, val)
1457
Mark Hammond8235ea12002-07-19 06:55:41 +00001458PyMODINIT_FUNC init_winreg(void)
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001459{
1460 PyObject *m, *d;
Fred Drake270e19b2000-06-29 16:14:14 +00001461 m = Py_InitModule3("_winreg", winreg_methods, module_doc);
Guido van Rossum9f3712c2000-03-28 20:37:15 +00001462 d = PyModule_GetDict(m);
1463 PyHKEY_Type.ob_type = &PyType_Type;
1464 PyHKEY_Type.tp_doc = PyHKEY_doc;
1465 Py_INCREF(&PyHKEY_Type);
1466 if (PyDict_SetItemString(d, "HKEYType",
1467 (PyObject *)&PyHKEY_Type) != 0)
1468 return;
1469 Py_INCREF(PyExc_WindowsError);
1470 if (PyDict_SetItemString(d, "error",
1471 PyExc_WindowsError) != 0)
1472 return;
1473
1474 /* Add the relevant constants */
1475 ADD_KEY(HKEY_CLASSES_ROOT);
1476 ADD_KEY(HKEY_CURRENT_USER);
1477 ADD_KEY(HKEY_LOCAL_MACHINE);
1478 ADD_KEY(HKEY_USERS);
1479 ADD_KEY(HKEY_PERFORMANCE_DATA);
1480#ifdef HKEY_CURRENT_CONFIG
1481 ADD_KEY(HKEY_CURRENT_CONFIG);
1482#endif
1483#ifdef HKEY_DYN_DATA
1484 ADD_KEY(HKEY_DYN_DATA);
1485#endif
1486 ADD_INT(KEY_QUERY_VALUE);
1487 ADD_INT(KEY_SET_VALUE);
1488 ADD_INT(KEY_CREATE_SUB_KEY);
1489 ADD_INT(KEY_ENUMERATE_SUB_KEYS);
1490 ADD_INT(KEY_NOTIFY);
1491 ADD_INT(KEY_CREATE_LINK);
1492 ADD_INT(KEY_READ);
1493 ADD_INT(KEY_WRITE);
1494 ADD_INT(KEY_EXECUTE);
1495 ADD_INT(KEY_ALL_ACCESS);
1496 ADD_INT(REG_OPTION_RESERVED);
1497 ADD_INT(REG_OPTION_NON_VOLATILE);
1498 ADD_INT(REG_OPTION_VOLATILE);
1499 ADD_INT(REG_OPTION_CREATE_LINK);
1500 ADD_INT(REG_OPTION_BACKUP_RESTORE);
1501 ADD_INT(REG_OPTION_OPEN_LINK);
1502 ADD_INT(REG_LEGAL_OPTION);
1503 ADD_INT(REG_CREATED_NEW_KEY);
1504 ADD_INT(REG_OPENED_EXISTING_KEY);
1505 ADD_INT(REG_WHOLE_HIVE_VOLATILE);
1506 ADD_INT(REG_REFRESH_HIVE);
1507 ADD_INT(REG_NO_LAZY_FLUSH);
1508 ADD_INT(REG_NOTIFY_CHANGE_NAME);
1509 ADD_INT(REG_NOTIFY_CHANGE_ATTRIBUTES);
1510 ADD_INT(REG_NOTIFY_CHANGE_LAST_SET);
1511 ADD_INT(REG_NOTIFY_CHANGE_SECURITY);
1512 ADD_INT(REG_LEGAL_CHANGE_FILTER);
1513 ADD_INT(REG_NONE);
1514 ADD_INT(REG_SZ);
1515 ADD_INT(REG_EXPAND_SZ);
1516 ADD_INT(REG_BINARY);
1517 ADD_INT(REG_DWORD);
1518 ADD_INT(REG_DWORD_LITTLE_ENDIAN);
1519 ADD_INT(REG_DWORD_BIG_ENDIAN);
1520 ADD_INT(REG_LINK);
1521 ADD_INT(REG_MULTI_SZ);
1522 ADD_INT(REG_RESOURCE_LIST);
1523 ADD_INT(REG_FULL_RESOURCE_DESCRIPTOR);
1524 ADD_INT(REG_RESOURCE_REQUIREMENTS_LIST);
1525}
1526