/// <include file='doc\MessageQueuePermission.uex' path='docs/doc[@for="MessageQueuePermission.MessageQueuePermission4"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public MessageQueuePermission(MessageQueuePermissionEntry[] permissionAccessEntries)
{
if (permissionAccessEntries == null)
throw new ArgumentNullException("permissionAccessEntries");
this.PermissionEntries.AddRange(permissionAccessEntries);
}
public MessageQueuePermission(MessageQueuePermissionAccess permissionAccess,
string machineName, string label, string category) : this()
{
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry(permissionAccess, machineName, label, category);
_list.Add(entry);
}
public MessageQueuePermission(MessageQueuePermissionAccess permissionAccess, string path)
: this()
{
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry(permissionAccess, path);
_list.Add(entry);
}
internal void ResolveFormatNames()
{
if (this.resolvedFormatNames == null)
{
this.resolvedFormatNames = new Hashtable(GetComparer());
IEnumerator enumerator = this.PermissionEntries.GetEnumerator();
while (enumerator.MoveNext())
{
MessageQueuePermissionEntry current = (MessageQueuePermissionEntry)enumerator.Current;
if (current.Path != null)
{
if (current.Path == "*")
{
this.resolvedFormatNames.Add("*", current.PermissionAccess);
}
else
{
try
{
MessageQueue queue = new MessageQueue(current.Path);
this.resolvedFormatNames.Add(queue.FormatName, current.PermissionAccess);
}
catch
{
}
}
}
else
{
try
{
MessageQueueCriteria criteria = new MessageQueueCriteria();
if (current.MachineName != null)
{
criteria.MachineName = current.MachineName;
}
if (current.Category != null)
{
criteria.Category = new Guid(current.Category);
}
if (current.Label != null)
{
criteria.Label = current.Label;
}
IEnumerator messageQueueEnumerator = MessageQueue.GetMessageQueueEnumerator(criteria, false);
while (messageQueueEnumerator.MoveNext())
{
MessageQueue queue2 = (MessageQueue)messageQueueEnumerator.Current;
this.resolvedFormatNames.Add(queue2.FormatName, current.PermissionAccess);
}
continue;
}
catch
{
continue;
}
}
}
}
}
public override void FromXml(SecurityElement securityElement)
{
this.PermissionEntries.Clear();
string strA = securityElement.Attribute("Unrestricted");
if ((strA != null) && (string.Compare(strA, "true", true, CultureInfo.InvariantCulture) == 0))
{
this.isUnrestricted = true;
}
else if (securityElement.Children != null)
{
for (int i = 0; i < securityElement.Children.Count; i++)
{
SecurityElement element = (SecurityElement)securityElement.Children[i];
MessageQueuePermissionEntry entry = null;
string str2 = element.Attribute("access");
int num2 = 0;
if (str2 != null)
{
string[] strArray = str2.Split(new char[] { '|' });
for (int j = 0; j < strArray.Length; j++)
{
string str3 = strArray[j].Trim();
if (Enum.IsDefined(typeof(MessageQueuePermissionAccess), str3))
{
num2 |= (int)Enum.Parse(typeof(MessageQueuePermissionAccess), str3);
}
}
}
if (element.Tag == "Path")
{
string path = element.Attribute("value");
if (path == null)
{
throw new InvalidOperationException(Res.GetString("InvalidXmlFormat"));
}
entry = new MessageQueuePermissionEntry((MessageQueuePermissionAccess)num2, path);
}
else
{
if (!(element.Tag == "Criteria"))
{
throw new InvalidOperationException(Res.GetString("InvalidXmlFormat"));
}
string label = element.Attribute("label");
string category = element.Attribute("category");
string machineName = element.Attribute("machine");
if (((machineName == null) && (label == null)) && (category == null))
{
throw new InvalidOperationException(Res.GetString("InvalidXmlFormat"));
}
entry = new MessageQueuePermissionEntry((MessageQueuePermissionAccess)num2, machineName, label, category);
}
this.PermissionEntries.Add(entry);
}
}
}
public void AddRange(MessageQueuePermissionEntry[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
for (int i = 0; i < value.Length; i++)
{
this.Add(value[i]);
}
}
public bool Contains(MessageQueuePermissionEntry value)
{
return base.List.Contains (value);
}
internal void ResolveFormatNames()
{
if (this.resolvedFormatNames == null)
{
this.resolvedFormatNames = new Hashtable(new CaseInsensitiveHashCodeProvider(CultureInfo.InvariantCulture), new CaseInsensitiveComparer(CultureInfo.InvariantCulture));
IEnumerator enumerator = this.PermissionEntries.GetEnumerator();
while (enumerator.MoveNext())
{
MessageQueuePermissionEntry entry = (MessageQueuePermissionEntry)enumerator.Current;
if (entry.Path != null)
{
if (entry.Path == Any)
{
this.resolvedFormatNames.Add(Any, entry.PermissionAccess);
}
else
{
try {
MessageQueue queue = new MessageQueue(entry.Path);
this.resolvedFormatNames.Add(queue.FormatName, entry.PermissionAccess);
}
catch (Exception) {
//if the format name cannot be resolved, it won't be added to the list
//permissions won't be granted.
}
}
}
else
{
try {
MessageQueueCriteria criteria = new MessageQueueCriteria();
if (entry.MachineName != null)
{
criteria.MachineName = entry.MachineName;
}
if (entry.Category != null)
{
criteria.Category = new Guid(entry.Category);
}
if (entry.Label != null)
{
criteria.Label = entry.Label;
}
IEnumerator messageQueues = MessageQueue.GetMessageQueueEnumerator(criteria, false);
while (messageQueues.MoveNext())
{
MessageQueue queue = (MessageQueue)messageQueues.Current;
this.resolvedFormatNames.Add(queue.FormatName, entry.PermissionAccess);
}
}
catch (Exception) {
//if the criteria cannot be resolved, nothing will be added to the list
//permissions won't be granted.
}
}
}
}
}
public MessageQueuePermission (MessageQueuePermissionAccess permissionAccess, string path)
: this ()
{
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry (permissionAccess, path);
_list.Add (entry);
}
public override SecurityElement ToXml()
{
SecurityElement element = new SecurityElement("IPermission");
Type type = base.GetType();
element.AddAttribute("class", type.FullName + ", " + type.Module.Assembly.FullName.Replace('"', '\''));
element.AddAttribute("version", "1");
if (this.isUnrestricted)
{
element.AddAttribute("Unrestricted", "true");
return(element);
}
IEnumerator enumerator = this.PermissionEntries.GetEnumerator();
while (enumerator.MoveNext())
{
SecurityElement child = null;
MessageQueuePermissionEntry current = (MessageQueuePermissionEntry)enumerator.Current;
if (current.Path != null)
{
child = new SecurityElement("Path");
child.AddAttribute("value", current.Path);
}
else
{
child = new SecurityElement("Criteria");
if (current.MachineName != null)
{
child.AddAttribute("machine", current.MachineName);
}
if (current.Category != null)
{
child.AddAttribute("category", current.Category);
}
if (current.Label != null)
{
child.AddAttribute("label", current.Label);
}
}
int permissionAccess = (int)current.PermissionAccess;
if (permissionAccess != 0)
{
StringBuilder builder = null;
int[] values = (int[])Enum.GetValues(typeof(MessageQueuePermissionAccess));
Array.Sort(values, System.InvariantComparer.Default);
for (int i = values.Length - 1; i >= 0; i--)
{
if ((values[i] != 0) && ((permissionAccess & values[i]) == values[i]))
{
if (builder == null)
{
builder = new StringBuilder();
}
else
{
builder.Append("|");
}
builder.Append(Enum.GetName(typeof(MessageQueuePermissionAccess), values[i]));
permissionAccess &= values[i] ^ values[i];
}
}
child.AddAttribute("access", builder.ToString());
}
element.AddChild(child);
}
return(element);
}
public override void FromXml(SecurityElement securityElement)
{
this.PermissionEntries.Clear();
string unrestrictedValue = securityElement.Attribute("Unrestricted");
if (unrestrictedValue != null && (string.Compare(unrestrictedValue, "true", true, CultureInfo.InvariantCulture) == 0))
{
this.isUnrestricted = true;
return;
}
if (securityElement.Children != null)
{
for (int index = 0; index < securityElement.Children.Count; ++index)
{
SecurityElement currentElement = (SecurityElement)securityElement.Children[index];
MessageQueuePermissionEntry entry = null;
string accessString = currentElement.Attribute("access");
int permissionAccess = 0;
if (accessString != null)
{
string[] accessArray = accessString.Split(new char[] { '|' });
for (int index2 = 0; index2 < accessArray.Length; ++index2)
{
string currentAccess = accessArray[index2].Trim();
if (Enum.IsDefined(typeof(MessageQueuePermissionAccess), currentAccess))
permissionAccess = permissionAccess | (int)Enum.Parse(typeof(MessageQueuePermissionAccess), currentAccess);
}
}
if (currentElement.Tag == "Path")
{
string path = currentElement.Attribute("value");
if (path == null)
throw new InvalidOperationException(Res.GetString(Res.InvalidXmlFormat));
entry = new MessageQueuePermissionEntry((MessageQueuePermissionAccess)permissionAccess, path);
}
else if (currentElement.Tag == "Criteria")
{
string label = currentElement.Attribute("label");
string category = currentElement.Attribute("category");
string machineName = currentElement.Attribute("machine");
if (machineName == null && label == null && category == null)
throw new InvalidOperationException(Res.GetString(Res.InvalidXmlFormat));
entry = new MessageQueuePermissionEntry((MessageQueuePermissionAccess)permissionAccess, machineName, label, category);
}
else
throw new InvalidOperationException(Res.GetString(Res.InvalidXmlFormat));
this.PermissionEntries.Add(entry);
}
}
}
public bool Contains(MessageQueuePermissionEntry value)
{
return(base.List.Contains(value));
}
public int Add(MessageQueuePermissionEntry value)
{
return(base.List.Add(value));
}
/// <include file='doc\MessageQueuePermission.uex' path='docs/doc[@for="MessageQueuePermission.ToXml"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override SecurityElement ToXml()
{
SecurityElement root = new SecurityElement("IPermission");
Type type = this.GetType();
root.AddAttribute("class", type.FullName + ", " + type.Module.Assembly.FullName.Replace('\"', '\''));
root.AddAttribute("version", "1");
if (this.isUnrestricted)
{
root.AddAttribute("Unrestricted", "true");
return(root);
}
IEnumerator enumerator = this.PermissionEntries.GetEnumerator();
while (enumerator.MoveNext())
{
SecurityElement currentElement = null;
MessageQueuePermissionEntry entry = (MessageQueuePermissionEntry)enumerator.Current;
if (entry.Path != null)
{
currentElement = new SecurityElement("Path");
currentElement.AddAttribute("value", entry.Path);
}
else
{
currentElement = new SecurityElement("Criteria");
if (entry.MachineName != null)
{
currentElement.AddAttribute("machine", entry.MachineName);
}
if (entry.Category != null)
{
currentElement.AddAttribute("category", entry.Category);
}
if (entry.Label != null)
{
currentElement.AddAttribute("label", entry.Label);
}
}
int currentAccess = (int)entry.PermissionAccess;
if (currentAccess != 0)
{
StringBuilder accessStringBuilder = null;
int[] enumValues = (int[])Enum.GetValues(typeof(MessageQueuePermissionAccess));
Array.Sort(enumValues, InvariantComparer.Default);
for (int index = (enumValues.Length - 1); index >= 0; --index)
{
if (enumValues[index] != 0 && ((currentAccess & enumValues[index]) == enumValues[index]))
{
if (accessStringBuilder == null)
{
accessStringBuilder = new StringBuilder();
}
else
{
accessStringBuilder.Append("|");
}
accessStringBuilder.Append(Enum.GetName(typeof(MessageQueuePermissionAccess), enumValues[index]));
currentAccess = currentAccess & (enumValues[index] ^ enumValues[index]);
}
}
currentElement.AddAttribute("access", accessStringBuilder.ToString());
}
root.AddChild(currentElement);
}
return(root);
}
public void CopyTo(MessageQueuePermissionEntry[] array,int index)
{
base.List.CopyTo (array, index);
}
public int IndexOf(MessageQueuePermissionEntry value)
{
return base.List.IndexOf (value);
}
public int IndexOf(MessageQueuePermissionEntry value)
{
return(base.List.IndexOf(value));
}
/// <include file='doc\MessageQueuePermission.uex' path='docs/doc[@for="MessageQueuePermission.MessageQueuePermission2"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public MessageQueuePermission(MessageQueuePermissionAccess permissionAccess, string path)
{
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry(permissionAccess, path);
this.PermissionEntries.Add(entry);
}
public void Insert(int index, MessageQueuePermissionEntry value)
{
base.List.Insert(index, value);
}
public void Remove(MessageQueuePermissionEntry value)
{
base.List.Remove(value);
}
public void Insert(int index, MessageQueuePermissionEntry value)
{
base.List.Insert (index, value);
}
public MessageQueuePermission(MessageQueuePermissionAccess permissionAccess, string path)
{
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry(permissionAccess, path);
this.PermissionEntries.Add(entry);
}
public void Remove(MessageQueuePermissionEntry value)
{
base.List.Remove (value);
}
public MessageQueuePermission (MessageQueuePermissionEntry[] permissionAccessEntries)
: this ()
{
foreach (MessageQueuePermissionEntry entry in permissionAccessEntries)
_list.Add (entry);
}
public int Add(MessageQueuePermissionEntry value)
{
return base.List.Add (value);
}
public MessageQueuePermission (MessageQueuePermissionAccess permissionAccess,
string machineName, string label, string category) : this ()
{
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry (permissionAccess, machineName, label, category);
_list.Add (entry);
}
/// <include file='doc\MessageQueuePermission.uex' path='docs/doc[@for="MessageQueuePermission.FromXml"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override void FromXml(SecurityElement securityElement)
{
this.PermissionEntries.Clear();
string unrestrictedValue = securityElement.Attribute("Unrestricted");
if (unrestrictedValue != null && (string.Compare(unrestrictedValue, "true", true, CultureInfo.InvariantCulture) == 0))
{
this.isUnrestricted = true;
return;
}
if (securityElement.Children != null)
{
for (int index = 0; index < securityElement.Children.Count; ++index)
{
SecurityElement currentElement = (SecurityElement)securityElement.Children[index];
MessageQueuePermissionEntry entry = null;
string accessString = currentElement.Attribute("access");
int permissionAccess = 0;
if (accessString != null)
{
string[] accessArray = accessString.Split(new char[] { '|' });
for (int index2 = 0; index2 < accessArray.Length; ++index2)
{
string currentAccess = accessArray[index2].Trim();
if (Enum.IsDefined(typeof(MessageQueuePermissionAccess), currentAccess))
{
permissionAccess = permissionAccess | (int)Enum.Parse(typeof(MessageQueuePermissionAccess), currentAccess);
}
}
}
if (currentElement.Tag == "Path")
{
string path = currentElement.Attribute("value");
if (path == null)
{
throw new InvalidOperationException(Res.GetString(Res.InvalidXmlFormat));
}
entry = new MessageQueuePermissionEntry((MessageQueuePermissionAccess)permissionAccess, path);
}
else if (currentElement.Tag == "Criteria")
{
string label = currentElement.Attribute("label");
string category = currentElement.Attribute("category");
string machineName = currentElement.Attribute("machine");
if (machineName == null && label == null && category == null)
{
throw new InvalidOperationException(Res.GetString(Res.InvalidXmlFormat));
}
entry = new MessageQueuePermissionEntry((MessageQueuePermissionAccess)permissionAccess, machineName, label, category);
}
else
{
throw new InvalidOperationException(Res.GetString(Res.InvalidXmlFormat));
}
this.PermissionEntries.Add(entry);
}
}
}
