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)); } }
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; }