/*

winreg.c

Windows Registry access module for Python.

* Simple registry access written by Mark Hammond in win32api

module circa 1995.

* 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 "pycore_object.h" // _PyObject_Init()

#include "pycore_moduleobject.h"

#include <windows.h>

#if defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)

typedef struct {

PyTypeObject *PyHKEY_Type;

} winreg_state;

/* Forward declares */

static BOOL PyHKEY_AsHKEY(winreg_state *st, PyObject *ob, HKEY *pRes, BOOL bNoneOK);

static BOOL clinic_HKEY_converter(winreg_state *st, PyObject *ob, void *p);

static PyObject *PyHKEY_FromHKEY(winreg_state *st, HKEY h);

static BOOL PyHKEY_Close(winreg_state *st, PyObject *obHandle);

/* The win32api module reports the function name that failed,

but this concept is not in the Python core.

Hopefully it will one day, and in the meantime I don't

want to lose this info...

*/

#define PyErr_SetFromWindowsErrWithFunction(rc, fnname) \

PyErr_SetFromWindowsErr(rc)

/* Doc strings */

PyDoc_STRVAR(module_doc,

"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"

"CreateKeyEx() - Creates the specified key, or opens it if it already exists.\n"

"DeleteKey() - Deletes the specified key.\n"

"DeleteKeyEx() - 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"

"ExpandEnvironmentStrings() - Expand the env strings in a REG_EXPAND_SZ\n"

" string.\n"

"FlushKey() - Writes all the attributes of the specified key to the registry.\n"

"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"

"OpenKey() - Opens the specified key.\n"

"OpenKeyEx() - Alias of OpenKey().\n"

"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"

"DisableReflectionKey() - Disables registry reflection for 32bit processes running on a 64bit OS.\n"

"EnableReflectionKey() - Restores registry reflection for a key.\n"

"QueryReflectionKey() - Determines the reflection state for a 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"

"to see what constants are used, and where.");

/* PyHKEY docstrings */

PyDoc_STRVAR(PyHKEY_doc,

"PyHKEY Object - A Python object, representing a win32 registry key.\n"

"\n"

"This object wraps a Windows HKEY object, automatically closing it when\n"

"the object is destroyed. To guarantee cleanup, you can call either\n"

"the Close() method on the PyHKEY, or the CloseKey() method.\n"

"\n"

"All functions which accept a handle object also accept an integer --\n"

"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"

"__bool__ - Handles with an open object return true, otherwise false.\n"

"__int__ - Converting a handle to an integer returns the Win32 handle.\n"

"rich comparison - Handle objects are compared using the handle value.");

/************************************************************************

The PyHKEY object definition

************************************************************************/

typedef struct {

PyObject_VAR_HEAD

HKEY hkey;

} PyHKEYObject;

#define PyHKEY_Check(st, op) Py_IS_TYPE(op, st->PyHKEY_Type)

static char *failMsg = "bad operand type";

static PyObject *

PyHKEY_unaryFailureFunc(PyObject *ob)

{

PyErr_SetString(PyExc_TypeError, failMsg);

return NULL;

}

static PyObject *

PyHKEY_binaryFailureFunc(PyObject *ob1, PyObject *ob2)

{

PyErr_SetString(PyExc_TypeError, failMsg);

return NULL;

}

static PyObject *

PyHKEY_ternaryFailureFunc(PyObject *ob1, PyObject *ob2, PyObject *ob3)

{

PyErr_SetString(PyExc_TypeError, failMsg);

return NULL;

}

static void

PyHKEY_deallocFunc(PyObject *ob)

{

/* 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);

PyTypeObject *tp = Py_TYPE(ob);

PyObject_GC_UnTrack(ob);

PyObject_GC_Del(ob);

Py_DECREF(tp);

}

static int

PyHKEY_traverseFunc(PyObject *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

return 0;

}

static int

PyHKEY_boolFunc(PyObject *ob)

{

return ((PyHKEYObject *)ob)->hkey != 0;

}

static PyObject *

PyHKEY_intFunc(PyObject *ob)

{

PyHKEYObject *pyhkey = (PyHKEYObject *)ob;

return PyLong_FromVoidPtr(pyhkey->hkey);

}

static PyObject *

PyHKEY_strFunc(PyObject *ob)

{

PyHKEYObject *pyhkey = (PyHKEYObject *)ob;

return PyUnicode_FromFormat("<PyHKEY:%p>", pyhkey->hkey);

}

static int

PyHKEY_compareFunc(PyObject *ob1, PyObject *ob2)

{

PyHKEYObject *pyhkey1 = (PyHKEYObject *)ob1;

PyHKEYObject *pyhkey2 = (PyHKEYObject *)ob2;

return pyhkey1 == pyhkey2 ? 0 :

(pyhkey1 < pyhkey2 ? -1 : 1);

}

static Py_hash_t

PyHKEY_hashFunc(PyObject *ob)

{

/* Just use the address.

XXX - should we use the handle value?

*/

return PyObject_GenericHash(ob);

}

