?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
_make_boundary(): Fix for SF bug #745478, broken boundary calculation
[python/dscho.git] / PC / _winreg.c
blobde66f6a34cfdd36743c580d515d9a8edeb2ecd3e
1 /*
2 _winreg.c
3
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
20 static BOOL PyHKEY_AsHKEY(PyObject *ob, HKEY *pRes, BOOL bNoneOK);
21 static PyObject *PyHKEY_FromHKEY(HKEY h);
22 static BOOL PyHKEY_Close(PyObject *obHandle);
23
24 static 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 */
37 PyDoc_STRVAR(module_doc,
38 "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"
71 "to see what constants are used, and where.");
72
73
74 PyDoc_STRVAR(CloseKey_doc,
75 "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"
80 "closed when the hkey object is destroyed by Python.");
81
82 PyDoc_STRVAR(ConnectRegistry_doc,
83 "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"
91 "If the function fails, an EnvironmentError exception is raised.");
92
93 PyDoc_STRVAR(CreateKey_doc,
94 "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"
104 "If the function fails, an exception is raised.");
105
106 PyDoc_STRVAR(DeleteKey_doc,
107 "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"
116 "is removed. If the method fails, an EnvironmentError exception is raised.");
117
118 PyDoc_STRVAR(DeleteValue_doc,
119 "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"
122 "value is a string that identifies the value to remove.");
123
124 PyDoc_STRVAR(EnumKey_doc,
125 "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"
131 "It is typically called repeatedly until an EnvironmentError exception is\n"
132 "raised, indicating no more values are available.");
133
134 PyDoc_STRVAR(EnumValue_doc,
135 "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"
140 "It is typically called repeatedly, until an EnvironmentError exception\n"
141 "is raised, indicating no more values.\n"
142 "\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"
147 "data_type is an integer that identifies the type of the value data.");
148
149 PyDoc_STRVAR(FlushKey_doc,
150 "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"
160 "If you don't know whether a FlushKey() call is required, it probably isn't.");
161
162 PyDoc_STRVAR(LoadKey_doc,
163 "LoadKey(key, sub_key, file_name) - Creates a subkey under the specified key\n"
164 "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"
179 "The docs imply key must be in the HKEY_USER or HKEY_LOCAL_MACHINE tree");
180
181 PyDoc_STRVAR(OpenKey_doc,
182 "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"
191 "If the function fails, an EnvironmentError exception is raised.");
192
193 PyDoc_STRVAR(OpenKeyEx_doc, "See OpenKey()");
194
195 PyDoc_STRVAR(QueryInfoKey_doc,
196 "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"
204 " as 100's of nanoseconds since Jan 1, 1600.");
205
206 PyDoc_STRVAR(QueryValue_doc,
207 "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"
210 "sub_key is a string that holds the name of the subkey with which the value\n"
211 " 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"
216 "But the underlying API call doesn't return the type, Lame Lame Lame, DONT USE THIS!!!");
217
218 PyDoc_STRVAR(QueryValueEx_doc,
219 "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"
222 "value_name is a string indicating the value to query");
223
224 PyDoc_STRVAR(SaveKey_doc,
225 "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"
236 "This function passes NULL for security_attributes to the API.");
237
238 PyDoc_STRVAR(SetValue_doc,
239 "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"
255 "KEY_SET_VALUE access.");
256
257 PyDoc_STRVAR(SetValueEx_doc,
258 "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"
261 "value_name is a string containing the name of the value to set, or None\n"
262 "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"
270 " 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"
273 " 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"
287 "the configuration registry. This helps the registry perform efficiently.");
288
289 /* PyHKEY docstrings */
290 PyDoc_STRVAR(PyHKEY_doc,
291 "PyHKEY Object - A Python object, representing a win32 registry key.\n"
292 "\n"
293 "This object wraps a Windows HKEY object, automatically closing it when\n"
294 "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"
310 "__cmp__ - Handle objects are compared using the handle value.");
311
312
313 PyDoc_STRVAR(PyHKEY_Close_doc,
314 "key.Close() - Closes the underlying Windows handle.\n"
315 "\n"
316 "If the handle is already closed, no error is raised.");
317
318 PyDoc_STRVAR(PyHKEY_Detach_doc,
319 "int = key.Detach() - Detaches the Windows handle from the handle object.\n"
320 "\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"
327 "handle object.\n"
328 "On 64 bit windows, the result of this function is a long integer");
329
330
331 /************************************************************************
332
333 The PyHKEY object definition
334
335 ************************************************************************/
336 typedef struct {
337 PyObject_VAR_HEAD
338 HKEY hkey;
339 } PyHKEYObject;
340
341 #define PyHKEY_Check(op) ((op)->ob_type == &PyHKEY_Type)
342
343 static char *failMsg = "bad operand type";
344
345 static PyObject *
346 PyHKEY_unaryFailureFunc(PyObject *ob)
347 {
348 PyErr_SetString(PyExc_TypeError, failMsg);
349 return NULL;
350 }
351 static PyObject *
352 PyHKEY_binaryFailureFunc(PyObject *ob1, PyObject *ob2)
353 {
354 PyErr_SetString(PyExc_TypeError, failMsg);
355 return NULL;
356 }
357 static PyObject *
358 PyHKEY_ternaryFailureFunc(PyObject *ob1, PyObject *ob2, PyObject *ob3)
359 {
360 PyErr_SetString(PyExc_TypeError, failMsg);
361 return NULL;
362 }
363
364 static void
365 PyHKEY_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);
374 PyObject_DEL(ob);
375 }
376
377 static int
378 PyHKEY_nonzeroFunc(PyObject *ob)
379 {
380 return ((PyHKEYObject *)ob)->hkey != 0;
381 }
382
383 static PyObject *
384 PyHKEY_intFunc(PyObject *ob)
385 {
386 PyHKEYObject *pyhkey = (PyHKEYObject *)ob;
387 return PyLong_FromVoidPtr(pyhkey->hkey);
388 }
389
390 static int
391 PyHKEY_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
401 static PyObject *
402 PyHKEY_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
410 static int
411 PyHKEY_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
419 static long
420 PyHKEY_hashFunc(PyObject *ob)
421 {
422 /* Just use the address.
423 XXX - should we use the handle value?
424 */
425 return _Py_HashPointer(ob);
426 }
427
428
429 static 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__ */
458 static PyObject *PyHKEY_getattr(PyObject *self, char *name);
459
460 /* The type itself */
461 PyTypeObject 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
489 static struct memberlist PyHKEY_memberlist[] = {
490 {"handle", T_INT, OFF(hkey)},
491 {NULL} /* Sentinel */
492 };
493
494 /************************************************************************
495
496 The PyHKEY object methods
497
498 ************************************************************************/
499 static PyObject *
500 PyHKEY_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
510 static PyObject *
511 PyHKEY_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
522 static struct PyMethodDef PyHKEY_methods[] = {
523 {"Close", PyHKEY_CloseMethod, METH_VARARGS, PyHKEY_Close_doc},
524 {"Detach", PyHKEY_DetachMethod, METH_VARARGS, PyHKEY_Detach_doc},
525 {NULL}
526 };
527
528 /*static*/ PyObject *
529 PyHKEY_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 ************************************************************************/
545 PyObject *
546 PyHKEY_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
554 BOOL
555 PyHKEY_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
572 BOOL
573 PyHKEY_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;
594 }
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
604 PyObject *
605 PyHKEY_FromHKEY(HKEY h)
606 {
607 PyHKEYObject *op;
608
609 /* Inline PyObject_New */
610 op = (PyHKEYObject *) PyObject_MALLOC(sizeof(PyHKEYObject));
611 if (op == NULL)
612 return PyErr_NoMemory();
613 PyObject_INIT(op, &PyHKEY_Type);
614 op->hkey = h;
615 return (PyObject *)op;
616 }
617
618
619 /************************************************************************
620 The module methods
621 ************************************************************************/
622 BOOL
623 PyWinObject_CloseHKEY(PyObject *obHandle)
624 {
625 BOOL ok;
626 if (PyHKEY_Check(obHandle)) {
627 ok = PyHKEY_Close(obHandle);
628 }
629 #if SIZEOF_LONG >= SIZEOF_HKEY
630 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 }
636 #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
644 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
660 ** some commercial packages install strings which dont conform,
661 ** causing this code to fail - however, "regedit" etc still work
662 ** with these strings (ie only we dont!).
663 */
664 static void
665 fixupMultiSZ(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
679 static int
680 countStrings(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. */
694 static BOOL
695 Py2Reg(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 {
832 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);
842 *retDataBuf = (BYTE *)PyMem_NEW(char,
843 *retDataSize);
844 if (*retDataBuf==NULL){
845 PyErr_NoMemory();
846 return FALSE;
847 }
848 memcpy(*retDataBuf, src_buf, *retDataSize);
849 }
850 break;
851 }
852 return TRUE;
853 }
854
855 /* Convert Registry data into PyObject*/
856 static PyObject *
857 Reg2Py(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);
894 if (obData == NULL)
895 return NULL;
896 for (index = 0; index < s; index++)
897 {
898 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 }
905 PyList_SetItem(obData,
906 index,
907 PyUnicode_DecodeMBCS(
908 (const char *)str[index],
909 (int)len,
910 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
939 static PyObject *
940 PyCloseKey(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
951 static PyObject *
952 PyConnectRegistry(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
970 static PyObject *
971 PyCreateKey(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
988 static PyObject *
989 PyDeleteKey(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
1006 static PyObject *
1007 PyDeleteValue(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
1027 static PyObject *
1028 PyEnumKey(PyObject *self, PyObject *args)
1029 {
1030 HKEY hKey;
1031 PyObject *obKey;
1032 int index;
1033 long rc;
1034 char *retBuf;
1035 DWORD len;
1036
1037 if (!PyArg_ParseTuple(args, "Oi:EnumKey", &obKey, &index))
1038 return NULL;
1039 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1040 return NULL;
1041
1042 if ((rc = RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, &len,
1043 NULL, NULL, NULL, NULL, NULL, NULL))
1044 != ERROR_SUCCESS)
1045 return PyErr_SetFromWindowsErrWithFunction(rc,
1046 "RegQueryInfoKey");
1047 ++len; /* include null terminator */
1048 retBuf = (char *)alloca(len);
1049
1050 if ((rc = RegEnumKey(hKey, index, retBuf, len)) != ERROR_SUCCESS)
1051 return PyErr_SetFromWindowsErrWithFunction(rc, "RegEnumKey");
1052 return Py_BuildValue("s", retBuf);
1053 }
1054
1055 static PyObject *
1056 PyEnumValue(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;
1083 retValueBuf = (char *)alloca(retValueSize);
1084 retDataBuf = (char *)alloca(retDataSize);
1085
1086 Py_BEGIN_ALLOW_THREADS
1087 rc = RegEnumValue(hKey,
1088 index,
1089 retValueBuf,
1090 &retValueSize,
1091 NULL,
1092 &typ,
1093 (BYTE *)retDataBuf,
1094 &retDataSize);
1095 Py_END_ALLOW_THREADS
1096
1097 if (rc != ERROR_SUCCESS)
1098 return PyErr_SetFromWindowsErrWithFunction(rc,
1099 "PyRegEnumValue");
1100 obData = Reg2Py(retDataBuf, retDataSize, typ);
1101 if (obData == NULL)
1102 return NULL;
1103 retVal = Py_BuildValue("sOi", retValueBuf, obData, typ);
1104 Py_DECREF(obData);
1105 return retVal;
1106 }
1107
1108 static PyObject *
1109 PyFlushKey(PyObject *self, PyObject *args)
1110 {
1111 HKEY hKey;
1112 PyObject *obKey;
1113 long rc;
1114 if (!PyArg_ParseTuple(args, "O:FlushKey", &obKey))
1115 return NULL;
1116 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1117 return NULL;
1118 Py_BEGIN_ALLOW_THREADS
1119 rc = RegFlushKey(hKey);
1120 Py_END_ALLOW_THREADS
1121 if (rc != ERROR_SUCCESS)
1122 return PyErr_SetFromWindowsErrWithFunction(rc, "RegFlushKey");
1123 Py_INCREF(Py_None);
1124 return Py_None;
1125 }
1126 static PyObject *
1127 PyLoadKey(PyObject *self, PyObject *args)
1128 {
1129 HKEY hKey;
1130 PyObject *obKey;
1131 char *subKey;
1132 char *fileName;
1133
1134 long rc;
1135 if (!PyArg_ParseTuple(args, "Oss:LoadKey", &obKey, &subKey, &fileName))
1136 return NULL;
1137 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1138 return NULL;
1139 Py_BEGIN_ALLOW_THREADS
1140 rc = RegLoadKey(hKey, subKey, fileName );
1141 Py_END_ALLOW_THREADS
1142 if (rc != ERROR_SUCCESS)
1143 return PyErr_SetFromWindowsErrWithFunction(rc, "RegLoadKey");
1144 Py_INCREF(Py_None);
1145 return Py_None;
1146 }
1147
1148 static PyObject *
1149 PyOpenKey(PyObject *self, PyObject *args)
1150 {
1151 HKEY hKey;
1152 PyObject *obKey;
1153
1154 char *subKey;
1155 int res = 0;
1156 HKEY retKey;
1157 long rc;
1158 REGSAM sam = KEY_READ;
1159 if (!PyArg_ParseTuple(args, "Oz|ii:OpenKey", &obKey, &subKey,
1160 &res, &sam))
1161 return NULL;
1162 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1163 return NULL;
1164
1165 Py_BEGIN_ALLOW_THREADS
1166 rc = RegOpenKeyEx(hKey, subKey, res, sam, &retKey);
1167 Py_END_ALLOW_THREADS
1168 if (rc != ERROR_SUCCESS)
1169 return PyErr_SetFromWindowsErrWithFunction(rc, "RegOpenKeyEx");
1170 return PyHKEY_FromHKEY(retKey);
1171 }
1172
1173
1174 static PyObject *
1175 PyQueryInfoKey(PyObject *self, PyObject *args)
1176 {
1177 HKEY hKey;
1178 PyObject *obKey;
1179 long rc;
1180 DWORD nSubKeys, nValues;
1181 FILETIME ft;
1182 LARGE_INTEGER li;
1183 PyObject *l;
1184 PyObject *ret;
1185 if (!PyArg_ParseTuple(args, "O:QueryInfoKey", &obKey))
1186 return NULL;
1187 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1188 return NULL;
1189 if ((rc = RegQueryInfoKey(hKey, NULL, NULL, 0, &nSubKeys, NULL, NULL,
1190 &nValues, NULL, NULL, NULL, &ft))
1191 != ERROR_SUCCESS)
1192 return PyErr_SetFromWindowsErrWithFunction(rc, "RegQueryInfoKey");
1193 li.LowPart = ft.dwLowDateTime;
1194 li.HighPart = ft.dwHighDateTime;
1195 l = PyLong_FromLongLong(li.QuadPart);
1196 if (l == NULL)
1197 return NULL;
1198 ret = Py_BuildValue("iiO", nSubKeys, nValues, l);
1199 Py_DECREF(l);
1200 return ret;
1201 }
1202
1203 static PyObject *
1204 PyQueryValue(PyObject *self, PyObject *args)
1205 {
1206 HKEY hKey;
1207 PyObject *obKey;
1208 char *subKey;
1209
1210 long rc;
1211 char *retBuf;
1212 long bufSize = 0;
1213 if (!PyArg_ParseTuple(args, "Oz:QueryValue", &obKey, &subKey))
1214 return NULL;
1215
1216 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1217 return NULL;
1218 if ((rc = RegQueryValue(hKey, subKey, NULL, &bufSize))
1219 != ERROR_SUCCESS)
1220 return PyErr_SetFromWindowsErrWithFunction(rc,
1221 "RegQueryValue");
1222 retBuf = (char *)alloca(bufSize);
1223 if ((rc = RegQueryValue(hKey, subKey, retBuf, &bufSize))
1224 != ERROR_SUCCESS)
1225 return PyErr_SetFromWindowsErrWithFunction(rc,
1226 "RegQueryValue");
1227 return Py_BuildValue("s", retBuf);
1228 }
1229
1230 static PyObject *
1231 PyQueryValueEx(PyObject *self, PyObject *args)
1232 {
1233 HKEY hKey;
1234 PyObject *obKey;
1235 char *valueName;
1236
1237 long rc;
1238 char *retBuf;
1239 DWORD bufSize = 0;
1240 DWORD typ;
1241 PyObject *obData;
1242 PyObject *result;
1243
1244 if (!PyArg_ParseTuple(args, "Oz:QueryValueEx", &obKey, &valueName))
1245 return NULL;
1246
1247 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1248 return NULL;
1249 if ((rc = RegQueryValueEx(hKey, valueName,
1250 NULL, NULL, NULL,
1251 &bufSize))
1252 != ERROR_SUCCESS)
1253 return PyErr_SetFromWindowsErrWithFunction(rc,
1254 "RegQueryValueEx");
1255 retBuf = (char *)alloca(bufSize);
1256 if ((rc = RegQueryValueEx(hKey, valueName, NULL,
1257 &typ, (BYTE *)retBuf, &bufSize))
1258 != ERROR_SUCCESS)
1259 return PyErr_SetFromWindowsErrWithFunction(rc,
1260 "RegQueryValueEx");
1261 obData = Reg2Py(retBuf, bufSize, typ);
1262 if (obData == NULL)
1263 return NULL;
1264 result = Py_BuildValue("Oi", obData, typ);
1265 Py_DECREF(obData);
1266 return result;
1267 }
1268
1269
1270 static PyObject *
1271 PySaveKey(PyObject *self, PyObject *args)
1272 {
1273 HKEY hKey;
1274 PyObject *obKey;
1275 char *fileName;
1276 LPSECURITY_ATTRIBUTES pSA = NULL;
1277
1278 long rc;
1279 if (!PyArg_ParseTuple(args, "Os:SaveKey", &obKey, &fileName))
1280 return NULL;
1281 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1282 return NULL;
1283 /* One day we may get security into the core?
1284 if (!PyWinObject_AsSECURITY_ATTRIBUTES(obSA, &pSA, TRUE))
1285 return NULL;
1286 */
1287 Py_BEGIN_ALLOW_THREADS
1288 rc = RegSaveKey(hKey, fileName, pSA );
1289 Py_END_ALLOW_THREADS
1290 if (rc != ERROR_SUCCESS)
1291 return PyErr_SetFromWindowsErrWithFunction(rc, "RegSaveKey");
1292 Py_INCREF(Py_None);
1293 return Py_None;
1294 }
1295
1296 static PyObject *
1297 PySetValue(PyObject *self, PyObject *args)
1298 {
1299 HKEY hKey;
1300 PyObject *obKey;
1301 char *subKey;
1302 char *str;
1303 DWORD typ;
1304 DWORD len;
1305 long rc;
1306 PyObject *obStrVal;
1307 PyObject *obSubKey;
1308 if (!PyArg_ParseTuple(args, "OOiO:SetValue",
1309 &obKey,
1310 &obSubKey,
1311 &typ,
1312 &obStrVal))
1313 return NULL;
1314 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1315 return NULL;
1316 if (typ != REG_SZ) {
1317 PyErr_SetString(PyExc_TypeError,
1318 "Type must be _winreg.REG_SZ");
1319 return NULL;
1320 }
1321 /* XXX - need Unicode support */
1322 str = PyString_AsString(obStrVal);
1323 if (str == NULL)
1324 return NULL;
1325 len = PyString_Size(obStrVal);
1326 if (obSubKey == Py_None)
1327 subKey = NULL;
1328 else {
1329 subKey = PyString_AsString(obSubKey);
1330 if (subKey == NULL)
1331 return NULL;
1332 }
1333 Py_BEGIN_ALLOW_THREADS
1334 rc = RegSetValue(hKey, subKey, REG_SZ, str, len+1);
1335 Py_END_ALLOW_THREADS
1336 if (rc != ERROR_SUCCESS)
1337 return PyErr_SetFromWindowsErrWithFunction(rc, "RegSetValue");
1338 Py_INCREF(Py_None);
1339 return Py_None;
1340 }
1341
1342 static PyObject *
1343 PySetValueEx(PyObject *self, PyObject *args)
1344 {
1345 HKEY hKey;
1346 PyObject *obKey;
1347 char *valueName;
1348 PyObject *obRes;
1349 PyObject *value;
1350 BYTE *data;
1351 DWORD len;
1352 DWORD typ;
1353
1354 LONG rc;
1355
1356 if (!PyArg_ParseTuple(args, "OzOiO:SetValueEx",
1357 &obKey,
1358 &valueName,
1359 &obRes,
1360 &typ,
1361 &value))
1362 return NULL;
1363 if (!PyHKEY_AsHKEY(obKey, &hKey, FALSE))
1364 return NULL;
1365 if (!Py2Reg(value, typ, &data, &len))
1366 {
1367 if (!PyErr_Occurred())
1368 PyErr_SetString(PyExc_ValueError,
1369 "Could not convert the data to the specified type.");
1370 return NULL;
1371 }
1372 Py_BEGIN_ALLOW_THREADS
1373 rc = RegSetValueEx(hKey, valueName, 0, typ, data, len);
1374 Py_END_ALLOW_THREADS
1375 PyMem_DEL(data);
1376 if (rc != ERROR_SUCCESS)
1377 return PyErr_SetFromWindowsErrWithFunction(rc,
1378 "RegSetValueEx");
1379 Py_INCREF(Py_None);
1380 return Py_None;
1381 }
1382
1383 static struct PyMethodDef winreg_methods[] = {
1384 {"CloseKey", PyCloseKey, METH_VARARGS, CloseKey_doc},
1385 {"ConnectRegistry", PyConnectRegistry, METH_VARARGS, ConnectRegistry_doc},
1386 {"CreateKey", PyCreateKey, METH_VARARGS, CreateKey_doc},
1387 {"DeleteKey", PyDeleteKey, METH_VARARGS, DeleteKey_doc},
1388 {"DeleteValue", PyDeleteValue, METH_VARARGS, DeleteValue_doc},
1389 {"EnumKey", PyEnumKey, METH_VARARGS, EnumKey_doc},
1390 {"EnumValue", PyEnumValue, METH_VARARGS, EnumValue_doc},
1391 {"FlushKey", PyFlushKey, METH_VARARGS, FlushKey_doc},
1392 {"LoadKey", PyLoadKey, METH_VARARGS, LoadKey_doc},
1393 {"OpenKey", PyOpenKey, METH_VARARGS, OpenKey_doc},
1394 {"OpenKeyEx", PyOpenKey, METH_VARARGS, OpenKeyEx_doc},
1395 {"QueryValue", PyQueryValue, METH_VARARGS, QueryValue_doc},
1396 {"QueryValueEx", PyQueryValueEx, METH_VARARGS, QueryValueEx_doc},
1397 {"QueryInfoKey", PyQueryInfoKey, METH_VARARGS, QueryInfoKey_doc},
1398 {"SaveKey", PySaveKey, METH_VARARGS, SaveKey_doc},
1399 {"SetValue", PySetValue, METH_VARARGS, SetValue_doc},
1400 {"SetValueEx", PySetValueEx, METH_VARARGS, SetValueEx_doc},
1401 NULL,
1402 };
1403
1404 static void
1405 insint(PyObject * d, char * name, long value)
1406 {
1407 PyObject *v = PyInt_FromLong(value);
1408 if (!v || PyDict_SetItemString(d, name, v))
1409 PyErr_Clear();
1410 Py_XDECREF(v);
1411 }
1412
1413 #define ADD_INT(val) insint(d, #val, val)
1414
1415 static void
1416 inskey(PyObject * d, char * name, HKEY key)
1417 {
1418 PyObject *v = PyLong_FromVoidPtr(key);
1419 if (!v || PyDict_SetItemString(d, name, v))
1420 PyErr_Clear();
1421 Py_XDECREF(v);
1422 }
1423
1424 #define ADD_KEY(val) inskey(d, #val, val)
1425
1426 PyMODINIT_FUNC init_winreg(void)
1427 {
1428 PyObject *m, *d;
1429 m = Py_InitModule3("_winreg", winreg_methods, module_doc);
1430 d = PyModule_GetDict(m);
1431 PyHKEY_Type.ob_type = &PyType_Type;
1432 PyHKEY_Type.tp_doc = PyHKEY_doc;
1433 Py_INCREF(&PyHKEY_Type);
1434 if (PyDict_SetItemString(d, "HKEYType",
1435 (PyObject *)&PyHKEY_Type) != 0)
1436 return;
1437 Py_INCREF(PyExc_WindowsError);
1438 if (PyDict_SetItemString(d, "error",
1439 PyExc_WindowsError) != 0)
1440 return;
1441
1442 /* Add the relevant constants */
1443 ADD_KEY(HKEY_CLASSES_ROOT);
1444 ADD_KEY(HKEY_CURRENT_USER);
1445 ADD_KEY(HKEY_LOCAL_MACHINE);
1446 ADD_KEY(HKEY_USERS);
1447 ADD_KEY(HKEY_PERFORMANCE_DATA);
1448 #ifdef HKEY_CURRENT_CONFIG
1449 ADD_KEY(HKEY_CURRENT_CONFIG);
1450 #endif
1451 #ifdef HKEY_DYN_DATA
1452 ADD_KEY(HKEY_DYN_DATA);
1453 #endif
1454 ADD_INT(KEY_QUERY_VALUE);
1455 ADD_INT(KEY_SET_VALUE);
1456 ADD_INT(KEY_CREATE_SUB_KEY);
1457 ADD_INT(KEY_ENUMERATE_SUB_KEYS);
1458 ADD_INT(KEY_NOTIFY);
1459 ADD_INT(KEY_CREATE_LINK);
1460 ADD_INT(KEY_READ);
1461 ADD_INT(KEY_WRITE);
1462 ADD_INT(KEY_EXECUTE);
1463 ADD_INT(KEY_ALL_ACCESS);
1464 ADD_INT(REG_OPTION_RESERVED);
1465 ADD_INT(REG_OPTION_NON_VOLATILE);
1466 ADD_INT(REG_OPTION_VOLATILE);
1467 ADD_INT(REG_OPTION_CREATE_LINK);
1468 ADD_INT(REG_OPTION_BACKUP_RESTORE);
1469 ADD_INT(REG_OPTION_OPEN_LINK);
1470 ADD_INT(REG_LEGAL_OPTION);
1471 ADD_INT(REG_CREATED_NEW_KEY);
1472 ADD_INT(REG_OPENED_EXISTING_KEY);
1473 ADD_INT(REG_WHOLE_HIVE_VOLATILE);
1474 ADD_INT(REG_REFRESH_HIVE);
1475 ADD_INT(REG_NO_LAZY_FLUSH);
1476 ADD_INT(REG_NOTIFY_CHANGE_NAME);
1477 ADD_INT(REG_NOTIFY_CHANGE_ATTRIBUTES);
1478 ADD_INT(REG_NOTIFY_CHANGE_LAST_SET);
1479 ADD_INT(REG_NOTIFY_CHANGE_SECURITY);
1480 ADD_INT(REG_LEGAL_CHANGE_FILTER);
1481 ADD_INT(REG_NONE);
1482 ADD_INT(REG_SZ);
1483 ADD_INT(REG_EXPAND_SZ);
1484 ADD_INT(REG_BINARY);
1485 ADD_INT(REG_DWORD);
1486 ADD_INT(REG_DWORD_LITTLE_ENDIAN);
1487 ADD_INT(REG_DWORD_BIG_ENDIAN);
1488 ADD_INT(REG_LINK);
1489 ADD_INT(REG_MULTI_SZ);
1490 ADD_INT(REG_RESOURCE_LIST);
1491 ADD_INT(REG_FULL_RESOURCE_DESCRIPTOR);
1492 ADD_INT(REG_RESOURCE_REQUIREMENTS_LIST);
1493 }
1494