2000-03-28 20:37:15 +00:00
|
|
|
/*
|
2008-05-25 07:45:51 +00:00
|
|
|
winreg.c
|
2000-03-28 20:37:15 +00:00
|
|
|
|
|
|
|
Windows Registry access module for Python.
|
|
|
|
|
|
|
|
* Simple registry access written by Mark Hammond in win32api
|
2010-05-09 15:52:27 +00:00
|
|
|
module circa 1995.
|
2000-03-28 20:37:15 +00:00
|
|
|
* Bill Tutt expanded the support significantly not long after.
|
|
|
|
* Numerous other people have submitted patches since then.
|
|
|
|
* Ripped from win32api module 03-Feb-2000 by Mark Hammond, and
|
|
|
|
basic Unicode support added.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "Python.h"
|
|
|
|
#include "structmember.h"
|
Merged revisions 55631-55794 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/branches/p3yk
................
r55636 | neal.norwitz | 2007-05-29 00:06:39 -0700 (Tue, 29 May 2007) | 149 lines
Merged revisions 55506-55635 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r55507 | georg.brandl | 2007-05-22 07:28:17 -0700 (Tue, 22 May 2007) | 2 lines
Remove the "panel" module doc file which has been ignored since 1994.
........
r55522 | mark.hammond | 2007-05-22 19:04:28 -0700 (Tue, 22 May 2007) | 4 lines
Remove definition of PY_UNICODE_TYPE from pyconfig.h, allowing the
definition in unicodeobject.h to be used, giving us the desired
wchar_t in place of 'unsigned short'. As discussed on python-dev.
........
r55525 | neal.norwitz | 2007-05-22 23:35:32 -0700 (Tue, 22 May 2007) | 6 lines
Add -3 option to the interpreter to warn about features that are
deprecated and will be changed/removed in Python 3.0.
This patch is mostly from Anthony. I tweaked some format and added
a little doc.
........
r55527 | neal.norwitz | 2007-05-22 23:57:35 -0700 (Tue, 22 May 2007) | 1 line
Whitespace cleanup
........
r55528 | neal.norwitz | 2007-05-22 23:58:36 -0700 (Tue, 22 May 2007) | 1 line
Add a bunch more deprecation warnings for builtins that are going away in 3.0
........
r55549 | georg.brandl | 2007-05-24 09:49:29 -0700 (Thu, 24 May 2007) | 2 lines
shlex.split() now has an optional "posix" parameter.
........
r55550 | georg.brandl | 2007-05-24 10:33:33 -0700 (Thu, 24 May 2007) | 2 lines
Fix parameter passing.
........
r55555 | facundo.batista | 2007-05-24 10:50:54 -0700 (Thu, 24 May 2007) | 6 lines
Added an optional timeout parameter to urllib.ftpwrapper, with tests
(for this and a basic one, because there weren't any). Changed also
NEWS, but didn't find documentation for this function, assumed it
wasn't public...
........
r55563 | facundo.batista | 2007-05-24 13:01:59 -0700 (Thu, 24 May 2007) | 4 lines
Removed the .recv() in the test, is not necessary, and was
causing problems that didn't have anything to do with was
actually being tested...
........
r55564 | facundo.batista | 2007-05-24 13:51:19 -0700 (Thu, 24 May 2007) | 5 lines
Let's see if reading exactly what is written allow this live
test to pass (now I know why there were so few tests in ftp,
http, etc, :( ).
........
r55567 | facundo.batista | 2007-05-24 20:10:28 -0700 (Thu, 24 May 2007) | 4 lines
Trying to make the tests work in Windows and Solaris, everywhere
else just works
........
r55568 | facundo.batista | 2007-05-24 20:47:19 -0700 (Thu, 24 May 2007) | 4 lines
Fixing stupid error, and introducing a sleep, to see if the
other thread is awakened and finish sending data.
........
r55569 | facundo.batista | 2007-05-24 21:20:22 -0700 (Thu, 24 May 2007) | 4 lines
Commenting out the tests until find out who can test them in
one of the problematic enviroments.
........
r55570 | neal.norwitz | 2007-05-24 22:13:40 -0700 (Thu, 24 May 2007) | 2 lines
Get test passing again by commenting out the reference to the test class.
........
r55575 | vinay.sajip | 2007-05-25 00:05:59 -0700 (Fri, 25 May 2007) | 1 line
Updated docstring for SysLogHandler (#1720726).
........
r55576 | vinay.sajip | 2007-05-25 00:06:55 -0700 (Fri, 25 May 2007) | 1 line
Updated documentation for SysLogHandler (#1720726).
........
r55592 | brett.cannon | 2007-05-25 13:17:15 -0700 (Fri, 25 May 2007) | 3 lines
Remove direct call's to file's constructor and replace them with calls to
open() as ths is considered best practice.
........
r55601 | kristjan.jonsson | 2007-05-26 12:19:50 -0700 (Sat, 26 May 2007) | 1 line
Remove the rgbimgmodule from PCBuild8
........
r55602 | kristjan.jonsson | 2007-05-26 12:31:39 -0700 (Sat, 26 May 2007) | 1 line
Include <windows.h> after python.h, so that WINNT is properly set before windows.h is included. Fixes warnings in PC builds.
........
r55603 | walter.doerwald | 2007-05-26 14:04:13 -0700 (Sat, 26 May 2007) | 2 lines
Fix typo.
........
r55604 | peter.astrand | 2007-05-26 15:18:20 -0700 (Sat, 26 May 2007) | 1 line
Applied patch 1669481, slightly modified: Support close_fds on Win32
........
r55606 | neal.norwitz | 2007-05-26 21:08:54 -0700 (Sat, 26 May 2007) | 2 lines
Add the new function object attribute names from py3k.
........
r55617 | lars.gustaebel | 2007-05-27 12:49:30 -0700 (Sun, 27 May 2007) | 20 lines
Added errors argument to TarFile class that allows the user to
specify an error handling scheme for character conversion. Additional
scheme "utf-8" in read mode. Unicode input filenames are now
supported by design. The values of the pax_headers dictionary are now
limited to unicode objects.
Fixed: The prefix field is no longer used in PAX_FORMAT (in
conformance with POSIX).
Fixed: In read mode use a possible pax header size field.
Fixed: Strip trailing slashes from pax header name values.
Fixed: Give values in user-specified pax_headers precedence when
writing.
Added unicode tests. Added pax/regtype4 member to testtar.tar all
possible number fields in a pax header.
Added two chapters to the documentation about the different formats
tarfile.py supports and how unicode issues are handled.
........
r55618 | raymond.hettinger | 2007-05-27 22:23:22 -0700 (Sun, 27 May 2007) | 1 line
Explain when groupby() issues a new group.
........
r55634 | martin.v.loewis | 2007-05-28 21:01:29 -0700 (Mon, 28 May 2007) | 2 lines
Test pre-commit hook for a link to a .py file.
........
r55635 | martin.v.loewis | 2007-05-28 21:02:03 -0700 (Mon, 28 May 2007) | 2 lines
Revert 55634.
........
................
r55639 | neal.norwitz | 2007-05-29 00:58:11 -0700 (Tue, 29 May 2007) | 1 line
Remove sys.exc_{type,exc_value,exc_traceback}
................
r55641 | neal.norwitz | 2007-05-29 01:03:50 -0700 (Tue, 29 May 2007) | 1 line
Missed one sys.exc_type. I wonder why exc_{value,traceback} were already gone
................
r55642 | neal.norwitz | 2007-05-29 01:08:33 -0700 (Tue, 29 May 2007) | 1 line
Missed more doc for sys.exc_* attrs.
................
r55643 | neal.norwitz | 2007-05-29 01:18:19 -0700 (Tue, 29 May 2007) | 1 line
Remove sys.exc_clear()
................
r55665 | guido.van.rossum | 2007-05-29 19:45:43 -0700 (Tue, 29 May 2007) | 4 lines
Make None, True, False keywords.
We can now also delete all the other places that explicitly forbid
assignment to None, but I'm not going to bother right now.
................
r55666 | guido.van.rossum | 2007-05-29 20:01:51 -0700 (Tue, 29 May 2007) | 3 lines
Found another place that needs check for forbidden names.
Fixed test_syntax.py accordingly (it helped me find that one).
................
r55668 | guido.van.rossum | 2007-05-29 20:41:48 -0700 (Tue, 29 May 2007) | 2 lines
Mark None, True, False as keywords.
................
r55673 | neal.norwitz | 2007-05-29 23:28:25 -0700 (Tue, 29 May 2007) | 3 lines
Get the dis module working on modules again after changing dicts
to not return lists and also new-style classes. Add a test.
................
r55674 | neal.norwitz | 2007-05-29 23:35:45 -0700 (Tue, 29 May 2007) | 1 line
Umm, it helps to add the module that the test uses
................
r55675 | neal.norwitz | 2007-05-29 23:53:05 -0700 (Tue, 29 May 2007) | 4 lines
Try to fix up all the other places that were assigning to True/False.
There's at least one more problem in test.test_xmlrpc. I have other
changes in that file and that should be fixed soon (I hope).
................
r55679 | neal.norwitz | 2007-05-30 00:31:55 -0700 (Wed, 30 May 2007) | 1 line
Fix up another place that was assigning to True/False.
................
r55688 | brett.cannon | 2007-05-30 14:19:47 -0700 (Wed, 30 May 2007) | 2 lines
Ditch MimeWriter.
................
r55692 | brett.cannon | 2007-05-30 14:52:00 -0700 (Wed, 30 May 2007) | 2 lines
Remove the mimify module.
................
r55707 | guido.van.rossum | 2007-05-31 05:08:45 -0700 (Thu, 31 May 2007) | 2 lines
Backport the addition of show_code() to dis.py -- it's too handy.
................
r55708 | guido.van.rossum | 2007-05-31 06:22:57 -0700 (Thu, 31 May 2007) | 7 lines
Fix a fairly long-standing bug in the check for assignment to None (and other
keywords, these days). In 2.5, you could write foo(None=1) without getting
a SyntaxError (although foo()'s definition would have to use **kwds to avoid
getting a runtime error complaining about an unknown keyword of course).
This ought to be backported to 2.5.2 or at least 2.6.
................
r55724 | brett.cannon | 2007-05-31 19:32:41 -0700 (Thu, 31 May 2007) | 2 lines
Remove the cfmfile.
................
r55727 | neal.norwitz | 2007-05-31 22:19:44 -0700 (Thu, 31 May 2007) | 1 line
Remove reload() builtin.
................
r55729 | neal.norwitz | 2007-05-31 22:51:30 -0700 (Thu, 31 May 2007) | 59 lines
Merged revisions 55636-55728 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r55637 | georg.brandl | 2007-05-29 00:16:47 -0700 (Tue, 29 May 2007) | 2 lines
Fix rst markup.
........
r55638 | neal.norwitz | 2007-05-29 00:51:39 -0700 (Tue, 29 May 2007) | 1 line
Fix typo in doc
........
r55671 | neal.norwitz | 2007-05-29 21:53:41 -0700 (Tue, 29 May 2007) | 1 line
Fix indentation (whitespace only).
........
r55676 | thomas.heller | 2007-05-29 23:58:30 -0700 (Tue, 29 May 2007) | 1 line
Fix compiler warnings.
........
r55677 | thomas.heller | 2007-05-30 00:01:25 -0700 (Wed, 30 May 2007) | 2 lines
Correct the name of a field in the WIN32_FIND_DATAA and WIN32_FIND_DATAW structures.
Closes bug #1726026.
........
r55686 | brett.cannon | 2007-05-30 13:46:26 -0700 (Wed, 30 May 2007) | 2 lines
Have MimeWriter raise a DeprecationWarning as per PEP 4 and its documentation.
........
r55690 | brett.cannon | 2007-05-30 14:48:58 -0700 (Wed, 30 May 2007) | 3 lines
Have mimify raise a DeprecationWarning. The docs and PEP 4 have listed the
module as deprecated for a while.
........
r55696 | brett.cannon | 2007-05-30 15:24:28 -0700 (Wed, 30 May 2007) | 2 lines
Have md5 raise a DeprecationWarning as per PEP 4.
........
r55705 | neal.norwitz | 2007-05-30 21:14:22 -0700 (Wed, 30 May 2007) | 1 line
Add some spaces in the example code.
........
r55716 | brett.cannon | 2007-05-31 12:20:00 -0700 (Thu, 31 May 2007) | 2 lines
Have the sha module raise a DeprecationWarning as specified in PEP 4.
........
r55719 | brett.cannon | 2007-05-31 12:40:42 -0700 (Thu, 31 May 2007) | 2 lines
Cause buildtools to raise a DeprecationWarning.
........
r55721 | brett.cannon | 2007-05-31 13:01:11 -0700 (Thu, 31 May 2007) | 2 lines
Have cfmfile raise a DeprecationWarning as per PEP 4.
........
r55726 | neal.norwitz | 2007-05-31 21:56:47 -0700 (Thu, 31 May 2007) | 1 line
Mail if there is an installation failure.
........
................
r55730 | neal.norwitz | 2007-05-31 23:22:07 -0700 (Thu, 31 May 2007) | 2 lines
Remove the code that was missed in rev 55303.
................
r55738 | neal.norwitz | 2007-06-01 19:10:43 -0700 (Fri, 01 Jun 2007) | 1 line
Fix doc breakage
................
r55741 | neal.norwitz | 2007-06-02 00:41:58 -0700 (Sat, 02 Jun 2007) | 1 line
Remove timing module (plus some remnants of other modules).
................
r55742 | neal.norwitz | 2007-06-02 00:51:44 -0700 (Sat, 02 Jun 2007) | 1 line
Remove posixfile module (plus some remnants of other modules).
................
r55744 | neal.norwitz | 2007-06-02 10:18:56 -0700 (Sat, 02 Jun 2007) | 1 line
Fix doc breakage.
................
r55745 | neal.norwitz | 2007-06-02 11:32:16 -0700 (Sat, 02 Jun 2007) | 1 line
Make a whatsnew 3.0 template.
................
r55754 | neal.norwitz | 2007-06-03 23:24:18 -0700 (Sun, 03 Jun 2007) | 1 line
SF #1730441, os._execvpe raises UnboundLocal due to new try/except semantics
................
r55755 | neal.norwitz | 2007-06-03 23:26:00 -0700 (Sun, 03 Jun 2007) | 1 line
Get rid of extra whitespace
................
r55794 | guido.van.rossum | 2007-06-06 15:29:22 -0700 (Wed, 06 Jun 2007) | 3 lines
Make this compile in GCC 2.96, which does not allow interspersing
declarations and code.
................
2007-06-06 23:52:48 +00:00
|
|
|
#include "windows.h"
|
2000-03-28 20:37:15 +00:00
|
|
|
|
|
|
|
static BOOL PyHKEY_AsHKEY(PyObject *ob, HKEY *pRes, BOOL bNoneOK);
|
2015-05-13 06:21:57 +00:00
|
|
|
static BOOL clinic_HKEY_converter(PyObject *ob, void *p);
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *PyHKEY_FromHKEY(HKEY h);
|
|
|
|
static BOOL PyHKEY_Close(PyObject *obHandle);
|
|
|
|
|
|
|
|
static char errNotAHandle[] = "Object is not a handle";
|
|
|
|
|
|
|
|
/* The win32api module reports the function name that failed,
|
|
|
|
but this concept is not in the Python core.
|
2017-11-05 13:37:50 +00:00
|
|
|
Hopefully it will one day, and in the meantime I don't
|
2000-03-28 20:37:15 +00:00
|
|
|
want to lose this info...
|
|
|
|
*/
|
|
|
|
#define PyErr_SetFromWindowsErrWithFunction(rc, fnname) \
|
2010-05-09 15:52:27 +00:00
|
|
|
PyErr_SetFromWindowsErr(rc)
|
2000-03-28 20:37:15 +00:00
|
|
|
|
|
|
|
/* Forward declares */
|
|
|
|
|
|
|
|
/* Doc strings */
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(module_doc,
|
2000-03-28 20:37:15 +00:00
|
|
|
"This module provides access to the Windows registry API.\n"
|
|
|
|
"\n"
|
|
|
|
"Functions:\n"
|
|
|
|
"\n"
|
|
|
|
"CloseKey() - Closes a registry key.\n"
|
|
|
|
"ConnectRegistry() - Establishes a connection to a predefined registry handle\n"
|
|
|
|
" on another computer.\n"
|
|
|
|
"CreateKey() - Creates the specified key, or opens it if it already exists.\n"
|
|
|
|
"DeleteKey() - Deletes the specified key.\n"
|
|
|
|
"DeleteValue() - Removes a named value from the specified registry key.\n"
|
|
|
|
"EnumKey() - Enumerates subkeys of the specified open registry key.\n"
|
|
|
|
"EnumValue() - Enumerates values of the specified open registry key.\n"
|
2015-05-13 06:21:57 +00:00
|
|
|
"ExpandEnvironmentStrings() - Expand the env strings in a REG_EXPAND_SZ\n"
|
|
|
|
" string.\n"
|
2000-03-28 20:37:15 +00:00
|
|
|
"FlushKey() - Writes all the attributes of the specified key to the registry.\n"
|
2015-05-13 06:21:57 +00:00
|
|
|
"LoadKey() - Creates a subkey under HKEY_USER or HKEY_LOCAL_MACHINE and\n"
|
|
|
|
" stores registration information from a specified file into that\n"
|
|
|
|
" subkey.\n"
|
2012-10-29 23:16:39 +00:00
|
|
|
"OpenKey() - Opens the specified key.\n"
|
|
|
|
"OpenKeyEx() - Alias of OpenKey().\n"
|
2000-03-28 20:37:15 +00:00
|
|
|
"QueryValue() - Retrieves the value associated with the unnamed value for a\n"
|
|
|
|
" specified key in the registry.\n"
|
|
|
|
"QueryValueEx() - Retrieves the type and data for a specified value name\n"
|
|
|
|
" associated with an open registry key.\n"
|
|
|
|
"QueryInfoKey() - Returns information about the specified key.\n"
|
|
|
|
"SaveKey() - Saves the specified key, and all its subkeys a file.\n"
|
|
|
|
"SetValue() - Associates a value with a specified key.\n"
|
|
|
|
"SetValueEx() - Stores data in the value field of an open registry key.\n"
|
|
|
|
"\n"
|
|
|
|
"Special objects:\n"
|
|
|
|
"\n"
|
|
|
|
"HKEYType -- type object for HKEY objects\n"
|
|
|
|
"error -- exception raised for Win32 errors\n"
|
|
|
|
"\n"
|
|
|
|
"Integer constants:\n"
|
|
|
|
"Many constants are defined - see the documentation for each function\n"
|
2002-06-13 20:33:02 +00:00
|
|
|
"to see what constants are used, and where.");
|
2000-03-28 20:37:15 +00:00
|
|
|
|
|
|
|
|
2008-04-07 03:17:54 +00:00
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
/* PyHKEY docstrings */
|
2002-06-13 20:33:02 +00:00
|
|
|
PyDoc_STRVAR(PyHKEY_doc,
|
2000-03-28 20:37:15 +00:00
|
|
|
"PyHKEY Object - A Python object, representing a win32 registry key.\n"
|
|
|
|
"\n"
|
2000-06-09 06:01:47 +00:00
|
|
|
"This object wraps a Windows HKEY object, automatically closing it when\n"
|
2000-03-28 20:37:15 +00:00
|
|
|
"the object is destroyed. To guarantee cleanup, you can call either\n"
|
|
|
|
"the Close() method on the PyHKEY, or the CloseKey() method.\n"
|
|
|
|
"\n"
|
2018-02-02 08:52:55 +00:00
|
|
|
"All functions which accept a handle object also accept an integer --\n"
|
2000-03-28 20:37:15 +00:00
|
|
|
"however, use of the handle object is encouraged.\n"
|
|
|
|
"\n"
|
|
|
|
"Functions:\n"
|
|
|
|
"Close() - Closes the underlying handle.\n"
|
|
|
|
"Detach() - Returns the integer Win32 handle, detaching it from the object\n"
|
|
|
|
"\n"
|
|
|
|
"Properties:\n"
|
|
|
|
"handle - The integer Win32 handle.\n"
|
|
|
|
"\n"
|
|
|
|
"Operations:\n"
|
2006-11-28 19:15:13 +00:00
|
|
|
"__bool__ - Handles with an open object return true, otherwise false.\n"
|
2000-03-28 20:37:15 +00:00
|
|
|
"__int__ - Converting a handle to an integer returns the Win32 handle.\n"
|
2009-02-01 10:28:51 +00:00
|
|
|
"rich comparison - Handle objects are compared using the handle value.");
|
2000-03-28 20:37:15 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
|
|
|
|
The PyHKEY object definition
|
|
|
|
|
|
|
|
************************************************************************/
|
|
|
|
typedef struct {
|
2010-05-09 15:52:27 +00:00
|
|
|
PyObject_VAR_HEAD
|
|
|
|
HKEY hkey;
|
2000-03-28 20:37:15 +00:00
|
|
|
} PyHKEYObject;
|
|
|
|
|
|
|
|
#define PyHKEY_Check(op) ((op)->ob_type == &PyHKEY_Type)
|
|
|
|
|
|
|
|
static char *failMsg = "bad operand type";
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
PyHKEY_unaryFailureFunc(PyObject *ob)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyErr_SetString(PyExc_TypeError, failMsg);
|
|
|
|
return NULL;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
static PyObject *
|
|
|
|
PyHKEY_binaryFailureFunc(PyObject *ob1, PyObject *ob2)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyErr_SetString(PyExc_TypeError, failMsg);
|
|
|
|
return NULL;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
static PyObject *
|
|
|
|
PyHKEY_ternaryFailureFunc(PyObject *ob1, PyObject *ob2, PyObject *ob3)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyErr_SetString(PyExc_TypeError, failMsg);
|
|
|
|
return NULL;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
PyHKEY_deallocFunc(PyObject *ob)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
/* Can not call PyHKEY_Close, as the ob->tp_type
|
|
|
|
has already been cleared, thus causing the type
|
|
|
|
check to fail!
|
|
|
|
*/
|
|
|
|
PyHKEYObject *obkey = (PyHKEYObject *)ob;
|
|
|
|
if (obkey->hkey)
|
|
|
|
RegCloseKey((HKEY)obkey->hkey);
|
|
|
|
PyObject_DEL(ob);
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-11-28 19:15:13 +00:00
|
|
|
PyHKEY_boolFunc(PyObject *ob)
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
return ((PyHKEYObject *)ob)->hkey != 0;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
PyHKEY_intFunc(PyObject *ob)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyHKEYObject *pyhkey = (PyHKEYObject *)ob;
|
|
|
|
return PyLong_FromVoidPtr(pyhkey->hkey);
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
PyHKEY_strFunc(PyObject *ob)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyHKEYObject *pyhkey = (PyHKEYObject *)ob;
|
|
|
|
return PyUnicode_FromFormat("<PyHKEY:%p>", pyhkey->hkey);
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
PyHKEY_compareFunc(PyObject *ob1, PyObject *ob2)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyHKEYObject *pyhkey1 = (PyHKEYObject *)ob1;
|
|
|
|
PyHKEYObject *pyhkey2 = (PyHKEYObject *)ob2;
|
|
|
|
return pyhkey1 == pyhkey2 ? 0 :
|
|
|
|
(pyhkey1 < pyhkey2 ? -1 : 1);
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2010-10-23 17:37:54 +00:00
|
|
|
static Py_hash_t
|
2000-03-28 20:37:15 +00:00
|
|
|
PyHKEY_hashFunc(PyObject *ob)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
/* Just use the address.
|
|
|
|
XXX - should we use the handle value?
|
|
|
|
*/
|
|
|
|
return _Py_HashPointer(ob);
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static PyNumberMethods PyHKEY_NumberMethods =
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyHKEY_binaryFailureFunc, /* nb_add */
|
|
|
|
PyHKEY_binaryFailureFunc, /* nb_subtract */
|
|
|
|
PyHKEY_binaryFailureFunc, /* nb_multiply */
|
|
|
|
PyHKEY_binaryFailureFunc, /* nb_remainder */
|
|
|
|
PyHKEY_binaryFailureFunc, /* nb_divmod */
|
|
|
|
PyHKEY_ternaryFailureFunc, /* nb_power */
|
|
|
|
PyHKEY_unaryFailureFunc, /* nb_negative */
|
|
|
|
PyHKEY_unaryFailureFunc, /* nb_positive */
|
|
|
|
PyHKEY_unaryFailureFunc, /* nb_absolute */
|
|
|
|
PyHKEY_boolFunc, /* nb_bool */
|
|
|
|
PyHKEY_unaryFailureFunc, /* nb_invert */
|
|
|
|
PyHKEY_binaryFailureFunc, /* nb_lshift */
|
|
|
|
PyHKEY_binaryFailureFunc, /* nb_rshift */
|
|
|
|
PyHKEY_binaryFailureFunc, /* nb_and */
|
|
|
|
PyHKEY_binaryFailureFunc, /* nb_xor */
|
|
|
|
PyHKEY_binaryFailureFunc, /* nb_or */
|
|
|
|
PyHKEY_intFunc, /* nb_int */
|
|
|
|
0, /* nb_reserved */
|
|
|
|
PyHKEY_unaryFailureFunc, /* nb_float */
|
2000-03-28 20:37:15 +00:00
|
|
|
};
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
module winreg
|
|
|
|
class winreg.HKEYType "PyHKEYObject *" "&PyHKEY_Type"
|
|
|
|
[clinic start generated code]*/
|
|
|
|
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=4c964eba3bf914d6]*/
|
|
|
|
|
|
|
|
/*[python input]
|
|
|
|
class REGSAM_converter(CConverter):
|
|
|
|
type = 'REGSAM'
|
|
|
|
format_unit = 'i'
|
|
|
|
|
|
|
|
class DWORD_converter(CConverter):
|
|
|
|
type = 'DWORD'
|
|
|
|
format_unit = 'k'
|
|
|
|
|
|
|
|
class HKEY_converter(CConverter):
|
|
|
|
type = 'HKEY'
|
|
|
|
converter = 'clinic_HKEY_converter'
|
|
|
|
|
|
|
|
class HKEY_return_converter(CReturnConverter):
|
|
|
|
type = 'HKEY'
|
|
|
|
|
|
|
|
def render(self, function, data):
|
|
|
|
self.declare(data)
|
|
|
|
self.err_occurred_if_null_pointer("_return_value", data)
|
|
|
|
data.return_conversion.append(
|
|
|
|
'return_value = PyHKEY_FromHKEY(_return_value);\n')
|
|
|
|
|
|
|
|
# HACK: this only works for PyHKEYObjects, nothing else.
|
|
|
|
# Should this be generalized and enshrined in clinic.py,
|
|
|
|
# destroy this converter with prejudice.
|
|
|
|
class self_return_converter(CReturnConverter):
|
|
|
|
type = 'PyHKEYObject *'
|
|
|
|
|
|
|
|
def render(self, function, data):
|
|
|
|
self.declare(data)
|
|
|
|
data.return_conversion.append(
|
|
|
|
'return_value = (PyObject *)_return_value;\n')
|
|
|
|
[python start generated code]*/
|
|
|
|
/*[python end generated code: output=da39a3ee5e6b4b0d input=22f7aedc6d68e80e]*/
|
|
|
|
|
|
|
|
#include "clinic/winreg.c.h"
|
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
|
|
|
|
The PyHKEY object methods
|
|
|
|
|
|
|
|
************************************************************************/
|
|
|
|
/*[clinic input]
|
|
|
|
winreg.HKEYType.Close
|
|
|
|
|
|
|
|
Closes the underlying Windows handle.
|
|
|
|
|
|
|
|
If the handle is already closed, no error is raised.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
winreg_HKEYType_Close_impl(PyHKEYObject *self)
|
|
|
|
/*[clinic end generated code: output=fced3a624fb0c344 input=6786ac75f6b89de6]*/
|
|
|
|
{
|
|
|
|
if (!PyHKEY_Close((PyObject *)self))
|
|
|
|
return NULL;
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*[clinic input]
|
|
|
|
winreg.HKEYType.Detach
|
|
|
|
|
|
|
|
Detaches the Windows handle from the handle object.
|
|
|
|
|
|
|
|
The result is the value of the handle before it is detached. If the
|
|
|
|
handle is already detached, this will return zero.
|
|
|
|
|
|
|
|
After calling this function, the handle is effectively invalidated,
|
|
|
|
but the handle is not closed. You would call this function when you
|
|
|
|
need the underlying win32 handle to exist beyond the lifetime of the
|
|
|
|
handle object.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
winreg_HKEYType_Detach_impl(PyHKEYObject *self)
|
|
|
|
/*[clinic end generated code: output=dda5a9e1a01ae78f input=dd2cc09e6c6ba833]*/
|
|
|
|
{
|
|
|
|
void* ret;
|
|
|
|
ret = (void*)self->hkey;
|
|
|
|
self->hkey = 0;
|
|
|
|
return PyLong_FromVoidPtr(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*[clinic input]
|
|
|
|
winreg.HKEYType.__enter__ -> self
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
|
|
|
static PyHKEYObject *
|
|
|
|
winreg_HKEYType___enter___impl(PyHKEYObject *self)
|
|
|
|
/*[clinic end generated code: output=52c34986dab28990 input=c40fab1f0690a8e2]*/
|
|
|
|
{
|
|
|
|
Py_XINCREF(self);
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*[clinic input]
|
|
|
|
winreg.HKEYType.__exit__
|
|
|
|
|
|
|
|
exc_type: object
|
|
|
|
exc_value: object
|
|
|
|
traceback: object
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
|
|
|
static PyObject *
|
2015-05-13 15:58:35 +00:00
|
|
|
winreg_HKEYType___exit___impl(PyHKEYObject *self, PyObject *exc_type,
|
|
|
|
PyObject *exc_value, PyObject *traceback)
|
|
|
|
/*[clinic end generated code: output=923ebe7389e6a263 input=fb32489ee92403c7]*/
|
2015-05-13 06:21:57 +00:00
|
|
|
{
|
|
|
|
if (!PyHKEY_Close((PyObject *)self))
|
|
|
|
return NULL;
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*[clinic input]
|
|
|
|
[clinic start generated code]*/
|
|
|
|
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=da39a3ee5e6b4b0d]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
|
2008-07-02 20:50:16 +00:00
|
|
|
static struct PyMethodDef PyHKEY_methods[] = {
|
2015-05-13 06:21:57 +00:00
|
|
|
WINREG_HKEYTYPE_CLOSE_METHODDEF
|
|
|
|
WINREG_HKEYTYPE_DETACH_METHODDEF
|
|
|
|
WINREG_HKEYTYPE___ENTER___METHODDEF
|
|
|
|
WINREG_HKEYTYPE___EXIT___METHODDEF
|
2010-05-09 15:52:27 +00:00
|
|
|
{NULL}
|
2008-07-02 20:50:16 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define OFF(e) offsetof(PyHKEYObject, e)
|
|
|
|
static PyMemberDef PyHKEY_memberlist[] = {
|
2010-05-09 15:52:27 +00:00
|
|
|
{"handle", T_INT, OFF(hkey), READONLY},
|
|
|
|
{NULL} /* Sentinel */
|
2008-07-02 20:50:16 +00:00
|
|
|
};
|
2000-03-28 20:37:15 +00:00
|
|
|
|
|
|
|
/* The type itself */
|
|
|
|
PyTypeObject PyHKEY_Type =
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyVarObject_HEAD_INIT(0, 0) /* fill in type at module init */
|
|
|
|
"PyHKEY",
|
|
|
|
sizeof(PyHKEYObject),
|
|
|
|
0,
|
|
|
|
PyHKEY_deallocFunc, /* tp_dealloc */
|
|
|
|
0, /* tp_print */
|
|
|
|
0, /* tp_getattr */
|
|
|
|
0, /* tp_setattr */
|
|
|
|
0, /* tp_reserved */
|
|
|
|
0, /* tp_repr */
|
|
|
|
&PyHKEY_NumberMethods, /* tp_as_number */
|
|
|
|
0, /* tp_as_sequence */
|
|
|
|
0, /* tp_as_mapping */
|
|
|
|
PyHKEY_hashFunc, /* tp_hash */
|
|
|
|
0, /* tp_call */
|
|
|
|
PyHKEY_strFunc, /* tp_str */
|
|
|
|
0, /* tp_getattro */
|
|
|
|
0, /* tp_setattro */
|
|
|
|
0, /* tp_as_buffer */
|
|
|
|
0, /* tp_flags */
|
|
|
|
PyHKEY_doc, /* tp_doc */
|
|
|
|
0, /*tp_traverse*/
|
|
|
|
0, /*tp_clear*/
|
|
|
|
0, /*tp_richcompare*/
|
|
|
|
0, /*tp_weaklistoffset*/
|
|
|
|
0, /*tp_iter*/
|
|
|
|
0, /*tp_iternext*/
|
|
|
|
PyHKEY_methods, /*tp_methods*/
|
|
|
|
PyHKEY_memberlist, /*tp_members*/
|
2000-03-28 20:37:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
The public PyHKEY API (well, not public yet :-)
|
|
|
|
************************************************************************/
|
|
|
|
PyObject *
|
|
|
|
PyHKEY_New(HKEY hInit)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyHKEYObject *key = PyObject_NEW(PyHKEYObject, &PyHKEY_Type);
|
|
|
|
if (key)
|
|
|
|
key->hkey = hInit;
|
|
|
|
return (PyObject *)key;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
|
|
PyHKEY_Close(PyObject *ob_handle)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
LONG rc;
|
|
|
|
PyHKEYObject *key;
|
|
|
|
|
|
|
|
if (!PyHKEY_Check(ob_handle)) {
|
|
|
|
PyErr_SetString(PyExc_TypeError, "bad operand type");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
key = (PyHKEYObject *)ob_handle;
|
|
|
|
rc = key->hkey ? RegCloseKey((HKEY)key->hkey) : ERROR_SUCCESS;
|
|
|
|
key->hkey = 0;
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");
|
|
|
|
return rc == ERROR_SUCCESS;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
|
|
PyHKEY_AsHKEY(PyObject *ob, HKEY *pHANDLE, BOOL bNoneOK)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
if (ob == Py_None) {
|
|
|
|
if (!bNoneOK) {
|
|
|
|
PyErr_SetString(
|
|
|
|
PyExc_TypeError,
|
|
|
|
"None is not a valid HKEY in this context");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
*pHANDLE = (HKEY)0;
|
|
|
|
}
|
|
|
|
else if (PyHKEY_Check(ob)) {
|
|
|
|
PyHKEYObject *pH = (PyHKEYObject *)ob;
|
|
|
|
*pHANDLE = pH->hkey;
|
|
|
|
}
|
|
|
|
else if (PyLong_Check(ob)) {
|
|
|
|
/* We also support integers */
|
|
|
|
PyErr_Clear();
|
|
|
|
*pHANDLE = (HKEY)PyLong_AsVoidPtr(ob);
|
|
|
|
if (PyErr_Occurred())
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
PyErr_SetString(
|
|
|
|
PyExc_TypeError,
|
|
|
|
"The object is not a PyHKEY object");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
return TRUE;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
BOOL
|
|
|
|
clinic_HKEY_converter(PyObject *ob, void *p)
|
|
|
|
{
|
|
|
|
if (!PyHKEY_AsHKEY(ob, (HKEY *)p, FALSE))
|
|
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
PyObject *
|
|
|
|
PyHKEY_FromHKEY(HKEY h)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyHKEYObject *op;
|
|
|
|
|
|
|
|
/* Inline PyObject_New */
|
|
|
|
op = (PyHKEYObject *) PyObject_MALLOC(sizeof(PyHKEYObject));
|
|
|
|
if (op == NULL)
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
PyObject_INIT(op, &PyHKEY_Type);
|
|
|
|
op->hkey = h;
|
|
|
|
return (PyObject *)op;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
The module methods
|
|
|
|
************************************************************************/
|
|
|
|
BOOL
|
|
|
|
PyWinObject_CloseHKEY(PyObject *obHandle)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
BOOL ok;
|
|
|
|
if (PyHKEY_Check(obHandle)) {
|
|
|
|
ok = PyHKEY_Close(obHandle);
|
|
|
|
}
|
2000-06-30 17:48:51 +00:00
|
|
|
#if SIZEOF_LONG >= SIZEOF_HKEY
|
2010-05-09 15:52:27 +00:00
|
|
|
else if (PyLong_Check(obHandle)) {
|
|
|
|
long rc = RegCloseKey((HKEY)PyLong_AsLong(obHandle));
|
|
|
|
ok = (rc == ERROR_SUCCESS);
|
|
|
|
if (!ok)
|
|
|
|
PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");
|
|
|
|
}
|
2000-06-30 17:48:51 +00:00
|
|
|
#else
|
2010-05-09 15:52:27 +00:00
|
|
|
else if (PyLong_Check(obHandle)) {
|
|
|
|
long rc = RegCloseKey((HKEY)PyLong_AsVoidPtr(obHandle));
|
|
|
|
ok = (rc == ERROR_SUCCESS);
|
|
|
|
if (!ok)
|
|
|
|
PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");
|
|
|
|
}
|
2000-06-30 17:48:51 +00:00
|
|
|
#endif
|
2010-05-09 15:52:27 +00:00
|
|
|
else {
|
|
|
|
PyErr_SetString(
|
|
|
|
PyExc_TypeError,
|
|
|
|
"A handle must be a HKEY object or an integer");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
return ok;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
Private Helper functions for the registry interfaces
|
|
|
|
|
|
|
|
** Note that fixupMultiSZ and countString have both had changes
|
|
|
|
** made to support "incorrect strings". The registry specification
|
|
|
|
** calls for strings to be terminated with 2 null bytes. It seems
|
2017-11-05 13:37:50 +00:00
|
|
|
** some commercial packages install strings which don't conform,
|
2000-03-28 20:37:15 +00:00
|
|
|
** causing this code to fail - however, "regedit" etc still work
|
2017-11-05 13:37:50 +00:00
|
|
|
** with these strings (ie only we don't!).
|
2000-03-28 20:37:15 +00:00
|
|
|
*/
|
|
|
|
static void
|
2007-09-03 07:43:05 +00:00
|
|
|
fixupMultiSZ(wchar_t **str, wchar_t *data, int len)
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
wchar_t *P;
|
|
|
|
int i;
|
|
|
|
wchar_t *Q;
|
|
|
|
|
|
|
|
Q = data + len;
|
|
|
|
for (P = data, i = 0; P < Q && *P != '\0'; P++, i++) {
|
|
|
|
str[i] = P;
|
|
|
|
for(; *P != '\0'; P++)
|
|
|
|
;
|
|
|
|
}
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-09-03 07:43:05 +00:00
|
|
|
countStrings(wchar_t *data, int len)
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
int strings;
|
|
|
|
wchar_t *P;
|
|
|
|
wchar_t *Q = data + len;
|
|
|
|
|
|
|
|
for (P = data, strings = 0; P < Q && *P != '\0'; P++, strings++)
|
|
|
|
for (; P < Q && *P != '\0'; P++)
|
|
|
|
;
|
|
|
|
return strings;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert PyObject into Registry data.
|
|
|
|
Allocates space as needed. */
|
|
|
|
static BOOL
|
|
|
|
Py2Reg(PyObject *value, DWORD typ, BYTE **retDataBuf, DWORD *retDataSize)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_ssize_t i,j;
|
|
|
|
switch (typ) {
|
|
|
|
case REG_DWORD:
|
|
|
|
if (value != Py_None && !PyLong_Check(value))
|
|
|
|
return FALSE;
|
|
|
|
*retDataBuf = (BYTE *)PyMem_NEW(DWORD, 1);
|
2016-05-25 18:26:07 +00:00
|
|
|
if (*retDataBuf == NULL){
|
2010-05-09 15:52:27 +00:00
|
|
|
PyErr_NoMemory();
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
*retDataSize = sizeof(DWORD);
|
|
|
|
if (value == Py_None) {
|
|
|
|
DWORD zero = 0;
|
|
|
|
memcpy(*retDataBuf, &zero, sizeof(DWORD));
|
|
|
|
}
|
|
|
|
else {
|
2012-12-27 16:12:45 +00:00
|
|
|
DWORD d = PyLong_AsUnsignedLong(value);
|
2010-05-09 15:52:27 +00:00
|
|
|
memcpy(*retDataBuf, &d, sizeof(DWORD));
|
|
|
|
}
|
|
|
|
break;
|
2016-05-24 22:42:04 +00:00
|
|
|
case REG_QWORD:
|
|
|
|
if (value != Py_None && !PyLong_Check(value))
|
|
|
|
return FALSE;
|
|
|
|
*retDataBuf = (BYTE *)PyMem_NEW(DWORD64, 1);
|
2016-05-25 18:26:07 +00:00
|
|
|
if (*retDataBuf == NULL){
|
2016-05-24 22:42:04 +00:00
|
|
|
PyErr_NoMemory();
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
*retDataSize = sizeof(DWORD64);
|
|
|
|
if (value == Py_None) {
|
|
|
|
DWORD64 zero = 0;
|
|
|
|
memcpy(*retDataBuf, &zero, sizeof(DWORD64));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
DWORD64 d = PyLong_AsUnsignedLongLong(value);
|
|
|
|
memcpy(*retDataBuf, &d, sizeof(DWORD64));
|
|
|
|
}
|
|
|
|
break;
|
2010-05-09 15:52:27 +00:00
|
|
|
case REG_SZ:
|
|
|
|
case REG_EXPAND_SZ:
|
|
|
|
{
|
2011-11-21 11:43:50 +00:00
|
|
|
if (value != Py_None) {
|
|
|
|
Py_ssize_t len;
|
|
|
|
if (!PyUnicode_Check(value))
|
|
|
|
return FALSE;
|
|
|
|
*retDataBuf = (BYTE*)PyUnicode_AsWideCharString(value, &len);
|
|
|
|
if (*retDataBuf == NULL)
|
|
|
|
return FALSE;
|
|
|
|
*retDataSize = Py_SAFE_DOWNCAST(
|
|
|
|
(len + 1) * sizeof(wchar_t),
|
|
|
|
Py_ssize_t, DWORD);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
*retDataBuf = (BYTE *)PyMem_NEW(wchar_t, 1);
|
|
|
|
if (*retDataBuf == NULL) {
|
|
|
|
PyErr_NoMemory();
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
((wchar_t *)*retDataBuf)[0] = L'\0';
|
|
|
|
*retDataSize = 1 * sizeof(wchar_t);
|
|
|
|
}
|
|
|
|
break;
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
case REG_MULTI_SZ:
|
|
|
|
{
|
|
|
|
DWORD size = 0;
|
|
|
|
wchar_t *P;
|
|
|
|
|
|
|
|
if (value == Py_None)
|
|
|
|
i = 0;
|
|
|
|
else {
|
|
|
|
if (!PyList_Check(value))
|
|
|
|
return FALSE;
|
|
|
|
i = PyList_Size(value);
|
|
|
|
}
|
|
|
|
for (j = 0; j < i; j++)
|
|
|
|
{
|
|
|
|
PyObject *t;
|
2011-11-21 11:43:50 +00:00
|
|
|
wchar_t *wstr;
|
|
|
|
Py_ssize_t len;
|
|
|
|
|
2010-05-09 15:52:27 +00:00
|
|
|
t = PyList_GET_ITEM(value, j);
|
|
|
|
if (!PyUnicode_Check(t))
|
|
|
|
return FALSE;
|
2011-11-21 11:43:50 +00:00
|
|
|
wstr = PyUnicode_AsUnicodeAndSize(t, &len);
|
|
|
|
if (wstr == NULL)
|
|
|
|
return FALSE;
|
|
|
|
size += Py_SAFE_DOWNCAST((len + 1) * sizeof(wchar_t),
|
2010-08-17 20:08:40 +00:00
|
|
|
size_t, DWORD);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*retDataSize = size + 2;
|
|
|
|
*retDataBuf = (BYTE *)PyMem_NEW(char,
|
|
|
|
*retDataSize);
|
2016-05-25 18:26:07 +00:00
|
|
|
if (*retDataBuf == NULL){
|
2010-05-09 15:52:27 +00:00
|
|
|
PyErr_NoMemory();
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
P = (wchar_t *)*retDataBuf;
|
|
|
|
|
|
|
|
for (j = 0; j < i; j++)
|
|
|
|
{
|
|
|
|
PyObject *t;
|
2011-11-21 11:43:50 +00:00
|
|
|
wchar_t *wstr;
|
|
|
|
Py_ssize_t len;
|
|
|
|
|
2010-05-09 15:52:27 +00:00
|
|
|
t = PyList_GET_ITEM(value, j);
|
2011-11-21 11:43:50 +00:00
|
|
|
wstr = PyUnicode_AsUnicodeAndSize(t, &len);
|
|
|
|
if (wstr == NULL)
|
|
|
|
return FALSE;
|
|
|
|
wcscpy(P, wstr);
|
|
|
|
P += (len + 1);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
/* And doubly-terminate the list... */
|
|
|
|
*P = '\0';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case REG_BINARY:
|
|
|
|
/* ALSO handle ALL unknown data types here. Even if we can't
|
|
|
|
support it natively, we should handle the bits. */
|
|
|
|
default:
|
2014-07-03 15:58:06 +00:00
|
|
|
if (value == Py_None) {
|
2010-05-09 15:52:27 +00:00
|
|
|
*retDataSize = 0;
|
2014-07-03 15:58:06 +00:00
|
|
|
*retDataBuf = NULL;
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
else {
|
|
|
|
Py_buffer view;
|
|
|
|
|
|
|
|
if (!PyObject_CheckBuffer(value)) {
|
|
|
|
PyErr_Format(PyExc_TypeError,
|
|
|
|
"Objects of type '%s' can not "
|
|
|
|
"be used as binary registry values",
|
|
|
|
value->ob_type->tp_name);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (PyObject_GetBuffer(value, &view, PyBUF_SIMPLE) < 0)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
*retDataBuf = (BYTE *)PyMem_NEW(char, view.len);
|
2016-05-25 18:26:07 +00:00
|
|
|
if (*retDataBuf == NULL){
|
2010-05-09 15:52:27 +00:00
|
|
|
PyBuffer_Release(&view);
|
|
|
|
PyErr_NoMemory();
|
|
|
|
return FALSE;
|
|
|
|
}
|
2010-08-17 20:08:40 +00:00
|
|
|
*retDataSize = Py_SAFE_DOWNCAST(view.len, Py_ssize_t, DWORD);
|
2010-05-09 15:52:27 +00:00
|
|
|
memcpy(*retDataBuf, view.buf, view.len);
|
|
|
|
PyBuffer_Release(&view);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return TRUE;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert Registry data into PyObject*/
|
|
|
|
static PyObject *
|
2007-09-03 07:43:05 +00:00
|
|
|
Reg2Py(BYTE *retDataBuf, DWORD retDataSize, DWORD typ)
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyObject *obData;
|
|
|
|
|
|
|
|
switch (typ) {
|
|
|
|
case REG_DWORD:
|
|
|
|
if (retDataSize == 0)
|
2012-12-27 20:04:42 +00:00
|
|
|
obData = PyLong_FromUnsignedLong(0);
|
2010-05-09 15:52:27 +00:00
|
|
|
else
|
2016-05-24 22:42:04 +00:00
|
|
|
obData = PyLong_FromUnsignedLong(*(DWORD *)retDataBuf);
|
|
|
|
break;
|
|
|
|
case REG_QWORD:
|
|
|
|
if (retDataSize == 0)
|
|
|
|
obData = PyLong_FromUnsignedLongLong(0);
|
|
|
|
else
|
|
|
|
obData = PyLong_FromUnsignedLongLong(*(DWORD64 *)retDataBuf);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
case REG_SZ:
|
|
|
|
case REG_EXPAND_SZ:
|
|
|
|
{
|
2016-12-17 21:30:27 +00:00
|
|
|
/* REG_SZ should be a NUL terminated string, but only by
|
|
|
|
* convention. The buffer may have been saved without a NUL
|
|
|
|
* or with embedded NULs. To be consistent with reg.exe and
|
|
|
|
* regedit.exe, consume only up to the first NUL. */
|
2010-05-09 15:52:27 +00:00
|
|
|
wchar_t *data = (wchar_t *)retDataBuf;
|
2016-12-17 21:30:27 +00:00
|
|
|
size_t len = wcsnlen(data, retDataSize / sizeof(wchar_t));
|
|
|
|
obData = PyUnicode_FromWideChar(data, len);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case REG_MULTI_SZ:
|
|
|
|
if (retDataSize == 0)
|
|
|
|
obData = PyList_New(0);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int index = 0;
|
|
|
|
wchar_t *data = (wchar_t *)retDataBuf;
|
|
|
|
int len = retDataSize / 2;
|
|
|
|
int s = countStrings(data, len);
|
2015-02-16 11:28:22 +00:00
|
|
|
wchar_t **str = PyMem_New(wchar_t *, s);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (str == NULL)
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
|
|
|
|
fixupMultiSZ(str, data, len);
|
|
|
|
obData = PyList_New(s);
|
2014-03-13 16:35:32 +00:00
|
|
|
if (obData == NULL) {
|
2014-03-13 18:08:10 +00:00
|
|
|
PyMem_Free(str);
|
2010-05-09 15:52:27 +00:00
|
|
|
return NULL;
|
2014-03-13 16:35:32 +00:00
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
for (index = 0; index < s; index++)
|
|
|
|
{
|
|
|
|
size_t len = wcslen(str[index]);
|
|
|
|
if (len > INT_MAX) {
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
"registry string is too long for a Python string");
|
|
|
|
Py_DECREF(obData);
|
2014-03-13 18:08:10 +00:00
|
|
|
PyMem_Free(str);
|
2010-05-09 15:52:27 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
PyList_SetItem(obData,
|
|
|
|
index,
|
2011-09-28 05:41:54 +00:00
|
|
|
PyUnicode_FromWideChar(str[index], len));
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
2013-07-07 14:21:41 +00:00
|
|
|
PyMem_Free(str);
|
2010-05-09 15:52:27 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case REG_BINARY:
|
|
|
|
/* ALSO handle ALL unknown data types here. Even if we can't
|
|
|
|
support it natively, we should handle the bits. */
|
|
|
|
default:
|
|
|
|
if (retDataSize == 0) {
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
obData = Py_None;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
obData = PyBytes_FromStringAndSize(
|
|
|
|
(char *)retDataBuf, retDataSize);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return obData;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The Python methods */
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.CloseKey
|
|
|
|
|
|
|
|
hkey: object
|
|
|
|
A previously opened key.
|
|
|
|
/
|
|
|
|
|
|
|
|
Closes a previously opened registry key.
|
|
|
|
|
|
|
|
Note that if the key is not closed using this method, it will be
|
|
|
|
closed when the hkey object is destroyed by Python.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_CloseKey(PyObject *module, PyObject *hkey)
|
|
|
|
/*[clinic end generated code: output=a4fa537019a80d15 input=5b1aac65ba5127ad]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2015-05-13 06:21:57 +00:00
|
|
|
if (!PyHKEY_Close(hkey))
|
2010-05-09 15:52:27 +00:00
|
|
|
return NULL;
|
2015-05-13 06:21:57 +00:00
|
|
|
Py_RETURN_NONE;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.ConnectRegistry -> HKEY
|
|
|
|
|
2015-05-13 15:58:35 +00:00
|
|
|
computer_name: Py_UNICODE(accept={str, NoneType})
|
2015-05-13 06:21:57 +00:00
|
|
|
The name of the remote computer, of the form r"\\computername". If
|
|
|
|
None, the local computer is used.
|
|
|
|
key: HKEY
|
|
|
|
The predefined key to connect to.
|
|
|
|
/
|
|
|
|
|
2016-04-17 05:32:47 +00:00
|
|
|
Establishes a connection to the registry on another computer.
|
2015-05-13 06:21:57 +00:00
|
|
|
|
|
|
|
The return value is the handle of the opened key.
|
|
|
|
If the function fails, an OSError exception is raised.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
|
|
|
static HKEY
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_ConnectRegistry_impl(PyObject *module, Py_UNICODE *computer_name,
|
2015-05-13 15:58:35 +00:00
|
|
|
HKEY key)
|
2016-07-07 14:35:15 +00:00
|
|
|
/*[clinic end generated code: output=5ab79d02aa3167b4 input=5f98a891a347e68e]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
HKEY retKey;
|
|
|
|
long rc;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegConnectRegistryW(computer_name, key, &retKey);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
|
|
PyErr_SetFromWindowsErrWithFunction(rc, "ConnectRegistry");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return retKey;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.CreateKey -> HKEY
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or one of the predefined HKEY_* constants.
|
2015-05-13 15:58:35 +00:00
|
|
|
sub_key: Py_UNICODE(accept={str, NoneType})
|
2015-05-13 06:21:57 +00:00
|
|
|
The name of the key this method opens or creates.
|
|
|
|
/
|
|
|
|
|
|
|
|
Creates or opens the specified key.
|
|
|
|
|
|
|
|
If key is one of the predefined keys, sub_key may be None. In that case,
|
|
|
|
the handle returned is the same key handle passed in to the function.
|
|
|
|
|
|
|
|
If the key already exists, this function opens the existing key.
|
|
|
|
|
|
|
|
The return value is the handle of the opened key.
|
|
|
|
If the function fails, an OSError exception is raised.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
|
|
|
static HKEY
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_CreateKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key)
|
|
|
|
/*[clinic end generated code: output=9c81d4095527c927 input=3cdd1622488acea2]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
HKEY retKey;
|
|
|
|
long rc;
|
2015-05-13 06:21:57 +00:00
|
|
|
|
|
|
|
rc = RegCreateKeyW(key, sub_key, &retKey);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
|
|
PyErr_SetFromWindowsErrWithFunction(rc, "CreateKey");
|
2010-05-09 15:52:27 +00:00
|
|
|
return NULL;
|
2015-05-13 06:21:57 +00:00
|
|
|
}
|
|
|
|
return retKey;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.CreateKeyEx -> HKEY
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or one of the predefined HKEY_* constants.
|
2015-05-13 15:58:35 +00:00
|
|
|
sub_key: Py_UNICODE(accept={str, NoneType})
|
2015-05-13 06:21:57 +00:00
|
|
|
The name of the key this method opens or creates.
|
|
|
|
reserved: int = 0
|
|
|
|
A reserved integer, and must be zero. Default is zero.
|
|
|
|
access: REGSAM(c_default='KEY_WRITE') = winreg.KEY_WRITE
|
|
|
|
An integer that specifies an access mask that describes the
|
|
|
|
desired security access for the key. Default is KEY_WRITE.
|
|
|
|
|
|
|
|
Creates or opens the specified key.
|
|
|
|
|
|
|
|
If key is one of the predefined keys, sub_key may be None. In that case,
|
|
|
|
the handle returned is the same key handle passed in to the function.
|
|
|
|
|
|
|
|
If the key already exists, this function opens the existing key
|
|
|
|
|
|
|
|
The return value is the handle of the opened key.
|
|
|
|
If the function fails, an OSError exception is raised.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
|
|
|
static HKEY
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_CreateKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
|
2015-05-13 15:58:35 +00:00
|
|
|
int reserved, REGSAM access)
|
2016-07-07 14:35:15 +00:00
|
|
|
/*[clinic end generated code: output=b9fce6dc5c4e39b1 input=42c2b03f98406b66]*/
|
2010-04-21 23:56:21 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
HKEY retKey;
|
|
|
|
long rc;
|
2010-09-27 17:56:36 +00:00
|
|
|
|
2017-07-26 22:17:57 +00:00
|
|
|
rc = RegCreateKeyExW(key, sub_key, reserved, NULL, 0,
|
2010-09-27 17:56:36 +00:00
|
|
|
access, NULL, &retKey, NULL);
|
2015-05-13 06:21:57 +00:00
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
|
|
PyErr_SetFromWindowsErrWithFunction(rc, "CreateKeyEx");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return retKey;
|
2010-04-21 23:56:21 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.DeleteKey
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
|
|
|
sub_key: Py_UNICODE
|
|
|
|
A string that must be the name of a subkey of the key identified by
|
|
|
|
the key parameter. This value must not be None, and the key may not
|
|
|
|
have subkeys.
|
|
|
|
/
|
|
|
|
|
|
|
|
Deletes the specified key.
|
|
|
|
|
|
|
|
This method can not delete keys with subkeys.
|
|
|
|
|
|
|
|
If the function succeeds, the entire key, including all of its values,
|
|
|
|
is removed. If the function fails, an OSError exception is raised.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_DeleteKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key)
|
|
|
|
/*[clinic end generated code: output=7734b1e431991ae4 input=b31d225b935e4211]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
long rc;
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegDeleteKeyW(key, sub_key );
|
2010-05-09 15:52:27 +00:00
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc, "RegDeleteKey");
|
2015-05-13 06:21:57 +00:00
|
|
|
Py_RETURN_NONE;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.DeleteKeyEx
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
|
|
|
sub_key: Py_UNICODE
|
|
|
|
A string that must be the name of a subkey of the key identified by
|
|
|
|
the key parameter. This value must not be None, and the key may not
|
|
|
|
have subkeys.
|
|
|
|
access: REGSAM(c_default='KEY_WOW64_64KEY') = winreg.KEY_WOW64_64KEY
|
|
|
|
An integer that specifies an access mask that describes the
|
|
|
|
desired security access for the key. Default is KEY_WOW64_64KEY.
|
|
|
|
reserved: int = 0
|
|
|
|
A reserved integer, and must be zero. Default is zero.
|
|
|
|
|
|
|
|
Deletes the specified key (64-bit OS only).
|
|
|
|
|
|
|
|
This method can not delete keys with subkeys.
|
|
|
|
|
|
|
|
If the function succeeds, the entire key, including all of its values,
|
|
|
|
is removed. If the function fails, an OSError exception is raised.
|
|
|
|
On unsupported Windows versions, NotImplementedError is raised.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2010-04-21 23:56:21 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_DeleteKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
|
2015-05-13 15:58:35 +00:00
|
|
|
REGSAM access, int reserved)
|
2016-07-07 14:35:15 +00:00
|
|
|
/*[clinic end generated code: output=01378d86ad3eb936 input=711d9d89e7ecbed7]*/
|
2010-04-21 23:56:21 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
HMODULE hMod;
|
|
|
|
typedef LONG (WINAPI *RDKEFunc)(HKEY, const wchar_t*, REGSAM, int);
|
|
|
|
RDKEFunc pfn = NULL;
|
|
|
|
long rc;
|
|
|
|
|
|
|
|
/* Only available on 64bit platforms, so we must load it
|
|
|
|
dynamically. */
|
2012-01-14 16:54:09 +00:00
|
|
|
hMod = GetModuleHandleW(L"advapi32.dll");
|
2010-05-09 15:52:27 +00:00
|
|
|
if (hMod)
|
|
|
|
pfn = (RDKEFunc)GetProcAddress(hMod,
|
|
|
|
"RegDeleteKeyExW");
|
|
|
|
if (!pfn) {
|
|
|
|
PyErr_SetString(PyExc_NotImplementedError,
|
|
|
|
"not implemented on this platform");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = (*pfn)(key, sub_key, access, reserved);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc, "RegDeleteKeyEx");
|
2015-05-13 06:21:57 +00:00
|
|
|
Py_RETURN_NONE;
|
2010-04-21 23:56:21 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.DeleteValue
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
2015-05-13 15:58:35 +00:00
|
|
|
value: Py_UNICODE(accept={str, NoneType})
|
2015-05-13 06:21:57 +00:00
|
|
|
A string that identifies the value to remove.
|
|
|
|
/
|
|
|
|
|
|
|
|
Removes a named value from a registry key.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_DeleteValue_impl(PyObject *module, HKEY key, Py_UNICODE *value)
|
|
|
|
/*[clinic end generated code: output=67e7e9a514f84951 input=a78d3407a4197b21]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
long rc;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegDeleteValueW(key, value);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc !=ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc,
|
|
|
|
"RegDeleteValue");
|
2015-05-13 06:21:57 +00:00
|
|
|
Py_RETURN_NONE;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.EnumKey
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
|
|
|
index: int
|
|
|
|
An integer that identifies the index of the key to retrieve.
|
|
|
|
/
|
|
|
|
|
|
|
|
Enumerates subkeys of an open registry key.
|
|
|
|
|
|
|
|
The function retrieves the name of one subkey each time it is called.
|
|
|
|
It is typically called repeatedly until an OSError exception is
|
|
|
|
raised, indicating no more values are available.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_EnumKey_impl(PyObject *module, HKEY key, int index)
|
|
|
|
/*[clinic end generated code: output=25a6ec52cd147bc4 input=fad9a7c00ab0e04b]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
long rc;
|
|
|
|
PyObject *retStr;
|
2010-05-26 17:43:50 +00:00
|
|
|
|
|
|
|
/* The Windows docs claim that the max key name length is 255
|
|
|
|
* characters, plus a terminating nul character. However,
|
|
|
|
* empirical testing demonstrates that it is possible to
|
|
|
|
* create a 256 character key that is missing the terminating
|
|
|
|
* nul. RegEnumKeyEx requires a 257 character buffer to
|
|
|
|
* retrieve such a key name. */
|
|
|
|
wchar_t tmpbuf[257];
|
2012-04-02 15:23:29 +00:00
|
|
|
DWORD len = sizeof(tmpbuf)/sizeof(wchar_t); /* includes NULL terminator */
|
2010-05-09 15:52:27 +00:00
|
|
|
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegEnumKeyExW(key, index, tmpbuf, &len, NULL, NULL, NULL, NULL);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc, "RegEnumKeyEx");
|
|
|
|
|
2011-09-28 05:41:54 +00:00
|
|
|
retStr = PyUnicode_FromWideChar(tmpbuf, len);
|
2010-05-09 15:52:27 +00:00
|
|
|
return retStr; /* can be NULL */
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.EnumValue
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
|
|
|
index: int
|
|
|
|
An integer that identifies the index of the value to retrieve.
|
|
|
|
/
|
|
|
|
|
|
|
|
Enumerates values of an open registry key.
|
|
|
|
|
|
|
|
The function retrieves the name of one subkey each time it is called.
|
|
|
|
It is typically called repeatedly, until an OSError exception
|
|
|
|
is raised, indicating no more values.
|
|
|
|
|
|
|
|
The result is a tuple of 3 items:
|
|
|
|
value_name
|
|
|
|
A string that identifies the value.
|
|
|
|
value_data
|
|
|
|
An object that holds the value data, and whose type depends
|
|
|
|
on the underlying registry type.
|
|
|
|
data_type
|
|
|
|
An integer that identifies the type of the value data.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_EnumValue_impl(PyObject *module, HKEY key, int index)
|
|
|
|
/*[clinic end generated code: output=d363b5a06f8789ac input=4414f47a6fb238b5]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
long rc;
|
|
|
|
wchar_t *retValueBuf;
|
2010-08-16 22:11:29 +00:00
|
|
|
BYTE *tmpBuf;
|
2010-05-09 15:52:27 +00:00
|
|
|
BYTE *retDataBuf;
|
2010-05-26 17:43:50 +00:00
|
|
|
DWORD retValueSize, bufValueSize;
|
|
|
|
DWORD retDataSize, bufDataSize;
|
2010-05-09 15:52:27 +00:00
|
|
|
DWORD typ;
|
|
|
|
PyObject *obData;
|
|
|
|
PyObject *retVal;
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
if ((rc = RegQueryInfoKeyW(key, NULL, NULL, NULL, NULL, NULL, NULL,
|
2010-05-09 15:52:27 +00:00
|
|
|
NULL,
|
|
|
|
&retValueSize, &retDataSize, NULL, NULL))
|
|
|
|
!= ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc,
|
|
|
|
"RegQueryInfoKey");
|
|
|
|
++retValueSize; /* include null terminators */
|
|
|
|
++retDataSize;
|
2010-05-26 17:43:50 +00:00
|
|
|
bufDataSize = retDataSize;
|
|
|
|
bufValueSize = retValueSize;
|
2015-02-16 11:28:22 +00:00
|
|
|
retValueBuf = PyMem_New(wchar_t, retValueSize);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (retValueBuf == NULL)
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
retDataBuf = (BYTE *)PyMem_Malloc(retDataSize);
|
|
|
|
if (retDataBuf == NULL) {
|
|
|
|
PyMem_Free(retValueBuf);
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
}
|
|
|
|
|
2010-05-26 17:43:50 +00:00
|
|
|
while (1) {
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegEnumValueW(key,
|
2010-05-26 17:43:50 +00:00
|
|
|
index,
|
|
|
|
retValueBuf,
|
|
|
|
&retValueSize,
|
|
|
|
NULL,
|
|
|
|
&typ,
|
|
|
|
(BYTE *)retDataBuf,
|
|
|
|
&retDataSize);
|
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
|
|
|
|
if (rc != ERROR_MORE_DATA)
|
|
|
|
break;
|
|
|
|
|
|
|
|
bufDataSize *= 2;
|
2010-08-16 22:11:29 +00:00
|
|
|
tmpBuf = (BYTE *)PyMem_Realloc(retDataBuf, bufDataSize);
|
2010-06-08 20:57:52 +00:00
|
|
|
if (tmpBuf == NULL) {
|
2010-05-26 17:43:50 +00:00
|
|
|
PyErr_NoMemory();
|
|
|
|
retVal = NULL;
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-06-08 20:57:52 +00:00
|
|
|
retDataBuf = tmpBuf;
|
2010-05-26 17:43:50 +00:00
|
|
|
retDataSize = bufDataSize;
|
|
|
|
retValueSize = bufValueSize;
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
|
|
retVal = PyErr_SetFromWindowsErrWithFunction(rc,
|
|
|
|
"PyRegEnumValue");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
obData = Reg2Py(retDataBuf, retDataSize, typ);
|
|
|
|
if (obData == NULL) {
|
|
|
|
retVal = NULL;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
retVal = Py_BuildValue("uOi", retValueBuf, obData, typ);
|
|
|
|
Py_DECREF(obData);
|
2003-11-30 22:01:43 +00:00
|
|
|
fail:
|
2010-05-09 15:52:27 +00:00
|
|
|
PyMem_Free(retValueBuf);
|
|
|
|
PyMem_Free(retDataBuf);
|
|
|
|
return retVal;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.ExpandEnvironmentStrings
|
|
|
|
|
|
|
|
string: Py_UNICODE
|
|
|
|
/
|
|
|
|
|
|
|
|
Expand environment vars.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
Merged revisions 59843-59863 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r59844 | raymond.hettinger | 2008-01-07 21:56:05 +0100 (Mon, 07 Jan 2008) | 1 line
Use get() instead of pop() for the optimized version of _replace().
........
r59847 | raymond.hettinger | 2008-01-07 22:33:51 +0100 (Mon, 07 Jan 2008) | 1 line
Documentation nits.
........
r59849 | raymond.hettinger | 2008-01-08 03:02:05 +0100 (Tue, 08 Jan 2008) | 1 line
Expand comment.
........
r59850 | raymond.hettinger | 2008-01-08 03:24:15 +0100 (Tue, 08 Jan 2008) | 1 line
Docs on named tuple's naming conventions and limits of subclassing
........
r59851 | christian.heimes | 2008-01-08 04:40:04 +0100 (Tue, 08 Jan 2008) | 1 line
It's verbose, not debug
........
r59852 | facundo.batista | 2008-01-08 13:25:20 +0100 (Tue, 08 Jan 2008) | 4 lines
Issue #1757: The hash of a Decimal instance is no longer affected
by the current context. Thanks Mark Dickinson.
........
r59853 | andrew.kuchling | 2008-01-08 15:30:55 +0100 (Tue, 08 Jan 2008) | 1 line
Patch 1137: allow assigning to .buffer_size attribute of PyExpat.parser objects
........
r59854 | andrew.kuchling | 2008-01-08 15:56:02 +0100 (Tue, 08 Jan 2008) | 1 line
Patch 1114: fix compilation of curses module on 64-bit AIX, and any other LP64 platforms where attr_t isn't a C long
........
r59856 | thomas.heller | 2008-01-08 16:15:09 +0100 (Tue, 08 Jan 2008) | 5 lines
Use relative instead of absolute filenames in the C-level tracebacks.
This prevents traceback prints pointing to files in this way:
File "\loewis\25\python\Modules\_ctypes\callbacks.c", line 206, in 'calling callback function'
........
r59857 | christian.heimes | 2008-01-08 16:46:10 +0100 (Tue, 08 Jan 2008) | 2 lines
Added __enter__ and __exit__ functions to HKEY object
Added ExpandEnvironmentStrings to the _winreg module.
........
r59858 | georg.brandl | 2008-01-08 17:18:26 +0100 (Tue, 08 Jan 2008) | 2 lines
Fix markup errors from r59857 and clarify key.__enter__/__exit__ docs
........
r59860 | georg.brandl | 2008-01-08 20:42:30 +0100 (Tue, 08 Jan 2008) | 2 lines
Better method for associating .py files with the interpreter.
........
r59862 | facundo.batista | 2008-01-08 22:10:12 +0100 (Tue, 08 Jan 2008) | 9 lines
Issue 846388. Adds a call to PyErr_CheckSignals to
SRE_MATCH so that signal handlers can be invoked during
long regular expression matches. It also adds a new
error return value indicating that an exception
occurred in a signal handler during the match, allowing
exceptions in the signal handler to propagate up to the
main loop. Thanks Josh Hoyt and Ralf Schmitt.
........
2008-01-09 00:17:24 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_ExpandEnvironmentStrings_impl(PyObject *module, Py_UNICODE *string)
|
|
|
|
/*[clinic end generated code: output=cba46ac293a8af1a input=b2a9714d2b751aa6]*/
|
Merged revisions 59843-59863 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r59844 | raymond.hettinger | 2008-01-07 21:56:05 +0100 (Mon, 07 Jan 2008) | 1 line
Use get() instead of pop() for the optimized version of _replace().
........
r59847 | raymond.hettinger | 2008-01-07 22:33:51 +0100 (Mon, 07 Jan 2008) | 1 line
Documentation nits.
........
r59849 | raymond.hettinger | 2008-01-08 03:02:05 +0100 (Tue, 08 Jan 2008) | 1 line
Expand comment.
........
r59850 | raymond.hettinger | 2008-01-08 03:24:15 +0100 (Tue, 08 Jan 2008) | 1 line
Docs on named tuple's naming conventions and limits of subclassing
........
r59851 | christian.heimes | 2008-01-08 04:40:04 +0100 (Tue, 08 Jan 2008) | 1 line
It's verbose, not debug
........
r59852 | facundo.batista | 2008-01-08 13:25:20 +0100 (Tue, 08 Jan 2008) | 4 lines
Issue #1757: The hash of a Decimal instance is no longer affected
by the current context. Thanks Mark Dickinson.
........
r59853 | andrew.kuchling | 2008-01-08 15:30:55 +0100 (Tue, 08 Jan 2008) | 1 line
Patch 1137: allow assigning to .buffer_size attribute of PyExpat.parser objects
........
r59854 | andrew.kuchling | 2008-01-08 15:56:02 +0100 (Tue, 08 Jan 2008) | 1 line
Patch 1114: fix compilation of curses module on 64-bit AIX, and any other LP64 platforms where attr_t isn't a C long
........
r59856 | thomas.heller | 2008-01-08 16:15:09 +0100 (Tue, 08 Jan 2008) | 5 lines
Use relative instead of absolute filenames in the C-level tracebacks.
This prevents traceback prints pointing to files in this way:
File "\loewis\25\python\Modules\_ctypes\callbacks.c", line 206, in 'calling callback function'
........
r59857 | christian.heimes | 2008-01-08 16:46:10 +0100 (Tue, 08 Jan 2008) | 2 lines
Added __enter__ and __exit__ functions to HKEY object
Added ExpandEnvironmentStrings to the _winreg module.
........
r59858 | georg.brandl | 2008-01-08 17:18:26 +0100 (Tue, 08 Jan 2008) | 2 lines
Fix markup errors from r59857 and clarify key.__enter__/__exit__ docs
........
r59860 | georg.brandl | 2008-01-08 20:42:30 +0100 (Tue, 08 Jan 2008) | 2 lines
Better method for associating .py files with the interpreter.
........
r59862 | facundo.batista | 2008-01-08 22:10:12 +0100 (Tue, 08 Jan 2008) | 9 lines
Issue 846388. Adds a call to PyErr_CheckSignals to
SRE_MATCH so that signal handlers can be invoked during
long regular expression matches. It also adds a new
error return value indicating that an exception
occurred in a signal handler during the match, allowing
exceptions in the signal handler to propagate up to the
main loop. Thanks Josh Hoyt and Ralf Schmitt.
........
2008-01-09 00:17:24 +00:00
|
|
|
{
|
2011-11-22 01:27:30 +00:00
|
|
|
wchar_t *retValue = NULL;
|
2010-05-09 15:52:27 +00:00
|
|
|
DWORD retValueSize;
|
|
|
|
DWORD rc;
|
|
|
|
PyObject *o;
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
retValueSize = ExpandEnvironmentStringsW(string, retValue, 0);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (retValueSize == 0) {
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(retValueSize,
|
|
|
|
"ExpandEnvironmentStrings");
|
|
|
|
}
|
2015-02-16 11:28:22 +00:00
|
|
|
retValue = PyMem_New(wchar_t, retValueSize);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (retValue == NULL) {
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = ExpandEnvironmentStringsW(string, retValue, retValueSize);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (rc == 0) {
|
|
|
|
PyMem_Free(retValue);
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(retValueSize,
|
|
|
|
"ExpandEnvironmentStrings");
|
|
|
|
}
|
2011-11-22 01:27:30 +00:00
|
|
|
o = PyUnicode_FromWideChar(retValue, wcslen(retValue));
|
2010-05-09 15:52:27 +00:00
|
|
|
PyMem_Free(retValue);
|
|
|
|
return o;
|
Merged revisions 59843-59863 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r59844 | raymond.hettinger | 2008-01-07 21:56:05 +0100 (Mon, 07 Jan 2008) | 1 line
Use get() instead of pop() for the optimized version of _replace().
........
r59847 | raymond.hettinger | 2008-01-07 22:33:51 +0100 (Mon, 07 Jan 2008) | 1 line
Documentation nits.
........
r59849 | raymond.hettinger | 2008-01-08 03:02:05 +0100 (Tue, 08 Jan 2008) | 1 line
Expand comment.
........
r59850 | raymond.hettinger | 2008-01-08 03:24:15 +0100 (Tue, 08 Jan 2008) | 1 line
Docs on named tuple's naming conventions and limits of subclassing
........
r59851 | christian.heimes | 2008-01-08 04:40:04 +0100 (Tue, 08 Jan 2008) | 1 line
It's verbose, not debug
........
r59852 | facundo.batista | 2008-01-08 13:25:20 +0100 (Tue, 08 Jan 2008) | 4 lines
Issue #1757: The hash of a Decimal instance is no longer affected
by the current context. Thanks Mark Dickinson.
........
r59853 | andrew.kuchling | 2008-01-08 15:30:55 +0100 (Tue, 08 Jan 2008) | 1 line
Patch 1137: allow assigning to .buffer_size attribute of PyExpat.parser objects
........
r59854 | andrew.kuchling | 2008-01-08 15:56:02 +0100 (Tue, 08 Jan 2008) | 1 line
Patch 1114: fix compilation of curses module on 64-bit AIX, and any other LP64 platforms where attr_t isn't a C long
........
r59856 | thomas.heller | 2008-01-08 16:15:09 +0100 (Tue, 08 Jan 2008) | 5 lines
Use relative instead of absolute filenames in the C-level tracebacks.
This prevents traceback prints pointing to files in this way:
File "\loewis\25\python\Modules\_ctypes\callbacks.c", line 206, in 'calling callback function'
........
r59857 | christian.heimes | 2008-01-08 16:46:10 +0100 (Tue, 08 Jan 2008) | 2 lines
Added __enter__ and __exit__ functions to HKEY object
Added ExpandEnvironmentStrings to the _winreg module.
........
r59858 | georg.brandl | 2008-01-08 17:18:26 +0100 (Tue, 08 Jan 2008) | 2 lines
Fix markup errors from r59857 and clarify key.__enter__/__exit__ docs
........
r59860 | georg.brandl | 2008-01-08 20:42:30 +0100 (Tue, 08 Jan 2008) | 2 lines
Better method for associating .py files with the interpreter.
........
r59862 | facundo.batista | 2008-01-08 22:10:12 +0100 (Tue, 08 Jan 2008) | 9 lines
Issue 846388. Adds a call to PyErr_CheckSignals to
SRE_MATCH so that signal handlers can be invoked during
long regular expression matches. It also adds a new
error return value indicating that an exception
occurred in a signal handler during the match, allowing
exceptions in the signal handler to propagate up to the
main loop. Thanks Josh Hoyt and Ralf Schmitt.
........
2008-01-09 00:17:24 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.FlushKey
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
|
|
|
/
|
|
|
|
|
|
|
|
Writes all the attributes of a key to the registry.
|
|
|
|
|
|
|
|
It is not necessary to call FlushKey to change a key. Registry changes
|
|
|
|
are flushed to disk by the registry using its lazy flusher. Registry
|
|
|
|
changes are also flushed to disk at system shutdown. Unlike
|
|
|
|
CloseKey(), the FlushKey() method returns only when all the data has
|
|
|
|
been written to the registry.
|
|
|
|
|
|
|
|
An application should only call FlushKey() if it requires absolute
|
|
|
|
certainty that registry changes are on disk. If you don't know whether
|
|
|
|
a FlushKey() call is required, it probably isn't.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_FlushKey_impl(PyObject *module, HKEY key)
|
|
|
|
/*[clinic end generated code: output=e6fc230d4c5dc049 input=f57457c12297d82f]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
long rc;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegFlushKey(key);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc, "RegFlushKey");
|
2015-05-13 06:21:57 +00:00
|
|
|
Py_RETURN_NONE;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
2015-05-13 06:21:57 +00:00
|
|
|
|
|
|
|
|
|
|
|
/*[clinic input]
|
|
|
|
winreg.LoadKey
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
|
|
|
sub_key: Py_UNICODE
|
|
|
|
A string that identifies the sub-key to load.
|
|
|
|
file_name: Py_UNICODE
|
|
|
|
The name of the file to load registry data from. This file must
|
|
|
|
have been created with the SaveKey() function. Under the file
|
|
|
|
allocation table (FAT) file system, the filename may not have an
|
|
|
|
extension.
|
|
|
|
/
|
|
|
|
|
|
|
|
Insert data into the registry from a file.
|
|
|
|
|
|
|
|
Creates a subkey under the specified key and stores registration
|
|
|
|
information from a specified file into that subkey.
|
|
|
|
|
|
|
|
A call to LoadKey() fails if the calling process does not have the
|
|
|
|
SE_RESTORE_PRIVILEGE privilege.
|
|
|
|
|
|
|
|
If key is a handle returned by ConnectRegistry(), then the path
|
|
|
|
specified in fileName is relative to the remote computer.
|
|
|
|
|
|
|
|
The MSDN docs imply key must be in the HKEY_USER or HKEY_LOCAL_MACHINE
|
|
|
|
tree.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_LoadKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
|
2015-05-13 15:58:35 +00:00
|
|
|
Py_UNICODE *file_name)
|
2016-07-07 14:35:15 +00:00
|
|
|
/*[clinic end generated code: output=87344005c5905cde input=e3b5b45ade311582]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
long rc;
|
2015-05-13 06:21:57 +00:00
|
|
|
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegLoadKeyW(key, sub_key, file_name );
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc, "RegLoadKey");
|
2015-05-13 06:21:57 +00:00
|
|
|
Py_RETURN_NONE;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.OpenKey -> HKEY
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
2015-05-13 15:58:35 +00:00
|
|
|
sub_key: Py_UNICODE(accept={str, NoneType})
|
2015-05-13 06:21:57 +00:00
|
|
|
A string that identifies the sub_key to open.
|
|
|
|
reserved: int = 0
|
|
|
|
A reserved integer that must be zero. Default is zero.
|
|
|
|
access: REGSAM(c_default='KEY_READ') = winreg.KEY_READ
|
|
|
|
An integer that specifies an access mask that describes the desired
|
|
|
|
security access for the key. Default is KEY_READ.
|
|
|
|
|
|
|
|
Opens the specified key.
|
|
|
|
|
|
|
|
The result is a new handle to the specified key.
|
|
|
|
If the function fails, an OSError exception is raised.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
|
|
|
static HKEY
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_OpenKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
|
2015-05-13 15:58:35 +00:00
|
|
|
int reserved, REGSAM access)
|
2016-07-07 14:35:15 +00:00
|
|
|
/*[clinic end generated code: output=a905f1b947f3ce85 input=098505ac36a9ae28]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
HKEY retKey;
|
|
|
|
long rc;
|
|
|
|
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegOpenKeyExW(key, sub_key, reserved, access, &retKey);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
|
|
PyErr_SetFromWindowsErrWithFunction(rc, "RegOpenKeyEx");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return retKey;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*[clinic input]
|
|
|
|
winreg.OpenKeyEx = winreg.OpenKey
|
|
|
|
|
|
|
|
Opens the specified key.
|
|
|
|
|
|
|
|
The result is a new handle to the specified key.
|
|
|
|
If the function fails, an OSError exception is raised.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
|
|
|
static HKEY
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_OpenKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
|
2015-05-13 15:58:35 +00:00
|
|
|
int reserved, REGSAM access)
|
2016-07-07 14:35:15 +00:00
|
|
|
/*[clinic end generated code: output=226042593b37e940 input=c6c4972af8622959]*/
|
2015-05-13 06:21:57 +00:00
|
|
|
{
|
|
|
|
return winreg_OpenKey_impl(module, key, sub_key, reserved, access);
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.QueryInfoKey
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
|
|
|
/
|
|
|
|
|
|
|
|
Returns information about a key.
|
|
|
|
|
|
|
|
The result is a tuple of 3 items:
|
|
|
|
An integer that identifies the number of sub keys this key has.
|
|
|
|
An integer that identifies the number of values this key has.
|
|
|
|
An integer that identifies when the key was last modified (if available)
|
|
|
|
as 100's of nanoseconds since Jan 1, 1600.
|
|
|
|
[clinic start generated code]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
|
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_QueryInfoKey_impl(PyObject *module, HKEY key)
|
|
|
|
/*[clinic end generated code: output=dc657b8356a4f438 input=c3593802390cde1f]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
|
|
|
long rc;
|
|
|
|
DWORD nSubKeys, nValues;
|
|
|
|
FILETIME ft;
|
|
|
|
LARGE_INTEGER li;
|
|
|
|
PyObject *l;
|
|
|
|
PyObject *ret;
|
2015-05-13 06:21:57 +00:00
|
|
|
|
|
|
|
if ((rc = RegQueryInfoKey(key, NULL, NULL, 0, &nSubKeys, NULL, NULL,
|
2010-05-09 15:52:27 +00:00
|
|
|
&nValues, NULL, NULL, NULL, &ft))
|
2000-03-28 20:37:15 +00:00
|
|
|
!= ERROR_SUCCESS)
|
2010-05-09 15:52:27 +00:00
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc, "RegQueryInfoKey");
|
2000-03-28 20:37:15 +00:00
|
|
|
li.LowPart = ft.dwLowDateTime;
|
|
|
|
li.HighPart = ft.dwHighDateTime;
|
|
|
|
l = PyLong_FromLongLong(li.QuadPart);
|
|
|
|
if (l == NULL)
|
2010-05-09 15:52:27 +00:00
|
|
|
return NULL;
|
2000-03-28 20:37:15 +00:00
|
|
|
ret = Py_BuildValue("iiO", nSubKeys, nValues, l);
|
|
|
|
Py_DECREF(l);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.QueryValue
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
2015-05-13 15:58:35 +00:00
|
|
|
sub_key: Py_UNICODE(accept={str, NoneType})
|
2015-05-13 06:21:57 +00:00
|
|
|
A string that holds the name of the subkey with which the value
|
|
|
|
is associated. If this parameter is None or empty, the function
|
|
|
|
retrieves the value set by the SetValue() method for the key
|
|
|
|
identified by key.
|
|
|
|
/
|
|
|
|
|
|
|
|
Retrieves the unnamed value for a key.
|
|
|
|
|
|
|
|
Values in the registry have name, type, and data components. This method
|
|
|
|
retrieves the data for a key's first value that has a NULL name.
|
|
|
|
But since the underlying API call doesn't return the type, you'll
|
|
|
|
probably be happier using QueryValueEx; this function is just here for
|
|
|
|
completeness.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_QueryValue_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key)
|
|
|
|
/*[clinic end generated code: output=2bb8d1e02c10d0b6 input=41cafbbf423b21d6]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
long rc;
|
|
|
|
PyObject *retStr;
|
|
|
|
wchar_t *retBuf;
|
2010-05-26 17:43:50 +00:00
|
|
|
DWORD bufSize = 0;
|
|
|
|
DWORD retSize = 0;
|
|
|
|
wchar_t *tmp;
|
2010-05-09 15:52:27 +00:00
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegQueryValueW(key, sub_key, NULL, &retSize);
|
2010-05-26 17:43:50 +00:00
|
|
|
if (rc == ERROR_MORE_DATA)
|
|
|
|
retSize = 256;
|
|
|
|
else if (rc != ERROR_SUCCESS)
|
2010-05-09 15:52:27 +00:00
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc,
|
|
|
|
"RegQueryValue");
|
2010-05-26 17:43:50 +00:00
|
|
|
|
|
|
|
bufSize = retSize;
|
|
|
|
retBuf = (wchar_t *) PyMem_Malloc(bufSize);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (retBuf == NULL)
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
|
2010-05-26 17:43:50 +00:00
|
|
|
while (1) {
|
|
|
|
retSize = bufSize;
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegQueryValueW(key, sub_key, retBuf, &retSize);
|
2010-05-26 17:43:50 +00:00
|
|
|
if (rc != ERROR_MORE_DATA)
|
|
|
|
break;
|
|
|
|
|
|
|
|
bufSize *= 2;
|
|
|
|
tmp = (wchar_t *) PyMem_Realloc(retBuf, bufSize);
|
|
|
|
if (tmp == NULL) {
|
|
|
|
PyMem_Free(retBuf);
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
}
|
|
|
|
retBuf = tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
2010-05-09 15:52:27 +00:00
|
|
|
PyMem_Free(retBuf);
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc,
|
|
|
|
"RegQueryValue");
|
|
|
|
}
|
|
|
|
|
2011-09-28 05:41:54 +00:00
|
|
|
retStr = PyUnicode_FromWideChar(retBuf, wcslen(retBuf));
|
2010-05-09 15:52:27 +00:00
|
|
|
PyMem_Free(retBuf);
|
|
|
|
return retStr;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
|
|
|
|
/*[clinic input]
|
|
|
|
winreg.QueryValueEx
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
2015-05-13 15:58:35 +00:00
|
|
|
name: Py_UNICODE(accept={str, NoneType})
|
2015-05-13 06:21:57 +00:00
|
|
|
A string indicating the value to query.
|
|
|
|
/
|
|
|
|
|
|
|
|
Retrieves the type and value of a specified sub-key.
|
|
|
|
|
|
|
|
Behaves mostly like QueryValue(), but also returns the type of the
|
|
|
|
specified value name associated with the given open registry key.
|
|
|
|
|
|
|
|
The return value is a tuple of the value and the type_id.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_QueryValueEx_impl(PyObject *module, HKEY key, Py_UNICODE *name)
|
|
|
|
/*[clinic end generated code: output=5b4fa3e33d6d3e8f input=cf366cada4836891]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
long rc;
|
2010-05-26 17:43:50 +00:00
|
|
|
BYTE *retBuf, *tmp;
|
|
|
|
DWORD bufSize = 0, retSize;
|
2010-05-09 15:52:27 +00:00
|
|
|
DWORD typ;
|
|
|
|
PyObject *obData;
|
|
|
|
PyObject *result;
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegQueryValueExW(key, name, NULL, NULL, NULL, &bufSize);
|
2010-05-26 17:43:50 +00:00
|
|
|
if (rc == ERROR_MORE_DATA)
|
|
|
|
bufSize = 256;
|
|
|
|
else if (rc != ERROR_SUCCESS)
|
2010-05-09 15:52:27 +00:00
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc,
|
|
|
|
"RegQueryValueEx");
|
|
|
|
retBuf = (BYTE *)PyMem_Malloc(bufSize);
|
|
|
|
if (retBuf == NULL)
|
|
|
|
return PyErr_NoMemory();
|
2010-05-26 17:43:50 +00:00
|
|
|
|
|
|
|
while (1) {
|
|
|
|
retSize = bufSize;
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegQueryValueExW(key, name, NULL, &typ,
|
2010-05-26 17:43:50 +00:00
|
|
|
(BYTE *)retBuf, &retSize);
|
|
|
|
if (rc != ERROR_MORE_DATA)
|
|
|
|
break;
|
|
|
|
|
|
|
|
bufSize *= 2;
|
|
|
|
tmp = (char *) PyMem_Realloc(retBuf, bufSize);
|
|
|
|
if (tmp == NULL) {
|
|
|
|
PyMem_Free(retBuf);
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
}
|
|
|
|
retBuf = tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
2010-05-09 15:52:27 +00:00
|
|
|
PyMem_Free(retBuf);
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc,
|
|
|
|
"RegQueryValueEx");
|
|
|
|
}
|
|
|
|
obData = Reg2Py(retBuf, bufSize, typ);
|
|
|
|
PyMem_Free(retBuf);
|
|
|
|
if (obData == NULL)
|
|
|
|
return NULL;
|
|
|
|
result = Py_BuildValue("Oi", obData, typ);
|
|
|
|
Py_DECREF(obData);
|
|
|
|
return result;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.SaveKey
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
|
|
|
file_name: Py_UNICODE
|
|
|
|
The name of the file to save registry data to. This file cannot
|
|
|
|
already exist. If this filename includes an extension, it cannot be
|
|
|
|
used on file allocation table (FAT) file systems by the LoadKey(),
|
|
|
|
ReplaceKey() or RestoreKey() methods.
|
|
|
|
/
|
|
|
|
|
|
|
|
Saves the specified key, and all its subkeys to the specified file.
|
|
|
|
|
|
|
|
If key represents a key on a remote computer, the path described by
|
|
|
|
file_name is relative to the remote computer.
|
|
|
|
|
|
|
|
The caller of this method must possess the SeBackupPrivilege
|
|
|
|
security privilege. This function passes NULL for security_attributes
|
|
|
|
to the API.
|
|
|
|
[clinic start generated code]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
|
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_SaveKey_impl(PyObject *module, HKEY key, Py_UNICODE *file_name)
|
|
|
|
/*[clinic end generated code: output=1dda1502bd4c30d8 input=da735241f91ac7a2]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
LPSECURITY_ATTRIBUTES pSA = NULL;
|
|
|
|
|
|
|
|
long rc;
|
2000-03-28 20:37:15 +00:00
|
|
|
/* One day we may get security into the core?
|
2010-05-09 15:52:27 +00:00
|
|
|
if (!PyWinObject_AsSECURITY_ATTRIBUTES(obSA, &pSA, TRUE))
|
|
|
|
return NULL;
|
2000-03-28 20:37:15 +00:00
|
|
|
*/
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegSaveKeyW(key, file_name, pSA );
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc, "RegSaveKey");
|
2015-05-13 06:21:57 +00:00
|
|
|
Py_RETURN_NONE;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.SetValue
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
2015-05-13 15:58:35 +00:00
|
|
|
sub_key: Py_UNICODE(accept={str, NoneType})
|
2015-05-13 06:21:57 +00:00
|
|
|
A string that names the subkey with which the value is associated.
|
|
|
|
type: DWORD
|
|
|
|
An integer that specifies the type of the data. Currently this must
|
|
|
|
be REG_SZ, meaning only strings are supported.
|
2015-05-13 15:58:35 +00:00
|
|
|
value: Py_UNICODE(zeroes=True)
|
2015-05-13 06:21:57 +00:00
|
|
|
A string that specifies the new value.
|
|
|
|
/
|
|
|
|
|
|
|
|
Associates a value with a specified key.
|
|
|
|
|
|
|
|
If the key specified by the sub_key parameter does not exist, the
|
|
|
|
SetValue function creates it.
|
|
|
|
|
|
|
|
Value lengths are limited by available memory. Long values (more than
|
|
|
|
2048 bytes) should be stored as files with the filenames stored in
|
|
|
|
the configuration registry to help the registry perform efficiently.
|
|
|
|
|
|
|
|
The key identified by the key parameter must have been opened with
|
|
|
|
KEY_SET_VALUE access.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_SetValue_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
|
2015-05-13 15:58:35 +00:00
|
|
|
DWORD type, Py_UNICODE *value,
|
|
|
|
Py_ssize_clean_t value_length)
|
2016-07-07 14:35:15 +00:00
|
|
|
/*[clinic end generated code: output=1e31931174820631 input=2cd2adab79339c53]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
long rc;
|
2015-05-13 06:21:57 +00:00
|
|
|
|
|
|
|
if (type != REG_SZ) {
|
2010-05-09 15:52:27 +00:00
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"Type must be winreg.REG_SZ");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegSetValueW(key, sub_key, REG_SZ, value, value_length+1);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc, "RegSetValue");
|
2015-05-13 06:21:57 +00:00
|
|
|
Py_RETURN_NONE;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.SetValueEx
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
2015-05-13 15:58:35 +00:00
|
|
|
value_name: Py_UNICODE(accept={str, NoneType})
|
2015-05-13 06:21:57 +00:00
|
|
|
A string containing the name of the value to set, or None.
|
|
|
|
reserved: object
|
|
|
|
Can be anything - zero is always passed to the API.
|
|
|
|
type: DWORD
|
|
|
|
An integer that specifies the type of the data, one of:
|
|
|
|
REG_BINARY -- Binary data in any form.
|
|
|
|
REG_DWORD -- A 32-bit number.
|
2016-05-24 22:42:04 +00:00
|
|
|
REG_DWORD_LITTLE_ENDIAN -- A 32-bit number in little-endian format. Equivalent to REG_DWORD
|
2015-05-13 06:21:57 +00:00
|
|
|
REG_DWORD_BIG_ENDIAN -- A 32-bit number in big-endian format.
|
|
|
|
REG_EXPAND_SZ -- A null-terminated string that contains unexpanded
|
|
|
|
references to environment variables (for example,
|
|
|
|
%PATH%).
|
|
|
|
REG_LINK -- A Unicode symbolic link.
|
2016-04-17 05:32:47 +00:00
|
|
|
REG_MULTI_SZ -- A sequence of null-terminated strings, terminated
|
2015-05-13 06:21:57 +00:00
|
|
|
by two null characters. Note that Python handles
|
|
|
|
this termination automatically.
|
|
|
|
REG_NONE -- No defined value type.
|
2016-05-24 22:42:04 +00:00
|
|
|
REG_QWORD -- A 64-bit number.
|
|
|
|
REG_QWORD_LITTLE_ENDIAN -- A 64-bit number in little-endian format. Equivalent to REG_QWORD.
|
2015-05-13 06:21:57 +00:00
|
|
|
REG_RESOURCE_LIST -- A device-driver resource list.
|
|
|
|
REG_SZ -- A null-terminated string.
|
|
|
|
value: object
|
|
|
|
A string that specifies the new value.
|
|
|
|
/
|
|
|
|
|
|
|
|
Stores data in the value field of an open registry key.
|
|
|
|
|
|
|
|
This method can also set additional value and type information for the
|
|
|
|
specified key. The key identified by the key parameter must have been
|
|
|
|
opened with KEY_SET_VALUE access.
|
|
|
|
|
|
|
|
To open the key, use the CreateKeyEx() or OpenKeyEx() methods.
|
|
|
|
|
|
|
|
Value lengths are limited by available memory. Long values (more than
|
|
|
|
2048 bytes) should be stored as files with the filenames stored in
|
|
|
|
the configuration registry to help the registry perform efficiently.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_SetValueEx_impl(PyObject *module, HKEY key, Py_UNICODE *value_name,
|
2015-05-13 15:58:35 +00:00
|
|
|
PyObject *reserved, DWORD type, PyObject *value)
|
2016-07-07 15:20:03 +00:00
|
|
|
/*[clinic end generated code: output=c88c8426b6c00ec7 input=900a9e3990bfb196]*/
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
BYTE *data;
|
|
|
|
DWORD len;
|
|
|
|
|
|
|
|
LONG rc;
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
if (!Py2Reg(value, type, &data, &len))
|
2010-05-09 15:52:27 +00:00
|
|
|
{
|
|
|
|
if (!PyErr_Occurred())
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"Could not convert the data to the specified type.");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = RegSetValueExW(key, value_name, 0, type, data, len);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
PyMem_DEL(data);
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc,
|
|
|
|
"RegSetValueEx");
|
2015-05-13 06:21:57 +00:00
|
|
|
Py_RETURN_NONE;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.DisableReflectionKey
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
|
|
|
/
|
|
|
|
|
|
|
|
Disables registry reflection for 32bit processes running on a 64bit OS.
|
|
|
|
|
|
|
|
Will generally raise NotImplemented if executed on a 32bit OS.
|
|
|
|
|
|
|
|
If the key is not on the reflection list, the function succeeds but has
|
|
|
|
no effect. Disabling reflection for a key does not affect reflection
|
|
|
|
of any subkeys.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2008-04-07 03:17:54 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_DisableReflectionKey_impl(PyObject *module, HKEY key)
|
|
|
|
/*[clinic end generated code: output=830cce504cc764b4 input=a6c9e5ca5410193c]*/
|
2008-04-07 03:17:54 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
HMODULE hMod;
|
|
|
|
typedef LONG (WINAPI *RDRKFunc)(HKEY);
|
|
|
|
RDRKFunc pfn = NULL;
|
|
|
|
LONG rc;
|
|
|
|
|
|
|
|
/* Only available on 64bit platforms, so we must load it
|
|
|
|
dynamically.*/
|
2012-01-14 16:54:09 +00:00
|
|
|
hMod = GetModuleHandleW(L"advapi32.dll");
|
2010-05-09 15:52:27 +00:00
|
|
|
if (hMod)
|
|
|
|
pfn = (RDRKFunc)GetProcAddress(hMod,
|
|
|
|
"RegDisableReflectionKey");
|
|
|
|
if (!pfn) {
|
|
|
|
PyErr_SetString(PyExc_NotImplementedError,
|
|
|
|
"not implemented on this platform");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = (*pfn)(key);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc,
|
|
|
|
"RegDisableReflectionKey");
|
2015-05-13 06:21:57 +00:00
|
|
|
Py_RETURN_NONE;
|
2008-04-07 03:17:54 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.EnableReflectionKey
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
|
|
|
/
|
|
|
|
|
|
|
|
Restores registry reflection for the specified disabled key.
|
|
|
|
|
|
|
|
Will generally raise NotImplemented if executed on a 32bit OS.
|
|
|
|
Restoring reflection for a key does not affect reflection of any
|
|
|
|
subkeys.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2008-04-07 03:17:54 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_EnableReflectionKey_impl(PyObject *module, HKEY key)
|
|
|
|
/*[clinic end generated code: output=86fa1385fdd9ce57 input=7748abbacd1e166a]*/
|
2008-04-07 03:17:54 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
HMODULE hMod;
|
|
|
|
typedef LONG (WINAPI *RERKFunc)(HKEY);
|
|
|
|
RERKFunc pfn = NULL;
|
|
|
|
LONG rc;
|
|
|
|
|
|
|
|
/* Only available on 64bit platforms, so we must load it
|
|
|
|
dynamically.*/
|
2012-01-14 16:54:09 +00:00
|
|
|
hMod = GetModuleHandleW(L"advapi32.dll");
|
2010-05-09 15:52:27 +00:00
|
|
|
if (hMod)
|
|
|
|
pfn = (RERKFunc)GetProcAddress(hMod,
|
|
|
|
"RegEnableReflectionKey");
|
|
|
|
if (!pfn) {
|
|
|
|
PyErr_SetString(PyExc_NotImplementedError,
|
|
|
|
"not implemented on this platform");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = (*pfn)(key);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc,
|
|
|
|
"RegEnableReflectionKey");
|
2015-05-13 06:21:57 +00:00
|
|
|
Py_RETURN_NONE;
|
2008-04-07 03:17:54 +00:00
|
|
|
}
|
|
|
|
|
2015-05-13 06:21:57 +00:00
|
|
|
/*[clinic input]
|
|
|
|
winreg.QueryReflectionKey
|
|
|
|
|
|
|
|
key: HKEY
|
|
|
|
An already open key, or any one of the predefined HKEY_* constants.
|
|
|
|
/
|
|
|
|
|
|
|
|
Returns the reflection state for the specified key as a bool.
|
|
|
|
|
|
|
|
Will generally raise NotImplemented if executed on a 32bit OS.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
|
2008-04-07 03:17:54 +00:00
|
|
|
static PyObject *
|
2016-07-07 14:35:15 +00:00
|
|
|
winreg_QueryReflectionKey_impl(PyObject *module, HKEY key)
|
|
|
|
/*[clinic end generated code: output=4e774af288c3ebb9 input=9f325eacb5a65d88]*/
|
2008-04-07 03:17:54 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
HMODULE hMod;
|
|
|
|
typedef LONG (WINAPI *RQRKFunc)(HKEY, BOOL *);
|
|
|
|
RQRKFunc pfn = NULL;
|
|
|
|
BOOL result;
|
|
|
|
LONG rc;
|
|
|
|
|
|
|
|
/* Only available on 64bit platforms, so we must load it
|
|
|
|
dynamically.*/
|
2012-01-14 16:54:09 +00:00
|
|
|
hMod = GetModuleHandleW(L"advapi32.dll");
|
2010-05-09 15:52:27 +00:00
|
|
|
if (hMod)
|
|
|
|
pfn = (RQRKFunc)GetProcAddress(hMod,
|
|
|
|
"RegQueryReflectionKey");
|
|
|
|
if (!pfn) {
|
|
|
|
PyErr_SetString(PyExc_NotImplementedError,
|
|
|
|
"not implemented on this platform");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
2015-05-13 06:21:57 +00:00
|
|
|
rc = (*pfn)(key, &result);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return PyErr_SetFromWindowsErrWithFunction(rc,
|
|
|
|
"RegQueryReflectionKey");
|
|
|
|
return PyBool_FromLong(result);
|
2008-04-07 03:17:54 +00:00
|
|
|
}
|
|
|
|
|
2000-03-28 20:37:15 +00:00
|
|
|
static struct PyMethodDef winreg_methods[] = {
|
2015-05-13 06:21:57 +00:00
|
|
|
WINREG_CLOSEKEY_METHODDEF
|
|
|
|
WINREG_CONNECTREGISTRY_METHODDEF
|
|
|
|
WINREG_CREATEKEY_METHODDEF
|
|
|
|
WINREG_CREATEKEYEX_METHODDEF
|
|
|
|
WINREG_DELETEKEY_METHODDEF
|
|
|
|
WINREG_DELETEKEYEX_METHODDEF
|
|
|
|
WINREG_DELETEVALUE_METHODDEF
|
|
|
|
WINREG_DISABLEREFLECTIONKEY_METHODDEF
|
|
|
|
WINREG_ENABLEREFLECTIONKEY_METHODDEF
|
|
|
|
WINREG_ENUMKEY_METHODDEF
|
|
|
|
WINREG_ENUMVALUE_METHODDEF
|
|
|
|
WINREG_EXPANDENVIRONMENTSTRINGS_METHODDEF
|
|
|
|
WINREG_FLUSHKEY_METHODDEF
|
|
|
|
WINREG_LOADKEY_METHODDEF
|
|
|
|
WINREG_OPENKEY_METHODDEF
|
|
|
|
WINREG_OPENKEYEX_METHODDEF
|
|
|
|
WINREG_QUERYVALUE_METHODDEF
|
|
|
|
WINREG_QUERYVALUEEX_METHODDEF
|
|
|
|
WINREG_QUERYINFOKEY_METHODDEF
|
|
|
|
WINREG_QUERYREFLECTIONKEY_METHODDEF
|
|
|
|
WINREG_SAVEKEY_METHODDEF
|
|
|
|
WINREG_SETVALUE_METHODDEF
|
|
|
|
WINREG_SETVALUEEX_METHODDEF
|
2010-05-09 15:52:27 +00:00
|
|
|
NULL,
|
2000-03-28 20:37:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
insint(PyObject * d, char * name, long value)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyObject *v = PyLong_FromLong(value);
|
|
|
|
if (!v || PyDict_SetItemString(d, name, v))
|
|
|
|
PyErr_Clear();
|
|
|
|
Py_XDECREF(v);
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define ADD_INT(val) insint(d, #val, val)
|
|
|
|
|
|
|
|
static void
|
|
|
|
inskey(PyObject * d, char * name, HKEY key)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyObject *v = PyLong_FromVoidPtr(key);
|
|
|
|
if (!v || PyDict_SetItemString(d, name, v))
|
|
|
|
PyErr_Clear();
|
|
|
|
Py_XDECREF(v);
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define ADD_KEY(val) inskey(d, #val, val)
|
|
|
|
|
2008-06-11 05:26:20 +00:00
|
|
|
|
|
|
|
static struct PyModuleDef winregmodule = {
|
2010-05-09 15:52:27 +00:00
|
|
|
PyModuleDef_HEAD_INIT,
|
|
|
|
"winreg",
|
|
|
|
module_doc,
|
|
|
|
-1,
|
|
|
|
winreg_methods,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL
|
2008-06-11 05:26:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
PyMODINIT_FUNC PyInit_winreg(void)
|
2000-03-28 20:37:15 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyObject *m, *d;
|
|
|
|
m = PyModule_Create(&winregmodule);
|
|
|
|
if (m == NULL)
|
|
|
|
return NULL;
|
|
|
|
d = PyModule_GetDict(m);
|
|
|
|
PyHKEY_Type.tp_doc = PyHKEY_doc;
|
|
|
|
if (PyType_Ready(&PyHKEY_Type) < 0)
|
|
|
|
return NULL;
|
|
|
|
Py_INCREF(&PyHKEY_Type);
|
|
|
|
if (PyDict_SetItemString(d, "HKEYType",
|
|
|
|
(PyObject *)&PyHKEY_Type) != 0)
|
|
|
|
return NULL;
|
2012-12-19 12:33:35 +00:00
|
|
|
Py_INCREF(PyExc_OSError);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (PyDict_SetItemString(d, "error",
|
2012-12-19 12:33:35 +00:00
|
|
|
PyExc_OSError) != 0)
|
2010-05-09 15:52:27 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Add the relevant constants */
|
|
|
|
ADD_KEY(HKEY_CLASSES_ROOT);
|
|
|
|
ADD_KEY(HKEY_CURRENT_USER);
|
|
|
|
ADD_KEY(HKEY_LOCAL_MACHINE);
|
|
|
|
ADD_KEY(HKEY_USERS);
|
|
|
|
ADD_KEY(HKEY_PERFORMANCE_DATA);
|
2000-03-28 20:37:15 +00:00
|
|
|
#ifdef HKEY_CURRENT_CONFIG
|
2010-05-09 15:52:27 +00:00
|
|
|
ADD_KEY(HKEY_CURRENT_CONFIG);
|
2000-03-28 20:37:15 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HKEY_DYN_DATA
|
2010-05-09 15:52:27 +00:00
|
|
|
ADD_KEY(HKEY_DYN_DATA);
|
2000-03-28 20:37:15 +00:00
|
|
|
#endif
|
2010-05-09 15:52:27 +00:00
|
|
|
ADD_INT(KEY_QUERY_VALUE);
|
|
|
|
ADD_INT(KEY_SET_VALUE);
|
|
|
|
ADD_INT(KEY_CREATE_SUB_KEY);
|
|
|
|
ADD_INT(KEY_ENUMERATE_SUB_KEYS);
|
|
|
|
ADD_INT(KEY_NOTIFY);
|
|
|
|
ADD_INT(KEY_CREATE_LINK);
|
|
|
|
ADD_INT(KEY_READ);
|
|
|
|
ADD_INT(KEY_WRITE);
|
|
|
|
ADD_INT(KEY_EXECUTE);
|
|
|
|
ADD_INT(KEY_ALL_ACCESS);
|
2008-04-07 03:17:54 +00:00
|
|
|
#ifdef KEY_WOW64_64KEY
|
2010-05-09 15:52:27 +00:00
|
|
|
ADD_INT(KEY_WOW64_64KEY);
|
2008-04-07 03:17:54 +00:00
|
|
|
#endif
|
|
|
|
#ifdef KEY_WOW64_32KEY
|
2010-05-09 15:52:27 +00:00
|
|
|
ADD_INT(KEY_WOW64_32KEY);
|
2008-04-07 03:17:54 +00:00
|
|
|
#endif
|
2010-05-09 15:52:27 +00:00
|
|
|
ADD_INT(REG_OPTION_RESERVED);
|
|
|
|
ADD_INT(REG_OPTION_NON_VOLATILE);
|
|
|
|
ADD_INT(REG_OPTION_VOLATILE);
|
|
|
|
ADD_INT(REG_OPTION_CREATE_LINK);
|
|
|
|
ADD_INT(REG_OPTION_BACKUP_RESTORE);
|
|
|
|
ADD_INT(REG_OPTION_OPEN_LINK);
|
|
|
|
ADD_INT(REG_LEGAL_OPTION);
|
|
|
|
ADD_INT(REG_CREATED_NEW_KEY);
|
|
|
|
ADD_INT(REG_OPENED_EXISTING_KEY);
|
|
|
|
ADD_INT(REG_WHOLE_HIVE_VOLATILE);
|
|
|
|
ADD_INT(REG_REFRESH_HIVE);
|
|
|
|
ADD_INT(REG_NO_LAZY_FLUSH);
|
|
|
|
ADD_INT(REG_NOTIFY_CHANGE_NAME);
|
|
|
|
ADD_INT(REG_NOTIFY_CHANGE_ATTRIBUTES);
|
|
|
|
ADD_INT(REG_NOTIFY_CHANGE_LAST_SET);
|
|
|
|
ADD_INT(REG_NOTIFY_CHANGE_SECURITY);
|
|
|
|
ADD_INT(REG_LEGAL_CHANGE_FILTER);
|
|
|
|
ADD_INT(REG_NONE);
|
|
|
|
ADD_INT(REG_SZ);
|
|
|
|
ADD_INT(REG_EXPAND_SZ);
|
|
|
|
ADD_INT(REG_BINARY);
|
|
|
|
ADD_INT(REG_DWORD);
|
|
|
|
ADD_INT(REG_DWORD_LITTLE_ENDIAN);
|
|
|
|
ADD_INT(REG_DWORD_BIG_ENDIAN);
|
2016-05-24 22:42:04 +00:00
|
|
|
ADD_INT(REG_QWORD);
|
|
|
|
ADD_INT(REG_QWORD_LITTLE_ENDIAN);
|
2010-05-09 15:52:27 +00:00
|
|
|
ADD_INT(REG_LINK);
|
|
|
|
ADD_INT(REG_MULTI_SZ);
|
|
|
|
ADD_INT(REG_RESOURCE_LIST);
|
|
|
|
ADD_INT(REG_FULL_RESOURCE_DESCRIPTOR);
|
|
|
|
ADD_INT(REG_RESOURCE_REQUIREMENTS_LIST);
|
|
|
|
return m;
|
2000-03-28 20:37:15 +00:00
|
|
|
}
|
|
|
|
|
2007-09-03 07:43:05 +00:00
|
|
|
|