public override SecurityElement ToXml()
{
SecurityElement se = PermissionHelper.Element(this.GetType(), version);
if (IsUnrestricted())
{
se.AddAttribute("Unrestricted", "true");
}
else
{
// attribute is present for both True and False
se.AddAttribute("AllowBlankPassword", allowBlankPassword.ToString());
foreach (DictionaryEntry de in _connections)
{
SecurityElement child = new SecurityElement("add");
child.AddAttribute("ConnectionString", (string)de.Key);
object[] restrictionsInfo = (object[])de.Value;
child.AddAttribute("KeyRestrictions", (string)restrictionsInfo [0]);
KeyRestrictionBehavior krb = (KeyRestrictionBehavior)restrictionsInfo [1];
child.AddAttribute("KeyRestrictionBehavior", krb.ToString());
se.AddChild(child);
}
}
return(se);
}
public virtual void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
state = PermissionState.None;
_connections [connectionString] = new object [2] {
restrictions, behavior
};
}
// <IPermission class="...Permission" version="1" AllowBlankPassword=false>
// <add ConnectionString="provider=x;data source=y;" KeyRestrictions="address=;server=" KeyRestrictionBehavior=PreventUsage/>
// </IPermission>
/// <include file='doc\OraclePermission.uex' path='docs/doc[@for="OraclePermission.FromXml"]/*' />
override public void FromXml(SecurityElement securityElement)
{
// code derived from CodeAccessPermission.ValidateElement
if (null == securityElement)
{
throw ADP.ArgumentNull("securityElement");
}
string tag = securityElement.Tag;
if (!tag.Equals(XmlStr._Permission) && !tag.Equals(XmlStr._IPermission))
{
// TODO: do we need to check this?
//String className = el.Attribute( XmlStr._class );
//return className == null || !className.Equals( ip.GetType().AssemblyQualifiedName );
throw ADP.NotAPermissionElement();
}
String version = securityElement.Attribute(XmlStr._Version);
if ((null != version) && !version.Equals(XmlStr._VersionNumber))
{
throw ADP.InvalidXMLBadVersion();
}
string unrestrictedValue = securityElement.Attribute(XmlStr._Unrestricted);
_isUnrestricted = (null != unrestrictedValue) && Boolean.Parse(unrestrictedValue);
Clear(); // MDAC 83105
if (!_isUnrestricted)
{
string allowNull = securityElement.Attribute(XmlStr._AllowBlankPassword);
_allowBlankPassword = (null != allowNull) && Boolean.Parse(allowNull);
ArrayList children = securityElement.Children;
if (null != children)
{
foreach (SecurityElement keyElement in children)
{
if (keyElement.Tag.Equals(XmlStr._add))
{
string constr = keyElement.Attribute(XmlStr._ConnectionString);
string restrt = keyElement.Attribute(XmlStr._KeyRestrictions);
string behavr = keyElement.Attribute(XmlStr._KeyRestrictionBehavior);
KeyRestrictionBehavior behavior = KeyRestrictionBehavior.AllowOnly;
if (null != behavr)
{
behavior = (KeyRestrictionBehavior)Enum.Parse(typeof(KeyRestrictionBehavior), behavr, true);
}
Add(constr, restrt, behavior);
}
}
}
}
else
{
_allowBlankPassword = false;
}
}
// <IPermission class="...Permission" version="1" AllowBlankPassword=false>
// <add ConnectionString="provider=x;data source=y;" KeyRestrictions="address=;server=" KeyRestrictionBehavior=PreventUsage/>
// </IPermission>
override public void FromXml(SecurityElement securityElement)
{
// code derived from CodeAccessPermission.ValidateElement
if (null == securityElement)
{
throw ADP.ArgumentNull("securityElement");
}
string tag = securityElement.Tag;
if (!tag.Equals(XmlStr._Permission) && !tag.Equals(XmlStr._IPermission))
{
throw ADP.NotAPermissionElement();
}
String version = securityElement.Attribute(XmlStr._Version);
if ((null != version) && !version.Equals(XmlStr._VersionNumber))
{
throw ADP.InvalidXMLBadVersion();
}
string unrestrictedValue = securityElement.Attribute(XmlStr._Unrestricted);
_IsUnrestricted = (null != unrestrictedValue) && Boolean.Parse(unrestrictedValue);
Clear(); // MDAC 83105
if (!_IsUnrestricted)
{
string allowNull = securityElement.Attribute(XmlStr._AllowBlankPassword);
AllowBlankPassword = (null != allowNull) && Boolean.Parse(allowNull);
ArrayList children = securityElement.Children;
if (null != children)
{
foreach (SecurityElement keyElement in children)
{
tag = keyElement.Tag;
if ((XmlStr._add == tag) || ((null != tag) && (XmlStr._add == tag.ToLower(CultureInfo.InvariantCulture))))
{
string constr = keyElement.Attribute(XmlStr._ConnectionString);
string restrt = keyElement.Attribute(XmlStr._KeyRestrictions);
string behavr = keyElement.Attribute(XmlStr._KeyRestrictionBehavior);
KeyRestrictionBehavior behavior = KeyRestrictionBehavior.AllowOnly;
if (null != behavr)
{
behavior = (KeyRestrictionBehavior)Enum.Parse(typeof(KeyRestrictionBehavior), behavr, true);
}
constr = DecodeXmlValue(constr);
restrt = DecodeXmlValue(restrt);
Add(constr, restrt, behavior);
}
}
}
}
else
{
AllowBlankPassword = false;
}
}
private DBConnectionString(DBConnectionString connectionString, string[] restrictionValues, KeyRestrictionBehavior behavior)
{
this._encryptedUsersConnectionString = connectionString._encryptedUsersConnectionString;
this._parsetable = connectionString._parsetable;
this._keychain = connectionString._keychain;
this._hasPassword = connectionString._hasPassword;
this._restrictionValues = restrictionValues;
this._restrictions = null;
this._behavior = behavior;
}
private DBConnectionString(DbConnectionOptions connectionOptions, string restrictions, KeyRestrictionBehavior behavior, Hashtable synonyms, bool mustCloneDictionary) // used by DBDataPermission
{
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 (!ADP.IsEmpty(restrictions))
{
_restrictionValues = ParseRestrictions(restrictions, synonyms);
_restrictions = restrictions;
}
}
public override void FromXml(SecurityElement securityElement)
{
if (securityElement == null)
{
throw ADP.ArgumentNull("securityElement");
}
string tag = securityElement.Tag;
if (!tag.Equals("Permission") && !tag.Equals("IPermission"))
{
throw ADP.NotAPermissionElement();
}
string str7 = securityElement.Attribute("version");
if ((str7 != null) && !str7.Equals("1"))
{
throw ADP.InvalidXMLBadVersion();
}
string str6 = securityElement.Attribute("Unrestricted");
this._isUnrestricted = (str6 != null) && bool.Parse(str6);
this.Clear();
if (!this._isUnrestricted)
{
string str5 = securityElement.Attribute("AllowBlankPassword");
this._allowBlankPassword = (str5 != null) && bool.Parse(str5);
ArrayList children = securityElement.Children;
if (children != null)
{
foreach (SecurityElement element in children)
{
tag = element.Tag;
if (("add" == tag) || ((tag != null) && ("add" == tag.ToLower(CultureInfo.InvariantCulture))))
{
string str3 = element.Attribute("ConnectionString");
string str2 = element.Attribute("KeyRestrictions");
string str4 = element.Attribute("KeyRestrictionBehavior");
KeyRestrictionBehavior allowOnly = KeyRestrictionBehavior.AllowOnly;
if (str4 != null)
{
allowOnly = (KeyRestrictionBehavior)Enum.Parse(typeof(KeyRestrictionBehavior), str4, true);
}
str3 = this.DecodeXmlValue(str3);
str2 = this.DecodeXmlValue(str2);
this.Add(str3, str2, allowOnly);
}
}
}
}
else
{
this._allowBlankPassword = false;
}
}
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;
}
}
/// <summary>
/// Adds a new connection string and a set of restricted keywords
/// to this <see cref="HsqlDataPermission"/> object.
/// </summary>
/// <param name="connectionString">The connection string.</param>
/// <param name="restrictions">The key restrictions.</param>
/// <param name="behavior">
/// One of the <see cref="KeyRestrictionBehavior"/> enumeration
/// values.
/// </param>
public override void Add(string connectionString,
string restrictions,
KeyRestrictionBehavior behavior)
{
base.Add(connectionString, restrictions, behavior);
if (behavior == KeyRestrictionBehavior.AllowOnly)
{
//
}
}
// DBDataPermissionAttribute.KeyRestrictionBehavior
internal static ArgumentOutOfRangeException InvalidKeyRestrictionBehavior(KeyRestrictionBehavior value)
{
#if DEBUG
switch (value)
{
case KeyRestrictionBehavior.PreventUsage:
case KeyRestrictionBehavior.AllowOnly:
Debug.Assert(false, "valid KeyRestrictionBehavior " + value.ToString());
break;
}
#endif
return(InvalidEnumerationValue(typeof(KeyRestrictionBehavior), (int)value));
}
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);
}
/// <include file='doc\OdbcPermission.uex' path='docs/doc[@for="OdbcPermission.Add"]/*' />
override public void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
switch (behavior)
{
case KeyRestrictionBehavior.PreventUsage:
case KeyRestrictionBehavior.AllowOnly:
break;
default:
throw ADP.Argument("value");
}
DBConnectionString entry = new OdbcConnectionString(connectionString, restrictions, behavior); // MDAC 85142
base.AddPermissionEntry(entry);
}
/// <include file='doc\DBDataPermission.uex' path='docs/doc[@for="DBDataPermission.AddWithAllow"]/*' />
virtual public void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
switch (behavior)
{
case KeyRestrictionBehavior.PreventUsage:
case KeyRestrictionBehavior.AllowOnly:
break;
default:
throw ADP.Argument("value");
}
DBConnectionString entry = new DBConnectionString(connectionString, restrictions, behavior, UdlSupport.UdlAsKeyword);
AddPermissionEntry(entry);
}
public override void FromXml(SecurityElement securityElement)
{
PermissionHelper.CheckSecurityElement(securityElement, "securityElement", version, version);
// Note: we do not (yet) care about the return value
// as we only accept version 1 (min/max values)
state = (PermissionHelper.IsUnrestricted(securityElement) ?
PermissionState.Unrestricted : PermissionState.None);
allowBlankPassword = false;
string blank = securityElement.Attribute("AllowBlankPassword");
if (blank != null)
{
#if NET_2_0
// avoid possible exceptions with Fx 2.0
if (!Boolean.TryParse(blank, out allowBlankPassword))
{
allowBlankPassword = false;
}
#else
try
{
allowBlankPassword = Boolean.Parse(blank);
}
catch
{
allowBlankPassword = false;
}
#endif
}
if (securityElement.Children != null)
{
foreach (SecurityElement child in securityElement.Children)
{
string connect = child.Attribute("ConnectionString");
string restricts = child.Attribute("KeyRestrictions");
KeyRestrictionBehavior behavior = (KeyRestrictionBehavior)Enum.Parse(
typeof(KeyRestrictionBehavior), child.Attribute("KeyRestrictionBehavior"));
if ((connect != null) && (connect.Length > 0))
{
Add(connect, restricts, behavior);
}
}
}
}
/// <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
}
private DBConnectionString(DbConnectionOptions connectionOptions, string restrictions, KeyRestrictionBehavior behavior, Hashtable synonyms, bool mustCloneDictionary)
{
switch (behavior)
{
case KeyRestrictionBehavior.AllowOnly:
case KeyRestrictionBehavior.PreventUsage:
this._behavior = behavior;
this._encryptedUsersConnectionString = connectionOptions.UsersConnectionString(false);
this._hasPassword = connectionOptions.HasPasswordKeyword;
this._parsetable = connectionOptions.Parsetable;
this._keychain = connectionOptions.KeyChain;
if (this._hasPassword && !connectionOptions.HasPersistablePassword)
{
if (mustCloneDictionary)
{
this._parsetable = (Hashtable)this._parsetable.Clone();
}
if (this._parsetable.ContainsKey("password"))
{
this._parsetable["password"] = "******";
}
if (this._parsetable.ContainsKey("pwd"))
{
this._parsetable["pwd"] = "*";
}
this._keychain = connectionOptions.ReplacePasswordPwd(out this._encryptedUsersConnectionString, true);
}
if (!ADP.IsEmpty(restrictions))
{
this._restrictionValues = ParseRestrictions(restrictions, synonyms);
this._restrictions = restrictions;
}
return;
}
throw ADP.InvalidKeyRestrictionBehavior(behavior);
}
public virtual void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
}
public virtual void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
DBConnectionString entry = new DBConnectionString(connectionString, restrictions, behavior, null, false);
this.AddPermissionEntry(entry);
}
internal DBConnectionString(string value, string restrictions, KeyRestrictionBehavior behavior, Hashtable synonyms, bool useOdbcRules) : this(new DbConnectionOptions(value, synonyms, useOdbcRules), restrictions, behavior, synonyms, false)
{
}
#pragma warning restore 169
internal DBConnectionString(string value, string restrictions, KeyRestrictionBehavior behavior, Hashtable synonyms, bool useOdbcRules)
: this(new DbConnectionOptions(value, synonyms, useOdbcRules), restrictions, behavior, synonyms, false)
{
// useOdbcRules is only used to parse the connection string, not to parse restrictions because values don't apply there
// the hashtable doesn't need clone since it isn't shared with anything else
}
internal SqlConnectionString(string connectionString, string restrictions, KeyRestrictionBehavior behavior) : base(connectionString, restrictions, behavior, UdlSupport.ThrowIfFound) {
}
#pragma warning restore 169
internal DBConnectionString(string value, string restrictions, KeyRestrictionBehavior behavior, Hashtable synonyms, bool useOdbcRules)
: this(new DbConnectionOptions(value, synonyms, useOdbcRules), restrictions, behavior, synonyms, false)
{
// useOdbcRules is only used to parse the connection string, not to parse restrictions because values don't apply there
// the hashtable doesn't need clone since it isn't shared with anything else
}
protected override void AddConnectionString (string connectionString, string restrictions,
KeyRestrictionBehavior behavior, Hashtable synonyms, bool useFirstKeyValue)
{
base.AddConnectionString (connectionString, restrictions, behavior, synonyms, useFirstKeyValue);
}
public override void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior) {
DBConnectionString constr = new DBConnectionString(connectionString, restrictions, behavior, SqlConnectionString.GetParseSynonyms(), false);
AddPermissionEntry(constr);
}
public override void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior) {
DBConnectionString constr = new DBConnectionString(connectionString, restrictions, behavior, null, true);
AddPermissionEntry(constr);
}
public virtual void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
DBConnectionString entry = new DBConnectionString(connectionString, restrictions, behavior, null, false);
this.AddPermissionEntry(entry);
}
protected override void AddConnectionString (string connectionString, string restrictions,
KeyRestrictionBehavior behavior, Hashtable synonyms, bool useFirstKeyValue)
{
throw new NotImplementedException ();
}
internal DBConnectionString Intersect(DBConnectionString entry)
{
KeyRestrictionBehavior behavior = _behavior;
string[] restrictionValues = null;
if (null == entry)
{
behavior = KeyRestrictionBehavior.AllowOnly;
}
else if (_behavior != entry._behavior)
{
// subset of the AllowOnly array
behavior = KeyRestrictionBehavior.AllowOnly;
if (KeyRestrictionBehavior.AllowOnly == entry._behavior)
{
// this PreventUsage and entry AllowOnly
if (!ADP.IsEmptyArray(_restrictionValues))
{
if (!ADP.IsEmptyArray(entry._restrictionValues))
{
restrictionValues = NewRestrictionAllowOnly(entry._restrictionValues, _restrictionValues);
}
}
else
{
restrictionValues = entry._restrictionValues;
}
}
else if (!ADP.IsEmptyArray(_restrictionValues))
{
// this AllowOnly and entry PreventUsage
if (!ADP.IsEmptyArray(entry._restrictionValues))
{
restrictionValues = NewRestrictionAllowOnly(_restrictionValues, entry._restrictionValues);
}
else
{
restrictionValues = _restrictionValues;
}
}
}
else if (KeyRestrictionBehavior.PreventUsage == _behavior)
{
// both PreventUsage
if (ADP.IsEmptyArray(_restrictionValues))
{
restrictionValues = entry._restrictionValues;
}
else if (ADP.IsEmptyArray(entry._restrictionValues))
{
restrictionValues = _restrictionValues;
}
else
{
restrictionValues = NoDuplicateUnion(_restrictionValues, entry._restrictionValues);
}
}
else if (!ADP.IsEmptyArray(_restrictionValues) && !ADP.IsEmptyArray(entry._restrictionValues))
{
// both AllowOnly with restrictions
if (_restrictionValues.Length <= entry._restrictionValues.Length)
{
restrictionValues = NewRestrictionIntersect(_restrictionValues, entry._restrictionValues);
}
else
{
restrictionValues = NewRestrictionIntersect(entry._restrictionValues, _restrictionValues);
}
}
// verify _hasPassword & _parsetable are in sync between Everett/Whidbey
Debug.Assert(!_hasPassword || ContainsKey(KEY.Password) || ContainsKey(KEY.Pwd), "OnDeserialized password mismatch this");
Debug.Assert(null == entry || !entry._hasPassword || entry.ContainsKey(KEY.Password) || entry.ContainsKey(KEY.Pwd), "OnDeserialized password mismatch entry");
DBConnectionString value = new DBConnectionString(this, restrictionValues, behavior);
ValidateCombinedSet(this, value);
ValidateCombinedSet(entry, value);
return(value);
}
internal static ArgumentOutOfRangeException InvalidKeyRestrictionBehavior(KeyRestrictionBehavior value)
{
return InvalidEnumerationValue(typeof(KeyRestrictionBehavior), (int) value);
}
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);
}
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);
}
protected virtual void AddConnectionString (string connectionString, string restrictions,
KeyRestrictionBehavior behavior, Hashtable synonyms, bool useFirstKeyValue)
{
_connections [connectionString] = new object [2] { restrictions, behavior };
}
public virtual void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior) { // V1.0.5000
DBConnectionString constr = new DBConnectionString(connectionString, restrictions, behavior, null, false);
AddPermissionEntry(constr);
}
public virtual void SetRestriction (string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
throw new NotImplementedException ();
}
public DbConnectionString(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
: this(connectionString)
{
this.behavior = behavior;
}
public DbConnectionString (string connectionString, string restrictions, KeyRestrictionBehavior behavior)
: this (connectionString)
{
this.behavior = behavior;
}
public override void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
base.Add(connectionString, restrictions, behavior);
}
public virtual void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior) // V1.0.5000
{
DBConnectionString constr = new DBConnectionString(connectionString, restrictions, behavior, null, false);
AddPermissionEntry(constr);
}
public virtual void Add (string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
state = PermissionState.None;
AddConnectionString (connectionString, restrictions, behavior, null, false);
}
internal static Exception InvalidKeyRestrictionBehavior(KeyRestrictionBehavior value)
{
return(InvalidEnumerationValue(typeof(KeyRestrictionBehavior), (int)value));
}
public virtual void Add (string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
state = PermissionState.None;
_connections [connectionString] = new object [2] { restrictions, behavior };
}
/// <summary>
/// Adds a new connection string and a set of restricted keywords
/// to this <see cref="HsqlDataPermission"/> object.
/// </summary>
/// <param name="connectionString">The connection string.</param>
/// <param name="restrictions">The key restrictions.</param>
/// <param name="behavior">
/// One of the <see cref="KeyRestrictionBehavior"/> enumeration
/// values.
/// </param>
public override void Add(string connectionString,
string restrictions,
KeyRestrictionBehavior behavior)
{
base.Add(connectionString, restrictions, behavior);
if (behavior == KeyRestrictionBehavior.AllowOnly)
{
//
}
}
public override void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
}
public override void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
DBConnectionString constr = new DBConnectionString(connectionString, restrictions, behavior, SqlConnectionString.GetParseSynonyms(), false);
AddPermissionEntry(constr);
}
internal DBConnectionString Intersect(DBConnectionString entry)
{
KeyRestrictionBehavior behavior = _behavior;
string[] restrictionValues = null;
if (null == entry)
{
//Debug.WriteLine("0 entry AllowNothing");
behavior = KeyRestrictionBehavior.AllowOnly;
}
else if (this._behavior != entry._behavior) // subset of the AllowOnly array
{
behavior = KeyRestrictionBehavior.AllowOnly;
if (KeyRestrictionBehavior.AllowOnly == entry._behavior) // this PreventUsage and entry AllowOnly
{
if (!ADP.IsEmptyArray(_restrictionValues))
{
if (!ADP.IsEmptyArray(entry._restrictionValues))
{
//Debug.WriteLine("1 this PreventUsage with restrictions and entry AllowOnly with restrictions");
restrictionValues = NewRestrictionAllowOnly(entry._restrictionValues, _restrictionValues);
}
else
{
//Debug.WriteLine("2 this PreventUsage with restrictions and entry AllowOnly with no restrictions");
}
}
else
{
//Debug.WriteLine("3/4 this PreventUsage with no restrictions and entry AllowOnly");
restrictionValues = entry._restrictionValues;
}
}
else if (!ADP.IsEmptyArray(_restrictionValues)) // this AllowOnly and entry PreventUsage
{
if (!ADP.IsEmptyArray(entry._restrictionValues))
{
//Debug.WriteLine("5 this AllowOnly with restrictions and entry PreventUsage with restrictions");
restrictionValues = NewRestrictionAllowOnly(_restrictionValues, entry._restrictionValues);
}
else
{
//Debug.WriteLine("6 this AllowOnly and entry PreventUsage with no restrictions");
restrictionValues = _restrictionValues;
}
}
else
{
//Debug.WriteLine("7/8 this AllowOnly with no restrictions and entry PreventUsage");
}
}
else if (KeyRestrictionBehavior.PreventUsage == this._behavior) // both PreventUsage
{
if (ADP.IsEmptyArray(_restrictionValues))
{
//Debug.WriteLine("9/10 both PreventUsage and this with no restrictions");
restrictionValues = entry._restrictionValues;
}
else if (ADP.IsEmptyArray(entry._restrictionValues))
{
//Debug.WriteLine("11 both PreventUsage and entry with no restrictions");
restrictionValues = _restrictionValues;
}
else
{
//Debug.WriteLine("12 both PreventUsage with restrictions");
restrictionValues = NoDuplicateUnion(_restrictionValues, entry._restrictionValues);
}
}
else if (!ADP.IsEmptyArray(_restrictionValues) && !ADP.IsEmptyArray(entry._restrictionValues)) // both AllowOnly with restrictions
{
if (this._restrictionValues.Length <= entry._restrictionValues.Length)
{
//Debug.WriteLine("13a this AllowOnly with restrictions and entry AllowOnly with restrictions");
restrictionValues = NewRestrictionIntersect(_restrictionValues, entry._restrictionValues);
}
else
{
//Debug.WriteLine("13b this AllowOnly with restrictions and entry AllowOnly with restrictions");
restrictionValues = NewRestrictionIntersect(entry._restrictionValues, _restrictionValues);
}
}
else // both AllowOnly
//Debug.WriteLine("14/15/16 this AllowOnly and entry AllowOnly but no restrictions");
{
}
// verify _hasPassword & _parsetable are in sync between Everett/Whidbey
Debug.Assert(!_hasPassword || ContainsKey(KEY.Password) || ContainsKey(KEY.Pwd), "OnDeserialized password mismatch this");
Debug.Assert(null == entry || !entry._hasPassword || entry.ContainsKey(KEY.Password) || entry.ContainsKey(KEY.Pwd), "OnDeserialized password mismatch entry");
DBConnectionString value = new DBConnectionString(this, restrictionValues, behavior);
ValidateCombinedSet(this, value);
ValidateCombinedSet(entry, value);
return(value);
}
public override void Add(string connectionString, string restrictions, KeyRestrictionBehavior behavior)
{
DBConnectionString constr = new DBConnectionString(connectionString, restrictions, behavior, null, true);
AddPermissionEntry(constr);
}
void \u206E([In] string obj0, [In] string obj1, [In] KeyRestrictionBehavior obj2)
{
// ISSUE: unable to decompile the method.
}
internal DBConnectionString Intersect(DBConnectionString entry)
{
KeyRestrictionBehavior allowOnly = this._behavior;
string[] restrictionValues = null;
if (entry == null)
{
allowOnly = KeyRestrictionBehavior.AllowOnly;
}
else if (this._behavior != entry._behavior)
{
allowOnly = KeyRestrictionBehavior.AllowOnly;
if (entry._behavior == KeyRestrictionBehavior.AllowOnly)
{
if (!ADP.IsEmptyArray(this._restrictionValues))
{
if (!ADP.IsEmptyArray(entry._restrictionValues))
{
restrictionValues = NewRestrictionAllowOnly(entry._restrictionValues, this._restrictionValues);
}
}
else
{
restrictionValues = entry._restrictionValues;
}
}
else if (!ADP.IsEmptyArray(this._restrictionValues))
{
if (!ADP.IsEmptyArray(entry._restrictionValues))
{
restrictionValues = NewRestrictionAllowOnly(this._restrictionValues, entry._restrictionValues);
}
else
{
restrictionValues = this._restrictionValues;
}
}
}
else if (KeyRestrictionBehavior.PreventUsage == this._behavior)
{
if (ADP.IsEmptyArray(this._restrictionValues))
{
restrictionValues = entry._restrictionValues;
}
else if (ADP.IsEmptyArray(entry._restrictionValues))
{
restrictionValues = this._restrictionValues;
}
else
{
restrictionValues = NoDuplicateUnion(this._restrictionValues, entry._restrictionValues);
}
}
else if (!ADP.IsEmptyArray(this._restrictionValues) && !ADP.IsEmptyArray(entry._restrictionValues))
{
if (this._restrictionValues.Length <= entry._restrictionValues.Length)
{
restrictionValues = NewRestrictionIntersect(this._restrictionValues, entry._restrictionValues);
}
else
{
restrictionValues = NewRestrictionIntersect(entry._restrictionValues, this._restrictionValues);
}
}
return(new DBConnectionString(this, restrictionValues, allowOnly));
}
