public void Dispose()
{
try
{
Connection?.Abort(1000);
}
catch (AlreadyClosedException ex)
{
}
catch (Exception ex)
{
}
}
// perform security handshake and ACK connection
protected override async Task OnOpenAsync(CancellationToken token)
{
bool success = false;
try
{
// TODO: Sort out the timeout here
var timeoutHelper = new TimeoutHelper(TimeSpan.FromSeconds(30));
// first validate our content type
ValidateContentType(ref timeoutHelper);
// next read any potential upgrades and finish consuming the preamble
for (;;)
{
if (size == 0)
{
offset = 0;
size = await Connection.ReadAsync(0, connectionBuffer.Length, timeoutHelper.RemainingTime());
if (size == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(decoder.CreatePrematureEOFException());
}
}
for (;;)
{
DecodeBytes();
switch (decoder.CurrentState)
{
case ServerSessionDecoder.State.UpgradeRequest:
ProcessUpgradeRequest(ref timeoutHelper);
// accept upgrade
await Connection.WriteAsync(ServerSessionEncoder.UpgradeResponseBytes, 0, ServerSessionEncoder.UpgradeResponseBytes.Length, true, timeoutHelper.RemainingTime());
IConnection connectionToUpgrade = Connection;
if (size > 0)
{
// TODO: Switch to using PreReadConnection constructor which doesn't take a buffer. This is currently causing an extra buffer allocation.
connectionToUpgrade = new PreReadConnection(connectionToUpgrade, connectionBuffer, offset, size);
}
try
{
Connection = await InitialServerConnectionReader.UpgradeConnectionAsync(connectionToUpgrade, upgradeAcceptor, this);
if (channelBindingProvider != null && channelBindingProvider.IsChannelBindingSupportEnabled)
{
SetChannelBinding(channelBindingProvider.GetChannelBinding(upgradeAcceptor, ChannelBindingKind.Endpoint));
}
connectionBuffer = Connection.AsyncReadBuffer;
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
// Audit Authentication Failure
WriteAuditFailure(upgradeAcceptor as StreamSecurityUpgradeAcceptor, exception);
throw;
}
break;
case ServerSessionDecoder.State.Start:
SetupSecurityIfNecessary();
// we've finished the preamble. Ack and return.
await Connection.WriteAsync(ServerSessionEncoder.AckResponseBytes, 0,
ServerSessionEncoder.AckResponseBytes.Length, true, timeoutHelper.RemainingTime());
SetupSessionReader();
success = true;
return;
}
if (size == 0)
{
break;
}
}
}
}
finally
{
if (!success)
{
Connection.Abort();
}
}
}
/// <include file='docs/mysqlcommand.xml' path='docs/ExecuteReader1/*'/>
public new MySqlDataReader ExecuteReader(CommandBehavior behavior)
{
// interceptors didn't handle this so we fall through
bool success = false;
CheckState();
Driver driver = connection.driver;
cmdText = cmdText.Trim();
string sql = cmdText.Trim(';');
lock (driver)
{
// We have to recheck that there is no reader, after we got the lock
if (connection.Reader != null)
{
throw (new MySqlException("Resources.DataReaderOpen"));
}
commandTimer = new CommandTimer(connection, CommandTimeout);
lastInsertedId = -1;
if (CommandType == CommandType.TableDirect)
{
sql = "SELECT * FROM " + sql;
}
else if (CommandType == CommandType.Text)
{
// validates single word statetment (maybe is a stored procedure call)
if (sql.IndexOf(" ") == -1)
{
if (AddCallStatement(sql))
{
sql = "call " + sql;
}
}
}
// if we are on a replicated connection, we are only allow readonly statements
if (connection.Settings.Replication && !InternallyCreated)
{
EnsureCommandIsReadOnly(sql);
}
if (statement == null || !statement.IsPrepared)
{
if (CommandType == CommandType.StoredProcedure)
{
statement = new StoredProcedure(this, sql);
}
else
{
statement = new PreparableStatement(this, sql);
}
}
// stored procs are the only statement type that need do anything during resolve
statement.Resolve(false);
// Now that we have completed our resolve step, we can handle our
// command behaviors
HandleCommandBehaviors(behavior);
updatedRowCount = -1;
try
{
MySqlDataReader reader = new MySqlDataReader(this, statement, behavior);
connection.Reader = reader;
canceled = false;
// execute the statement
statement.Execute();
// wait for data to return
reader.NextResult();
success = true;
return(reader);
}
catch (TimeoutException tex)
{
connection.HandleTimeoutOrThreadAbort(tex);
throw; //unreached
}
catch (ThreadAbortException taex)
{
connection.HandleTimeoutOrThreadAbort(taex);
throw;
}
catch (IOException ioex)
{
connection.Abort(); // Closes connection without returning it to the pool
throw new MySqlException("Resources.FatalErrorDuringExecute", ioex);
}
catch (MySqlException ex)
{
if (ex.InnerException is TimeoutException)
{
throw; // already handled
}
try
{
ResetReader();
ResetSqlSelectLimit();
}
catch (Exception)
{
// Reset SqlLimit did not work, connection is hosed.
Connection.Abort();
throw new MySqlException(ex.Message, true, ex);
}
// if we caught an exception because of a cancel, then just return null
if (ex.IsQueryAborted)
{
return(null);
}
if (ex.IsFatal)
{
Connection.Close();
}
if (ex.Number == 0)
{
throw new MySqlException("Resources.FatalErrorDuringExecute", ex);
}
throw;
}
finally
{
if (connection != null)
{
if (connection.Reader == null)
{
// Something went seriously wrong, and reader would not
// be able to clear timeout on closing.
// So we clear timeout here.
ClearCommandTimer();
}
if (!success)
{
// ExecuteReader failed.Close Reader and set to null to
// prevent subsequent errors with DataReaderOpen
ResetReader();
}
}
}
}
}
///<summary>Called from CheckAutoClose, in a separate thread,
///when we decide to close the connection.</summary>
public void AutoCloseConnection()
{
m_connection.Abort(Constants.ReplySuccess, "AutoClose", ShutdownInitiator.Library, Timeout.InfiniteTimeSpan);
}
/// <include file='docs/mysqlcommand.xml' path='docs/ExecuteReader1/*'/>
public new MySqlDataReader ExecuteReader(CommandBehavior behavior)
{
#if !CF && !RT
// give our interceptors a shot at it first
MySqlDataReader interceptedReader = null;
if (connection != null &&
connection.commandInterceptor != null &&
connection.commandInterceptor.ExecuteReader(CommandText, behavior, ref interceptedReader))
{
return(interceptedReader);
}
#endif
// interceptors didn't handle this so we fall through
bool success = false;
CheckState();
Driver driver = connection.driver;
cmdText = cmdText.Trim();
if (String.IsNullOrEmpty(cmdText))
{
Throw(new InvalidOperationException(Resources.CommandTextNotInitialized));
}
string sql = cmdText.Trim(';');
#if !CF && !NETSTANDARD1_3
// Load balancing getting a new connection
if (connection.hasBeenOpen && !driver.HasStatus(ServerStatusFlags.InTransaction))
{
ReplicationManager.GetNewConnection(connection.Settings.Server, !IsReadOnlyCommand(sql), connection);
}
#endif
lock (driver)
{
// We have to recheck that there is no reader, after we got the lock
if (connection.Reader != null)
{
Throw(new MySqlException(Resources.DataReaderOpen));
}
#if !CF && !RT && !NETSTANDARD1_3
System.Transactions.Transaction curTrans = System.Transactions.Transaction.Current;
if (curTrans != null)
{
bool inRollback = false;
if (driver.CurrentTransaction != null)
{
inRollback = driver.CurrentTransaction.InRollback;
}
if (!inRollback)
{
System.Transactions.TransactionStatus status = System.Transactions.TransactionStatus.InDoubt;
try
{
// in some cases (during state transitions) this throws
// an exception. Ignore exceptions, we're only interested
// whether transaction was aborted or not.
status = curTrans.TransactionInformation.Status;
}
catch (System.Transactions.TransactionException)
{
}
if (status == System.Transactions.TransactionStatus.Aborted)
{
Throw(new System.Transactions.TransactionAbortedException());
}
}
}
#endif
commandTimer = new CommandTimer(connection, CommandTimeout);
lastInsertedId = -1;
if (CommandType == CommandType.TableDirect)
{
sql = "SELECT * FROM " + sql;
}
else if (CommandType == CommandType.Text)
{
// validates single word statetment (maybe is a stored procedure call)
if (sql.IndexOf(" ") == -1)
{
if (AddCallStatement(sql))
{
sql = "call " + sql;
}
}
}
// if we are on a replicated connection, we are only allow readonly statements
if (connection.Settings.Replication && !InternallyCreated)
{
EnsureCommandIsReadOnly(sql);
}
if (statement == null || !statement.IsPrepared)
{
if (CommandType == CommandType.StoredProcedure)
{
statement = new StoredProcedure(this, sql);
}
else
{
statement = new PreparableStatement(this, sql);
}
}
// stored procs are the only statement type that need do anything during resolve
statement.Resolve(false);
// Now that we have completed our resolve step, we can handle our
// command behaviors
HandleCommandBehaviors(behavior);
updatedRowCount = -1;
try
{
MySqlDataReader reader = new MySqlDataReader(this, statement, behavior);
connection.Reader = reader;
canceled = false;
// execute the statement
statement.Execute();
// wait for data to return
reader.NextResult();
success = true;
return(reader);
}
catch (TimeoutException tex)
{
connection.HandleTimeoutOrThreadAbort(tex);
throw; //unreached
}
catch (ThreadAbortException taex)
{
connection.HandleTimeoutOrThreadAbort(taex);
throw;
}
catch (IOException ioex)
{
connection.Abort(); // Closes connection without returning it to the pool
throw new MySqlException(Resources.FatalErrorDuringExecute, ioex);
}
catch (MySqlException ex)
{
if (ex.InnerException is TimeoutException)
{
throw; // already handled
}
try
{
ResetReader();
ResetSqlSelectLimit();
}
catch (Exception)
{
// Reset SqlLimit did not work, connection is hosed.
Connection.Abort();
throw new MySqlException(ex.Message, true, ex);
}
// if we caught an exception because of a cancel, then just return null
if (ex.IsQueryAborted)
{
return(null);
}
if (ex.IsFatal)
{
Connection.Close();
}
if (ex.Number == 0)
{
throw new MySqlException(Resources.FatalErrorDuringExecute, ex);
}
throw;
}
finally
{
if (connection != null)
{
if (connection.Reader == null)
{
// Something went seriously wrong, and reader would not
// be able to clear timeout on closing.
// So we clear timeout here.
ClearCommandTimer();
}
if (!success)
{
// ExecuteReader failed.Close Reader and set to null to
// prevent subsequent errors with DataReaderOpen
ResetReader();
}
}
}
}
}
override public void EnlistTransaction(SysTx.Transaction transaction)
{
SqlConnection.VerifyExecutePermission();
ValidateConnectionForExecute(null);
// If a connection has a local transaction outstanding and you try
// to enlist in a DTC transaction, SQL Server will rollback the
// local transaction and then do the enlist (7.0 and 2000). So, if
// the user tries to do this, throw.
if (HasLocalTransaction)
{
throw ADP.LocalTransactionPresent();
}
if (null != transaction && transaction.Equals(EnlistedTransaction))
{
// No-op if this is the current transaction
return;
}
// If a connection is already enlisted in a DTC transaction and you
// try to enlist in another one, in 7.0 the existing DTC transaction
// would roll back and then the connection would enlist in the new
// one. In SQL 2000 & Yukon, when you enlist in a DTC transaction
// while the connection is already enlisted in a DTC transaction,
// the connection simply switches enlistments. Regardless, simply
// enlist in the user specified distributed transaction. This
// behavior matches OLEDB and ODBC.
TdsParser bestEffortCleanupTarget = null;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
#if DEBUG
TdsParser.ReliabilitySection tdsReliabilitySection = new TdsParser.ReliabilitySection();
RuntimeHelpers.PrepareConstrainedRegions();
try
{
tdsReliabilitySection.Start();
#else
{
#endif //DEBUG
bestEffortCleanupTarget = SqlInternalConnection.GetBestEffortCleanupTarget(Connection);
Enlist(transaction);
}
#if DEBUG
finally
{
tdsReliabilitySection.Stop();
}
#endif //DEBUG
}
catch (System.OutOfMemoryException e)
{
Connection.Abort(e);
throw;
}
catch (System.StackOverflowException e)
{
Connection.Abort(e);
throw;
}
catch (System.Threading.ThreadAbortException e)
{
Connection.Abort(e);
SqlInternalConnection.BestEffortCleanup(bestEffortCleanupTarget);
throw;
}
}
virtual internal SqlTransaction BeginSqlTransaction(IsolationLevel iso, string transactionName, bool shouldReconnect)
{
SqlStatistics statistics = null;
TdsParser bestEffortCleanupTarget = null;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
#if DEBUG
TdsParser.ReliabilitySection tdsReliabilitySection = new TdsParser.ReliabilitySection();
RuntimeHelpers.PrepareConstrainedRegions();
try
{
tdsReliabilitySection.Start();
#else
{
#endif //DEBUG
bestEffortCleanupTarget = SqlInternalConnection.GetBestEffortCleanupTarget(Connection);
statistics = SqlStatistics.StartTimer(Connection.Statistics);
SqlConnection.ExecutePermission.Demand(); // MDAC 81476
ValidateConnectionForExecute(null);
if (HasLocalTransactionFromAPI)
{
throw ADP.ParallelTransactionsNotSupported(Connection);
}
if (iso == IsolationLevel.Unspecified)
{
iso = IsolationLevel.ReadCommitted; // Default to ReadCommitted if unspecified.
}
SqlTransaction transaction = new SqlTransaction(this, Connection, iso, AvailableInternalTransaction);
transaction.InternalTransaction.RestoreBrokenConnection = shouldReconnect;
ExecuteTransaction(TransactionRequest.Begin, transactionName, iso, transaction.InternalTransaction, false);
transaction.InternalTransaction.RestoreBrokenConnection = false;
return(transaction);
}
#if DEBUG
finally
{
tdsReliabilitySection.Stop();
}
#endif //DEBUG
}
catch (System.OutOfMemoryException e)
{
Connection.Abort(e);
throw;
}
catch (System.StackOverflowException e)
{
Connection.Abort(e);
throw;
}
catch (System.Threading.ThreadAbortException e)
{
Connection.Abort(e);
SqlInternalConnection.BestEffortCleanup(bestEffortCleanupTarget);
throw;
}
finally
{
SqlStatistics.StopTimer(statistics);
}
}