Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Core / CSharp / MS / Internal / FontCache / FontSourceCollection.cs / 1305600 / FontSourceCollection.cs
//----------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// Description: The FontSourceCollection class represents a collection of font files.
//
// History:
// 08/25/2005 : mleonov - Created it
//
//---------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Packaging;
using System.Net;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Windows;
using System.Windows.Media;
using System.Windows.Threading;
using Microsoft.Win32;
using MS.Win32;
using MS.Utility;
using MS.Internal;
using MS.Internal.IO.Packaging;
using MS.Internal.PresentationCore;
using MS.Internal.Text.TextInterface;
namespace MS.Internal.FontCache
{
internal class FontSourceCollectionFactory : IFontSourceCollectionFactory
{
public FontSourceCollectionFactory() { }
///
/// Critical - Calls FontSourceCollection security critical ctor
/// Safe - The uriString is a user input and should not expose security critical info
/// since the user provides this info. Also we never call the ctor with
/// isWindowsFonts = true. Thus it is safe to construct a FontSourceCollection
/// from a user string because the user string is treated as untrusted.
///
[SecurityCritical, SecurityTreatAsSafe]
public IFontSourceCollection Create(string uriString)
{
return new FontSourceCollection(new Uri(uriString), false);
}
}
///
/// FontSourceCollection class represents a collection of font files.
///
internal class FontSourceCollection : IFontSourceCollection
{
///
/// Critical - Calls into security critical Initialize() method.
///
[SecurityCritical]
public FontSourceCollection(Uri folderUri, bool isWindowsFonts)
{
Initialize(folderUri, isWindowsFonts, false);
}
///
/// Critical - Calls into security critical Initialize() method.
///
[SecurityCritical]
public FontSourceCollection(Uri folderUri, bool isWindowsFonts, bool tryGetCompositeFontsOnly)
{
Initialize(folderUri, isWindowsFonts, tryGetCompositeFontsOnly);
}
///
/// Critical - The folderUri parameter is critical as it may contain privileged information
/// about the file system (i.e., location of Windows Fonts); it is assigned to
/// the _uri field which is declared critical.
///
/// The isWindowsFonts parameter is critical for set as it is used to make a
/// security decision (i.e., whether to assert read access); it is assigned to
/// the _isWindowsFonts field which is declared critical.
///
[SecurityCritical]
private void Initialize(Uri folderUri, bool isWindowsFonts, bool tryGetCompositeFontsOnly)
{
_uri = folderUri;
_isWindowsFonts = isWindowsFonts;
_tryGetCompositeFontsOnly = tryGetCompositeFontsOnly;
bool isComposite = false;
// Check whether the given uri is a font file. In some cases we will construct a DWrite Font Collection by passing
// a file path and not a directory path. In this case we need to construct a FontCollection that only holds this
// file.
bool isSingleSupportedFile = Util.IsSupportedFontExtension(Util.GetUriExtension(_uri), out isComposite);
if (isSingleSupportedFile || !Util.IsEnumerableFontUriScheme(_uri))
{
_fontSources = new List(1);
_fontSources.Add(new FontSource(_uri, false, isComposite));
}
else
{
InitializeDirectoryProperties();
}
}
///
/// Critical: accesses critical _uri and WindowsFontsUriObject
/// TreatAsSafe: only does comparisons to determine if _uri is the system dir
///
[SecurityCritical, SecurityTreatAsSafe]
private void InitializeDirectoryProperties()
{
_isFileSystemFolder = false;
if (_uri.IsFile)
{
if (_isWindowsFonts)
{
if (object.ReferenceEquals(_uri, Util.WindowsFontsUriObject))
{
// We know the local path and that it's a folder
_isFileSystemFolder = true;
}
else
{
// It's a file within the Windows Fonts folder
_isFileSystemFolder = false;
}
}
else
{
// Get the local path
string localPath = _uri.LocalPath;
// Decide if it's a file or folder based on syntax, not contents of file system
_isFileSystemFolder = localPath[localPath.Length - 1] == Path.DirectorySeparatorChar;
}
}
}
///
/// Critical - as this allows you list files in windows font directory
/// and returns the file list.
/// Safe - This only does an elevation for WindowsFont directory which is safe,
/// and relevant data is already protected via FontSource methods.
///
///
[SecurityCritical, SecurityTreatAsSafe]
private void SetFontSources()
{
if (_fontSources != null)
return;
lock (this)
{
List fontSources;
if (_uri.IsFile)
{
ICollection files;
bool isOnlyCompositeFontFiles = false;
if (_isFileSystemFolder)
{
if (_isWindowsFonts)
{
PermissionSet permissionSet = new PermissionSet(null);
// Read and path discovery permission for the %windir%\font path.
permissionSet.AddPermission(new FileIOPermission(
FileIOPermissionAccess.Read | FileIOPermissionAccess.PathDiscovery,
Util.WindowsFontsUriObject.LocalPath));
// Registry read permissions for the Fonts system registry entry.
permissionSet.AddPermission(new RegistryPermission(
RegistryPermissionAccess.Read,
InstalledWindowsFontsRegistryKeyFullPath));
permissionSet.Assert(); // BlessedAssert
try
{
if (_tryGetCompositeFontsOnly)
{
files = Directory.GetFiles(_uri.LocalPath, "*" + Util.CompositeFontExtension);
isOnlyCompositeFontFiles = true;
}
else
{
// fontPaths accumulates font file paths obtained from the registry and the file system
// This collection is a set, i.e. only keys matter, not values.
Dictionary fontPaths = new Dictionary(512, StringComparer.OrdinalIgnoreCase);
using (RegistryKey fontsKey = Registry.LocalMachine.OpenSubKey(InstalledWindowsFontsRegistryKey))
{
// The registry key should be present on a valid Windows installation.
Invariant.Assert(fontsKey != null);
foreach (string fontValue in fontsKey.GetValueNames())
{
string fileName = fontsKey.GetValue(fontValue) as string;
if (fileName != null)
{
// See if the path doesn't contain any directory information.
// Shell uses the same method to determine whether to prepend the path with %windir%\fonts.
if (Path.GetFileName(fileName) == fileName)
fileName = Path.Combine(Util.WindowsFontsLocalPath, fileName);
fontPaths[fileName] = null;
}
}
}
foreach (string file in Directory.GetFiles(_uri.LocalPath))
{
fontPaths[file] = null;
}
files = fontPaths.Keys;
}
}
finally
{
if (_isWindowsFonts)
CodeAccessPermission.RevertAssert();
}
}
else
{
if (_tryGetCompositeFontsOnly)
{
files = Directory.GetFiles(_uri.LocalPath, "*" + Util.CompositeFontExtension);
isOnlyCompositeFontFiles = true;
}
else
{
files = Directory.GetFiles(_uri.LocalPath);
}
}
}
else
{
files = new string[1] {_uri.LocalPath};
}
fontSources = new List(files.Count);
if (isOnlyCompositeFontFiles)
{
foreach (string file in files)
{
fontSources.Add(new FontSource(new Uri(file, UriKind.Absolute), _isWindowsFonts, true));
}
}
else
{
bool isComposite;
foreach (string file in files)
{
if (Util.IsSupportedFontExtension(Path.GetExtension(file), out isComposite))
fontSources.Add(new FontSource(new Uri(file, UriKind.Absolute), _isWindowsFonts, isComposite));
}
}
}
else
{
List resourceEntries = FontResourceCache.LookupFolder(_uri);
if (resourceEntries == null)
fontSources = new List(0);
else
{
bool isComposite = false;
// Enumerate application resources, content files and container structure.
fontSources = new List(resourceEntries.Count);
foreach (string resourceName in resourceEntries)
{
// If resourceName is an empty string, this means that the _uri is a full file name;
// otherwise resourceName is a file name within a folder.
if (String.IsNullOrEmpty(resourceName))
{
isComposite = Util.IsCompositeFont(Path.GetExtension(_uri.AbsoluteUri));
fontSources.Add(new FontSource(_uri, _isWindowsFonts, isComposite));
}
else
{
isComposite = Util.IsCompositeFont(Path.GetExtension(resourceName));
fontSources.Add(new FontSource(new Uri(_uri, resourceName), _isWindowsFonts, isComposite));
}
}
}
}
_fontSources = fontSources;
}
}
#region IEnumerable Members
IEnumerator System.Collections.Generic.IEnumerable.GetEnumerator()
{
SetFontSources();
return (IEnumerator)_fontSources.GetEnumerator();
}
#endregion
#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
SetFontSources();
return _fontSources.GetEnumerator();
}
#endregion
///
/// Critical - fontUri can contain information about local file system.
///
[SecurityCritical]
private Uri _uri;
///
/// Critical - this value is used to make security decisions (i.e., whether to do an Assert)
/// so it can only be set by critical code.
///
[SecurityCritical]
private bool _isWindowsFonts;
// _isFileSystemFolder flag makes sense only when _uri.IsFile is set to true.
private bool _isFileSystemFolder;
private volatile IList _fontSources;
// Flag to indicate that only composite fonts in the provided URI location should be retrieved.
private bool _tryGetCompositeFontsOnly;
private const string InstalledWindowsFontsRegistryKey = @"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts";
private const string InstalledWindowsFontsRegistryKeyFullPath = @"HKEY_LOCAL_MACHINE\" + InstalledWindowsFontsRegistryKey;
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// Description: The FontSourceCollection class represents a collection of font files.
//
// History:
// 08/25/2005 : mleonov - Created it
//
//---------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Packaging;
using System.Net;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Windows;
using System.Windows.Media;
using System.Windows.Threading;
using Microsoft.Win32;
using MS.Win32;
using MS.Utility;
using MS.Internal;
using MS.Internal.IO.Packaging;
using MS.Internal.PresentationCore;
using MS.Internal.Text.TextInterface;
namespace MS.Internal.FontCache
{
internal class FontSourceCollectionFactory : IFontSourceCollectionFactory
{
public FontSourceCollectionFactory() { }
///
/// Critical - Calls FontSourceCollection security critical ctor
/// Safe - The uriString is a user input and should not expose security critical info
/// since the user provides this info. Also we never call the ctor with
/// isWindowsFonts = true. Thus it is safe to construct a FontSourceCollection
/// from a user string because the user string is treated as untrusted.
///
[SecurityCritical, SecurityTreatAsSafe]
public IFontSourceCollection Create(string uriString)
{
return new FontSourceCollection(new Uri(uriString), false);
}
}
///
/// FontSourceCollection class represents a collection of font files.
///
internal class FontSourceCollection : IFontSourceCollection
{
///
/// Critical - Calls into security critical Initialize() method.
///
[SecurityCritical]
public FontSourceCollection(Uri folderUri, bool isWindowsFonts)
{
Initialize(folderUri, isWindowsFonts, false);
}
///
/// Critical - Calls into security critical Initialize() method.
///
[SecurityCritical]
public FontSourceCollection(Uri folderUri, bool isWindowsFonts, bool tryGetCompositeFontsOnly)
{
Initialize(folderUri, isWindowsFonts, tryGetCompositeFontsOnly);
}
///
/// Critical - The folderUri parameter is critical as it may contain privileged information
/// about the file system (i.e., location of Windows Fonts); it is assigned to
/// the _uri field which is declared critical.
///
/// The isWindowsFonts parameter is critical for set as it is used to make a
/// security decision (i.e., whether to assert read access); it is assigned to
/// the _isWindowsFonts field which is declared critical.
///
[SecurityCritical]
private void Initialize(Uri folderUri, bool isWindowsFonts, bool tryGetCompositeFontsOnly)
{
_uri = folderUri;
_isWindowsFonts = isWindowsFonts;
_tryGetCompositeFontsOnly = tryGetCompositeFontsOnly;
bool isComposite = false;
// Check whether the given uri is a font file. In some cases we will construct a DWrite Font Collection by passing
// a file path and not a directory path. In this case we need to construct a FontCollection that only holds this
// file.
bool isSingleSupportedFile = Util.IsSupportedFontExtension(Util.GetUriExtension(_uri), out isComposite);
if (isSingleSupportedFile || !Util.IsEnumerableFontUriScheme(_uri))
{
_fontSources = new List(1);
_fontSources.Add(new FontSource(_uri, false, isComposite));
}
else
{
InitializeDirectoryProperties();
}
}
///
/// Critical: accesses critical _uri and WindowsFontsUriObject
/// TreatAsSafe: only does comparisons to determine if _uri is the system dir
///
[SecurityCritical, SecurityTreatAsSafe]
private void InitializeDirectoryProperties()
{
_isFileSystemFolder = false;
if (_uri.IsFile)
{
if (_isWindowsFonts)
{
if (object.ReferenceEquals(_uri, Util.WindowsFontsUriObject))
{
// We know the local path and that it's a folder
_isFileSystemFolder = true;
}
else
{
// It's a file within the Windows Fonts folder
_isFileSystemFolder = false;
}
}
else
{
// Get the local path
string localPath = _uri.LocalPath;
// Decide if it's a file or folder based on syntax, not contents of file system
_isFileSystemFolder = localPath[localPath.Length - 1] == Path.DirectorySeparatorChar;
}
}
}
///
/// Critical - as this allows you list files in windows font directory
/// and returns the file list.
/// Safe - This only does an elevation for WindowsFont directory which is safe,
/// and relevant data is already protected via FontSource methods.
///
///
[SecurityCritical, SecurityTreatAsSafe]
private void SetFontSources()
{
if (_fontSources != null)
return;
lock (this)
{
List fontSources;
if (_uri.IsFile)
{
ICollection files;
bool isOnlyCompositeFontFiles = false;
if (_isFileSystemFolder)
{
if (_isWindowsFonts)
{
PermissionSet permissionSet = new PermissionSet(null);
// Read and path discovery permission for the %windir%\font path.
permissionSet.AddPermission(new FileIOPermission(
FileIOPermissionAccess.Read | FileIOPermissionAccess.PathDiscovery,
Util.WindowsFontsUriObject.LocalPath));
// Registry read permissions for the Fonts system registry entry.
permissionSet.AddPermission(new RegistryPermission(
RegistryPermissionAccess.Read,
InstalledWindowsFontsRegistryKeyFullPath));
permissionSet.Assert(); // BlessedAssert
try
{
if (_tryGetCompositeFontsOnly)
{
files = Directory.GetFiles(_uri.LocalPath, "*" + Util.CompositeFontExtension);
isOnlyCompositeFontFiles = true;
}
else
{
// fontPaths accumulates font file paths obtained from the registry and the file system
// This collection is a set, i.e. only keys matter, not values.
Dictionary fontPaths = new Dictionary(512, StringComparer.OrdinalIgnoreCase);
using (RegistryKey fontsKey = Registry.LocalMachine.OpenSubKey(InstalledWindowsFontsRegistryKey))
{
// The registry key should be present on a valid Windows installation.
Invariant.Assert(fontsKey != null);
foreach (string fontValue in fontsKey.GetValueNames())
{
string fileName = fontsKey.GetValue(fontValue) as string;
if (fileName != null)
{
// See if the path doesn't contain any directory information.
// Shell uses the same method to determine whether to prepend the path with %windir%\fonts.
if (Path.GetFileName(fileName) == fileName)
fileName = Path.Combine(Util.WindowsFontsLocalPath, fileName);
fontPaths[fileName] = null;
}
}
}
foreach (string file in Directory.GetFiles(_uri.LocalPath))
{
fontPaths[file] = null;
}
files = fontPaths.Keys;
}
}
finally
{
if (_isWindowsFonts)
CodeAccessPermission.RevertAssert();
}
}
else
{
if (_tryGetCompositeFontsOnly)
{
files = Directory.GetFiles(_uri.LocalPath, "*" + Util.CompositeFontExtension);
isOnlyCompositeFontFiles = true;
}
else
{
files = Directory.GetFiles(_uri.LocalPath);
}
}
}
else
{
files = new string[1] {_uri.LocalPath};
}
fontSources = new List(files.Count);
if (isOnlyCompositeFontFiles)
{
foreach (string file in files)
{
fontSources.Add(new FontSource(new Uri(file, UriKind.Absolute), _isWindowsFonts, true));
}
}
else
{
bool isComposite;
foreach (string file in files)
{
if (Util.IsSupportedFontExtension(Path.GetExtension(file), out isComposite))
fontSources.Add(new FontSource(new Uri(file, UriKind.Absolute), _isWindowsFonts, isComposite));
}
}
}
else
{
List resourceEntries = FontResourceCache.LookupFolder(_uri);
if (resourceEntries == null)
fontSources = new List(0);
else
{
bool isComposite = false;
// Enumerate application resources, content files and container structure.
fontSources = new List(resourceEntries.Count);
foreach (string resourceName in resourceEntries)
{
// If resourceName is an empty string, this means that the _uri is a full file name;
// otherwise resourceName is a file name within a folder.
if (String.IsNullOrEmpty(resourceName))
{
isComposite = Util.IsCompositeFont(Path.GetExtension(_uri.AbsoluteUri));
fontSources.Add(new FontSource(_uri, _isWindowsFonts, isComposite));
}
else
{
isComposite = Util.IsCompositeFont(Path.GetExtension(resourceName));
fontSources.Add(new FontSource(new Uri(_uri, resourceName), _isWindowsFonts, isComposite));
}
}
}
}
_fontSources = fontSources;
}
}
#region IEnumerable Members
IEnumerator System.Collections.Generic.IEnumerable.GetEnumerator()
{
SetFontSources();
return (IEnumerator)_fontSources.GetEnumerator();
}
#endregion
#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
SetFontSources();
return _fontSources.GetEnumerator();
}
#endregion
///
/// Critical - fontUri can contain information about local file system.
///
[SecurityCritical]
private Uri _uri;
///
/// Critical - this value is used to make security decisions (i.e., whether to do an Assert)
/// so it can only be set by critical code.
///
[SecurityCritical]
private bool _isWindowsFonts;
// _isFileSystemFolder flag makes sense only when _uri.IsFile is set to true.
private bool _isFileSystemFolder;
private volatile IList _fontSources;
// Flag to indicate that only composite fonts in the provided URI location should be retrieved.
private bool _tryGetCompositeFontsOnly;
private const string InstalledWindowsFontsRegistryKey = @"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts";
private const string InstalledWindowsFontsRegistryKeyFullPath = @"HKEY_LOCAL_MACHINE\" + InstalledWindowsFontsRegistryKey;
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- CommandPlan.cs
- SchemaImporterExtension.cs
- BitConverter.cs
- DataSysAttribute.cs
- SpellerStatusTable.cs
- StorageSetMapping.cs
- WebConfigurationFileMap.cs
- BuilderPropertyEntry.cs
- UnaryOperationBinder.cs
- ColumnReorderedEventArgs.cs
- CompiledQuery.cs
- Rotation3DKeyFrameCollection.cs
- FlowDocumentFormatter.cs
- WSSecurityPolicy11.cs
- IntSecurity.cs
- PositiveTimeSpanValidatorAttribute.cs
- BitStack.cs
- XmlSchemaObjectTable.cs
- IOException.cs
- SqlProviderServices.cs
- GraphicsPath.cs
- ASCIIEncoding.cs
- XhtmlBasicTextViewAdapter.cs
- WebServiceAttribute.cs
- DragEventArgs.cs
- InfocardClientCredentials.cs
- SymbolResolver.cs
- ToolStripManager.cs
- RSAOAEPKeyExchangeDeformatter.cs
- MimeParameters.cs
- DescendentsWalker.cs
- WindowsHyperlink.cs
- SQLUtility.cs
- SharedDp.cs
- mediaeventargs.cs
- TemplateControlBuildProvider.cs
- MouseActionConverter.cs
- _TransmitFileOverlappedAsyncResult.cs
- KeyEventArgs.cs
- MergeFilterQuery.cs
- CodeAccessSecurityEngine.cs
- altserialization.cs
- HttpContextServiceHost.cs
- SpeechEvent.cs
- CellPartitioner.cs
- CalendarTable.cs
- ProfileInfo.cs
- BookmarkResumptionRecord.cs
- ExpressionEditorSheet.cs
- X509CertificateStore.cs
- AspNetSynchronizationContext.cs
- TableRowGroup.cs
- glyphs.cs
- MiniCustomAttributeInfo.cs
- DiscoveryReference.cs
- UTF32Encoding.cs
- HeaderUtility.cs
- ViewGenerator.cs
- LabelEditEvent.cs
- StoreContentChangedEventArgs.cs
- RegexBoyerMoore.cs
- CatalogZone.cs
- Rectangle.cs
- DeviceContext2.cs
- InvalidEnumArgumentException.cs
- CodeDelegateInvokeExpression.cs
- CellTreeNodeVisitors.cs
- RuleSettings.cs
- BrowserInteropHelper.cs
- EtwTrace.cs
- XmlWhitespace.cs
- FactoryGenerator.cs
- CacheChildrenQuery.cs
- HelpKeywordAttribute.cs
- PowerModeChangedEventArgs.cs
- XmlAttributeOverrides.cs
- ChildrenQuery.cs
- ImageListImage.cs
- CompiledRegexRunner.cs
- WebPartDisplayMode.cs
- LocalBuilder.cs
- TitleStyle.cs
- SortedList.cs
- ValueTable.cs
- safesecurityhelperavalon.cs
- SortableBindingList.cs
- WindowsStatic.cs
- StylusPointProperty.cs
- followingsibling.cs
- WebPartPersonalization.cs
- FontSourceCollection.cs
- ServiceProviders.cs
- QuaternionAnimation.cs
- BamlBinaryWriter.cs
- ZeroOpNode.cs
- TreeNodeConverter.cs
- EditorAttribute.cs
- ParserContext.cs
- EntityProxyTypeInfo.cs
- ComponentRenameEvent.cs