|
//------------------------------------------------------------------------------
// <copyright file="StringResourceManager.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web {
using System;
using System.Collections;
using System.Text;
using System.IO;
using System.Runtime.InteropServices;
using System.Globalization;
using System.Security;
using System.Security.Permissions;
using Debug=System.Web.Util.Debug;
internal class StringResourceManager {
internal const int RESOURCE_TYPE = 0xEBB;
internal const int RESOURCE_ID = 101;
private StringResourceManager() {
}
internal unsafe static string ResourceToString(IntPtr pv, int offset, int size) {
return new String((sbyte *)pv, offset, size, Encoding.UTF8);
}
internal static SafeStringResource ReadSafeStringResource(Type t) {
// At designtime CodeGenDir is null.
if (HttpRuntime.CodegenDirInternal != null) {
// Module.FullyQualifiedName was changed to check for FileIOPermission regardless of the name being an existing file or not.
// we need to Assert in order to succeed the Demand() (ASURT 121603)
(InternalSecurityPermissions.PathDiscovery(HttpRuntime.CodegenDirInternal)).Assert();
}
string dllPath = t.Module.FullyQualifiedName;
IntPtr hModule = UnsafeNativeMethods.GetModuleHandle(dllPath);
if (hModule == IntPtr.Zero) {
// GetModuleHandle could fail if the assembly was renamed to .delete. So we fall back to
// calling Marshal.GetHINSTANCE, which is more reliable. Ideally, we should always do this
// directly, but to limit the risk, we only do it as a fall back (VSWhidbey 394621)
hModule = Marshal.GetHINSTANCE(t.Module);
if (hModule == IntPtr.Zero) {
throw new HttpException(SR.GetString(SR.Resource_problem,
"GetModuleHandle", HttpException.HResultFromLastError(Marshal.GetLastWin32Error()).ToString(CultureInfo.InvariantCulture)));
}
}
IntPtr hrsrc = UnsafeNativeMethods.FindResource(hModule, (IntPtr)RESOURCE_ID, (IntPtr)RESOURCE_TYPE);
if (hrsrc == IntPtr.Zero) {
throw new HttpException(SR.GetString(SR.Resource_problem,
"FindResource", HttpException.HResultFromLastError(Marshal.GetLastWin32Error()).ToString(CultureInfo.InvariantCulture)));
}
int resSize = UnsafeNativeMethods.SizeofResource(hModule, hrsrc);
IntPtr hglob = UnsafeNativeMethods.LoadResource(hModule, hrsrc);
if (hglob == IntPtr.Zero) {
throw new HttpException(SR.GetString(SR.Resource_problem,
"LoadResource", HttpException.HResultFromLastError(Marshal.GetLastWin32Error()).ToString(CultureInfo.InvariantCulture)));
}
IntPtr pv = UnsafeNativeMethods.LockResource(hglob);
if (pv == IntPtr.Zero) {
throw new HttpException(SR.GetString(SR.Resource_problem,
"LockResource", HttpException.HResultFromLastError(Marshal.GetLastWin32Error()).ToString(CultureInfo.InvariantCulture)));
}
// Make sure the end of the resource lies within the module. this can be an issue
// if the resource has been hacked with an invalid length (ASURT 145040)
if (!UnsafeNativeMethods.IsValidResource(hModule, pv, resSize)) {
throw new InvalidOperationException();
}
return new SafeStringResource(pv, resSize);
}
}
internal class StringResourceBuilder {
private ArrayList _literalStrings = null;
private int _offset = 0;
internal StringResourceBuilder() {
}
internal void AddString(string s, out int offset, out int size, out bool fAsciiOnly) {
if (_literalStrings == null)
_literalStrings = new ArrayList();
_literalStrings.Add(s);
// Compute the UTF8 length of the string
size = Encoding.UTF8.GetByteCount(s);
// Check if the string contains only 7-bit ascii characters
fAsciiOnly = (size == s.Length);
offset = _offset;
// Update the offset in the literal string memory block
_offset += size;
}
internal bool HasStrings {
get { return _literalStrings != null; }
}
internal void CreateResourceFile(string resFileName) {
using (Stream strm = new FileStream(resFileName, FileMode.Create)) {
Encoding encoding = Encoding.UTF8;
BinaryWriter writer = new BinaryWriter(strm, encoding);
writer.Write(0x00000000);
writer.Write(0x00000020);
writer.Write(0x0000FFFF);
writer.Write(0x0000FFFF);
writer.Write(0x00000000);
writer.Write(0x00000000);
writer.Write(0x00000000);
writer.Write(0x00000000);
// Resource size
writer.Write(_offset);
// Resource header size
writer.Write(0x00000020);
// Type
writer.Write(StringResourceManager.RESOURCE_TYPE << 16 | 0xFFFF);
// Resource ID
writer.Write(StringResourceManager.RESOURCE_ID << 16 | 0xFFFF);
writer.Write(0x00000000);
writer.Write(0x00000000);
writer.Write(0x00000000);
writer.Write(0x00000000);
#if DEBUG
long startPos = strm.Position;
#endif
foreach (string s in _literalStrings) {
byte[] data = encoding.GetBytes(s);
writer.Write(data);
}
// Make sure the stream has the size we expect
#if DEBUG
Debug.Assert(strm.Position-startPos == _offset, "strm.Position-startPos == _offset");
#endif
}
}
}
// Used to wrap an IntPtr in a way that it can safely be handed out to
// untrusted code (ASURT 73586)
internal class SafeStringResource {
private IntPtr _stringResourcePointer;
private int _resourceSize;
internal SafeStringResource(IntPtr stringResourcePointer, int resourceSize) {
_stringResourcePointer = stringResourcePointer;
_resourceSize = resourceSize;
}
internal IntPtr StringResourcePointer { get { return _stringResourcePointer; } }
internal int ResourceSize { get { return _resourceSize; } }
}
}
|