public SessionData(SessionData recoveryData) {
_initialDatabase = recoveryData._initialDatabase;
_initialCollation = recoveryData._initialCollation;
_initialLanguage = recoveryData._initialLanguage;
_resolvedAliases = recoveryData._resolvedAliases;
for (int i = 0; i < _maxNumberOfSessionStates; i++) {
if (recoveryData._initialState[i] != null) {
_initialState[i] = (byte[])recoveryData._initialState[i].Clone();
}
}
}
public DashBoard(SessionData ob)
{
InitializeComponent();
x = ob;
}
internal void TdsLogin(SqlLogin rec, TdsEnums.FeatureExtension requestedFeatures, SessionData recoverySessionData)
{
_physicalStateObj.SetTimeoutSeconds(rec.timeout);
Debug.Assert(recoverySessionData == null || (requestedFeatures | TdsEnums.FeatureExtension.SessionRecovery) != 0, "Recovery session data without session recovery feature request");
Debug.Assert(TdsEnums.MAXLEN_HOSTNAME >= rec.hostName.Length, "_workstationId.Length exceeds the max length for this value");
Debug.Assert(rec.userName == null || (rec.userName != null && TdsEnums.MAXLEN_USERNAME >= rec.userName.Length), "_userID.Length exceeds the max length for this value");
Debug.Assert(rec.password == null || (rec.password != null && TdsEnums.MAXLEN_PASSWORD >= rec.password.Length), "_password.Length exceeds the max length for this value");
Debug.Assert(TdsEnums.MAXLEN_APPNAME >= rec.applicationName.Length, "_applicationName.Length exceeds the max length for this value");
Debug.Assert(TdsEnums.MAXLEN_SERVERNAME >= rec.serverName.Length, "_dataSource.Length exceeds the max length for this value");
Debug.Assert(TdsEnums.MAXLEN_LANGUAGE >= rec.language.Length, "_currentLanguage .Length exceeds the max length for this value");
Debug.Assert(TdsEnums.MAXLEN_DATABASE >= rec.database.Length, "_initialCatalog.Length exceeds the max length for this value");
Debug.Assert(TdsEnums.MAXLEN_ATTACHDBFILE >= rec.attachDBFilename.Length, "_attachDBFileName.Length exceeds the max length for this value");
Debug.Assert(_connHandler != null, "SqlConnectionInternalTds handler can not be null at this point.");
_connHandler.TimeoutErrorInternal.EndPhase(SqlConnectionTimeoutErrorPhase.LoginBegin);
_connHandler.TimeoutErrorInternal.SetAndBeginPhase(SqlConnectionTimeoutErrorPhase.ProcessConnectionAuth);
// get the password up front to use in sspi logic below
byte[] encryptedPassword = null;
int encryptedPasswordLengthInBytes;
bool useFeatureExt = (requestedFeatures != TdsEnums.FeatureExtension.None);
string userName;
{
userName = rec.userName;
encryptedPassword = TdsParserStaticMethods.EncryptPassword(rec.password);
encryptedPasswordLengthInBytes = encryptedPassword.Length; // password in clear text is already encrypted and its length is in byte
}
// set the message type
_physicalStateObj._outputMessageType = TdsEnums.MT_LOGIN7;
// length in bytes
int length = TdsEnums.YUKON_LOG_REC_FIXED_LEN;
string clientInterfaceName = TdsEnums.SQL_PROVIDER_NAME;
Debug.Assert(TdsEnums.MAXLEN_CLIENTINTERFACE >= clientInterfaceName.Length, "cchCltIntName can specify at most 128 unicode characters. See Tds spec");
// add up variable-len portions (multiply by 2 for byte len of char strings)
//
checked
{
length += (rec.hostName.Length + rec.applicationName.Length +
rec.serverName.Length + clientInterfaceName.Length +
rec.language.Length + rec.database.Length +
rec.attachDBFilename.Length) * 2;
if (useFeatureExt)
{
length += 4;
}
}
// allocate memory for SSPI variables
byte[] outSSPIBuff = null;
UInt32 outSSPILength = 0;
// only add lengths of password and username if not using SSPI
if (!rec.useSSPI)
{
checked
{
length += (userName.Length * 2) + encryptedPasswordLengthInBytes
;
}
}
else
{
if (rec.useSSPI)
{
// now allocate proper length of buffer, and set length
outSSPIBuff = new byte[s_maxSSPILength];
outSSPILength = s_maxSSPILength;
// Call helper function for SSPI data and actual length.
// Since we don't have SSPI data from the server, send null for the
// byte[] buffer and 0 for the int length.
Debug.Assert(SniContext.Snix_Login == _physicalStateObj.SniContext, String.Format((IFormatProvider)null, "Unexpected SniContext. Expecting Snix_Login, actual value is '{0}'", _physicalStateObj.SniContext));
_physicalStateObj.SniContext = SniContext.Snix_LoginSspi;
SSPIData(null, 0, outSSPIBuff, ref outSSPILength);
if (outSSPILength > Int32.MaxValue)
{
throw SQL.InvalidSSPIPacketSize(); // SqlBu 332503
}
_physicalStateObj.SniContext = SniContext.Snix_Login;
checked
{
length += (Int32)outSSPILength;
}
}
}
int feOffset = length;
if (useFeatureExt)
{
if ((requestedFeatures & TdsEnums.FeatureExtension.SessionRecovery) != 0)
{
length += WriteSessionRecoveryFeatureRequest(recoverySessionData, false);
};
length++; // for terminator
}
try
{
WriteInt(length, _physicalStateObj);
if (recoverySessionData == null)
{
WriteInt((TdsEnums.DENALI_MAJOR << 24) | (TdsEnums.DENALI_INCREMENT << 16) | TdsEnums.DENALI_MINOR, _physicalStateObj);
}
else
{
WriteUnsignedInt(recoverySessionData._tdsVersion, _physicalStateObj);
}
WriteInt(rec.packetSize, _physicalStateObj);
WriteInt(TdsEnums.CLIENT_PROG_VER, _physicalStateObj);
WriteInt(TdsParserStaticMethods.GetCurrentProcessIdForTdsLoginOnly(), _physicalStateObj);
WriteInt(0, _physicalStateObj); // connectionID is unused
// Log7Flags (DWORD)
int log7Flags = 0;
/*
Current snapshot from TDS spec with the offsets added:
0) fByteOrder:1, // byte order of numeric data types on client
1) fCharSet:1, // character set on client
2) fFloat:2, // Type of floating point on client
4) fDumpLoad:1, // Dump/Load and BCP enable
5) fUseDb:1, // USE notification
6) fDatabase:1, // Initial database fatal flag
7) fSetLang:1, // SET LANGUAGE notification
8) fLanguage:1, // Initial language fatal flag
9) fODBC:1, // Set if client is ODBC driver
10) fTranBoundary:1, // Transaction boundary notification
11) fDelegatedSec:1, // Security with delegation is available
12) fUserType:3, // Type of user
15) fIntegratedSecurity:1, // Set if client is using integrated security
16) fSQLType:4, // Type of SQL sent from client
20) fOLEDB:1, // Set if client is OLEDB driver
21) fSpare1:3, // first bit used for read-only intent, rest unused
24) fResetPassword:1, // set if client wants to reset password
25) fNoNBCAndSparse:1, // set if client does not support NBC and Sparse column
26) fUserInstance:1, // This connection wants to connect to a SQL "user instance"
27) fUnknownCollationHandling:1, // This connection can handle unknown collation correctly.
28) fExtension:1 // Extensions are used
32 - total
*/
// first byte
log7Flags |= TdsEnums.USE_DB_ON << 5;
log7Flags |= TdsEnums.INIT_DB_FATAL << 6;
log7Flags |= TdsEnums.SET_LANG_ON << 7;
// second byte
log7Flags |= TdsEnums.INIT_LANG_FATAL << 8;
log7Flags |= TdsEnums.ODBC_ON << 9;
if (rec.useReplication)
{
log7Flags |= TdsEnums.REPL_ON << 12;
}
if (rec.useSSPI)
{
log7Flags |= TdsEnums.SSPI_ON << 15;
}
// third byte
if (rec.readOnlyIntent)
{
log7Flags |= TdsEnums.READONLY_INTENT_ON << 21; // read-only intent flag is a first bit of fSpare1
}
// 4th one
if (rec.userInstance)
{
log7Flags |= 1 << 26;
}
if (useFeatureExt)
{
log7Flags |= 1 << 28;
}
WriteInt(log7Flags, _physicalStateObj);
WriteInt(0, _physicalStateObj); // ClientTimeZone is not used
WriteInt(0, _physicalStateObj); // LCID is unused by server
// Start writing offset and length of variable length portions
int offset = TdsEnums.YUKON_LOG_REC_FIXED_LEN;
// write offset/length pairs
// note that you must always set ibHostName since it indicaters the beginning of the variable length section of the login record
WriteShort(offset, _physicalStateObj); // host name offset
WriteShort(rec.hostName.Length, _physicalStateObj);
offset += rec.hostName.Length * 2;
// Only send user/password over if not fSSPI... If both user/password and SSPI are in login
// rec, only SSPI is used. Confirmed same bahavior as in luxor.
if (rec.useSSPI == false)
{
WriteShort(offset, _physicalStateObj); // userName offset
WriteShort(userName.Length, _physicalStateObj);
offset += userName.Length * 2;
// the encrypted password is a byte array - so length computations different than strings
WriteShort(offset, _physicalStateObj); // password offset
WriteShort(encryptedPasswordLengthInBytes / 2, _physicalStateObj);
offset += encryptedPasswordLengthInBytes;
}
else
{
// case where user/password data is not used, send over zeros
WriteShort(0, _physicalStateObj); // userName offset
WriteShort(0, _physicalStateObj);
WriteShort(0, _physicalStateObj); // password offset
WriteShort(0, _physicalStateObj);
}
WriteShort(offset, _physicalStateObj); // app name offset
WriteShort(rec.applicationName.Length, _physicalStateObj);
offset += rec.applicationName.Length * 2;
WriteShort(offset, _physicalStateObj); // server name offset
WriteShort(rec.serverName.Length, _physicalStateObj);
offset += rec.serverName.Length * 2;
WriteShort(offset, _physicalStateObj);
if (useFeatureExt)
{
WriteShort(4, _physicalStateObj); // length of ibFeatgureExtLong (which is a DWORD)
offset += 4;
}
else
{
WriteShort(0, _physicalStateObj); // ununsed (was remote password ?)
}
WriteShort(offset, _physicalStateObj); // client interface name offset
WriteShort(clientInterfaceName.Length, _physicalStateObj);
offset += clientInterfaceName.Length * 2;
WriteShort(offset, _physicalStateObj); // language name offset
WriteShort(rec.language.Length, _physicalStateObj);
offset += rec.language.Length * 2;
WriteShort(offset, _physicalStateObj); // database name offset
WriteShort(rec.database.Length, _physicalStateObj);
offset += rec.database.Length * 2;
if (null == s_nicAddress)
s_nicAddress = TdsParserStaticMethods.GetNetworkPhysicalAddressForTdsLoginOnly();
_physicalStateObj.WriteByteArray(s_nicAddress, s_nicAddress.Length, 0);
WriteShort(offset, _physicalStateObj); // ibSSPI offset
if (rec.useSSPI)
{
WriteShort((int)outSSPILength, _physicalStateObj);
offset += (int)outSSPILength;
}
else
{
WriteShort(0, _physicalStateObj);
}
WriteShort(offset, _physicalStateObj); // DB filename offset
WriteShort(rec.attachDBFilename.Length, _physicalStateObj);
offset += rec.attachDBFilename.Length * 2;
WriteShort(offset, _physicalStateObj); // reset password offset
WriteShort(0, _physicalStateObj);
WriteInt(0, _physicalStateObj); // reserved for chSSPI
// write variable length portion
WriteString(rec.hostName, _physicalStateObj);
// if we are using SSPI, do not send over username/password, since we will use SSPI instead
// same behavior as Luxor
if (!rec.useSSPI)
{
WriteString(userName, _physicalStateObj);
{
_physicalStateObj.WriteByteArray(encryptedPassword, encryptedPasswordLengthInBytes, 0);
}
}
WriteString(rec.applicationName, _physicalStateObj);
WriteString(rec.serverName, _physicalStateObj);
// write ibFeatureExtLong
if (useFeatureExt)
{
WriteInt(feOffset, _physicalStateObj);
}
WriteString(clientInterfaceName, _physicalStateObj);
WriteString(rec.language, _physicalStateObj);
WriteString(rec.database, _physicalStateObj);
// send over SSPI data if we are using SSPI
if (rec.useSSPI)
_physicalStateObj.WriteByteArray(outSSPIBuff, (int)outSSPILength, 0);
WriteString(rec.attachDBFilename, _physicalStateObj);
if (useFeatureExt)
{
if ((requestedFeatures & TdsEnums.FeatureExtension.SessionRecovery) != 0)
{
length += WriteSessionRecoveryFeatureRequest(recoverySessionData, true);
};
_physicalStateObj.WriteByte(0xFF); // terminator
}
}
catch (Exception e)
{
if (ADP.IsCatchableExceptionType(e))
{
// be sure to wipe out our buffer if we started sending stuff
_physicalStateObj._outputPacketNumber = 1; // end of message - reset to 1 - per ramas
_physicalStateObj.ResetBuffer();
}
throw;
}
_physicalStateObj.WritePacket(TdsEnums.HARDFLUSH);
_physicalStateObj._pendingData = true;
_physicalStateObj._messageStatus = 0;
}// tdsLogin
internal int WriteSessionRecoveryFeatureRequest(SessionData reconnectData, bool write /* if false just calculates the length */)
{
int len = 1;
if (write)
{
_physicalStateObj.WriteByte(TdsEnums.FEATUREEXT_SRECOVERY);
}
if (reconnectData == null)
{
if (write)
{
WriteInt(0, _physicalStateObj);
}
len += 4;
}
else
{
Debug.Assert(reconnectData._unrecoverableStatesCount == 0, "Unrecoverable state count should be 0");
int initialLength = 0; // sizeof(DWORD) - length itself
initialLength += 1 + 2 * TdsParserStaticMethods.NullAwareStringLength(reconnectData._initialDatabase);
initialLength += 1 + 2 * TdsParserStaticMethods.NullAwareStringLength(reconnectData._initialLanguage);
initialLength += (reconnectData._initialCollation == null) ? 1 : 6;
for (int i = 0; i < SessionData._maxNumberOfSessionStates; i++)
{
if (reconnectData._initialState[i] != null)
{
initialLength += 1 /* StateId*/ + StateValueLength(reconnectData._initialState[i].Length);
}
}
int currentLength = 0; // sizeof(DWORD) - length itself
currentLength += 1 + 2 * (reconnectData._initialDatabase == reconnectData._database ? 0 : TdsParserStaticMethods.NullAwareStringLength(reconnectData._database));
currentLength += 1 + 2 * (reconnectData._initialLanguage == reconnectData._language ? 0 : TdsParserStaticMethods.NullAwareStringLength(reconnectData._language));
currentLength += (reconnectData._collation != null && !SqlCollation.AreSame(reconnectData._collation, reconnectData._initialCollation)) ? 6 : 1;
bool[] writeState = new bool[SessionData._maxNumberOfSessionStates];
for (int i = 0; i < SessionData._maxNumberOfSessionStates; i++)
{
if (reconnectData._delta[i] != null)
{
Debug.Assert(reconnectData._delta[i]._recoverable, "State should be recoverable");
writeState[i] = true;
if (reconnectData._initialState[i] != null && reconnectData._initialState[i].Length == reconnectData._delta[i]._dataLength)
{
writeState[i] = false;
for (int j = 0; j < reconnectData._delta[i]._dataLength; j++)
{
if (reconnectData._initialState[i][j] != reconnectData._delta[i]._data[j])
{
writeState[i] = true;
break;
}
}
}
if (writeState[i])
{
currentLength += 1 /* StateId*/ + StateValueLength(reconnectData._delta[i]._dataLength);
}
}
}
if (write)
{
WriteInt(8 + initialLength + currentLength, _physicalStateObj); // length of data w/o total length (initil+current+2*sizeof(DWORD))
WriteInt(initialLength, _physicalStateObj);
WriteIdentifier(reconnectData._initialDatabase, _physicalStateObj);
WriteCollation(reconnectData._initialCollation, _physicalStateObj);
WriteIdentifier(reconnectData._initialLanguage, _physicalStateObj);
for (int i = 0; i < SessionData._maxNumberOfSessionStates; i++)
{
if (reconnectData._initialState[i] != null)
{
_physicalStateObj.WriteByte((byte)i);
if (reconnectData._initialState[i].Length < 0xFF)
{
_physicalStateObj.WriteByte((byte)reconnectData._initialState[i].Length);
}
else
{
_physicalStateObj.WriteByte(0xFF);
WriteInt(reconnectData._initialState[i].Length, _physicalStateObj);
}
_physicalStateObj.WriteByteArray(reconnectData._initialState[i], reconnectData._initialState[i].Length, 0);
}
}
WriteInt(currentLength, _physicalStateObj);
WriteIdentifier(reconnectData._database != reconnectData._initialDatabase ? reconnectData._database : null, _physicalStateObj);
WriteCollation(SqlCollation.AreSame(reconnectData._initialCollation, reconnectData._collation) ? null : reconnectData._collation, _physicalStateObj);
WriteIdentifier(reconnectData._language != reconnectData._initialLanguage ? reconnectData._language : null, _physicalStateObj);
for (int i = 0; i < SessionData._maxNumberOfSessionStates; i++)
{
if (writeState[i])
{
_physicalStateObj.WriteByte((byte)i);
if (reconnectData._delta[i]._dataLength < 0xFF)
{
_physicalStateObj.WriteByte((byte)reconnectData._delta[i]._dataLength);
}
else
{
_physicalStateObj.WriteByte(0xFF);
WriteInt(reconnectData._delta[i]._dataLength, _physicalStateObj);
}
_physicalStateObj.WriteByteArray(reconnectData._delta[i]._data, reconnectData._delta[i]._dataLength, 0);
}
}
}
len += initialLength + currentLength + 12 /* length fields (initial, current, total) */;
}
return len;
}
private bool TryProcessSessionState(TdsParserStateObject stateObj, int length, SessionData sdata)
{
if (length < 5)
{
throw SQL.ParsingError();
}
UInt32 seqNum;
if (!stateObj.TryReadUInt32(out seqNum))
{
return false;
}
if (seqNum == UInt32.MaxValue)
{
_connHandler.DoNotPoolThisConnection();
}
byte status;
if (!stateObj.TryReadByte(out status))
{
return false;
}
if (status > 1)
{
throw SQL.ParsingError();
}
bool recoverable = status != 0;
length -= 5;
while (length > 0)
{
byte stateId;
if (!stateObj.TryReadByte(out stateId))
{
return false;
}
int stateLen;
byte stateLenByte;
if (!stateObj.TryReadByte(out stateLenByte))
{
return false;
}
if (stateLenByte < 0xFF)
{
stateLen = stateLenByte;
}
else
{
if (!stateObj.TryReadInt32(out stateLen))
{
return false;
}
}
byte[] buffer = null;
lock (sdata._delta)
{
if (sdata._delta[stateId] == null)
{
buffer = new byte[stateLen];
sdata._delta[stateId] = new SessionStateRecord { _version = seqNum, _dataLength = stateLen, _data = buffer, _recoverable = recoverable };
sdata._deltaDirty = true;
if (!recoverable)
{
checked { sdata._unrecoverableStatesCount++; }
}
}
else
{
if (sdata._delta[stateId]._version <= seqNum)
{
SessionStateRecord sv = sdata._delta[stateId];
sv._version = seqNum;
sv._dataLength = stateLen;
if (sv._recoverable != recoverable)
{
if (recoverable)
{
Debug.Assert(sdata._unrecoverableStatesCount > 0, "Unrecoverable states count >0");
sdata._unrecoverableStatesCount--;
}
else
{
checked { sdata._unrecoverableStatesCount++; }
}
sv._recoverable = recoverable;
}
buffer = sv._data;
if (buffer.Length < stateLen)
{
buffer = new byte[stateLen];
sv._data = buffer;
}
}
}
}
if (buffer != null)
{
if (!stateObj.TryReadByteArray(buffer, 0, stateLen))
{
return false;
}
}
else
{
if (!stateObj.TrySkipBytes(stateLen))
return false;
}
if (stateLenByte < 0xFF)
{
length -= 2 + stateLen;
}
else
{
length -= 6 + stateLen;
}
}
sdata.AssertUnrecoverableStateCountIsCorrect();
return true;
}
// although the new password is generally not used it must be passed to the c'tor
// the new Login7 packet will always write out the new password (or a length of zero and no bytes if not present)
//
internal SqlInternalConnectionTds(
DbConnectionPoolIdentity identity,
SqlConnectionString connectionOptions,
SqlCredential credential,
object providerInfo,
string newPassword,
SecureString newSecurePassword,
bool redirectedUserInstance,
SqlConnectionString userConnectionOptions = null, // NOTE: userConnectionOptions may be different to connectionOptions if the connection string has been expanded (see SqlConnectionString.Expand)
SessionData reconnectSessionData = null,
DbConnectionPool pool = null,
string accessToken = null,
bool applyTransientFaultHandling = false
) : base(connectionOptions) {
#if DEBUG
if (reconnectSessionData != null) {
reconnectSessionData._debugReconnectDataApplied = true;
}
try { // use this to help validate this object is only created after the following permission has been previously demanded in the current codepath
if (userConnectionOptions != null) {
// As mentioned above, userConnectionOptions may be different to connectionOptions, so we need to demand on the correct connection string
userConnectionOptions.DemandPermission();
}
else {
connectionOptions.DemandPermission();
}
}
catch(System.Security.SecurityException) {
System.Diagnostics.Debug.Assert(false, "unexpected SecurityException for current codepath");
throw;
}
#endif
Debug.Assert(reconnectSessionData == null || connectionOptions.ConnectRetryCount > 0, "Reconnect data supplied with CR turned off");
_dbConnectionPool = pool;
if (connectionOptions.ConnectRetryCount > 0) {
_recoverySessionData = reconnectSessionData;
if (reconnectSessionData == null) {
_currentSessionData = new SessionData();
}
else {
_currentSessionData = new SessionData(_recoverySessionData);
_originalDatabase = _recoverySessionData._initialDatabase;
_originalLanguage = _recoverySessionData._initialLanguage;
}
}
if (connectionOptions.UserInstance && InOutOfProcHelper.InProc) {
throw SQL.UserInstanceNotAvailableInProc();
}
if (accessToken != null) {
_accessTokenInBytes = System.Text.Encoding.Unicode.GetBytes(accessToken);
}
_identity = identity;
Debug.Assert(newSecurePassword != null || newPassword != null, "cannot have both new secure change password and string based change password to be null");
Debug.Assert(credential == null || (String.IsNullOrEmpty(connectionOptions.UserID) && String.IsNullOrEmpty(connectionOptions.Password)), "cannot mix the new secure password system and the connection string based password");
Debug.Assert(credential == null || !connectionOptions.IntegratedSecurity, "Cannot use SqlCredential and Integrated Security");
Debug.Assert(credential == null || !connectionOptions.ContextConnection, "Cannot use SqlCredential with context connection");
_poolGroupProviderInfo = (SqlConnectionPoolGroupProviderInfo)providerInfo;
_fResetConnection = connectionOptions.ConnectionReset;
if (_fResetConnection && _recoverySessionData == null) {
_originalDatabase = connectionOptions.InitialCatalog;
_originalLanguage = connectionOptions.CurrentLanguage;
}
timeoutErrorInternal = new SqlConnectionTimeoutErrorInternal();
_credential = credential;
_parserLock.Wait(canReleaseFromAnyThread:false);
ThreadHasParserLockForClose = true; // In case of error, let ourselves know that we already own the parser lock
RuntimeHelpers.PrepareConstrainedRegions();
try {
#if DEBUG
TdsParser.ReliabilitySection tdsReliabilitySection = new TdsParser.ReliabilitySection();
RuntimeHelpers.PrepareConstrainedRegions();
try {
tdsReliabilitySection.Start();
#else
{
#endif //DEBUG
_timeout = TimeoutTimer.StartSecondsTimeout(connectionOptions.ConnectTimeout);
// If transient fault handling is enabled then we can retry the login upto the ConnectRetryCount.
int connectionEstablishCount = applyTransientFaultHandling ? connectionOptions.ConnectRetryCount + 1 : 1;
int transientRetryIntervalInMilliSeconds = connectionOptions.ConnectRetryInterval * 1000; // Max value of transientRetryInterval is 60*1000 ms. The max value allowed for ConnectRetryInterval is 60
for (int i = 0; i < connectionEstablishCount; i++)
{
try
{
OpenLoginEnlist(_timeout, connectionOptions, credential, newPassword, newSecurePassword, redirectedUserInstance);
break;
}
catch (SqlException sqlex)
{
if (i + 1 == connectionEstablishCount
|| !applyTransientFaultHandling
|| _timeout.IsExpired
|| _timeout.MillisecondsRemaining < transientRetryIntervalInMilliSeconds
|| !IsTransientError(sqlex))
{
throw sqlex;
}
else
{
Thread.Sleep(transientRetryIntervalInMilliSeconds);
}
}
}
}
#if DEBUG
finally {
tdsReliabilitySection.Stop();
}
#endif //DEBUG
}
catch (System.OutOfMemoryException) {
DoomThisConnection();
throw;
}
catch (System.StackOverflowException) {
DoomThisConnection();
throw;
}
catch (System.Threading.ThreadAbortException) {
DoomThisConnection();
throw;
}
finally {
ThreadHasParserLockForClose = false;
_parserLock.Release();
}
if (Bid.AdvancedOn) {
Bid.Trace("<sc.SqlInternalConnectionTds.ctor|ADV> %d#, constructed new TDS internal connection\n", ObjectID);
}
}
////////////////////////////////////////////////////////////////////////////////////////
// LOGIN-RELATED METHODS
////////////////////////////////////////////////////////////////////////////////////////
private void CompleteLogin(bool enlistOK) {
_parser.Run(RunBehavior.UntilDone, null, null, null, _parser._physicalStateObj);
if (_routingInfo == null) { // ROR should not affect state of connection recovery
if (_federatedAuthenticationRequested && !_federatedAuthenticationAcknowledged) {
Bid.Trace("<sc.SqlInternalConnectionTds.CompleteLogin|ERR> %d#, Server did not acknowledge the federated authentication request\n", ObjectID);
throw SQL.ParsingError(ParsingErrorState.FedAuthNotAcknowledged);
}
if (_federatedAuthenticationInfoRequested && !_federatedAuthenticationInfoReceived) {
Bid.Trace("<sc.SqlInternalConnectionTds.CompleteLogin|ERR> %d#, Server never sent the requested federated authentication info\n", ObjectID);
throw SQL.ParsingError(ParsingErrorState.FedAuthInfoNotReceived);
}
if (!_sessionRecoveryAcknowledged) {
_currentSessionData = null;
if (_recoverySessionData != null) {
throw SQL.CR_NoCRAckAtReconnection(this);
}
}
if (_currentSessionData != null && _recoverySessionData==null) {
_currentSessionData._initialDatabase = CurrentDatabase;
_currentSessionData._initialCollation = _currentSessionData._collation;
_currentSessionData._initialLanguage = _currentLanguage;
}
bool isEncrypted = _parser.EncryptionOptions == EncryptionOptions.ON;
if (_recoverySessionData != null) {
if (_recoverySessionData._encrypted != isEncrypted) {
throw SQL.CR_EncryptionChanged(this);
}
}
if (_currentSessionData != null) {
_currentSessionData._encrypted = isEncrypted;
}
_recoverySessionData = null;
}
Debug.Assert(SniContext.Snix_Login == Parser._physicalStateObj.SniContext, String.Format((IFormatProvider)null, "SniContext should be Snix_Login; actual Value: {0}", Parser._physicalStateObj.SniContext));
_parser._physicalStateObj.SniContext = SniContext.Snix_EnableMars;
_parser.EnableMars();
_fConnectionOpen = true; // mark connection as open
if (Bid.AdvancedOn) {
Bid.Trace("<sc.SqlInternalConnectionTds.CompleteLogin|ADV> Post-Login Phase: Server connection obtained.\n");
}
// for non-pooled connections, enlist in a distributed transaction
// if present - and user specified to enlist
if(enlistOK && ConnectionOptions.Enlist) {
_parser._physicalStateObj.SniContext = SniContext.Snix_AutoEnlist;
SysTx.Transaction tx = ADP.GetCurrentTransaction();
Enlist(tx);
}
_parser._physicalStateObj.SniContext=SniContext.Snix_Login;
}
//DataPassing x = new DataPassing();
private void button1_Click(object sender, EventArgs e)
{
changeloadingtotrue();
String Error = " "; ;
if (IsValidEmail(EmailTB.Text) != true)
{
Error += "Please Enter correct Email!!\n ";
}
if (EmailTB.Text == "")
{
Error += "Please Enter Email Address !!\n";
}
if (PasswordTB.Text == "")
{
Error += " Please Enter Password !!";
}
if (Error != " ")
{
changeloadingtotrue();
MessageBox.Show(Error);
LoadingLabel.Visible = false;
}
else
{
changeloadingtotrue();
//LoadingLabel.Visible = true;
SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["AzureString"].ConnectionString);
SqlCommand cmd = new SqlCommand("Select * from College where Email=@username and Password=@password", con);
cmd.Parameters.AddWithValue("@username", EmailTB.Text);
cmd.Parameters.AddWithValue("@password", PasswordTB.Text);
try
{
con.Open();
SqlDataAdapter adapt = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
adapt.Fill(ds);
con.Close();
int count = ds.Tables[0].Rows.Count;
//If count is equal to 1, than show frmMain form
MessageBox.Show(count.ToString());
if (count == 1)
{
MessageBox.Show("Login Successful!");
SqlCommand cmd1 = new SqlCommand("Select * from Senpai_Organization where Email=@username", con);
cmd1.Parameters.AddWithValue("@username", EmailTB.Text);
con.Open();
SqlDataAdapter adapt1 = new SqlDataAdapter(cmd1);
DataSet ds1 = new DataSet();
adapt1.Fill(ds1);
count = ds1.Tables[0].Columns.Count;
MessageBox.Show(ds1.Tables[0].Rows[0]["Email"].ToString() + count);
SessionData sv = new SessionData();
sv.SenpaiId = ds1.Tables[0].Rows[0]["College_Id"].ToString(); ;
sv.Email = ds1.Tables[0].Rows[0]["Email"].ToString();
sv.Name = ds1.Tables[0].Rows[0]["InstituteName"].ToString();
sv.PhoneNumber = ds1.Tables[0].Rows[0]["PhoneNumber"].ToString();
sv.HeadPersonName = ds1.Tables[0].Rows[0]["HeadPersonName"].ToString();
sv.City = ds1.Tables[0].Rows[0]["City"].ToString();
sv.AboutUs = ds1.Tables[0].Rows[0]["AboutUs"].ToString();
sv.StaffroomListId = ds1.Tables[0].Rows[0]["StaffRoomListTable"].ToString();
DashBoard d = new DashBoard(sv);
d.Show();
this.Visible = false;
MessageBox.Show("Name = "+sv.Name);
}
else
{
MessageBox.Show("Login Failed.");
LoadingLabel.Visible = false;
}
}
catch
{
MessageBox.Show("We are experiencing some technical difficulty. Kindly try again after some time.");
}
}
}
////////////////////////////////////////////////////////////////////////////////////////
// DISTRIBUTED TRANSACTION METHODS
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
// LOGIN-RELATED METHODS
////////////////////////////////////////////////////////////////////////////////////////
private void CompleteLogin(bool enlistOK)
{
_parser.Run(RunBehavior.UntilDone, null, null, null, _parser._physicalStateObj);
if (_routingInfo == null)
{ // ROR should not affect state of connection recovery
if (!_sessionRecoveryAcknowledged)
{
_currentSessionData = null;
if (_recoverySessionData != null)
{
throw SQL.CR_NoCRAckAtReconnection(this);
}
}
if (_currentSessionData != null && _recoverySessionData == null)
{
_currentSessionData._initialDatabase = CurrentDatabase;
_currentSessionData._initialCollation = _currentSessionData._collation;
_currentSessionData._initialLanguage = _currentLanguage;
}
bool isEncrypted = _parser.EncryptionOptions == EncryptionOptions.ON;
if (_recoverySessionData != null)
{
if (_recoverySessionData._encrypted != isEncrypted)
{
throw SQL.CR_EncryptionChanged(this);
}
}
if (_currentSessionData != null)
{
_currentSessionData._encrypted = isEncrypted;
}
_recoverySessionData = null;
}
Debug.Assert(SniContext.Snix_Login == Parser._physicalStateObj.SniContext, String.Format((IFormatProvider)null, "SniContext should be Snix_Login; actual Value: {0}", Parser._physicalStateObj.SniContext));
_parser._physicalStateObj.SniContext = SniContext.Snix_EnableMars;
_parser.EnableMars();
_fConnectionOpen = true; // mark connection as open
_parser._physicalStateObj.SniContext = SniContext.Snix_Login;
}
// although the new password is generally not used it must be passed to the c'tor
// the new Login7 packet will always write out the new password (or a length of zero and no bytes if not present)
//
internal SqlInternalConnectionTds(
DbConnectionPoolIdentity identity,
SqlConnectionString connectionOptions,
object providerInfo,
bool redirectedUserInstance,
SqlConnectionString userConnectionOptions = null, // NOTE: userConnectionOptions may be different to connectionOptions if the connection string has been expanded (see SqlConnectionString.Expand)
SessionData reconnectSessionData = null,
bool applyTransientFaultHandling = false) : base(connectionOptions)
{
#if DEBUG
if (reconnectSessionData != null)
{
reconnectSessionData._debugReconnectDataApplied = true;
}
#endif
Debug.Assert(reconnectSessionData == null || connectionOptions.ConnectRetryCount > 0, "Reconnect data supplied with CR turned off");
if (connectionOptions.ConnectRetryCount > 0)
{
_recoverySessionData = reconnectSessionData;
if (reconnectSessionData == null)
{
_currentSessionData = new SessionData();
}
else
{
_currentSessionData = new SessionData(_recoverySessionData);
_originalDatabase = _recoverySessionData._initialDatabase;
_originalLanguage = _recoverySessionData._initialLanguage;
}
}
_identity = identity;
_poolGroupProviderInfo = (SqlConnectionPoolGroupProviderInfo)providerInfo;
_fResetConnection = connectionOptions.ConnectionReset;
if (_fResetConnection && _recoverySessionData == null)
{
_originalDatabase = connectionOptions.InitialCatalog;
_originalLanguage = connectionOptions.CurrentLanguage;
}
_timeoutErrorInternal = new SqlConnectionTimeoutErrorInternal();
_parserLock.Wait(canReleaseFromAnyThread: false);
ThreadHasParserLockForClose = true; // In case of error, let ourselves know that we already own the parser lock
try
{
var timeout = TimeoutTimer.StartSecondsTimeout(connectionOptions.ConnectTimeout);
// If transient fault handling is enabled then we can retry the login upto the ConnectRetryCount.
int connectionEstablishCount = applyTransientFaultHandling ? connectionOptions.ConnectRetryCount + 1 : 1;
int transientRetryIntervalInMilliSeconds = connectionOptions.ConnectRetryInterval * 1000; // Max value of transientRetryInterval is 60*1000 ms. The max value allowed for ConnectRetryInterval is 60
for (int i = 0; i < connectionEstablishCount; i++)
{
try
{
OpenLoginEnlist(timeout, connectionOptions, redirectedUserInstance);
break;
}
catch (SqlException sqlex)
{
if (i + 1 == connectionEstablishCount
|| !applyTransientFaultHandling
|| timeout.IsExpired
|| timeout.MillisecondsRemaining < transientRetryIntervalInMilliSeconds
|| !IsTransientError(sqlex))
{
throw sqlex;
}
else
{
Thread.Sleep(transientRetryIntervalInMilliSeconds);
}
}
}
}
finally
{
ThreadHasParserLockForClose = false;
_parserLock.Release();
}
}
// although the new password is generally not used it must be passed to the c'tor
// the new Login7 packet will always write out the new password (or a length of zero and no bytes if not present)
//
internal SqlInternalConnectionTds(
DbConnectionPoolIdentity identity,
SqlConnectionString connectionOptions,
object providerInfo,
bool redirectedUserInstance,
SqlConnectionString userConnectionOptions = null, // NOTE: userConnectionOptions may be different to connectionOptions if the connection string has been expanded (see SqlConnectionString.Expand)
SessionData reconnectSessionData = null) : base(connectionOptions)
{
#if DEBUG
if (reconnectSessionData != null)
{
reconnectSessionData._debugReconnectDataApplied = true;
}
#endif
Debug.Assert(reconnectSessionData == null || connectionOptions.ConnectRetryCount > 0, "Reconnect data supplied with CR turned off");
if (connectionOptions.ConnectRetryCount > 0)
{
_recoverySessionData = reconnectSessionData;
if (reconnectSessionData == null)
{
_currentSessionData = new SessionData();
}
else
{
_currentSessionData = new SessionData(_recoverySessionData);
_originalDatabase = _recoverySessionData._initialDatabase;
_originalLanguage = _recoverySessionData._initialLanguage;
}
}
_identity = identity;
_poolGroupProviderInfo = (SqlConnectionPoolGroupProviderInfo)providerInfo;
_fResetConnection = connectionOptions.ConnectionReset;
if (_fResetConnection && _recoverySessionData == null)
{
_originalDatabase = connectionOptions.InitialCatalog;
_originalLanguage = connectionOptions.CurrentLanguage;
}
_timeoutErrorInternal = new SqlConnectionTimeoutErrorInternal();
_parserLock.Wait(canReleaseFromAnyThread: false);
ThreadHasParserLockForClose = true; // In case of error, let ourselves know that we already own the parser lock
try
{
var timeout = TimeoutTimer.StartSecondsTimeout(connectionOptions.ConnectTimeout);
OpenLoginEnlist(timeout, connectionOptions, redirectedUserInstance);
}
finally
{
ThreadHasParserLockForClose = false;
_parserLock.Release();
}
}
