Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

325 lines
14 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="SqlConnectionHelper.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.DataAccess {
using System;
using System.Collections.Specialized;
using System.Configuration;
using System.Configuration.Provider;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Security.Permissions;
using System.Threading;
using System.Web.Configuration;
using System.Web.Hosting;
using System.Web.Management;
using System.Web.Util;
internal static class SqlConnectionHelper {
internal const string s_strDataDir = "DataDirectory";
internal const string s_strUpperDataDirWithToken = "|DATADIRECTORY|";
internal const string s_strSqlExprFileExt = ".MDF";
internal const string s_strUpperUserInstance = "USER INSTANCE";
private const string s_localDbName = "(LOCALDB)";
private static object s_lock = new object();
internal static void EnsureNoUserInstance(string connectionString) {
SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(connectionString);
if (builder.UserInstance) {
throw new ProviderException(SR.GetString(SR.LocalDB_cannot_have_userinstance_flag));
}
}
internal static SqlConnectionHolder GetConnection(string connectionString, bool revertImpersonation) {
string strTempConnection = connectionString.ToUpperInvariant();
if (strTempConnection.Contains(s_strUpperDataDirWithToken)) {
EnsureDBFile(connectionString);
}
// Only block UserInstance for LocalDB connections
if (strTempConnection.Contains(s_localDbName)) {
EnsureNoUserInstance(connectionString);
}
SqlConnectionHolder holder = new SqlConnectionHolder(connectionString);
bool closeConn = true;
try {
try {
holder.Open(null, revertImpersonation);
closeConn = false;
}
finally {
if (closeConn) {
holder.Close();
holder = null;
}
}
}
catch {
throw;
}
return holder;
}
internal static string GetConnectionString(string specifiedConnectionString, bool lookupConnectionString, bool appLevel) {
System.Web.Util.Debug.Assert((specifiedConnectionString != null) && (specifiedConnectionString.Length != 0));
if (specifiedConnectionString == null || specifiedConnectionString.Length < 1)
return null;
string connectionString = null;
// Step 1: Check <connectionStrings> config section for this connection string
if (lookupConnectionString) {
RuntimeConfig config = (appLevel) ? RuntimeConfig.GetAppConfig() : RuntimeConfig.GetConfig();
ConnectionStringSettings connObj = config.ConnectionStrings.ConnectionStrings[specifiedConnectionString];
if (connObj != null)
connectionString = connObj.ConnectionString;
if (connectionString == null)
return null;
//HandlerBase.CheckAndReadRegistryValue (ref connectionString, true);
}
else {
connectionString = specifiedConnectionString;
}
return connectionString;
}
[PermissionSet(SecurityAction.Assert, Unrestricted = true)]
internal static string GetDataDirectory() {
if (HostingEnvironment.IsHosted)
return Path.Combine(HttpRuntime.AppDomainAppPath, HttpRuntime.DataDirectoryName);
string dataDir = AppDomain.CurrentDomain.GetData(s_strDataDir) as string;
if (string.IsNullOrEmpty(dataDir)) {
string appPath = null;
#if !FEATURE_PAL // FEATURE_PAL does not support ProcessModule
Process p = Process.GetCurrentProcess();
ProcessModule pm = (p != null ? p.MainModule : null);
string exeName = (pm != null ? pm.FileName : null);
if (!string.IsNullOrEmpty(exeName))
appPath = Path.GetDirectoryName(exeName);
#endif // !FEATURE_PAL
if (string.IsNullOrEmpty(appPath))
appPath = Environment.CurrentDirectory;
dataDir = Path.Combine(appPath, HttpRuntime.DataDirectoryName);
AppDomain.CurrentDomain.SetData(s_strDataDir, dataDir, new FileIOPermission(FileIOPermissionAccess.PathDiscovery, dataDir));
}
return dataDir;
}
private static void EnsureDBFile(string connectionString) {
string partialFileName = null;
string fullFileName = null;
string dataDir = GetDataDirectory();
bool lookingForDataDir = true;
bool lookingForDB = true;
string[] splitedConnStr = connectionString.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
bool lookingForUserInstance = !connectionString.ToUpperInvariant().Contains(s_localDbName); // We don't require UserInstance=True for LocalDb
bool lookingForTimeout = true;
foreach (string str in splitedConnStr) {
string strUpper = str.ToUpper(CultureInfo.InvariantCulture).Trim();
if (lookingForDataDir && strUpper.Contains(s_strUpperDataDirWithToken)) {
lookingForDataDir = false;
// Replace the AttachDBFilename part with "Pooling=false"
connectionString = connectionString.Replace(str, "Pooling=false");
// Extract the filenames
int startPos = strUpper.IndexOf(s_strUpperDataDirWithToken, StringComparison.Ordinal) + s_strUpperDataDirWithToken.Length;
partialFileName = strUpper.Substring(startPos).Trim();
while (partialFileName.StartsWith("\\", StringComparison.Ordinal))
partialFileName = partialFileName.Substring(1);
if (partialFileName.Contains("..")) // don't allow it to traverse-up
partialFileName = null;
else
fullFileName = Path.Combine(dataDir, partialFileName);
if (!lookingForDB)
break; // done
}
else if (lookingForDB && (strUpper.StartsWith("INITIAL CATALOG", StringComparison.Ordinal) || strUpper.StartsWith("DATABASE", StringComparison.Ordinal))) {
lookingForDB = false;
connectionString = connectionString.Replace(str, "Database=master");
if (!lookingForDataDir)
break; // done
}
else if (lookingForUserInstance && strUpper.StartsWith(s_strUpperUserInstance, StringComparison.Ordinal)) {
lookingForUserInstance = false;
int pos = strUpper.IndexOf('=');
if (pos < 0)
return;
string strTemp = strUpper.Substring(pos + 1).Trim();
if (strTemp != "TRUE")
return;
}
else if (lookingForTimeout && strUpper.StartsWith("CONNECT TIMEOUT", StringComparison.Ordinal)) {
lookingForTimeout = false;
}
}
if (lookingForUserInstance)
return;
if (fullFileName == null)
throw new ProviderException(SR.GetString(SR.SqlExpress_file_not_found_in_connection_string));
if (File.Exists(fullFileName))
return;
if (!HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.High))
throw new ProviderException(SR.GetString(SR.Provider_can_not_create_file_in_this_trust_level));
if (!connectionString.Contains("Database=master"))
connectionString += ";Database=master";
if (lookingForTimeout)
connectionString += ";Connect Timeout=45";
using (new ApplicationImpersonationContext())
lock (s_lock)
if (!File.Exists(fullFileName))
CreateMdfFile(fullFileName, dataDir, connectionString);
}
[PermissionSet(SecurityAction.Assert, Unrestricted = true)]
private static void CreateMdfFile(string fullFileName, string dataDir, string connectionString) {
bool creatingDir = false;
string databaseName = null;
HttpContext context = HttpContext.Current;
string tempFileName = null;
try {
if (!Directory.Exists(dataDir)) {
creatingDir = true;
Directory.CreateDirectory(dataDir);
creatingDir = false;
try {
if (context != null)
HttpRuntime.RestrictIISFolders(context);
}
catch { }
}
fullFileName = fullFileName.ToUpper(CultureInfo.InvariantCulture);
char[] strippedFileNameChars = Path.GetFileNameWithoutExtension(fullFileName).ToCharArray();
for (int iter = 0; iter < strippedFileNameChars.Length; iter++)
if (!char.IsLetterOrDigit(strippedFileNameChars[iter]))
strippedFileNameChars[iter] = '_';
string strippedFileName = new string(strippedFileNameChars);
if (strippedFileName.Length > 30)
databaseName = strippedFileName.Substring(0, 30) + "_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
else
databaseName = strippedFileName + "_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
tempFileName = Path.Combine(Path.GetDirectoryName(fullFileName), strippedFileName + "_TMP" + s_strSqlExprFileExt);
// Auto create the temporary database
SqlServices.Install(databaseName, tempFileName, connectionString);
DetachDB(databaseName, connectionString);
try {
File.Move(tempFileName, fullFileName);
}
catch {
if (!File.Exists(fullFileName)) {
File.Copy(tempFileName, fullFileName);
try {
File.Delete(tempFileName);
}
catch { }
}
}
try {
File.Delete(tempFileName.Replace("_TMP.MDF", "_TMP_log.LDF"));
}
catch { }
}
catch (Exception e) {
if (context == null || context.IsCustomErrorEnabled)
throw;
HttpException httpExec = new HttpException(e.Message, e);
if (e is UnauthorizedAccessException)
httpExec.SetFormatter(new SqlExpressConnectionErrorFormatter(creatingDir ? DataConnectionErrorEnum.CanNotCreateDataDir : DataConnectionErrorEnum.CanNotWriteToDataDir));
else
httpExec.SetFormatter(new SqlExpressDBFileAutoCreationErrorFormatter(e));
throw httpExec;
}
}
private static void DetachDB(string databaseName, string connectionString) {
SqlConnection connection = new SqlConnection(connectionString);
try {
connection.Open();
SqlCommand command = new SqlCommand("USE master", connection);
command.ExecuteNonQuery();
command = new SqlCommand("sp_detach_db", connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@dbname", databaseName);
command.Parameters.AddWithValue("@skipchecks", "true");
command.ExecuteNonQuery();
}
catch {
}
finally {
connection.Close();
}
}
}
internal sealed class SqlConnectionHolder {
internal SqlConnection _Connection;
private bool _Opened;
internal SqlConnection Connection {
get { return _Connection; }
}
internal SqlConnectionHolder(string connectionString) {
try {
_Connection = new SqlConnection(connectionString);
System.Web.Util.Debug.Assert(_Connection != null);
}
catch (ArgumentException e) {
throw new ArgumentException(SR.GetString(SR.SqlError_Connection_String), "connectionString", e);
}
}
internal void Open(HttpContext context, bool revertImpersonate) {
if (_Opened)
return; // Already opened
if (revertImpersonate) {
using (new ApplicationImpersonationContext()) {
Connection.Open();
}
}
else {
Connection.Open();
}
_Opened = true; // Open worked!
}
internal void Close() {
if (!_Opened) // Not open!
return;
// Close connection
Connection.Close();
_Opened = false;
}
}
}