mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
612 lines
30 KiB
C#
612 lines
30 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="RemoteWebConfigurationHost.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.Configuration {
|
|
using System.Collections;
|
|
using System.Configuration;
|
|
using System.Configuration.Internal;
|
|
using System.Web;
|
|
using System.Web.Util;
|
|
using System.Security;
|
|
using System.IO;
|
|
using System.Web.Hosting;
|
|
using System.Runtime.InteropServices;
|
|
using System.Reflection;
|
|
using System.Collections.Specialized;
|
|
using System.Xml;
|
|
using System.Security.Principal;
|
|
using System.Threading;
|
|
using System.Globalization;
|
|
using System.Security.Permissions;
|
|
|
|
[SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
|
|
internal sealed class RemoteWebConfigurationHost : DelegatingConfigHost
|
|
{
|
|
private const string KEY_MACHINE = "MACHINE";
|
|
|
|
private static object s_version = new object();
|
|
|
|
private string _Server;
|
|
private string _Username;
|
|
private string _Domain;
|
|
private string _Password;
|
|
private WindowsIdentity _Identity;
|
|
|
|
private Hashtable _PathMap; // configPath -> configFile
|
|
private string _ConfigPath;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
internal RemoteWebConfigurationHost() {}
|
|
|
|
public override void Init(IInternalConfigRoot configRoot, params object[] hostInitParams) {
|
|
throw ExceptionUtil.UnexpectedError("RemoteWebConfigurationHost::Init");
|
|
}
|
|
|
|
public override void InitForConfiguration(ref string locationSubPath, out string configPath, out string locationConfigPath,
|
|
IInternalConfigRoot root, params object[] hostInitConfigurationParams) {
|
|
|
|
|
|
WebLevel webLevel = (WebLevel) hostInitConfigurationParams[0];
|
|
// ConfigurationFileMap fileMap = (ConfigurationFileMap) hostInitConfigurationParams[1];
|
|
string path = (string) hostInitConfigurationParams[2];
|
|
string site = (string) hostInitConfigurationParams[3];
|
|
|
|
if (locationSubPath == null) {
|
|
locationSubPath = (string) hostInitConfigurationParams[4];
|
|
}
|
|
|
|
string server = (string) hostInitConfigurationParams[5];
|
|
string userName = (string) hostInitConfigurationParams[6];
|
|
string password = (string) hostInitConfigurationParams[7];
|
|
IntPtr tokenHandle = (IntPtr) hostInitConfigurationParams[8];
|
|
|
|
configPath = null;
|
|
locationConfigPath = null;
|
|
|
|
_Server = server;
|
|
_Username = GetUserNameFromFullName(userName);
|
|
_Domain = GetDomainFromFullName(userName);
|
|
_Password = password;
|
|
_Identity = (tokenHandle == IntPtr.Zero) ? null : new WindowsIdentity(tokenHandle); //CreateWindowsIdentity(username, domain, password, tokenHandle);
|
|
|
|
_PathMap = new Hashtable(StringComparer.OrdinalIgnoreCase);
|
|
|
|
#if !FEATURE_PAL // FEATURE_PAL does not have WindowsImpersonationContext, COM objects
|
|
//
|
|
// Send the path arguments to the server for parsing,
|
|
// and retreive the normalized paths and path mapping
|
|
// from config paths to file paths.
|
|
//
|
|
string filePaths;
|
|
try {
|
|
WindowsImpersonationContext wiContext = (_Identity != null) ? _Identity.Impersonate() : null;
|
|
try {
|
|
IRemoteWebConfigurationHostServer remoteSrv = RemoteWebConfigurationHost.CreateRemoteObject(server, _Username, _Domain, password); //(IRemoteWebConfigurationHostServer) Activator.CreateInstance(type);
|
|
try {
|
|
filePaths = remoteSrv.GetFilePaths((int) webLevel, path, site, locationSubPath);
|
|
} finally {
|
|
// Release COM objects
|
|
while (Marshal.ReleaseComObject(remoteSrv) > 0) {
|
|
}
|
|
}
|
|
} finally {
|
|
if (wiContext != null)
|
|
wiContext.Undo();
|
|
}
|
|
}
|
|
catch {
|
|
// Wrap finally clause with a try to avoid exception clauses being run
|
|
// while the thread is impersonated.
|
|
throw;
|
|
}
|
|
|
|
if (filePaths == null) {
|
|
throw ExceptionUtil.UnexpectedError("RemoteWebConfigurationHost::InitForConfiguration");
|
|
}
|
|
|
|
//
|
|
// Format of filePaths:
|
|
// appPath < appSiteName < appSiteID < configPath < locationConfigPath [< configPath < fileName]+
|
|
//
|
|
string[] parts = filePaths.Split(RemoteWebConfigurationHostServer.FilePathsSeparatorParams);
|
|
|
|
if (parts.Length < 7 || (parts.Length - 5) % 2 != 0) {
|
|
throw ExceptionUtil.UnexpectedError("RemoteWebConfigurationHost::InitForConfiguration");
|
|
}
|
|
|
|
// convert empty strings to nulls
|
|
for (int i = 0; i < parts.Length; i++) {
|
|
if (parts[i].Length == 0) {
|
|
parts[i] = null;
|
|
}
|
|
}
|
|
|
|
// get config paths
|
|
string appPath = parts[0];
|
|
string appSiteName = parts[1];
|
|
string appSiteID = parts[2];
|
|
configPath = parts[3];
|
|
locationConfigPath = parts[4];
|
|
_ConfigPath = configPath;
|
|
|
|
// Create a WebConfigurationFileMap to be used when we later initialize our delegating WebConfigurationHost
|
|
WebConfigurationFileMap configFileMap = new WebConfigurationFileMap();
|
|
VirtualPath appPathVirtualPath = VirtualPath.CreateAbsoluteAllowNull(appPath);
|
|
|
|
configFileMap.Site = appSiteID;
|
|
|
|
// populate the configpath->physical path mapping
|
|
for (int i = 5; i < parts.Length; i += 2) {
|
|
string configPathTemp = parts[i];
|
|
string physicalFilePath = parts[i+1];
|
|
|
|
_PathMap.Add(configPathTemp, physicalFilePath);
|
|
|
|
// Update the WebConfigurationFileMap
|
|
if (WebConfigurationHost.IsMachineConfigPath(configPathTemp)) {
|
|
configFileMap.MachineConfigFilename = physicalFilePath;
|
|
}
|
|
else {
|
|
string vPathString;
|
|
bool isRootApp;
|
|
|
|
if (WebConfigurationHost.IsRootWebConfigPath(configPathTemp)) {
|
|
vPathString = null;
|
|
isRootApp = false;
|
|
}
|
|
else {
|
|
VirtualPath vPath;
|
|
string dummy;
|
|
|
|
WebConfigurationHost.GetSiteIDAndVPathFromConfigPath(configPathTemp, out dummy, out vPath);
|
|
vPathString = VirtualPath.GetVirtualPathString(vPath);
|
|
isRootApp = (vPath == appPathVirtualPath);
|
|
}
|
|
|
|
configFileMap.VirtualDirectories.Add(vPathString,
|
|
new VirtualDirectoryMapping(Path.GetDirectoryName(physicalFilePath), isRootApp));
|
|
}
|
|
}
|
|
|
|
#else // !FEATURE_PAL: set dummy config path
|
|
string appPath = null;
|
|
_ConfigPath = configPath;
|
|
#endif // !FEATURE_PAL
|
|
|
|
// Delegate to a WebConfigurationHost for unhandled methods.
|
|
WebConfigurationHost webConfigurationHost = new WebConfigurationHost();
|
|
webConfigurationHost.Init(root, true, new UserMapPath(configFileMap, /*pathsAreLocal*/ false), null, appPath, appSiteName, appSiteID);
|
|
Host = webConfigurationHost;
|
|
}
|
|
|
|
// config path support
|
|
public override bool IsConfigRecordRequired(string configPath) {
|
|
// a record is required for every part of the config path
|
|
return configPath.Length <= _ConfigPath.Length;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
public override string GetStreamName(string configPath)
|
|
{
|
|
return (string) _PathMap[configPath];
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
public override object GetStreamVersion(string streamName) {
|
|
#if FEATURE_PAL // FEATURE_PAL: singelton version
|
|
return s_version;
|
|
#else
|
|
// for now, assume it is the same
|
|
// return s_version;
|
|
bool exists;
|
|
long size, createDate, lastWriteDate;
|
|
WindowsImpersonationContext wiContext = null;
|
|
|
|
try {
|
|
if (_Identity != null) {
|
|
wiContext = _Identity.Impersonate();
|
|
}
|
|
|
|
try {
|
|
//////////////////////////////////////////////////////////////////
|
|
// Step 3: Get the type and create the object on the remote server
|
|
IRemoteWebConfigurationHostServer remoteSrv = CreateRemoteObject(_Server, _Username, _Domain, _Password);
|
|
try {
|
|
//////////////////////////////////////////////////////////////////
|
|
// Step 4: Call the API
|
|
remoteSrv.GetFileDetails(streamName, out exists, out size, out createDate, out lastWriteDate);
|
|
}
|
|
finally {
|
|
while (Marshal.ReleaseComObject(remoteSrv) > 0) { } // release the COM object
|
|
}
|
|
}
|
|
finally {
|
|
if (wiContext != null) {
|
|
wiContext.Undo(); // revert impersonation
|
|
}
|
|
}
|
|
}
|
|
catch {
|
|
// Wrap finally clause with a try to avoid exception clauses being run
|
|
// while the thread is impersonated.
|
|
throw;
|
|
}
|
|
|
|
return new FileDetails(exists, size, DateTime.FromFileTimeUtc(createDate), DateTime.FromFileTimeUtc(lastWriteDate));
|
|
#endif // FEATURE_PAL
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
public override Stream OpenStreamForRead(string streamName) {
|
|
RemoteWebConfigurationHostStream rcs = new RemoteWebConfigurationHostStream(false, _Server, streamName, null, _Username, _Domain, _Password, _Identity);
|
|
if (rcs == null || rcs.Length < 1)
|
|
return null;
|
|
return rcs;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
public override Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext) {
|
|
RemoteWebConfigurationHostStream rcs = new RemoteWebConfigurationHostStream(true, _Server, streamName, templateStreamName, _Username, _Domain, _Password, _Identity);
|
|
writeContext = rcs;
|
|
return rcs;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
public override void DeleteStream(string StreamName)
|
|
{
|
|
//
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
public override void WriteCompleted(string streamName, bool success, object writeContext)
|
|
{
|
|
if (success) {
|
|
RemoteWebConfigurationHostStream rcs = (RemoteWebConfigurationHostStream)writeContext;
|
|
rcs.FlushForWriteCompleted();
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
public override bool IsFile(string StreamName)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
public override bool PrefetchAll(string configPath, string StreamName)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
public override bool PrefetchSection(string sectionGroupName, string sectionName)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
public override void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady) {
|
|
WebConfigurationHost.StaticGetRestrictedPermissions(configRecord, out permissionSet, out isHostReady);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
public override bool IsRemote {
|
|
get { return true; }
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
// Encrypt/decrypt support
|
|
public override string DecryptSection(string encryptedXmlString, ProtectedConfigurationProvider protectionProvider, ProtectedConfigurationSection protectedConfigSection) {
|
|
return CallEncryptOrDecrypt(false, encryptedXmlString, protectionProvider, protectedConfigSection);
|
|
}
|
|
public override string EncryptSection(string clearTextXmlString, ProtectedConfigurationProvider protectionProvider, ProtectedConfigurationSection protectedConfigSection) {
|
|
return CallEncryptOrDecrypt(true, clearTextXmlString, protectionProvider, protectedConfigSection);
|
|
}
|
|
|
|
private string CallEncryptOrDecrypt(bool doEncrypt, string xmlString, ProtectedConfigurationProvider protectionProvider, ProtectedConfigurationSection protectedConfigSection)
|
|
{
|
|
#if !FEATURE_PAL // FEATURE_PAL has no COM objects => no encryption
|
|
// ROTORTODO: COM Objects are not implemented.
|
|
// CORIOLISTODO: COM Objects are not implemented.
|
|
ProviderSettings ps;
|
|
NameValueCollection nvc;
|
|
string [] paramKeys;
|
|
string [] paramValues;
|
|
string returnString = null;
|
|
string typeName;
|
|
WindowsImpersonationContext wiContext = null;
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Step 1: Create list of parameters for the protection provider
|
|
typeName = protectionProvider.GetType().AssemblyQualifiedName;
|
|
ps = protectedConfigSection.Providers[protectionProvider.Name];
|
|
if (ps == null)
|
|
throw ExceptionUtil.ParameterInvalid("protectionProvider");
|
|
|
|
nvc = ps.Parameters;
|
|
if (nvc == null)
|
|
nvc = new NameValueCollection();
|
|
|
|
paramKeys = nvc.AllKeys;
|
|
paramValues = new string[paramKeys.Length];
|
|
for(int iter = 0; iter<paramKeys.Length; iter++)
|
|
paramValues[iter] = nvc[paramKeys[iter]];
|
|
|
|
////////////////////////////////////////////////////////////
|
|
// Step 2: Set the impersonation if required
|
|
if (_Identity != null)
|
|
wiContext = _Identity.Impersonate();
|
|
|
|
try {
|
|
try {
|
|
//////////////////////////////////////////////////////////////////
|
|
// Step 3: Get the type and create the object on the remote server
|
|
IRemoteWebConfigurationHostServer remoteSrv = CreateRemoteObject(_Server, _Username, _Domain, _Password);
|
|
try {
|
|
//////////////////////////////////////////////////////////////////
|
|
// Step 4: Call the API
|
|
returnString = remoteSrv.DoEncryptOrDecrypt(doEncrypt, xmlString, protectionProvider.Name, typeName, paramKeys, paramValues);
|
|
} finally {
|
|
while (Marshal.ReleaseComObject(remoteSrv) > 0) { } // release the COM object
|
|
}
|
|
} finally {
|
|
if (wiContext != null)
|
|
wiContext.Undo(); // revert impersonation
|
|
}
|
|
}
|
|
catch {
|
|
}
|
|
|
|
return returnString;
|
|
#else // !FEATURE_PAL
|
|
throw new NotImplementedException("ROTORTODO");
|
|
#endif // !FEATURE_PAL
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
|
private static string GetUserNameFromFullName(string fullUserName) {
|
|
if (string.IsNullOrEmpty(fullUserName))
|
|
return null;
|
|
if (fullUserName.Contains("@")) {
|
|
return fullUserName;
|
|
}
|
|
string[] splitted = fullUserName.Split(new char[] { '\\' });
|
|
if (splitted.Length == 1)
|
|
return fullUserName;
|
|
else
|
|
return splitted[1];
|
|
}
|
|
private static string GetDomainFromFullName(string fullUserName) {
|
|
if (string.IsNullOrEmpty(fullUserName))
|
|
return null;
|
|
if (fullUserName.Contains("@"))
|
|
return null;
|
|
string[] splitted = fullUserName.Split(new char[] { '\\' });
|
|
if (splitted.Length == 1)
|
|
return ".";
|
|
return splitted[0];
|
|
}
|
|
|
|
// impersonation support: create an identity from credentials
|
|
#if OLD_WAY
|
|
private static WindowsIdentity CreateWindowsIdentity(string userName, string password, IntPtr tokenHandle) {
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Step 0: Most common case: check if no credentials are supplied
|
|
if (string.IsNullOrEmpty(userName) && tokenHandle == IntPtr.Zero && string.IsNullOrEmpty(password))
|
|
return null;
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Step 1: Make sure that either username & password OR token is supplied
|
|
if ((string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(password)) || (!string.IsNullOrEmpty(userName) && string.IsNullOrEmpty(password)))
|
|
throw ExceptionUtil.ParameterNullOrEmpty("password");
|
|
|
|
if (!string.IsNullOrEmpty(userName) && tokenHandle != IntPtr.Zero)
|
|
throw ExceptionUtil.ParameterInvalid("tokenHandle");
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Step 2: Create token if not supplied
|
|
if (!string.IsNullOrEmpty(userName))
|
|
tokenHandle = CreateUserToken(userName, password);
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Step 3: Create a windows identity from the token
|
|
WindowsIdentity wi = new WindowsIdentity(tokenHandle);
|
|
|
|
if (!string.IsNullOrEmpty(userName) && tokenHandle != IntPtr.Zero) // Close the handle if we created it.
|
|
UnsafeNativeMethods.CloseHandle(tokenHandle);
|
|
return wi;
|
|
}
|
|
|
|
private static IntPtr CreateUserToken(string fullUserName, string password) {
|
|
string userName, domain;
|
|
if (fullUserName.Contains("@")) {
|
|
userName = fullUserName;
|
|
domain = null;
|
|
} else {
|
|
string[] splitted = fullUserName.Split(new char[] { '\\' });
|
|
if (splitted.Length == 1) {
|
|
userName = fullUserName;
|
|
domain = ".";
|
|
} else {
|
|
userName = splitted[1];
|
|
domain = splitted[0];
|
|
}
|
|
}
|
|
//This parameter causes LogonUser to create a primary token.
|
|
const int LOGON32_PROVIDER_DEFAULT = 0;
|
|
const int LOGON32_LOGON_INTERACTIVE = 2;
|
|
const int LOGON32_LOGON_NETWORK = 3;
|
|
const int LOGON32_LOGON_BATCH = 4;
|
|
const int LOGON32_LOGON_SERVICE = 5;
|
|
const int LOGON32_LOGON_NETWORK_CLEARTEXT = 8;
|
|
|
|
int[] Logon32Values = new int[] { LOGON32_LOGON_INTERACTIVE, LOGON32_LOGON_BATCH, LOGON32_LOGON_SERVICE, LOGON32_LOGON_NETWORK_CLEARTEXT, LOGON32_LOGON_NETWORK};
|
|
|
|
IntPtr tokenHandle = IntPtr.Zero;
|
|
int lastError = 0;
|
|
if (UnsafeNativeMethods.LogonUser(userName, domain, password, Logon32Values[0], LOGON32_PROVIDER_DEFAULT, ref tokenHandle) != 0)
|
|
return tokenHandle;
|
|
lastError = Marshal.GetHRForLastWin32Error();
|
|
for (int iter = 1; iter < Logon32Values.Length; iter++)
|
|
if (UnsafeNativeMethods.LogonUser(userName, domain, password, Logon32Values[iter], LOGON32_PROVIDER_DEFAULT, ref tokenHandle) != 0)
|
|
return tokenHandle;
|
|
Marshal.ThrowExceptionForHR(lastError);
|
|
return IntPtr.Zero;
|
|
}
|
|
#endif
|
|
internal static IRemoteWebConfigurationHostServer CreateRemoteObject(string server, string username, string domain, string password) {
|
|
|
|
#if !FEATURE_PAL // FEATURE_PAL has no COM objects
|
|
try {
|
|
if (string.IsNullOrEmpty(username))
|
|
return CreateRemoteObjectUsingGetTypeFromCLSID(server);
|
|
if (IntPtr.Size == 8)
|
|
return CreateRemoteObjectOn64BitPlatform(server, username, domain, password);
|
|
return CreateRemoteObjectOn32BitPlatform(server, username, domain, password);
|
|
} catch (COMException ex) {
|
|
if ((uint)ex.ErrorCode == 0x80040154)
|
|
throw new Exception(SR.GetString(SR.Make_sure_remote_server_is_enabled_for_config_access));
|
|
throw;
|
|
}
|
|
}
|
|
private static IRemoteWebConfigurationHostServer CreateRemoteObjectUsingGetTypeFromCLSID(string server) {
|
|
Type type = Type.GetTypeFromCLSID(typeof(RemoteWebConfigurationHostServer).GUID, server, true);
|
|
return (IRemoteWebConfigurationHostServer)Activator.CreateInstance(type);
|
|
}
|
|
|
|
private static IRemoteWebConfigurationHostServer CreateRemoteObjectOn32BitPlatform(string server, string username, string domain, string password)
|
|
{
|
|
MULTI_QI [] amqi = new MULTI_QI[1];
|
|
IntPtr guidbuf = IntPtr.Zero;
|
|
COAUTHINFO ca = null;
|
|
IntPtr captr = IntPtr.Zero;
|
|
COSERVERINFO cs = null;
|
|
Guid clsid = typeof(RemoteWebConfigurationHostServer).GUID;
|
|
int hr = 0;
|
|
COAUTHIDENTITY ci = null;
|
|
IntPtr ciptr = IntPtr.Zero;
|
|
|
|
try {
|
|
guidbuf = Marshal.AllocCoTaskMem(16);
|
|
Marshal.StructureToPtr(typeof(IRemoteWebConfigurationHostServer).GUID, guidbuf, false);
|
|
amqi[0] = new MULTI_QI(guidbuf);
|
|
|
|
ci = new COAUTHIDENTITY(username, domain, password);
|
|
ciptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(ci));
|
|
Marshal.StructureToPtr(ci, ciptr, false);
|
|
|
|
ca = new COAUTHINFO(RpcAuthent.WinNT, RpcAuthor.None, null, /*RpcLevel.Connect*/ RpcLevel.Default, RpcImpers.Impersonate, ciptr);
|
|
captr = Marshal.AllocCoTaskMem(Marshal.SizeOf(ca));
|
|
Marshal.StructureToPtr(ca, captr, false);
|
|
|
|
cs = new COSERVERINFO(server, captr);
|
|
hr = UnsafeNativeMethods.CoCreateInstanceEx(ref clsid, IntPtr.Zero, (int)ClsCtx.RemoteServer, cs, 1, amqi);
|
|
if ((uint)hr == 0x80040154)
|
|
throw new Exception(SR.GetString(SR.Make_sure_remote_server_is_enabled_for_config_access));
|
|
if (hr < 0)
|
|
Marshal.ThrowExceptionForHR(hr);
|
|
if (amqi[0].hr < 0)
|
|
Marshal.ThrowExceptionForHR(amqi[0].hr);
|
|
hr = UnsafeNativeMethods.CoSetProxyBlanket(amqi[0].pItf, RpcAuthent.WinNT, RpcAuthor.None, null, /*RpcLevel.Connect*/ RpcLevel.Default, RpcImpers.Impersonate, ciptr, 0);
|
|
if (hr < 0)
|
|
Marshal.ThrowExceptionForHR(hr);
|
|
return (IRemoteWebConfigurationHostServer)Marshal.GetObjectForIUnknown(amqi[0].pItf);
|
|
} finally {
|
|
if (amqi[0].pItf != IntPtr.Zero)
|
|
{
|
|
Marshal.Release(amqi[0].pItf);
|
|
amqi[0].pItf = IntPtr.Zero;
|
|
}
|
|
amqi[0].piid = IntPtr.Zero;
|
|
if (captr != IntPtr.Zero) {
|
|
Marshal.DestroyStructure(captr, typeof(COAUTHINFO));
|
|
Marshal.FreeCoTaskMem(captr);
|
|
}
|
|
if (ciptr != IntPtr.Zero) {
|
|
Marshal.DestroyStructure(ciptr, typeof(COAUTHIDENTITY));
|
|
Marshal.FreeCoTaskMem(ciptr);
|
|
}
|
|
if (guidbuf != IntPtr.Zero)
|
|
Marshal.FreeCoTaskMem(guidbuf);
|
|
}
|
|
#else // !FEATURE_PAL
|
|
throw new NotSupportedException();
|
|
#endif // !FEATURE_PAL
|
|
}
|
|
|
|
private static IRemoteWebConfigurationHostServer CreateRemoteObjectOn64BitPlatform(string server, string username, string domain, string password)
|
|
{
|
|
MULTI_QI_X64[] amqi = new MULTI_QI_X64[1];
|
|
IntPtr guidbuf = IntPtr.Zero;
|
|
COAUTHINFO_X64 ca = null;
|
|
IntPtr captr = IntPtr.Zero;
|
|
COSERVERINFO_X64 cs = null;
|
|
Guid clsid = typeof(RemoteWebConfigurationHostServer).GUID;
|
|
int hr = 0;
|
|
COAUTHIDENTITY_X64 ci = null;
|
|
IntPtr ciptr = IntPtr.Zero;
|
|
|
|
try {
|
|
guidbuf = Marshal.AllocCoTaskMem(16);
|
|
Marshal.StructureToPtr(typeof(IRemoteWebConfigurationHostServer).GUID, guidbuf, false);
|
|
amqi[0] = new MULTI_QI_X64(guidbuf);
|
|
|
|
ci = new COAUTHIDENTITY_X64(username, domain, password);
|
|
ciptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(ci));
|
|
Marshal.StructureToPtr(ci, ciptr, false);
|
|
|
|
ca = new COAUTHINFO_X64(RpcAuthent.WinNT, RpcAuthor.None, null, /*RpcLevel.Connect*/ RpcLevel.Default, RpcImpers.Impersonate, ciptr);
|
|
captr = Marshal.AllocCoTaskMem(Marshal.SizeOf(ca));
|
|
Marshal.StructureToPtr(ca, captr, false);
|
|
|
|
cs = new COSERVERINFO_X64(server, captr);
|
|
hr = UnsafeNativeMethods.CoCreateInstanceEx(ref clsid, IntPtr.Zero, (int)ClsCtx.RemoteServer, cs, 1, amqi);
|
|
if ((uint)hr == 0x80040154)
|
|
throw new Exception(SR.GetString(SR.Make_sure_remote_server_is_enabled_for_config_access));
|
|
if (hr < 0)
|
|
Marshal.ThrowExceptionForHR(hr);
|
|
if (amqi[0].hr < 0)
|
|
Marshal.ThrowExceptionForHR(amqi[0].hr);
|
|
hr = UnsafeNativeMethods.CoSetProxyBlanket(amqi[0].pItf, RpcAuthent.WinNT, RpcAuthor.None, null, /*RpcLevel.Connect*/ RpcLevel.Default, RpcImpers.Impersonate, ciptr, 0);
|
|
if (hr < 0)
|
|
Marshal.ThrowExceptionForHR(hr);
|
|
return (IRemoteWebConfigurationHostServer)Marshal.GetObjectForIUnknown(amqi[0].pItf);
|
|
} finally {
|
|
if (amqi[0].pItf != IntPtr.Zero) {
|
|
Marshal.Release(amqi[0].pItf);
|
|
amqi[0].pItf = IntPtr.Zero;
|
|
}
|
|
amqi[0].piid = IntPtr.Zero;
|
|
if (captr != IntPtr.Zero) {
|
|
Marshal.DestroyStructure(captr, typeof(COAUTHINFO_X64));
|
|
Marshal.FreeCoTaskMem(captr);
|
|
}
|
|
if (ciptr != IntPtr.Zero) {
|
|
Marshal.DestroyStructure(ciptr, typeof(COAUTHIDENTITY_X64));
|
|
Marshal.FreeCoTaskMem(ciptr);
|
|
}
|
|
if (guidbuf != IntPtr.Zero)
|
|
Marshal.FreeCoTaskMem(guidbuf);
|
|
}
|
|
}
|
|
}
|
|
}
|