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
429 lines
13 KiB
C#
429 lines
13 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
namespace System.ServiceModel.ComIntegration
|
|
{
|
|
using System;
|
|
using System.ServiceModel.Dispatcher;
|
|
using System.ServiceModel.Description;
|
|
using System.Collections.Generic;
|
|
using System.Collections;
|
|
using System.Diagnostics;
|
|
using System.EnterpriseServices;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Configuration;
|
|
using System.Transactions;
|
|
using SR = System.ServiceModel.SR;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.Runtime;
|
|
|
|
// The values of the enum are reflected from the values in the
|
|
// COM+ Admin SDK.
|
|
//
|
|
enum Bitness
|
|
{
|
|
Bitness32 = 0x01,
|
|
Bitness64 = 0x02
|
|
}
|
|
|
|
enum ThreadingModel
|
|
{
|
|
MTA,
|
|
STA
|
|
}
|
|
|
|
enum HostingMode
|
|
{
|
|
ComPlus, // Living in a DllHost.exe
|
|
WebHostOutOfProcess, // From webhost to dllhost.exe
|
|
WebHostInProcess // Inside webhost
|
|
}
|
|
|
|
class ServiceInfo
|
|
{
|
|
ServiceElement service;
|
|
Guid clsid;
|
|
Guid appid;
|
|
HostingMode hostingMode;
|
|
Guid partitionId;
|
|
Bitness bitness;
|
|
ThreadingModel threadingModel;
|
|
TransactionOption transactionOption;
|
|
IsolationLevel isolationLevel;
|
|
bool checkRoles;
|
|
string[] componentRoleMembers;
|
|
bool objectPoolingEnabled;
|
|
int maxPoolSize;
|
|
Type managedType;
|
|
List<ContractInfo> contracts;
|
|
string serviceName;
|
|
Dictionary<Guid, List<Type>> udts;
|
|
|
|
|
|
public string ServiceName
|
|
{
|
|
get
|
|
{
|
|
return serviceName;
|
|
}
|
|
}
|
|
|
|
|
|
// NOTE: Construction of this thing is quite inefficient-- it
|
|
// has several nested loops that could probably be
|
|
// improved. Such optimizations have been left for when
|
|
// it turns out to be a performance problem, for the
|
|
// sake of simplicity.
|
|
//
|
|
public ServiceInfo(Guid clsid,
|
|
ServiceElement service,
|
|
ComCatalogObject application,
|
|
ComCatalogObject classObject,
|
|
HostingMode hostingMode)
|
|
{
|
|
// Simple things...
|
|
//
|
|
this.service = service;
|
|
this.clsid = clsid;
|
|
this.appid = Fx.CreateGuid((string)application.GetValue("ID"));
|
|
this.partitionId = Fx.CreateGuid((string)application.GetValue("AppPartitionID"));
|
|
this.bitness = (Bitness)classObject.GetValue("Bitness");
|
|
this.transactionOption = (TransactionOption)classObject.GetValue("Transaction");
|
|
this.hostingMode = hostingMode;
|
|
this.managedType = TypeCacheManager.ResolveClsidToType(clsid);
|
|
this.serviceName = application.Name + "." + classObject.Name;
|
|
this.udts = new Dictionary<Guid, List<Type>>();
|
|
|
|
// Isolation Level
|
|
COMAdminIsolationLevel adminIsolationLevel;
|
|
adminIsolationLevel = (COMAdminIsolationLevel)classObject.GetValue("TxIsolationLevel");
|
|
switch (adminIsolationLevel)
|
|
{
|
|
case COMAdminIsolationLevel.Any:
|
|
this.isolationLevel = IsolationLevel.Unspecified;
|
|
break;
|
|
case COMAdminIsolationLevel.ReadUncommitted:
|
|
this.isolationLevel = IsolationLevel.ReadUncommitted;
|
|
break;
|
|
case COMAdminIsolationLevel.ReadCommitted:
|
|
this.isolationLevel = IsolationLevel.ReadCommitted;
|
|
break;
|
|
case COMAdminIsolationLevel.RepeatableRead:
|
|
this.isolationLevel = IsolationLevel.RepeatableRead;
|
|
break;
|
|
case COMAdminIsolationLevel.Serializable:
|
|
this.isolationLevel = IsolationLevel.Serializable;
|
|
break;
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ListenerInitFailed(
|
|
SR.GetString(SR.InvalidIsolationLevelValue,
|
|
this.clsid, adminIsolationLevel)));
|
|
}
|
|
|
|
// Threading Model
|
|
//
|
|
COMAdminThreadingModel adminThreadingModel;
|
|
adminThreadingModel = (COMAdminThreadingModel)classObject.GetValue("ThreadingModel");
|
|
switch (adminThreadingModel)
|
|
{
|
|
case COMAdminThreadingModel.Apartment:
|
|
case COMAdminThreadingModel.Main:
|
|
this.threadingModel = ThreadingModel.STA;
|
|
objectPoolingEnabled = false;
|
|
break;
|
|
|
|
default:
|
|
this.threadingModel = ThreadingModel.MTA;
|
|
objectPoolingEnabled = (bool)classObject.GetValue("ObjectPoolingEnabled");
|
|
break;
|
|
}
|
|
|
|
// Object Pool settings
|
|
//
|
|
|
|
if (objectPoolingEnabled)
|
|
{
|
|
maxPoolSize = (int)classObject.GetValue("MaxPoolSize");
|
|
}
|
|
else
|
|
maxPoolSize = 0;
|
|
// Security Settings
|
|
//
|
|
bool appSecurityEnabled;
|
|
appSecurityEnabled = (bool)application.GetValue(
|
|
"ApplicationAccessChecksEnabled");
|
|
if (appSecurityEnabled)
|
|
{
|
|
|
|
bool classSecurityEnabled;
|
|
classSecurityEnabled = (bool)classObject.GetValue(
|
|
"ComponentAccessChecksEnabled");
|
|
if (classSecurityEnabled)
|
|
{
|
|
this.checkRoles = true;
|
|
}
|
|
}
|
|
|
|
// Component Roles
|
|
//
|
|
ComCatalogCollection roles;
|
|
roles = classObject.GetCollection("RolesForComponent");
|
|
this.componentRoleMembers = CatalogUtil.GetRoleMembers(application, roles);
|
|
// Contracts
|
|
// One ContractInfo per unique IID exposed, so we need to
|
|
// filter duplicates.
|
|
//
|
|
this.contracts = new List<ContractInfo>();
|
|
ComCatalogCollection interfaces;
|
|
interfaces = classObject.GetCollection("InterfacesForComponent");
|
|
foreach (ServiceEndpointElement endpoint in service.Endpoints)
|
|
{
|
|
ContractInfo contract = null;
|
|
if (endpoint.Contract == ServiceMetadataBehavior.MexContractName)
|
|
continue;
|
|
|
|
Guid iid;
|
|
if (DiagnosticUtility.Utility.TryCreateGuid(endpoint.Contract, out iid))
|
|
{
|
|
// (Filter duplicates.)
|
|
bool duplicate = false;
|
|
foreach (ContractInfo otherContract in this.contracts)
|
|
{
|
|
if (iid == otherContract.IID)
|
|
{
|
|
duplicate = true;
|
|
break;
|
|
}
|
|
}
|
|
if (duplicate) continue;
|
|
|
|
foreach (ComCatalogObject interfaceObject in interfaces)
|
|
{
|
|
Guid otherInterfaceID;
|
|
if (DiagnosticUtility.Utility.TryCreateGuid((string)interfaceObject.GetValue("IID"), out otherInterfaceID))
|
|
{
|
|
if (otherInterfaceID == iid)
|
|
{
|
|
contract = new ContractInfo(iid,
|
|
endpoint,
|
|
interfaceObject,
|
|
application);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (contract == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ListenerInitFailed(
|
|
SR.GetString(SR.EndpointNotAnIID,
|
|
clsid.ToString("B").ToUpperInvariant(),
|
|
endpoint.Contract)));
|
|
}
|
|
this.contracts.Add(contract);
|
|
}
|
|
}
|
|
|
|
public Type ServiceType
|
|
{
|
|
get { return this.managedType; }
|
|
}
|
|
|
|
public ServiceElement ServiceElement
|
|
{
|
|
get { return this.service; }
|
|
}
|
|
|
|
public Guid Clsid
|
|
{
|
|
get { return this.clsid; }
|
|
}
|
|
|
|
public Guid AppID
|
|
{
|
|
get { return this.appid; }
|
|
}
|
|
public Guid PartitionId
|
|
{
|
|
get { return this.partitionId; }
|
|
}
|
|
|
|
public Bitness Bitness
|
|
{
|
|
get { return this.bitness; }
|
|
}
|
|
|
|
public bool CheckRoles
|
|
{
|
|
get { return this.checkRoles; }
|
|
}
|
|
|
|
|
|
public ThreadingModel ThreadingModel
|
|
{
|
|
get { return this.threadingModel; }
|
|
}
|
|
|
|
public TransactionOption TransactionOption
|
|
{
|
|
get { return this.transactionOption; }
|
|
}
|
|
|
|
public IsolationLevel IsolationLevel
|
|
{
|
|
get { return this.isolationLevel; }
|
|
}
|
|
|
|
public string[] ComponentRoleMembers
|
|
{
|
|
get { return this.componentRoleMembers; }
|
|
}
|
|
|
|
public List<ContractInfo> Contracts
|
|
{
|
|
get { return this.contracts; }
|
|
}
|
|
|
|
public HostingMode HostingMode
|
|
{
|
|
get { return this.hostingMode; }
|
|
}
|
|
|
|
public bool Pooled
|
|
{
|
|
get { return this.objectPoolingEnabled; }
|
|
}
|
|
|
|
public int MaxPoolSize
|
|
{
|
|
get { return this.maxPoolSize; }
|
|
}
|
|
|
|
internal Guid[] Assemblies
|
|
{
|
|
get
|
|
{
|
|
Guid[] ret = new Guid[this.udts.Keys.Count];
|
|
this.udts.Keys.CopyTo(ret, 0);
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
internal bool HasUdts()
|
|
{
|
|
// use the assembly count since we only add assemblies when we got UDTs
|
|
return (this.udts.Keys.Count > 0);
|
|
}
|
|
|
|
internal Type[] GetTypes(Guid assemblyId)
|
|
{
|
|
List<Type> ret = null;
|
|
udts.TryGetValue(assemblyId, out ret);
|
|
if (null == ret)
|
|
return new Type[0];
|
|
|
|
|
|
return ret.ToArray();
|
|
}
|
|
|
|
internal void AddUdt(Type udt, Guid assemblyId)
|
|
{
|
|
if (!udts.ContainsKey(assemblyId))
|
|
udts[assemblyId] = new List<Type>();
|
|
|
|
if (!udts[assemblyId].Contains(udt))
|
|
udts[assemblyId].Add(udt);
|
|
}
|
|
|
|
}
|
|
|
|
class ContractInfo
|
|
{
|
|
string name;
|
|
Guid iid;
|
|
string[] interfaceRoleMembers;
|
|
List<OperationInfo> operations;
|
|
|
|
public ContractInfo(Guid iid,
|
|
ServiceEndpointElement endpoint,
|
|
ComCatalogObject interfaceObject,
|
|
ComCatalogObject application)
|
|
{
|
|
this.name = endpoint.Contract;
|
|
this.iid = iid;
|
|
|
|
// Interface Roles
|
|
//
|
|
ComCatalogCollection roles;
|
|
roles = interfaceObject.GetCollection("RolesForInterface");
|
|
this.interfaceRoleMembers = CatalogUtil.GetRoleMembers(application,
|
|
roles);
|
|
|
|
// Operations
|
|
//
|
|
this.operations = new List<OperationInfo>();
|
|
|
|
ComCatalogCollection methods;
|
|
methods = interfaceObject.GetCollection("MethodsForInterface");
|
|
foreach (ComCatalogObject method in methods)
|
|
{
|
|
this.operations.Add(new OperationInfo(method,
|
|
application));
|
|
}
|
|
}
|
|
|
|
public string Name
|
|
{
|
|
get { return this.name; }
|
|
}
|
|
|
|
public Guid IID
|
|
{
|
|
get { return this.iid; }
|
|
}
|
|
|
|
public string[] InterfaceRoleMembers
|
|
{
|
|
get { return this.interfaceRoleMembers; }
|
|
}
|
|
|
|
public List<OperationInfo> Operations
|
|
{
|
|
get { return this.operations; }
|
|
}
|
|
}
|
|
|
|
class OperationInfo
|
|
{
|
|
string name;
|
|
string[] methodRoleMembers;
|
|
|
|
public OperationInfo(ComCatalogObject methodObject,
|
|
ComCatalogObject application)
|
|
{
|
|
this.name = (string)methodObject.GetValue("Name");
|
|
|
|
// Method Roles
|
|
//
|
|
ComCatalogCollection roles;
|
|
roles = methodObject.GetCollection("RolesForMethod");
|
|
this.methodRoleMembers = CatalogUtil.GetRoleMembers(application,
|
|
roles);
|
|
}
|
|
|
|
public string Name
|
|
{
|
|
get { return this.name; }
|
|
}
|
|
|
|
public string[] MethodRoleMembers
|
|
{
|
|
get { return this.methodRoleMembers; }
|
|
}
|
|
}
|
|
}
|