protected DbConnectionOptions(DbConnectionOptions connectionOptions) { this._usersConnectionString = connectionOptions._usersConnectionString; this.HasPasswordKeyword = connectionOptions.HasPasswordKeyword; this.UseOdbcRules = connectionOptions.UseOdbcRules; this._parsetable = connectionOptions._parsetable; this.KeyChain = connectionOptions.KeyChain; }
private DBConnectionString(DbConnectionOptions connectionOptions, string restrictions, KeyRestrictionBehavior behavior, Hashtable synonyms, bool mustCloneDictionary) { Debug.Assert(null != connectionOptions, "null connectionOptions"); switch (behavior) { case KeyRestrictionBehavior.PreventUsage: case KeyRestrictionBehavior.AllowOnly: _behavior = behavior; break; default: throw ADP.InvalidKeyRestrictionBehavior(behavior); } // grab all the parsed details from DbConnectionOptions _encryptedUsersConnectionString = connectionOptions.UsersConnectionString(false); _hasPassword = connectionOptions._hasPasswordKeyword; _parsetable = connectionOptions.Parsetable; _keychain = connectionOptions._keyChain; // we do not want to serialize out user password unless directed so by "persist security info=true" // otherwise all instances of user's password will be replaced with "*" if (_hasPassword && !connectionOptions.HasPersistablePassword) { if (mustCloneDictionary) { // clone the hashtable to replace user's password/pwd value with "*" // we only need to clone if coming from DbConnectionOptions and password exists _parsetable = (Hashtable)_parsetable.Clone(); } // different than Everett in that instead of removing password/pwd from // the hashtable, we replace the value with '*'. This is okay since we // serialize out with '*' so already knows what we do. Better this way // than to treat password specially later on which causes problems. const string star = "*"; if (_parsetable.ContainsKey(KEY.Password)) { _parsetable[KEY.Password] = star; } if (_parsetable.ContainsKey(KEY.Pwd)) { _parsetable[KEY.Pwd] = star; } // replace user's password/pwd value with "*" in the linked list and build a new string _keychain = connectionOptions.ReplacePasswordPwd(out _encryptedUsersConnectionString, true); } if (!string.IsNullOrEmpty(restrictions)) { _restrictionValues = ParseRestrictions(restrictions, synonyms); _restrictions = restrictions; } }
public DbConnectionOptions(string connectionString, Hashtable synonyms, bool useOdbcRules) { this.UseOdbcRules = useOdbcRules; this._parsetable = new Hashtable(); this._usersConnectionString = (connectionString != null) ? connectionString : ""; if (0 < this._usersConnectionString.Length) { this.KeyChain = ParseInternal(this._parsetable, this._usersConnectionString, true, synonyms, this.UseOdbcRules); this.HasPasswordKeyword = this._parsetable.ContainsKey("password") || this._parsetable.ContainsKey("pwd"); } }
// synonyms hashtable is meant to be read-only translation of parsed string // keywords/synonyms to a known keyword string public DbConnectionOptions(string connectionString, Dictionary<string, string> synonyms) { _parsetable = new Dictionary<string, string>(); _usersConnectionString = ((null != connectionString) ? connectionString : ""); // first pass on parsing, initial syntax check if (0 < _usersConnectionString.Length) { KeyChain = ParseInternal(_parsetable, _usersConnectionString, true, synonyms, false); HasPasswordKeyword = (_parsetable.ContainsKey(KEY.Password) || _parsetable.ContainsKey(SYNONYM.Pwd)); } }
protected DbConnectionOptions(DbConnectionOptions connectionOptions) { // Clone used by SqlConnectionString _usersConnectionString = connectionOptions._usersConnectionString; HasPasswordKeyword = connectionOptions.HasPasswordKeyword; _parsetable = connectionOptions._parsetable; KeyChain = connectionOptions.KeyChain; }
internal NameValuePair ReplacePasswordPwd(out string constr, bool fakePassword) { bool expanded = false; int copyPosition = 0; NameValuePair head = null, tail = null, next = null; StringBuilder builder = new StringBuilder(_usersConnectionString.Length); for (NameValuePair current = KeyChain; null != current; current = current.Next) { if ((KEY.Password != current.Name) && (SYNONYM.Pwd != current.Name)) { builder.Append(_usersConnectionString, copyPosition, current.Length); if (fakePassword) { next = new NameValuePair(current.Name, current.Value, current.Length); } } else if (fakePassword) { // replace user password/pwd value with * const string equalstar = "=*;"; builder.Append(current.Name).Append(equalstar); next = new NameValuePair(current.Name, "*", current.Name.Length + equalstar.Length); expanded = true; } else { // drop the password/pwd completely in returning for user expanded = true; } if (fakePassword) { if (null != tail) { tail = tail.Next = next; } else { tail = head = next; } } copyPosition += current.Length; } Debug.Assert(expanded, "password/pwd was not removed"); constr = builder.ToString(); return head; }
private static NameValuePair ParseInternal(Hashtable parsetable, string connectionString, bool buildChain, Hashtable synonyms) { Debug.Assert(null != connectionString, "null connectionstring"); StringBuilder buffer = new StringBuilder(); NameValuePair localKeychain = null, keychain = null; #if DEBUG try { #endif int nextStartPosition = 0; int endPosition = connectionString.Length; while (nextStartPosition < endPosition) { int startPosition = nextStartPosition; string keyname, keyvalue; nextStartPosition = GetKeyValuePair(connectionString, startPosition, buffer, out keyname, out keyvalue); if (ADP.IsEmpty(keyname)) { // if (nextStartPosition != endPosition) { throw; } break; } #if DEBUG DebugTraceKeyValuePair(keyname, keyvalue, synonyms); Debug.Assert(IsKeyNameValid(keyname), "ParseFailure, invalid keyname"); Debug.Assert(IsValueValidInternal(keyvalue), "parse failure, invalid keyvalue"); #endif string realkeyname = ((null != synonyms) ? (string)synonyms[keyname] : keyname); if (!IsKeyNameValid(realkeyname)) { throw ADP.KeywordNotSupported(keyname); } { parsetable[realkeyname] = keyvalue; // last key-value pair wins (or first) } if (null != localKeychain) { localKeychain = localKeychain.Next = new NameValuePair(realkeyname, keyvalue, nextStartPosition - startPosition); } else if (buildChain) { // first time only - don't contain modified chain from UDL file keychain = localKeychain = new NameValuePair(realkeyname, keyvalue, nextStartPosition - startPosition); } } #if DEBUG } catch (ArgumentException e) { ParseComparison(parsetable, connectionString, synonyms, e); throw; } ParseComparison(parsetable, connectionString, synonyms, null); #endif return keychain; }
private DBConnectionString(DBConnectionString connectionString, string[] restrictionValues, KeyRestrictionBehavior behavior) { // used by intersect for two equal connection strings with different restrictions _encryptedUsersConnectionString = connectionString._encryptedUsersConnectionString; _parsetable = connectionString._parsetable; _keychain = connectionString._keychain; _hasPassword = connectionString._hasPassword; _restrictionValues = restrictionValues; _restrictions = null; _behavior = behavior; Verify(restrictionValues); }
// synonyms hashtable is meant to be read-only translation of parsed string // keywords/synonyms to a known keyword string public DbConnectionOptions(string connectionString, Hashtable synonyms, bool useOdbcRules) { UseOdbcRules = useOdbcRules; _parsetable = new Hashtable(); _usersConnectionString = ((null != connectionString) ? connectionString : ""); // first pass on parsing, initial syntax check if (0 < _usersConnectionString.Length) { KeyChain = ParseInternal(_parsetable, _usersConnectionString, true, synonyms, UseOdbcRules); HasPasswordKeyword = (_parsetable.ContainsKey(KEY.Password) || _parsetable.ContainsKey(SYNONYM.Pwd)); HasUserIdKeyword = (_parsetable.ContainsKey(KEY.User_ID) || _parsetable.ContainsKey(SYNONYM.UID)); } }
protected DbConnectionOptions(DbConnectionOptions connectionOptions) { // Clone used by SqlConnectionString _usersConnectionString = connectionOptions._usersConnectionString; _hasPasswordKeyword = connectionOptions._hasPasswordKeyword; _hasUserIdKeyword = connectionOptions._hasUserIdKeyword; _useOdbcRules = connectionOptions._useOdbcRules; _parsetable = connectionOptions._parsetable; _keyChain = connectionOptions._keyChain; }
internal string ExpandDataDirectories(ref string filename, ref int position) { string value = null; StringBuilder builder = new StringBuilder(_usersConnectionString.Length); string datadir = null; int copyPosition = 0; bool expanded = false; for (NameValuePair current = _keyChain; null != current; current = current.Next) { value = current.Value; // remove duplicate keyswords from connectionstring //if ((object)this[current.Name] != (object)value) { // expanded = true; // copyPosition += current.Length; // continue; //} // There is a set of keywords we explictly do NOT want to expand |DataDirectory| on if (_useOdbcRules) { switch (current.Name) { case DbConnectionOptionKeywords.Driver: case DbConnectionOptionKeywords.Pwd: case DbConnectionOptionKeywords.UID: break; default: value = ExpandDataDirectory(current.Name, value, ref datadir); break; } } else { switch (current.Name) { case DbConnectionOptionKeywords.Provider: case DbConnectionOptionKeywords.DataProvider: case DbConnectionOptionKeywords.RemoteProvider: case DbConnectionOptionKeywords.ExtendedProperties: case DbConnectionOptionKeywords.UserID: case DbConnectionOptionKeywords.Password: case DbConnectionOptionKeywords.UID: case DbConnectionOptionKeywords.Pwd: break; default: value = ExpandDataDirectory(current.Name, value, ref datadir); break; } } if (null == value) { value = current.Value; } if (_useOdbcRules || (DbConnectionOptionKeywords.FileName != current.Name)) { if (value != current.Value) { expanded = true; AppendKeyValuePairBuilder(builder, current.Name, value, _useOdbcRules); builder.Append(';'); } else { builder.Append(_usersConnectionString, copyPosition, current.Length); } } else { // strip out 'File Name=myconnection.udl' for OleDb // remembering is value for which UDL file to open // and where to insert the strnig expanded = true; filename = value; position = builder.Length; } copyPosition += current.Length; } if (expanded) { value = builder.ToString(); } else { value = null; } return(value); }
static internal void AddEntry(NameValuePermission kvtree, ArrayList entries, DBConnectionString entry) { Debug.Assert(null != entry, "null DBConnectionString"); if (null != entry.KeyChain) { for (NameValuePair keychain = entry.KeyChain; null != keychain; keychain = keychain.Next) { NameValuePermission kv; kv = kvtree.CheckKeyForValue(keychain.Name); if (null == kv) { kv = new NameValuePermission(keychain.Name); kvtree.Add(kv); // add directly into live tree } kvtree = kv; kv = kvtree.CheckKeyForValue(keychain.Value); if (null == kv) { DBConnectionString insertValue = ((null != keychain.Next) ? null : entry); kv = new NameValuePermission(keychain.Value, insertValue); kvtree.Add(kv); // add directly into live tree if (null != insertValue) { entries.Add(insertValue); } } else if (null == keychain.Next) // shorter chain potential { if (null != kv._entry) { Debug.Assert(entries.Contains(kv._entry), "entries doesn't contain entry"); entries.Remove(kv._entry); kv._entry = kv._entry.Intersect(entry); // union new restrictions into existing tree } else { kv._entry = entry; } entries.Add(kv._entry); } kvtree = kv; } } else // global restrictions, MDAC 84443 { DBConnectionString kentry = kvtree._entry; if (null != kentry) { Debug.Assert(entries.Contains(kentry), "entries doesn't contain entry"); entries.Remove(kentry); kvtree._entry = kentry.Intersect(entry); } else { kvtree._entry = entry; } entries.Add(kvtree._entry); } }
private static NameValuePair ParseInternal(Dictionary<string, string> parsetable, string connectionString, bool buildChain, Dictionary<string, string> synonyms, bool firstKey) { Debug.Assert(null != connectionString, "null connectionstring"); StringBuilder buffer = new StringBuilder(); NameValuePair localKeychain = null, keychain = null; #if DEBUG try { #endif int nextStartPosition = 0; int endPosition = connectionString.Length; while (nextStartPosition < endPosition) { int startPosition = nextStartPosition; string keyname, keyvalue; nextStartPosition = GetKeyValuePair(connectionString, startPosition, buffer, firstKey, out keyname, out keyvalue); if (string.IsNullOrEmpty(keyname)) { // if (nextStartPosition != endPosition) { throw; } break; } #if DEBUG DebugTraceKeyValuePair(keyname, keyvalue, synonyms); Debug.Assert(IsKeyNameValid(keyname), "ParseFailure, invalid keyname"); Debug.Assert(IsValueValidInternal(keyvalue), "parse failure, invalid keyvalue"); #endif string synonym; string realkeyname = null != synonyms ? (synonyms.TryGetValue(keyname, out synonym) ? synonym : null) : keyname; if (!IsKeyNameValid(realkeyname)) { throw ADP.KeywordNotSupported(keyname); } if (!firstKey || !parsetable.ContainsKey(realkeyname)) { parsetable[realkeyname] = keyvalue; // last key-value pair wins (or first) } if (null != localKeychain) { localKeychain = localKeychain.Next = new NameValuePair(realkeyname, keyvalue, nextStartPosition - startPosition); } else if (buildChain) { // first time only - don't contain modified chain from UDL file keychain = localKeychain = new NameValuePair(realkeyname, keyvalue, nextStartPosition - startPosition); } } #if DEBUG } catch (ArgumentException e) { ParseComparison(parsetable, connectionString, synonyms, firstKey, e); throw; } ParseComparison(parsetable, connectionString, synonyms, firstKey, null); #endif return keychain; }
internal NameValuePair ReplacePasswordPwd(out string constr, bool fakePassword) { int startIndex = 0; NameValuePair pair4 = null; NameValuePair pair3 = null; NameValuePair pair2 = null; StringBuilder builder = new StringBuilder(this._usersConnectionString.Length); for (NameValuePair pair = this.KeyChain; pair != null; pair = pair.Next) { if (("password" != pair.Name) && ("pwd" != pair.Name)) { builder.Append(this._usersConnectionString, startIndex, pair.Length); if (fakePassword) { pair2 = new NameValuePair(pair.Name, pair.Value, pair.Length); } } else if (fakePassword) { builder.Append(pair.Name).Append("=*;"); pair2 = new NameValuePair(pair.Name, "*", pair.Name.Length + "=*;".Length); } if (fakePassword) { if (pair3 != null) { pair3 = pair3.Next = pair2; } else { pair3 = pair4 = pair2; } } startIndex += pair.Length; } constr = builder.ToString(); return pair4; }
private static NameValuePair ParseInternal(Hashtable parsetable, string connectionString, bool buildChain, Hashtable synonyms, bool firstKey) { StringBuilder buffer = new StringBuilder(); NameValuePair pair = null; NameValuePair pair2 = null; int num = 0; int length = connectionString.Length; while (num < length) { string str2; string str3; int currentPosition = num; num = GetKeyValuePair(connectionString, currentPosition, buffer, firstKey, out str2, out str3); if (ADP.IsEmpty(str2)) { return pair2; } string keyname = (synonyms != null) ? ((string) synonyms[str2]) : str2; if (!IsKeyNameValid(keyname)) { throw ADP.KeywordNotSupported(str2); } if (!firstKey || !parsetable.Contains(keyname)) { parsetable[keyname] = str3; } if (pair != null) { pair = pair.Next = new NameValuePair(keyname, str3, num - currentPosition); } else if (buildChain) { pair2 = pair = new NameValuePair(keyname, str3, num - currentPosition); } } return pair2; }