1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
//
// ApplicationActivator class is the base class that handles activation of Add-ins.
// There is a single designated instance of the ApplicationActivator in each Appdomain
// to which all Add-in activation calls are routed to. The AppdomainManager for the
// current Appdomain could provide its own custom ApplicationActivator, or an instance
// of the default ApplicationActivator is created.
//
namespace System.Runtime.Hosting {
using System.Deployment.Internal.Isolation;
using System.Deployment.Internal.Isolation.Manifest;
using System.IO;
using System.Reflection;
using System.Runtime.Remoting;
using System.Security;
using System.Security.Permissions;
using System.Security.Policy;
using System.Threading;
using System.Runtime.Versioning;
using System.Diagnostics.Contracts;
internal sealed class ManifestRunner {
private AppDomain m_domain;
private string m_path;
private string[] m_args;
private ApartmentState m_apt;
private RuntimeAssembly m_assembly;
private int m_runResult;
//
// We need to assert unmanaged code security permission to be
// able to call ActivationContext.ApplicationDirectory.
//
[System.Security.SecurityCritical] // auto-generated
[SecurityPermissionAttribute(SecurityAction.Assert, Unrestricted=true)]
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
internal ManifestRunner (AppDomain domain, ActivationContext activationContext) {
m_domain = domain;
string file, parameters;
CmsUtils.GetEntryPoint(activationContext, out file, out parameters);
if (String.IsNullOrEmpty(file))
throw new ArgumentException(Environment.GetResourceString("Argument_NoMain"));
if (String.IsNullOrEmpty(parameters))
m_args = new string[0];
else
m_args = parameters.Split(' ');
m_apt = ApartmentState.Unknown;
// get the 'merged' application directory path.
string directoryName = activationContext.ApplicationDirectory;
m_path = Path.Combine(directoryName, file);
}
internal RuntimeAssembly EntryAssembly {
[System.Security.SecurityCritical] // auto-generated
[FileIOPermissionAttribute(SecurityAction.Assert, Unrestricted=true)]
[SecurityPermissionAttribute(SecurityAction.Assert, Unrestricted=true)]
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
get {
if (m_assembly == null)
m_assembly = (RuntimeAssembly)Assembly.LoadFrom(m_path);
return m_assembly;
}
}
[System.Security.SecurityCritical] // auto-generated
private void NewThreadRunner () {
m_runResult = Run(false);
}
[System.Security.SecurityCritical] // auto-generated
private int RunInNewThread () {
Thread th = new Thread(new ThreadStart(NewThreadRunner));
th.SetApartmentState(m_apt);
th.Start();
th.Join();
return m_runResult;
}
[System.Security.SecurityCritical] // auto-generated
private int Run (bool checkAptModel) {
if (checkAptModel && m_apt != ApartmentState.Unknown) {
if (Thread.CurrentThread.GetApartmentState() != ApartmentState.Unknown && Thread.CurrentThread.GetApartmentState() != m_apt)
return RunInNewThread();
Thread.CurrentThread.SetApartmentState(m_apt);
}
return m_domain.nExecuteAssembly(EntryAssembly, m_args);
}
[System.Security.SecurityCritical] // auto-generated
internal int ExecuteAsAssembly () {
Object[] attrs = EntryAssembly.EntryPoint.GetCustomAttributes(typeof(STAThreadAttribute), false);
if (attrs.Length > 0)
m_apt = ApartmentState.STA;
attrs = EntryAssembly.EntryPoint.GetCustomAttributes(typeof(MTAThreadAttribute), false);
if (attrs.Length > 0)
if (m_apt == ApartmentState.Unknown)
m_apt = ApartmentState.MTA;
else
m_apt = ApartmentState.Unknown;
return Run(true);
}
}
[System.Runtime.InteropServices.ComVisible(true)]
public class ApplicationActivator {
public ApplicationActivator () {}
public virtual ObjectHandle CreateInstance (ActivationContext activationContext) {
return CreateInstance(activationContext, null);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
public virtual ObjectHandle CreateInstance (ActivationContext activationContext, string[] activationCustomData) {
if (activationContext == null)
throw new ArgumentNullException("activationContext");
Contract.EndContractBlock();
if (CmsUtils.CompareIdentities(AppDomain.CurrentDomain.ActivationContext, activationContext)) {
ManifestRunner runner = new ManifestRunner(AppDomain.CurrentDomain, activationContext);
return new ObjectHandle(runner.ExecuteAsAssembly());
}
AppDomainSetup adSetup = new AppDomainSetup(new ActivationArguments(activationContext, activationCustomData));
// inherit the calling domain's AppDomain Manager
AppDomainSetup currentDomainSetup = AppDomain.CurrentDomain.SetupInformation;
adSetup.AppDomainManagerType = currentDomainSetup.AppDomainManagerType;
adSetup.AppDomainManagerAssembly = currentDomainSetup.AppDomainManagerAssembly;
// we inherit the evidence from the calling domain
return CreateInstanceHelper(adSetup);
}
[System.Security.SecuritySafeCritical] // auto-generated
protected static ObjectHandle CreateInstanceHelper (AppDomainSetup adSetup) {
if (adSetup.ActivationArguments == null)
throw new ArgumentException(Environment.GetResourceString("Arg_MissingActivationArguments"));
Contract.EndContractBlock();
adSetup.ActivationArguments.ActivateInstance = true;
// inherit the caller's domain evidence for the activation.
Evidence activatorEvidence = AppDomain.CurrentDomain.Evidence;
// add the application identity as an evidence.
Evidence appEvidence = CmsUtils.MergeApplicationEvidence(null,
adSetup.ActivationArguments.ApplicationIdentity,
adSetup.ActivationArguments.ActivationContext,
adSetup.ActivationArguments.ActivationData);
HostSecurityManager securityManager = AppDomain.CurrentDomain.HostSecurityManager;
ApplicationTrust appTrust = securityManager.DetermineApplicationTrust(appEvidence, activatorEvidence, new TrustManagerContext());
if (appTrust == null || !appTrust.IsApplicationTrustedToRun)
throw new PolicyException(Environment.GetResourceString("Policy_NoExecutionPermission"),
System.__HResults.CORSEC_E_NO_EXEC_PERM,
null);
ObjRef or = AppDomain.nCreateInstance(adSetup.ActivationArguments.ApplicationIdentity.FullName,
adSetup,
appEvidence,
appEvidence == null ? AppDomain.CurrentDomain.InternalEvidence : null,
AppDomain.CurrentDomain.GetSecurityDescriptor());
if (or == null)
return null;
return RemotingServices.Unmarshal(or) as ObjectHandle;
}
}
}
|