/*[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(int_converter):

type = 'REGSAM'

class DWORD_converter(unsigned_long_converter):

type = 'DWORD'

class HKEY_converter(CConverter):

type = 'HKEY'

converter = 'clinic_HKEY_converter'

broken_limited_capi = True

def parse_arg(self, argname, displayname, *, limited_capi):

assert not limited_capi

return self.format_code("""

if (!{converter}(_PyModule_GetState(module), {argname}, &{paramname})) {{{{

goto exit;

}}}}

""",

argname=argname,

converter=self.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(_PyModule_GetState(module), _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=4979f33998ffb6f8]*/

#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]*/

{

winreg_state *st = _PyType_GetModuleState(Py_TYPE(self));

assert(st != NULL);

if (!PyHKEY_Close(st, (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;

if (PySys_Audit("winreg.PyHKEY.Detach", "n", (Py_ssize_t)self->hkey) < 0) {

return NULL;

}

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]*/

{

return (PyHKEYObject*)Py_XNewRef(self);

}

/*[clinic input]

winreg.HKEYType.__exit__

exc_type: object

exc_value: object

traceback: object

/

[clinic start generated code]*/

static PyObject *

winreg_HKEYType___exit___impl(PyHKEYObject *self, PyObject *exc_type,

PyObject *exc_value, PyObject *traceback)

/*[clinic end generated code: output=923ebe7389e6a263 input=1eac83cd06962689]*/

{

winreg_state *st = _PyType_GetModuleState(Py_TYPE(self));

assert(st != NULL);

if (!PyHKEY_Close(st, (PyObject *)self)) {

return NULL;

}

Py_RETURN_NONE;

}

/*[clinic input]

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=da39a3ee5e6b4b0d]*/

static struct PyMethodDef PyHKEY_methods[] = {

WINREG_HKEYTYPE_CLOSE_METHODDEF

WINREG_HKEYTYPE_DETACH_METHODDEF

WINREG_HKEYTYPE___ENTER___METHODDEF

WINREG_HKEYTYPE___EXIT___METHODDEF

{NULL}

};

#define OFF(e) offsetof(PyHKEYObject, e)

static PyMemberDef PyHKEY_memberlist[] = {

{"handle", Py_T_INT, OFF(hkey), Py_READONLY},

{NULL} /* Sentinel */

};

static PyType_Slot pyhkey_type_slots[] = {

{Py_tp_dealloc, PyHKEY_deallocFunc},

{Py_tp_members, PyHKEY_memberlist},

{Py_tp_methods, PyHKEY_methods},

{Py_tp_doc, (char *)PyHKEY_doc},

{Py_tp_traverse, PyHKEY_traverseFunc},

{Py_tp_hash, PyHKEY_hashFunc},

{Py_tp_str, PyHKEY_strFunc},

// Number protocol

{Py_nb_add, PyHKEY_binaryFailureFunc},

{Py_nb_subtract, PyHKEY_binaryFailureFunc},

{Py_nb_multiply, PyHKEY_binaryFailureFunc},

{Py_nb_remainder, PyHKEY_binaryFailureFunc},

{Py_nb_divmod, PyHKEY_binaryFailureFunc},

{Py_nb_power, PyHKEY_ternaryFailureFunc},

{Py_nb_negative, PyHKEY_unaryFailureFunc},

{Py_nb_positive, PyHKEY_unaryFailureFunc},

{Py_nb_absolute, PyHKEY_unaryFailureFunc},

{Py_nb_bool, PyHKEY_boolFunc},

{Py_nb_invert, PyHKEY_unaryFailureFunc},

{Py_nb_lshift, PyHKEY_binaryFailureFunc},

{Py_nb_rshift, PyHKEY_binaryFailureFunc},

{Py_nb_and, PyHKEY_binaryFailureFunc},

{Py_nb_xor, PyHKEY_binaryFailureFunc},

{Py_nb_or, PyHKEY_binaryFailureFunc},

{Py_nb_int, PyHKEY_intFunc},

{Py_nb_float, PyHKEY_unaryFailureFunc},

{0, NULL},

};

static PyType_Spec pyhkey_type_spec = {

.name = "winreg.PyHKEY",

.basicsize = sizeof(PyHKEYObject),

.flags = (Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE |

Py_TPFLAGS_DISALLOW_INSTANTIATION),

.slots = pyhkey_type_slots,

};

/************************************************************************

The public PyHKEY API (well, not public yet :-)

************************************************************************/

PyObject *

PyHKEY_New(PyObject *m, HKEY hInit)

{

winreg_state *st = _PyModule_GetState(m);

PyHKEYObject *key = PyObject_GC_New(PyHKEYObject, st->PyHKEY_Type);

if (key == NULL) {

return NULL;

}

key->hkey = hInit;

PyObject_GC_Track(key);

return (PyObject *)key;

}

BOOL

PyHKEY_Close(winreg_state *st, PyObject *ob_handle)

{

LONG rc;

HKEY key;

if (!PyHKEY_AsHKEY(st, ob_handle, &key, TRUE)) {

return FALSE;

}

if (PyHKEY_Check(st, ob_handle)) {

((PyHKEYObject*)ob_handle)->hkey = 0;

}

Py_BEGIN_ALLOW_THREADS

rc = key ? RegCloseKey(key) : ERROR_SUCCESS;

Py_END_ALLOW_THREADS

if (rc != ERROR_SUCCESS)

PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");

return rc == ERROR_SUCCESS;

}

BOOL

PyHKEY_AsHKEY(winreg_state *st, PyObject *ob, HKEY *pHANDLE, BOOL bNoneOK)

{

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(st ,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;

}

BOOL

clinic_HKEY_converter(winreg_state *st, PyObject *ob, void *p)

{

if (!PyHKEY_AsHKEY(st, ob, (HKEY *)p, FALSE)) {

return FALSE;

}

return TRUE;

}

PyObject *

PyHKEY_FromHKEY(winreg_state *st, HKEY h)

{

PyHKEYObject *op = (PyHKEYObject *)PyObject_GC_New(PyHKEYObject,

st->PyHKEY_Type);

if (op == NULL) {

return NULL;

}

op->hkey = h;

PyObject_GC_Track(op);

return (PyObject *)op;

}

/************************************************************************

The module methods

************************************************************************/

BOOL

PyWinObject_CloseHKEY(winreg_state *st, PyObject *obHandle)

{

BOOL ok;

if (PyHKEY_Check(st, obHandle)) {

ok = PyHKEY_Close(st, obHandle);

}

#if SIZEOF_LONG >= SIZEOF_HKEY

else if (PyLong_Check(obHandle)) {

long rc;

Py_BEGIN_ALLOW_THREADS

rc = RegCloseKey((HKEY)PyLong_AsLong(obHandle));

Py_END_ALLOW_THREADS

ok = (rc == ERROR_SUCCESS);

if (!ok)

PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");

}

#else

else if (PyLong_Check(obHandle)) {

long rc;

HKEY hkey = (HKEY)PyLong_AsVoidPtr(obHandle);

Py_BEGIN_ALLOW_THREADS

rc = RegCloseKey(hkey);

Py_END_ALLOW_THREADS

ok = (rc == ERROR_SUCCESS);

if (!ok)

PyErr_SetFromWindowsErrWithFunction(rc, "RegCloseKey");

}

#endif

else {

PyErr_SetString(

PyExc_TypeError,

"A handle must be a HKEY object or an integer");

return FALSE;

}

return ok;

}

/*

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

** some commercial packages install strings which don't conform,

** causing this code to fail - however, "regedit" etc still work

** with these strings (ie only we don't!).

*/

static void

fixupMultiSZ(wchar_t **str, wchar_t *data, int len)

{

wchar_t *P;

int i;

wchar_t *Q;

if (len > 0 && data[len - 1] == '\0') {

Q = data + len - 1;

}

else {

Q = data + len;

}

for (P = data, i = 0; P < Q; P++, i++) {

str[i] = P;

for (; P < Q && *P != '\0'; P++) {

;

}

}

}

static int

countStrings(wchar_t *data, int len)

{

int strings;

wchar_t *P, *Q;

if (len > 0 && data[len - 1] == '\0') {

Q = data + len - 1;

}

else {

Q = data + len;

}

for (P = data, strings = 0; P < Q; P++, strings++) {

for (; P < Q && *P != '\0'; P++) {

;

}

}

return strings;

}

/* Convert PyObject into Registry data.

Allocates space as needed. */

static BOOL

Py2Reg(PyObject *value, DWORD typ, BYTE **retDataBuf, DWORD *retDataSize)

{

Py_ssize_t i,j;

switch (typ) {

case REG_DWORD:

{

if (value != Py_None && !PyLong_Check(value)) {

return FALSE;

}

DWORD d;

if (value == Py_None) {

d = 0;

}

else if (PyLong_Check(value)) {

d = PyLong_AsUnsignedLong(value);

if (d == (DWORD)(-1) && PyErr_Occurred()) {

return FALSE;

}

}

*retDataBuf = (BYTE *)PyMem_NEW(DWORD, 1);

if (*retDataBuf == NULL) {

PyErr_NoMemory();

return FALSE;

}

memcpy(*retDataBuf, &d, sizeof(DWORD));

*retDataSize = sizeof(DWORD);

break;

}

case REG_QWORD:

{

if (value != Py_None && !PyLong_Check(value)) {

return FALSE;

}

DWORD64 d;

if (value == Py_None) {

d = 0;

}

else if (PyLong_Check(value)) {

d = PyLong_AsUnsignedLongLong(value);

if (d == (DWORD64)(-1) && PyErr_Occurred()) {

return FALSE;

}

}

*retDataBuf = (BYTE *)PyMem_NEW(DWORD64, 1);

if (*retDataBuf == NULL) {

PyErr_NoMemory();

return FALSE;

}

memcpy(*retDataBuf, &d, sizeof(DWORD64));

*retDataSize = sizeof(DWORD64);

break;

}

case REG_SZ:

case REG_EXPAND_SZ:

{

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;

}

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;

Py_ssize_t len;

t = PyList_GET_ITEM(value, j);

if (!PyUnicode_Check(t))

return FALSE;

len = PyUnicode_AsWideChar(t, NULL, 0);

if (len < 0)

return FALSE;

size += Py_SAFE_DOWNCAST(len * sizeof(wchar_t),

size_t, DWORD);

}

*retDataSize = size + 2;

*retDataBuf = (BYTE *)PyMem_NEW(char,

*retDataSize);

if (*retDataBuf == NULL){

PyErr_NoMemory();

return FALSE;

}

P = (wchar_t *)*retDataBuf;

for (j = 0; j < i; j++)

{

PyObject *t;

Py_ssize_t len;

t = PyList_GET_ITEM(value, j);

assert(size > 0);

len = PyUnicode_AsWideChar(t, P, size);

assert(len >= 0);

assert((unsigned)len < size);

size -= (DWORD)len + 1;

P += len + 1;

}

/* And doubly-terminate the list... */

*P = L'\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:

if (value == Py_None) {

*retDataSize = 0;

*retDataBuf = NULL;

}

else {

Py_buffer view;

if (!PyObject_CheckBuffer(value)) {

PyErr_Format(PyExc_TypeError,

"Objects of type '%s' can not "

"be used as binary registry values",

Py_TYPE(value)->tp_name);

return FALSE;

}

if (PyObject_GetBuffer(value, &view, PyBUF_SIMPLE) < 0)

return FALSE;

*retDataBuf = (BYTE *)PyMem_NEW(char, view.len);

if (*retDataBuf == NULL){

PyBuffer_Release(&view);

PyErr_NoMemory();

return FALSE;

}

*retDataSize = Py_SAFE_DOWNCAST(view.len, Py_ssize_t, DWORD);

memcpy(*retDataBuf, view.buf, view.len);

PyBuffer_Release(&view);

}

break;

}

return TRUE;

}

/* Convert Registry data into PyObject*/

static PyObject *

Reg2Py(BYTE *retDataBuf, DWORD retDataSize, DWORD typ)

{

PyObject *obData;

switch (typ) {

case REG_DWORD:

if (retDataSize == 0)

obData = PyLong_FromUnsignedLong(0);

else

obData = PyLong_FromUnsignedLong(*(DWORD *)retDataBuf);

break;

case REG_QWORD:

if (retDataSize == 0)

obData = PyLong_FromUnsignedLongLong(0);

else

obData = PyLong_FromUnsignedLongLong(*(DWORD64 *)retDataBuf);

break;

case REG_SZ:

case REG_EXPAND_SZ:

{

/* 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. */

wchar_t *data = (wchar_t *)retDataBuf;

size_t len = wcsnlen(data, retDataSize / sizeof(wchar_t));

obData = PyUnicode_FromWideChar(data, len);

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);

wchar_t **str = PyMem_New(wchar_t *, s);

if (str == NULL)

return PyErr_NoMemory();

fixupMultiSZ(str, data, len);

obData = PyList_New(s);

if (obData == NULL) {

PyMem_Free(str);

return NULL;

}

for (index = 0; index < s; index++)

{

size_t slen = wcsnlen(str[index], len);

PyObject *uni = PyUnicode_FromWideChar(str[index], slen);

if (uni == NULL) {

Py_DECREF(obData);

PyMem_Free(str);

return NULL;

}

PyList_SET_ITEM(obData, index, uni);

len -= Py_SAFE_DOWNCAST(slen + 1, size_t, int);

}

PyMem_Free(str);

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) {

obData = Py_NewRef(Py_None);

}

else

obData = PyBytes_FromStringAndSize(

(char *)retDataBuf, retDataSize);

break;

}

return obData;

}

/* The Python methods */

/*[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]*/

static PyObject *

winreg_CloseKey(PyObject *module, PyObject *hkey)

/*[clinic end generated code: output=a4fa537019a80d15 input=5b1aac65ba5127ad]*/

{

if (!PyHKEY_Close(_PyModule_GetState(module), hkey)) {

return NULL;

}

Py_RETURN_NONE;

}

#if defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM)

/*[clinic input]

winreg.ConnectRegistry -> HKEY

computer_name: Py_UNICODE(accept={str, NoneType})

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.

/

Establishes a connection to the registry on another computer.

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

winreg_ConnectRegistry_impl(PyObject *module, const wchar_t *computer_name,

HKEY key)

/*[clinic end generated code: output=c77d12428f4bfe29 input=5f98a891a347e68e]*/

{

HKEY retKey;

long rc;

if (PySys_Audit("winreg.ConnectRegistry", "un",

computer_name, (Py_ssize_t)key) < 0) {

return NULL;

}

Py_BEGIN_ALLOW_THREADS

rc = RegConnectRegistryW(computer_name, key, &retKey);

Py_END_ALLOW_THREADS

if (rc != ERROR_SUCCESS) {

PyErr_SetFromWindowsErrWithFunction(rc, "ConnectRegistry");

return NULL;

}

return retKey;

}

#endif /* MS_WINDOWS_DESKTOP || MS_WINDOWS_SYSTEM */

/*[clinic input]

winreg.CreateKey -> HKEY

key: HKEY

An already open key, or one of the predefined HKEY_* constants.

sub_key: Py_UNICODE(accept={str, NoneType})

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

winreg_CreateKey_impl(PyObject *module, HKEY key, const wchar_t *sub_key)

/*[clinic end generated code: output=58d3eb2ed428a84d input=3cdd1622488acea2]*/

{

HKEY retKey;

long rc;

if (PySys_Audit("winreg.CreateKey", "nun",

(Py_ssize_t)key, sub_key,

(Py_ssize_t)KEY_WRITE) < 0) {

return NULL;

}

Py_BEGIN_ALLOW_THREADS

rc = RegCreateKeyW(key, sub_key, &retKey);

Py_END_ALLOW_THREADS

if (rc != ERROR_SUCCESS) {

PyErr_SetFromWindowsErrWithFunction(rc, "CreateKey");

return NULL;

}

if (PySys_Audit("winreg.OpenKey/result", "n",

(Py_ssize_t)retKey) < 0) {

return NULL;

}

return retKey;

}

/*[clinic input]

winreg.CreateKeyEx -> HKEY

key: HKEY

An already open key, or one of the predefined HKEY_* constants.

sub_key: Py_UNICODE(accept={str, NoneType})

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

winreg_CreateKeyEx_impl(PyObject *module, HKEY key, const wchar_t *sub_key,

int reserved, REGSAM access)

/*[clinic end generated code: output=51b53e38d5e00d4b input=42c2b03f98406b66]*/

{

HKEY retKey;

long rc;

if (PySys_Audit("winreg.CreateKey", "nun",

(Py_ssize_t)key, sub_key,

(Py_ssize_t)access) < 0) {

return NULL;

}

Py_BEGIN_ALLOW_THREADS

rc = RegCreateKeyExW(key, sub_key, reserved, NULL, 0,

access, NULL, &retKey, NULL);

Py_END_ALLOW_THREADS

if (rc != ERROR_SUCCESS) {

PyErr_SetFromWindowsErrWithFunction(rc, "CreateKeyEx");

return NULL;

}

if (PySys_Audit("winreg.OpenKey/result", "n",