internal DeferrableContent(Stream stream, Baml2006SchemaContext schemaContext,
IXamlObjectWriterFactory objectWriterFactory, IServiceProvider serviceProvider,
object rootObject)
{
ObjectWriterParentSettings = objectWriterFactory.GetParentSettings();
if (ObjectWriterParentSettings.AccessLevel != null)
{
XamlLoadPermission loadPermission =
new XamlLoadPermission(ObjectWriterParentSettings.AccessLevel);
loadPermission.Demand();
this.LoadPermission = loadPermission;
}
bool assemblyTargetsFramework2 = false;
// The local assembly can be null if it is not specified in the XamlReaderSettings.
if (schemaContext.LocalAssembly != null)
{
assemblyTargetsFramework2 = schemaContext.LocalAssembly.ImageRuntimeVersion.StartsWith("v2", StringComparison.Ordinal);
}
// There is an incompatibility between the framework versions 3 and 4 regarding MarkupExtension resources.
// In version 3, MarkupExtension resources did not provide values when looked up.
// In version 4, they do.
if (assemblyTargetsFramework2)
{
ObjectWriterParentSettings.SkipProvideValueOnRoot = true;
}
this.Stream = stream;
this.SchemaContext = schemaContext;
this.ObjectWriterFactory = objectWriterFactory;
this.ServiceProvider = serviceProvider;
this.RootObject = rootObject;
}
internal DeferrableContent(Stream stream, Baml2006SchemaContext schemaContext, IXamlObjectWriterFactory objectWriterFactory, IServiceProvider serviceProvider, object rootObject)
{
this.ObjectWriterParentSettings = objectWriterFactory.GetParentSettings();
if (this.ObjectWriterParentSettings.AccessLevel != null)
{
XamlLoadPermission xamlLoadPermission = new XamlLoadPermission(this.ObjectWriterParentSettings.AccessLevel);
xamlLoadPermission.Demand();
this.LoadPermission = xamlLoadPermission;
}
bool flag = false;
if (schemaContext.LocalAssembly != null)
{
flag = schemaContext.LocalAssembly.ImageRuntimeVersion.StartsWith("v2", StringComparison.Ordinal);
}
if (flag)
{
this.ObjectWriterParentSettings.SkipProvideValueOnRoot = true;
}
this.Stream = stream;
this.SchemaContext = schemaContext;
this.ObjectWriterFactory = objectWriterFactory;
this.ServiceProvider = serviceProvider;
this.RootObject = rootObject;
}
private void VerifyInvariants(XamlLoadPermission original, bool isUnrestricted = false)
{
Assert.AreEqual(original, original);
Assert.AreEqual(isUnrestricted, original.IsUnrestricted());
XamlLoadPermission copy = (XamlLoadPermission)original.Copy();
Assert.AreEqual(original, copy);
Assert.AreEqual(original.IsUnrestricted(), copy.IsUnrestricted());
Assert.IsTrue(original.IsSubsetOf(copy));
Assert.IsTrue(copy.IsSubsetOf(original));
XamlLoadPermission xmlCopy = new XamlLoadPermission(PermissionState.None);
xmlCopy.FromXml(original.ToXml());
Assert.AreEqual(original, xmlCopy);
var intersect = (XamlLoadPermission)original.Intersect(copy);
Assert.AreEqual(original, intersect);
var union = (XamlLoadPermission)original.Union(copy);
Assert.AreEqual(original, union);
intersect = (XamlLoadPermission)original.Intersect(s_EmptyPerm);
Assert.AreEqual(s_EmptyPerm, intersect);
union = (XamlLoadPermission)original.Union(s_EmptyPerm);
Assert.AreEqual(original, union);
intersect = (XamlLoadPermission)original.Intersect(s_UnrestrictedPerm);
Assert.AreEqual(original, intersect);
union = (XamlLoadPermission)original.Union(s_UnrestrictedPerm);
Assert.AreEqual(s_UnrestrictedPerm, union);
}
internal DynamicMethodRuntime(XamlRuntimeSettings settings, XamlSchemaContext schemaContext, XamlAccessLevel accessLevel) : base(settings, true)
{
this._schemaContext = schemaContext;
this._xamlLoadPermission = new XamlLoadPermission(accessLevel);
this._localAssembly = Assembly.Load(accessLevel.AssemblyAccessToAssemblyName);
if (accessLevel.PrivateAccessToTypeName != null)
{
this._localType = this._localAssembly.GetType(accessLevel.PrivateAccessToTypeName, true);
}
}
public void SingleAssembly()
{
XamlAccessLevel assemblyAccess = XamlAccessLevel.AssemblyAccessTo(typeof(LoadPermissionTests).Assembly);
XamlLoadPermission assemblyPerm = new XamlLoadPermission(assemblyAccess);
VerifyInvariants(assemblyPerm);
XamlLoadPermission testPerm, intersect, union;
// Identical permission
XamlAccessLevel sameAssemblyAccess = XamlAccessLevel.AssemblyAccessTo(typeof(LoadPermissionTests).Assembly);
testPerm = new XamlLoadPermission(sameAssemblyAccess);
VerifyInvariants(testPerm);
Assert.AreEqual(assemblyPerm, testPerm);
Assert.IsTrue(testPerm.IsSubsetOf(assemblyPerm));
Assert.IsTrue(assemblyPerm.IsSubsetOf(testPerm));
intersect = (XamlLoadPermission)testPerm.Intersect(assemblyPerm);
Assert.AreEqual(assemblyPerm, intersect);
union = (XamlLoadPermission)testPerm.Union(assemblyPerm);
Assert.AreEqual(assemblyPerm, union);
Assert.IsTrue(testPerm.Includes(sameAssemblyAccess));
// Type permission to same assembly
XamlAccessLevel typeAccess = XamlAccessLevel.PrivateAccessTo(typeof(LoadPermissionTests));
testPerm = new XamlLoadPermission(typeAccess);
VerifyInvariants(testPerm);
Assert.AreNotEqual(assemblyPerm, testPerm);
Assert.IsFalse(testPerm.IsSubsetOf(assemblyPerm));
Assert.IsTrue(assemblyPerm.IsSubsetOf(testPerm));
intersect = (XamlLoadPermission)testPerm.Intersect(assemblyPerm);
Assert.AreEqual(assemblyPerm, intersect);
union = (XamlLoadPermission)testPerm.Union(assemblyPerm);
Assert.AreEqual(testPerm, union);
Assert.IsTrue(testPerm.Includes(sameAssemblyAccess));
Assert.IsTrue(testPerm.Includes(typeAccess));
// Assembly permission on different assembly
XamlAccessLevel diffAssemblyAccess = XamlAccessLevel.AssemblyAccessTo(typeof(string).Assembly);
testPerm = new XamlLoadPermission(diffAssemblyAccess);
VerifyInvariants(testPerm);
Assert.AreNotEqual(assemblyPerm, testPerm);
Assert.IsFalse(testPerm.IsSubsetOf(assemblyPerm));
Assert.IsFalse(assemblyPerm.IsSubsetOf(testPerm));
intersect = (XamlLoadPermission)testPerm.Intersect(assemblyPerm);
Assert.AreEqual(s_EmptyPerm, intersect);
union = (XamlLoadPermission)testPerm.Union(assemblyPerm);
Assert.IsTrue(testPerm.IsSubsetOf(union));
Assert.IsTrue(assemblyPerm.IsSubsetOf(union));
Assert.IsFalse(testPerm.Includes(sameAssemblyAccess));
Assert.IsFalse(testPerm.Includes(typeAccess));
}
public void Empty()
{
VerifyInvariants(s_EmptyPerm);
XamlLoadPermission emptyPerm = new XamlLoadPermission(new XamlAccessLevel[0]);
VerifyInvariants(emptyPerm);
Assert.AreEqual(s_EmptyPerm, emptyPerm);
XamlAccessLevel assemblyAccess = XamlAccessLevel.AssemblyAccessTo(typeof(LoadPermissionTests).Assembly);
Assert.IsFalse(s_EmptyPerm.Includes(assemblyAccess));
}
internal DynamicMethodRuntime(XamlRuntimeSettings settings, XamlSchemaContext schemaContext,
XamlAccessLevel accessLevel)
: base(settings, true /*isWriter*/)
{
Debug.Assert(schemaContext != null);
Debug.Assert(accessLevel != null);
_schemaContext = schemaContext;
_xamlLoadPermission = new XamlLoadPermission(accessLevel);
_localAssembly = Assembly.Load(accessLevel.AssemblyAccessToAssemblyName);
if (accessLevel.PrivateAccessToTypeName != null)
{
_localType = _localAssembly.GetType(accessLevel.PrivateAccessToTypeName, true /*throwOnError*/);
}
}
static void InitializeComponentFromXamlResource(Type componentType, string resource, object componentInstance, XamlSchemaContext schemaContext)
{
Stream initializeXaml = componentType.Assembly.GetManifestResourceStream(resource);
XmlReader xmlReader = null;
XamlReader reader = null;
XamlObjectWriter objectWriter = null;
try
{
xmlReader = XmlReader.Create(initializeXaml, new XmlReaderSettings {
XmlResolver = null
});
XamlXmlReaderSettings readerSettings = new XamlXmlReaderSettings();
readerSettings.LocalAssembly = componentType.Assembly;
readerSettings.AllowProtectedMembersOnRoot = true;
reader = new XamlXmlReader(xmlReader, schemaContext, readerSettings);
XamlObjectWriterSettings writerSettings = new XamlObjectWriterSettings();
writerSettings.RootObjectInstance = componentInstance;
writerSettings.AccessLevel = XamlAccessLevel.PrivateAccessTo(componentType);
objectWriter = new XamlObjectWriter(schemaContext, writerSettings);
// We need the XamlLoadPermission for the assembly we are dealing with.
XamlLoadPermission perm = new XamlLoadPermission(XamlAccessLevel.PrivateAccessTo(componentType));
perm.Assert();
try
{
XamlServices.Transform(reader, objectWriter);
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
finally
{
if ((xmlReader != null))
{
((IDisposable)(xmlReader)).Dispose();
}
if ((reader != null))
{
((IDisposable)(reader)).Dispose();
}
if ((objectWriter != null))
{
((IDisposable)(objectWriter)).Dispose();
}
}
}
public static void XamlLoadPermissionCallMethods()
{
XamlAccessLevel accessLevel = XamlAccessLevel.AssemblyAccessTo(Assembly.GetExecutingAssembly().GetName());
XamlLoadPermission xp = new XamlLoadPermission(accessLevel);
XamlLoadPermission xp2 = new XamlLoadPermission(PermissionState.Unrestricted);
XamlLoadPermission xp3 = new XamlLoadPermission(Array.Empty <XamlAccessLevel>());
bool testbool = xp.IsUnrestricted();
IPermission ip = xp.Copy();
IPermission ip2 = xp.Intersect(ip);
IPermission ip3 = xp.Union(ip);
testbool = xp.IsSubsetOf(ip);
testbool = xp.Equals(new object());
testbool = xp.Includes(accessLevel);
int hash = xp.GetHashCode();
SecurityElement se = new SecurityElement("");
xp.FromXml(se);
se = xp.ToXml();
}
//[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647
internal static object LoadBaml(
Stream stream,
ParserContext parserContext,
object parent,
bool closeStream)
{
object root = null;
#if DEBUG_CLR_MEM
bool clrTracingEnabled = false;
// Use local pass variable to correctly log nested parses.
int pass = 0;
if (CLRProfilerControl.ProcessIsUnderCLRProfiler &&
(CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance))
{
clrTracingEnabled = true;
pass = ++_CLRBamlPass;
CLRProfilerControl.CLRLogWriteLine("Begin_BamlParse_{0}", pass);
}
#endif // DEBUG_CLR_MEM
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordXamlBaml | EventTrace.Keyword.KeywordPerf, EventTrace.Event.WClientParseBamlBegin, parserContext.BaseUri);
if (TraceMarkup.IsEnabled)
{
TraceMarkup.Trace(TraceEventType.Start, TraceMarkup.Load);
}
try
{
//
// If the stream contains info about the Assembly that created it,
// set StreamCreatedAssembly from the stream instance.
//
IStreamInfo streamInfo = stream as IStreamInfo;
if (streamInfo != null)
{
parserContext.StreamCreatedAssembly = streamInfo.Assembly;
}
Baml2006ReaderSettings readerSettings = XamlReader.CreateBamlReaderSettings();
readerSettings.BaseUri = parserContext.BaseUri;
readerSettings.LocalAssembly = streamInfo.Assembly;
// We do not set OwnsStream = true so the Baml2006Reader will not close the stream.
// Calling code is responsible for disposing the stream
if (readerSettings.BaseUri == null || String.IsNullOrEmpty(readerSettings.BaseUri.ToString()))
{
readerSettings.BaseUri = BaseUriHelper.PackAppBaseUri;
}
var reader = new Baml2006ReaderInternal(stream, new Baml2006SchemaContext(readerSettings.LocalAssembly), readerSettings, parent);
// We don't actually use the GeneratedInternalTypeHelper any more.
// But for v3 compat, don't allow loading of internals in PT unless there is one.
Type internalTypeHelper = null;
if (streamInfo.Assembly != null)
{
try
{
internalTypeHelper = XamlTypeMapper.GetInternalTypeHelperTypeFromAssembly(parserContext);
}
// This can perform attribute reflection which will fail if the assembly has unresolvable
// attributes. If that happens, just assume there is no helper.
catch (Exception e)
{
if (MS.Internal.CriticalExceptions.IsCriticalException(e))
{
throw;
}
}
}
if (internalTypeHelper != null)
{
XamlAccessLevel accessLevel = XamlAccessLevel.AssemblyAccessTo(streamInfo.Assembly);
XamlLoadPermission loadPermission = new XamlLoadPermission(accessLevel);
loadPermission.Assert();
try
{
root = WpfXamlLoader.LoadBaml(reader, parserContext.SkipJournaledProperties, parent, accessLevel, parserContext.BaseUri);
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
else
{
root = WpfXamlLoader.LoadBaml(reader, parserContext.SkipJournaledProperties, parent, null, parserContext.BaseUri);
}
DependencyObject dObject = root as DependencyObject;
if (dObject != null)
{
dObject.SetValue(BaseUriHelper.BaseUriProperty, readerSettings.BaseUri);
}
Application app = root as Application;
if (app != null)
{
app.ApplicationMarkupBaseUri = GetBaseUri(readerSettings.BaseUri);
}
Debug.Assert(parent == null || root == parent);
}
finally
{
if (TraceMarkup.IsEnabled)
{
TraceMarkup.Trace(TraceEventType.Stop, TraceMarkup.Load, root);
}
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordXamlBaml | EventTrace.Keyword.KeywordPerf, EventTrace.Event.WClientParseBamlEnd, parserContext.BaseUri);
if (closeStream && stream != null)
{
stream.Close();
}
#if DEBUG_CLR_MEM
if (clrTracingEnabled && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance))
{
CLRProfilerControl.CLRLogWriteLine("End_BamlParse_{0}", pass);
}
#endif // DEBUG_CLR_MEM
}
return(root);
}
