internal OracleInternalConnection(OracleConnectionString connectionOptions)
{
this._connectionOptions = connectionOptions;
string userId = connectionOptions.UserId;
string password = connectionOptions.Password;
string dataSource = connectionOptions.DataSource;
bool integratedSecurity = connectionOptions.IntegratedSecurity;
bool unicode = connectionOptions.Unicode;
bool omitOracleConnectionName = this._connectionOptions.OmitOracleConnectionName;
this._connectionIsOpen = this.OpenOnLocalTransaction(userId, password, dataSource, integratedSecurity, unicode, omitOracleConnectionName);
if (this.UnicodeEnabled)
{
this._encodingDatabase = Encoding.Unicode;
}
else if (this.ServerVersionAtLeastOracle8i)
{
this._encodingDatabase = new OracleEncoding(this);
}
else
{
this._encodingDatabase = Encoding.Default;
}
this._encodingNational = Encoding.Unicode;
if (connectionOptions.Enlist && !connectionOptions.Pooling)
{
System.Transactions.Transaction currentTransaction = System.Data.Common.ADP.GetCurrentTransaction();
if (null != currentTransaction)
{
this.Enlist(userId, password, dataSource, currentTransaction, false);
}
}
}
internal OracleInternalConnection(OracleConnectionString connectionOptions)
{
this._connectionOptions = connectionOptions;
string userId = connectionOptions.UserId;
string password = connectionOptions.Password;
string dataSource = connectionOptions.DataSource;
bool integratedSecurity = connectionOptions.IntegratedSecurity;
bool unicode = connectionOptions.Unicode;
bool omitOracleConnectionName = this._connectionOptions.OmitOracleConnectionName;
this._connectionIsOpen = this.OpenOnLocalTransaction(userId, password, dataSource, integratedSecurity, unicode, omitOracleConnectionName);
if (this.UnicodeEnabled)
{
this._encodingDatabase = Encoding.Unicode;
}
else if (this.ServerVersionAtLeastOracle8i)
{
this._encodingDatabase = new OracleEncoding(this);
}
else
{
this._encodingDatabase = Encoding.Default;
}
this._encodingNational = Encoding.Unicode;
if (connectionOptions.Enlist && !connectionOptions.Pooling)
{
System.Transactions.Transaction currentTransaction = System.Data.Common.ADP.GetCurrentTransaction();
if (null != currentTransaction)
{
this.Enlist(userId, password, dataSource, currentTransaction, false);
}
}
}
internal static OracleInternalConnection GetPooledConnection(
string encryptedConnectionString,
OracleConnectionString options,
OracleConnection owningObject,
out bool isInTransaction)
{
// If Init() has not been called, call it and set up the cached members
if (null == _manager)
{
Init();
}
DBObjectPool pool = null;
string userId = null;
string poolKey;
if (true == options.IntegratedSecurity)
{
// If using integrated security, find the pool based on the connection string
// postpended with the windows identity userId. Otherwise, simply use the
// connection string. This will guarantee anyone using integrated security will
// always be sent to the appropriate pool.
// If this throws, Open will abort. Is there an issue here? UNDONE BUGBUG
// Will this fail on some platforms?
userId = DBObjectPool.GetCurrentIdentityName();
Debug.Assert(userId != null && userId != "", "OracleConnectionPoolManager: WindowsIdentity.Name returned empty string!");
poolKey = userId + encryptedConnectionString;
}
else
{
poolKey = encryptedConnectionString;
}
pool = _manager.FindPool(poolKey);
if (null == pool)
{
// If we didn't locate a pool, we need to create one.
OracleConnectionPoolControl poolControl;
poolControl = new OracleConnectionPoolControl(poolKey, options);
poolControl.UserId = userId;
pool = _manager.FindOrCreatePool(poolControl);
}
OracleInternalConnection con = (OracleInternalConnection)pool.GetObject(owningObject, out isInTransaction);
// If GetObject() failed, the pool timeout occurred.
if (con == null)
{
throw ADP.PooledOpenTimeout();
}
return(con);
}
public override void EnlistTransaction(System.Transactions.Transaction transaction)
{
OracleConnectionString str = this._connectionOptions;
this.RollbackDeadTransaction();
this.Enlist(str.UserId, str.Password, str.DataSource, transaction, true);
}
static internal OracleConnectionString ParseString(string connectionString)
{
OracleConnectionString result = null;
if (!ADP.IsEmpty(connectionString))
{
result = (OracleConnectionString)CacheQuery(connectionString, _parsedConnectionStringCache);
if (null == result)
{
#if USECRYPTO
string hashvalue = Crypto.ComputeHash(connectionString);
result = (DBConnectionString.CacheQuery(hashvalue, _parsedConnectionStringCache) as OracleConnectionString);
if (null == result) {
result = new OracleConnectionString(connectionString, null);
#else
result = new OracleConnectionString(connectionString);
#endif
if (result.ShouldCache())
{
#if USECRYPTO
if (!result.IsEncrypted) {
hashvalue = connectionString;
}
CacheAdd(hashvalue, result, ref _parsedConnectionStringCache);
#else
CacheAdd(connectionString, result, ref _parsedConnectionStringCache);
#endif
}
#if USECRYPTO
}
#endif
}
}
return result;
}
/// <include file='doc\OracleConnection.uex' path='docs/doc[@for="OracleConnection.Dispose"]/*' />
override protected void Dispose(bool disposing)
{
_parsedConnectionString = null;
Cleanup(disposing, false);
base.Dispose(disposing);
}
internal OraclePermission(OracleConnectionString connectionOptions)
{
this._keyvaluetree = System.Data.OracleClient.NameValuePermission.Default;
if (connectionOptions != null)
{
this._allowBlankPassword = connectionOptions.HasBlankPassword;
this.AddPermissionEntry(new System.Data.OracleClient.DBConnectionString(connectionOptions));
}
}
internal OraclePermission(OracleConnectionString connectionOptions)
{
this._keyvaluetree = System.Data.OracleClient.NameValuePermission.Default;
if (connectionOptions != null)
{
this._allowBlankPassword = connectionOptions.HasBlankPassword;
this.AddPermissionEntry(new System.Data.OracleClient.DBConnectionString(connectionOptions));
}
}
protected override System.Data.ProviderBase.DbConnectionPoolGroupOptions CreateConnectionPoolGroupOptions(System.Data.Common.DbConnectionOptions connectionOptions)
{
OracleConnectionString str = (OracleConnectionString)connectionOptions;
System.Data.ProviderBase.DbConnectionPoolGroupOptions options = null;
if (str.Pooling)
{
options = new System.Data.ProviderBase.DbConnectionPoolGroupOptions(str.IntegratedSecurity, str.MinPoolSize, str.MaxPoolSize, 0x7530, str.LoadBalanceTimeout, str.Enlist, false);
}
return(options);
}
/// <include file='doc\OracleConnection.uex' path='docs/doc[@for="OracleConnection.Open"]/*' />
public void Open()
{
OracleConnectionString parsedConnectionString = _parsedConnectionString;
OracleConnectionString.Demand(parsedConnectionString);
if (ConnectionState.Closed != _state)
{
throw ADP.ConnectionAlreadyOpen(_state);
}
OpenInternal(parsedConnectionString, null);
OnStateChange(ConnectionState.Closed, ConnectionState.Open);
}
protected override void Activate(System.Transactions.Transaction transaction)
{
bool flag = null != transaction;
OracleConnectionString str = this._connectionOptions;
if (flag && str.Enlist)
{
if (!transaction.Equals(base.EnlistedTransaction))
{
this.Enlist(str.UserId, str.Password, str.DataSource, transaction, false);
}
}
else if (!flag && (this._enlistContext != null))
{
this.UnEnlist();
}
}
private OracleConnectionString(OracleConnectionString value) : base(value, false) { // Clone
_permission = value._permission;
_enlist = value._enlist;
_integratedSecurity = value._integratedSecurity;
_persistSecurityInfo= value._persistSecurityInfo;
_pooling = value._pooling;
_unicode = value._unicode;
_connectionLifeTime = value._connectionLifeTime;
_maxPoolSize = value._maxPoolSize;
_minPoolSize = value._minPoolSize;
_dataSource = value._dataSource;
_userId = value._userId;
_password = value._password;
}
/// <include file='doc\OracleConnection.uex' path='docs/doc[@for="OracleConnection.EnlistDistributedTransaction"]/*' />
public void EnlistDistributedTransaction(ITransaction distributedTransaction) // MDAC 82856
{
OracleConnectionString parsedConnectionString = _parsedConnectionString; // prevent race condition
ConnectionState state = _state;
//(new NamedPermissionSet("FullTrust")).Demand(); // SECURITY: Need this if we ever become semi-trusted.
OraclePermission.Demand();
switch (state)
{
case ConnectionState.Closed:
throw ADP.ClosedConnectionError();
case ConnectionState.Open:
// Since in Oracle-land, the connection flows from the transaction and we don't
// have a way to enlist a connection in a distributed transaction, we simply
// close the existing connection and open a new, transacted, one.
// What this means is that we'll rollback any existing local transaction, so we
// need to make sure that there isn't a local transaction before we close the
// connection. Of course, if the local transaction is dead, we can roll it back
// first.
RollbackDeadTransaction();
if (HasTransaction)
{
throw ADP.TransactionPresent();
}
// Now silently close the current connection, and reopen a new distributed
// connection.
if (null != distributedTransaction)
{
CloseInternal();
OpenInternal(parsedConnectionString, (object)distributedTransaction);
}
break;
default:
Debug.Assert(false, "Invalid Connection State in OracleConnection.EnlistDistributedTransaction)");
break;
}
}
public OracleConnectionPoolControl(String key, OracleConnectionString connectionOptions) : base(key)
{
// CreationTimeout is in milliseconds, Connection Timeout is in seconds
// CreationTimeout = (connectionOptions.ConnectTimeout) * 1000;
MaxPool = connectionOptions.MaxPoolSize;
MinPool = connectionOptions.MinPoolSize;
TransactionAffinity = connectionOptions.Enlist;
_connectionOptions = connectionOptions;
int lifetime = connectionOptions.ConnectionLifeTime;
// Initialize the timespan class for the pool control, if it's not zero.
// If it was zero - that means infinite lifetime.
if (lifetime != 0)
{
_fCheckLifetime = true;
_lifetime = new TimeSpan(0, 0, lifetime);
}
}
static internal PermissionSet CreatePermission(OracleConnectionString constr) {
OraclePermission p = new OraclePermission(constr);
if (null == constr) {
p.Add(ADP.StrEmpty, ADP.StrEmpty, KeyRestrictionBehavior.AllowOnly); // ExecuteOnly permission
}
PermissionSet permission;
NamedPermissionSet fulltrust = new NamedPermissionSet("FullTrust"); // MDAC 83159
fulltrust.Assert();
try {
try {
permission = new PermissionSet(fulltrust);
permission.AddPermission(p);
}
finally {
CodeAccessPermission.RevertAssert();
}
}
catch {
throw;
}
return permission;
}
/// <include file='doc\OraclePermission.uex' path='docs/doc[@for="OraclePermission.AddWithAllow"]/*' />
/// <internalonly />
internal void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
switch (behavior)
{
case KeyRestrictionBehavior.PreventUsage:
case KeyRestrictionBehavior.AllowOnly:
break;
default:
throw ADP.Argument("value");
}
if (null == restrictions)
{
restrictions = ADP.StrEmpty;
}
DBConnectionString entry = new OracleConnectionString(connectionString, restrictions, behavior);
if (!entry.ContainsPersistablePassword())
{
entry = new DBConnectionString(entry, true);
}
AddEntry(entry);
_isUnrestricted = false; // MDAC 84639
}
static internal void Demand(OracleConnectionString parsedConnectionString)
{
PermissionSet permission = ((null != parsedConnectionString) ? parsedConnectionString._permission : OracleConnection.OraclePermission);
permission.Demand();
}
public void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
System.Data.OracleClient.DBConnectionString entry = new System.Data.OracleClient.DBConnectionString(connectionString, restrictions, behavior, OracleConnectionString.GetParseSynonyms(), false);
this.AddPermissionEntry(entry);
}
/// <include file='doc\OracleConnection.uex' path='docs/doc[@for="OracleConnection.Open"]/*' />
private void OpenInternal(OracleConnectionString parsedConnectionString, object transact)
{
bool isInTransaction;
try
{
try
{
if (null == parsedConnectionString)
{
throw ADP.NoConnectionString();
}
_state = ConnectionState.Connecting;
if (false == parsedConnectionString.Pooling || null != transact)
{
_internalConnection = new OracleInternalConnection(parsedConnectionString, transact);
}
else
{
#if ALLOWTRACING
if (ADP._traceObjectPoolActivity)
{
if (ContextUtil.IsInTransaction)
{
Debug.WriteLine("Getting Pooled Connection For TransactionId=" + ContextUtil.TransactionId + " ContextId=" + ContextUtil.ContextId);
}
else
{
Debug.WriteLine("Getting Pooled Connection without Transaction Context");
}
}
#endif //ALLOWTRACING
_internalConnection = OracleConnectionPoolManager.GetPooledConnection(
parsedConnectionString.EncryptedActualConnectionString,
parsedConnectionString,
this,
out isInTransaction
);
#if USEORAMTS
// Note that we'll only have a non-null transact object when we are manually
// enlisted -- automatically enlisted connections take a different path.
_internalConnection.ManualEnlistedTransaction = (ITransaction)transact;
#endif //USEORAMTS
}
_hidePassword = true;
_state = ConnectionState.Open;
_parsedConnectionString = parsedConnectionString;
if (UnicodeEnabled)
{
_encodingDatabase = System.Text.Encoding.Unicode; // for environments initialized in UTF16 mode, we can use straight Unicode
}
else if (ServerVersionAtLeastOracle8i)
{
_encodingDatabase = new OracleEncoding(this); // for Oracle8i or greater we'll use Oracle's conversion routines.
}
else
{
_encodingDatabase = System.Text.Encoding.Default; // anything prior to Oracle8i doesn't work with Oracle's conversion routines.
}
_encodingNational = System.Text.Encoding.Unicode; // we use Unicode for the NCHAR/NVARCHAR/NCLOB and let Oracle perform the conversion automatically.
}
finally
{
if (ConnectionState.Open != _state)
{
Cleanup(true, true);
}
}
}
catch // Prevent exception filters from running in our space
{
throw;
}
}
// (internal) Construct from an existing Connection object (copy constructor)
internal OracleConnection(OracleConnection connection) : this()
{
_state = ConnectionState.Closed;
_hidePassword = connection._hidePassword;
_parsedConnectionString = connection._parsedConnectionString;
}
