public static HKEYType ConnectRegistry(string computerName, BigInteger key)
{
if (string.IsNullOrEmpty(computerName))
{
computerName = string.Empty;
}
RegistryKey newKey;
try {
newKey = RegistryKey.OpenRemoteBaseKey(MapSystemKey(key), computerName);
}catch (IOException ioe) {
throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, PythonExceptions._WindowsError.ERROR_BAD_NETPATH, ioe.Message);
} catch (Exception e) {
throw new ExternalException(e.Message);
}
return(new HKEYType(newKey));
}
public static PythonTuple EnumValue(object key, int index)
{
HKEYType rootKey = GetRootKey(key);
if (index >= rootKey.GetKey().ValueCount)
{
throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, PythonExceptions._WindowsError.ERROR_BAD_COMMAND, "No more data is available");
}
var nativeRootKey = rootKey.GetKey();
string valueName = nativeRootKey.GetValueNames()[index];
int valueKind;
object value;
QueryValueExImpl(nativeRootKey, valueName, out valueKind, out value);
return(PythonTuple.MakeTuple(valueName, value, valueKind));
}
public static bool QueryReflectionKey(object key)
{
HKEYType rootKey = GetRootKey(key);
bool isDisabled;
if (!Environment.Is64BitOperatingSystem)
{
throw new NotImplementedException("not implemented on this platform");
}
int dwRet = RegQueryReflectionKey(rootKey.GetKey().Handle, out isDisabled);
if (dwRet != ERROR_SUCCESS)
{
throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, dwRet);
}
return(isDisabled);
}
public static HKEYType OpenKey(object key, string subKeyName, int reserved, int mask)
{
HKEYType rootKey = GetRootKey(key);
RegistryKey newKey = null;
// I'm assuming that the masks that CPy uses are the same as the Win32 API one mentioned here-
// http://msdn2.microsoft.com/en-us/library/ms724878(VS.85).aspx
// KEY_WRITE is a combination of KEY_SET_VALUE and KEY_CREATE_SUB_KEY. We'll open with write access
// if any of this is set.
// KEY_READ is a combination of KEY_QUERY_VALUE, KEY_ENUMERATE_SUB_KEYS and KEY_NOTIFY. We'll open
// with read access for all of these.
try {
if ((mask & KEY_SET_VALUE) == KEY_SET_VALUE ||
(mask & KEY_CREATE_SUB_KEY) == KEY_CREATE_SUB_KEY)
{
newKey = rootKey.key.OpenSubKey(subKeyName, true);
}
else if ((mask & KEY_QUERY_VALUE) == KEY_QUERY_VALUE ||
(mask & KEY_ENUMERATE_SUB_KEYS) == KEY_ENUMERATE_SUB_KEYS ||
(mask & KEY_NOTIFY) == KEY_NOTIFY)
{
newKey = rootKey.key.OpenSubKey(subKeyName, false);
}
else
{
throw new Win32Exception("Unexpected mode");
}
} catch (SecurityException) {
throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, PythonExceptions._WindowsError.ERROR_ACCESS_DENIED, "Access is denied");
}
if (newKey == null)
{
throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, PythonExceptions._WindowsError.ERROR_FILE_NOT_FOUND, "The system cannot find the file specified");
}
return(new HKEYType(newKey));
}
public void do_handshake()
{
try {
// make sure the remote side hasn't shutdown before authenticating so we don't
// hang if we're in blocking mode.
#pragma warning disable 219 // unused variable
int available = _socket._socket.Available;
#pragma warning restore 219
} catch (SocketException) {
throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, "socket closed before handshake");
}
EnsureSslStream(true);
var enabledSslProtocols = GetProtocolType(_protocol);
try {
if (_serverSide)
{
_sslStream.AuthenticateAsServer(_cert, _certsMode == PythonSsl.CERT_REQUIRED, enabledSslProtocols, false);
}
else
{
var collection = new X509CertificateCollection();
if (_cert != null)
{
collection.Add(_cert);
}
_sslStream.AuthenticateAsClient(_serverHostName ?? _socket._hostName, collection, enabledSslProtocols, false);
}
} catch (AuthenticationException e) {
((IDisposable)_socket._socket).Dispose();
throw PythonExceptions.CreateThrowable(PythonSsl.SSLError(_context), "errors while performing handshake: ", e.ToString());
}
if (_validationFailure != null)
{
throw _validationFailure;
}
}
public static PythonTuple EnumValue(object key, int index)
{
HKEYType rootKey = GetRootKey(key);
if (index >= rootKey.GetKey().ValueCount)
{
throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, PythonExceptions._OSError.ERROR_BAD_COMMAND, "No more data is available", null, PythonExceptions._OSError.ERROR_BAD_COMMAND);
}
var nativeRootKey = rootKey.GetKey();
string valueName = nativeRootKey.GetValueNames()[index];
// it looks like nativeRootKey.Handle fails on HKEY_PERFORMANCE_DATA so manually create the handle instead
var handle = rootKey.hkey == HKEY_PERFORMANCE_DATA ? new SafeRegistryHandle(new IntPtr(unchecked ((int)0x80000004)), true) : nativeRootKey.Handle;
int valueKind;
object value;
QueryValueExImpl(handle, valueName, out valueKind, out value);
return(PythonTuple.MakeTuple(valueName, value, valueKind));
}
public static Bytes byteswap(CodeContext /*!*/ context, [NotNone] IBufferProtocol fragment, int width)
{
if (width < 1 || width > 4)
{
throw PythonExceptions.CreateThrowable(error(context), "Size should be 1, 2, 3 or 4");
}
using var buffer = fragment.GetBuffer();
if (buffer.NumBytes() % width != 0)
{
throw PythonExceptions.CreateThrowable(error(context), "not a whole number of frames");
}
var array = buffer.ToArray();
if (width == 2)
{
for (var i = 0; i < array.Length; i += width)
{
array.ByteSwap(i, i + 1);
}
}
else if (width == 3)
{
for (var i = 0; i < array.Length; i += width)
{
array.ByteSwap(i, i + 2);
}
}
else if (width == 4)
{
for (var i = 0; i < array.Length; i += width)
{
array.ByteSwap(i, i + 3);
array.ByteSwap(i + 1, i + 2);
}
}
return(Bytes.Make(array));
}
public string GetLocale(CodeContext /*!*/ context, int category)
{
switch ((LocaleCategories)category)
{
case LocaleCategories.All:
if (Collate == CType &&
Collate == Time &&
Collate == Monetary &&
Collate == Numeric)
{
// they're all the same, return only 1 name
goto case LocaleCategories.Collate;
}
// return them all...
return(String.Format("LC_COLLATE={0};LC_CTYPE={1};LC_MONETARY={2};LC_NUMERIC={3};LC_TIME={4}",
GetLocale(context, LC_COLLATE),
GetLocale(context, LC_CTYPE),
GetLocale(context, LC_MONETARY),
GetLocale(context, LC_NUMERIC),
GetLocale(context, LC_TIME)));
case LocaleCategories.Collate: return(CultureToName(Collate));
case LocaleCategories.CType: return(CultureToName(CType));
case LocaleCategories.Time: return(CultureToName(Time));
case LocaleCategories.Monetary: return(CultureToName(Monetary));
case LocaleCategories.Numeric: return(CultureToName(Numeric));
default:
throw PythonExceptions.CreateThrowable(_localeerror(context), "unknown locale category");
}
}
private void ValidationError(object reason)
{
_validationFailure = PythonExceptions.CreateThrowable(PythonSsl.SSLError(_context), "errors while validating certificate chain: ", reason.ToString());
}
private static Exception Incomplete(CodeContext /*!*/ context, params object[] args)
{
return(PythonExceptions.CreateThrowable((PythonType)context.LanguageContext.GetModuleState(_IncompleteKey), args));
}
public static PythonTuple CreateProcess(
CodeContext context,
string applicationName,
string commandLineArgs,
object pSec /*subprocess.py passes None*/,
object tSec /*subprocess.py passes None*/,
int?bInheritHandles,
uint?dwCreationFlags,
object lpEnvironment,
string lpCurrentDirectory,
object lpStartupInfo /* subprocess.py passes STARTUPINFO*/)
{
object dwFlags = PythonOps.GetBoundAttr(context, lpStartupInfo, "dwFlags"); //public Int32 dwFlags;
object hStdInput = PythonOps.GetBoundAttr(context, lpStartupInfo, "hStdInput"); //public IntPtr hStdInput;
object hStdOutput = PythonOps.GetBoundAttr(context, lpStartupInfo, "hStdOutput"); //public IntPtr hStdOutput;
object hStdError = PythonOps.GetBoundAttr(context, lpStartupInfo, "hStdError"); //public IntPtr hStdError;
object wShowWindow = PythonOps.GetBoundAttr(context, lpStartupInfo, "wShowWindow"); //Int16 wShowWindow;
Int32 dwFlagsInt32 = dwFlags != null?Converter.ConvertToInt32(dwFlags) : 0;
IntPtr hStdInputIntPtr = hStdInput != null ? new IntPtr(Converter.ConvertToInt32(hStdInput)) : IntPtr.Zero;
IntPtr hStdOutputIntPtr = hStdOutput != null ? new IntPtr(Converter.ConvertToInt32(hStdOutput)) : IntPtr.Zero;
IntPtr hStdErrorIntPtr = hStdError != null ? new IntPtr(Converter.ConvertToInt32(hStdError)) : IntPtr.Zero;
Int16 wShowWindowInt16 = wShowWindow != null?Converter.ConvertToInt16(wShowWindow) : (short)0;
STARTUPINFO startupInfo = new STARTUPINFO();
startupInfo.dwFlags = dwFlagsInt32;
startupInfo.hStdInput = hStdInputIntPtr;
startupInfo.hStdOutput = hStdOutputIntPtr;
startupInfo.hStdError = hStdErrorIntPtr;
startupInfo.wShowWindow = wShowWindowInt16;
// No special security
SECURITY_ATTRIBUTES pSecSA = new SECURITY_ATTRIBUTES();
pSecSA.nLength = Marshal.SizeOf(pSecSA);
SECURITY_ATTRIBUTES tSecSA = new SECURITY_ATTRIBUTES();
tSecSA.nLength = Marshal.SizeOf(tSecSA);
if (pSec != null)
{
/* If pSec paseed in from Python is not NULL
* there needs to be some conversion done here...*/
}
if (tSec != null)
{
/* If tSec paseed in from Python is not NULL
* there needs to be some conversion done here...*/
}
// If needed convert lpEnvironment Dictionary to lpEnvironmentIntPtr
string lpEnvironmentStr = EnvironmentToNative(context, lpEnvironment);
PROCESS_INFORMATION lpProcessInformation = new PROCESS_INFORMATION();
bool result = CreateProcessPI(
String.IsNullOrEmpty(applicationName) ? null : applicationName /*applicationNameHelper*//*processStartInfo.FileName*/,
String.IsNullOrEmpty(commandLineArgs) ? null : commandLineArgs /*commandLineArgsHelper*//*processStartInfo.Arguments*/,
ref pSecSA, ref tSecSA,
bInheritHandles.HasValue && bInheritHandles.Value > 0 ? true : false,
dwCreationFlags.HasValue ? dwCreationFlags.Value : 0,
lpEnvironmentStr,
lpCurrentDirectory,
ref startupInfo,
out lpProcessInformation);
if (!result)
{
int error = Marshal.GetLastWin32Error();
throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, error, FormatError(error));
}
IntPtr hp = lpProcessInformation.hProcess;
IntPtr ht = lpProcessInformation.hThread;
int pid = lpProcessInformation.dwProcessId;
int tid = lpProcessInformation.dwThreadId;
return(PythonTuple.MakeTuple(
new PythonSubprocessHandle(hp, true),
new PythonSubprocessHandle(ht),
pid, tid));
}
private static Exception WindowsError(int code)
{
string message = CTypes.FormatError(code);
return(PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, code, message));
}
private static void QueryValueExImpl(SafeRegistryHandle handle, string valueName, out int valueKind, out object value)
{
valueName = valueName ?? ""; // it looks like RegQueryValueEx can fail with null, use empty string instead
valueKind = 0;
int dwRet;
byte[] data = new byte[128];
uint length = (uint)data.Length;
// query the size first, reading the data as we query...
dwRet = RegQueryValueEx(handle, valueName, IntPtr.Zero, out valueKind, data, ref length);
while (dwRet == ERROR_MORE_DATA)
{
data = new byte[data.Length * 2];
length = (uint)data.Length;
dwRet = RegQueryValueEx(handle, valueName, IntPtr.Zero, out valueKind, data, ref length);
}
if (dwRet == PythonExceptions._OSError.ERROR_FILE_NOT_FOUND)
{
throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, PythonExceptions._OSError.ERROR_FILE_NOT_FOUND, "The system cannot find the file specified", null, PythonExceptions._OSError.ERROR_FILE_NOT_FOUND);
}
if (dwRet != ERROR_SUCCESS)
{
throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, dwRet);
}
// convert the result into a Python object
switch (valueKind)
{
case REG_MULTI_SZ:
PythonList list = new PythonList();
int curIndex = 0;
while (curIndex < length)
{
for (int dataIndex = curIndex; dataIndex < length; dataIndex += 2)
{
if (data[dataIndex] == 0 && data[dataIndex + 1] == 0)
{
// got a full string
list.Add(ExtractString(data, curIndex, dataIndex));
curIndex = dataIndex + 2;
if (curIndex + 2 <= length && data[curIndex] == 0 && data[curIndex + 1] == 0)
{
// double null terminated
curIndex = data.Length;
break;
}
}
}
if (curIndex != data.Length)
{
// not null terminated
list.Add(ExtractString(data, curIndex, data.Length));
}
}
value = list;
break;
case REG_BINARY:
var tight_fit_data = new byte[length];
for (int i = 0; i < length; i++)
{
tight_fit_data[i] = data[i];
}
value = length == 0 ? null : new Bytes(tight_fit_data);
break;
case REG_EXPAND_SZ:
case REG_SZ:
if (length >= 2 && data[length - 1] == 0 && data[length - 2] == 0)
{
value = ExtractString(data, 0, (int)length - 2);
}
else
{
value = ExtractString(data, 0, (int)length);
}
break;
case REG_DWORD:
if (BitConverter.IsLittleEndian)
{
value = (uint)((data[3] << 24) | (data[2] << 16) | (data[1] << 8) | data[0]);
}
else
{
value = (uint)((data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3]);
}
break;
default:
value = null;
break;
}
}
private static Exception ErrorDecoding(CodeContext context, params object[] args)
{
return(PythonExceptions.CreateThrowable(SSLError(context), ArrayUtils.Insert("Error decoding PEM-encoded file ", args)));
}
private static Exception Error(CodeContext /*!*/ context, params object[] args)
{
return(PythonExceptions.CreateThrowable((PythonType)PythonContext.GetContext(context).GetModuleState(_ErrorKey), args));
}
private static Exception WindowsError(int code)
{
return(PythonExceptions.CreateThrowable(PythonExceptions.OSError, code, FormatError(code)));
}
private static Exception MakeException(CodeContext /*!*/ context, object value)
{
return(PythonExceptions.CreateThrowable((PythonType)PythonContext.GetContext(context).GetModuleState("selecterror"), value));
}
public static HKEYType OpenKey(object key, string subKeyName, [DefaultParameterValue(0)] int res, [DefaultParameterValue(KEY_READ)] int sam)
{
HKEYType rootKey = GetRootKey(key);
RegistryKey newKey = null;
// I'm assuming that the masks that CPy uses are the same as the Win32 API one mentioned here-
// http://msdn2.microsoft.com/en-us/library/ms724878(VS.85).aspx
// KEY_WRITE is a combination of KEY_SET_VALUE and KEY_CREATE_SUB_KEY. We'll open with write access
// if any of this is set.
// KEY_READ is a combination of KEY_QUERY_VALUE, KEY_ENUMERATE_SUB_KEYS and KEY_NOTIFY. We'll open
// with read access for all of these.
var nativeRootKey = rootKey.GetKey();
try {
if ((sam & KEY_SET_VALUE) == KEY_SET_VALUE ||
(sam & KEY_CREATE_SUB_KEY) == KEY_CREATE_SUB_KEY)
{
if (res != 0)
{
#if NETSTANDARD
newKey = nativeRootKey.OpenSubKey(subKeyName, (RegistryRights)res);
#else
newKey = nativeRootKey.OpenSubKey(subKeyName, RegistryKeyPermissionCheck.Default, (RegistryRights)res);
#endif
}
else
{
newKey = nativeRootKey.OpenSubKey(subKeyName, true);
}
}
else if ((sam & KEY_QUERY_VALUE) == KEY_QUERY_VALUE ||
(sam & KEY_ENUMERATE_SUB_KEYS) == KEY_ENUMERATE_SUB_KEYS ||
(sam & KEY_NOTIFY) == KEY_NOTIFY)
{
if (res != 0)
{
#if NETSTANDARD
newKey = nativeRootKey.OpenSubKey(subKeyName, (RegistryRights)res);
#else
newKey = nativeRootKey.OpenSubKey(subKeyName, RegistryKeyPermissionCheck.ReadSubTree, (RegistryRights)res);
#endif
}
else
{
newKey = nativeRootKey.OpenSubKey(subKeyName, false);
}
}
else
{
throw new Win32Exception("Unexpected mode");
}
} catch (SecurityException) {
throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, PythonExceptions._WindowsError.ERROR_ACCESS_DENIED, "Access is denied");
}
if (newKey == null)
{
throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, PythonExceptions._WindowsError.ERROR_FILE_NOT_FOUND, "The system cannot find the file specified");
}
return(new HKEYType(newKey));
}
