// Demonstrates:
// public Int32 IndexOf (MessageQueuePermissionEntry value)
public void IndexOfExample()
{
// <snippet6>
// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission();
// Get an instance of MessageQueuePermissionEntryCollection from the
// permission's PermissionEntries property.
MessageQueuePermissionEntryCollection collection =
permission.PermissionEntries;
// Create a new instance of MessageQueuePermissionEntry.
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Receive,
queue.MachineName,
queue.Label,
queue.Category.ToString());
// Add the entry to the collection.
collection.Add(entry);
// Display the index of the entry in the collection.
Console.WriteLine("Collection contains entry at index: {0}",
collection.IndexOf(entry));
// </snippet6>
}
// Demonstrates the following MessageQueuePermission constructor:
// public #ctor ()
public void CreatePermission1()
{
// <snippet1>
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission();
// </snippet1>
}
// Demonstrates the following MessageQueuePermission constructor:
// public #ctor (MessageQueuePermissionAccess permissionAccess,
// String path)
public void CreatePermission2()
{
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission(
MessageQueuePermissionAccess.Receive,
".\\exampleQueue");
}
// Demonstrates:
// public Void Insert (Int32 index, MessageQueuePermissionEntry value)
public void InsertExample()
{
// <snippet7>
// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission();
// Get an instance of MessageQueuePermissionEntryCollection from the
// permission's PermissionEntries property.
MessageQueuePermissionEntryCollection collection =
permission.PermissionEntries;
// Create a new instance of MessageQueuePermissionEntry.
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Receive,
queue.MachineName,
queue.Label,
queue.Category.ToString());
// Add the entry to the collection.
collection.Add(entry);
// Create another new instance of MessageQueuePermissionEntry.
MessageQueuePermissionEntry newEntry = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Send,
queue.MachineName,
queue.Label,
queue.Category.ToString());
// Insert the new entry into the collection before the original entry.
collection.Insert(0, newEntry);
// </snippet7>
}
// Demonstrates:
// public Int32 Add (MessageQueuePermissionEntry value)
public void AddExample()
{
// <snippet1>
// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission();
// Get an instance of MessageQueuePermissionEntryCollection from the
// permission's PermissionEntries property.
MessageQueuePermissionEntryCollection collection =
permission.PermissionEntries;
// Create a new instance of MessageQueuePermissionEntry.
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Receive,
queue.MachineName,
queue.Label,
queue.Category.ToString());
// Add the entry to the collection.
collection.Add(entry);
// </snippet1>
}
// Demonstrates:
// public Void AddRange (MessageQueuePermissionEntry[] value)
public void AddRangeExample1()
{
// <snippet2>
// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission();
// Get an instance of MessageQueuePermissionEntryCollection from the
// permission's PermissionEntries property.
MessageQueuePermissionEntryCollection collection =
permission.PermissionEntries;
// Create an array of type MessageQueuePermissionEntry.
MessageQueuePermissionEntry[] entries =
new MessageQueuePermissionEntry[1];
// Create a new instance of MessageQueuePermissionEntry and place the
// instance in the array.
entries[0] = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Receive,
queue.MachineName,
queue.Label,
queue.Category.ToString());
// Add the array to the collection.
collection.AddRange(entries);
// </snippet2>
}
// Demonstrates the following MessageQueuePermission constructor:
//public #ctor (MessageQueuePermissionEntry[] permissionAccessEntries)
public void CreatePermission4()
{
// <snippet4>
// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");
// Create an array of type MessageQueuePermissionEntry.
MessageQueuePermissionEntry[] entries =
new MessageQueuePermissionEntry[1];
// Create a new instance of MessageQueuePermissionEntry and place the
// instance in the array.
string machineName = queue.MachineName;
string label = queue.Label;
entries[0] = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Receive,
machineName,
label,
queue.Category.ToString());
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission(
entries);
// </snippet4>
}
// Demonstrates:
// public MessageQueuePermissionEntry Item [Int32 index] { get; set; }
public void ItemExample()
{
// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission();
// Get an instance of MessageQueuePermissionEntryCollection from the
// permission's PermissionEntries property.
MessageQueuePermissionEntryCollection collection =
permission.PermissionEntries;
// Create a new instance of MessageQueuePermissionEntry.
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Receive,
queue.MachineName,
queue.Label,
queue.Category.ToString());
// Add the entry to the collection.
collection.Add(entry);
// Display the entry's properties, using the collection's Item
// accessor.
Console.WriteLine("collection[0].PermissionAccess: {0}",
collection[0].PermissionAccess);
Console.WriteLine("collection[0].MachineName: {0}",
collection[0].MachineName);
Console.WriteLine("collection[0].Label: {0}", collection[0].Label);
Console.WriteLine("collection[0].Category: {0}",
collection[0].Category.ToString());
}
// Demonstrates the following MessageQueuePermission constructor:
//public #ctor (PermissionState state)
public void CreatePermission5()
{
// <snippet5>
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission(
System.Security.Permissions.PermissionState.Unrestricted);
// </snippet5>
}
//-------------------------------------------------
// CMessageQueuePermControls - Constructor
//
//-------------------------------------------------
internal CMessageQueuePermControls(IPermission perm, Object oParent) : base(perm, oParent)
{
// If they don't have a permission for this permission set, we will
// feed our property page a 'none' permission state.
if (perm == null)
{
m_perm = new MessageQueuePermission(PermissionState.None);
}
}// CMessageQueuePermControls
public MessageQueuePermissionEntry(MessageQueuePermissionAccess permissionAccess, string path)
{
if (path == null)
{
throw new ArgumentNullException("path");
}
MessageQueuePermission.ValidatePath(path);
_permissionAccess = permissionAccess;
_path = path;
}
public MessageQueuePermissionEntry(MessageQueuePermissionAccess permissionAccess, string machineName, string label, string category)
{
if (machineName == null)
{
throw new ArgumentNullException("machineName");
}
MessageQueuePermission.ValidateMachineName(machineName);
_permissionAccess = permissionAccess;
_machineName = machineName;
_label = label;
_category = category;
}
// Demonstrates the use of MessageQueuePermissionAccess
public void CreatePermission()
{
// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");
string machineName = queue.MachineName;
string label = queue.Label;
string category = queue.Category.ToString();
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission(
MessageQueuePermissionAccess.Receive,
machineName,
label,
category);
}
public void Unrestricted()
{
MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute(SecurityAction.Assert);
a.MachineName = "localhost";
a.Unrestricted = true;
MessageQueuePermission mqp = (MessageQueuePermission)a.CreatePermission();
Assert.IsTrue(mqp.IsUnrestricted(), "IsUnrestricted");
a.Unrestricted = false;
mqp = (MessageQueuePermission)a.CreatePermission();
Assert.IsFalse(mqp.IsUnrestricted(), "!IsUnrestricted");
}
public void Default()
{
MessageQueuePermissionAttribute a = new MessageQueuePermissionAttribute(SecurityAction.Assert);
Assert.AreEqual(a.ToString(), a.TypeId.ToString(), "TypeId");
Assert.IsFalse(a.Unrestricted, "Unrestricted");
Assert.IsNull(a.Category, "Category");
Assert.IsNull(a.Label, "Label");
Assert.IsNull(a.MachineName, "MachineName");
Assert.IsNull(a.Path, "Path");
Assert.AreEqual(MessageQueuePermissionAccess.None, a.PermissionAccess, "PermissionAccess");
a.MachineName = "localhost";
MessageQueuePermission sp = (MessageQueuePermission)a.CreatePermission();
Assert.IsFalse(sp.IsUnrestricted(), "IsUnrestricted");
}
// Demonstrates:
// public Void AddRange (MessageQueuePermissionEntryCollection value)
public void AddRangeExample2()
{
// <snippet3>
// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission();
// Create a new instance of MessageQueuePermissionEntry.
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Receive,
queue.MachineName,
queue.Label,
queue.Category.ToString());
// Add the entry to the permission's collection.
permission.PermissionEntries.Add(entry);
// Create another new instance of MessageQueuePermission.
MessageQueuePermission newPermission = new MessageQueuePermission();
// Use AddRange() to append the original permission's collection to the
// new permission's collection.
newPermission.PermissionEntries.AddRange(permission.PermissionEntries);
// To show that AddRange() copies collections by value and not by
// reference, we'll clear the original permission's collection, then
// display a count of how many entries are in the original permission's
// collection and how many entries are in the new permission's
// collection.
// Clear the original permission's collection.
permission.PermissionEntries.Clear();
// The original permission now contains 0 entries, but the new
// permission still contains 1 entry.
Console.WriteLine("Original permission contains {0} entries.",
permission.PermissionEntries.Count);
Console.WriteLine("New permission contains {0} entries.",
newPermission.PermissionEntries.Count);
// </snippet3>
}
public void GetPermissionEntries()
{
// <snippet6>
// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");
// Create an array of type MessageQueuePermissionEntry.
MessageQueuePermissionEntry[] entries =
new MessageQueuePermissionEntry[1];
// Create a new instance of MessageQueuePermissionEntry and place the
// instance in the array.
string machineName = queue.MachineName;
string label = queue.Label;
entries[0] = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Receive,
machineName,
label,
queue.Category.ToString());
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission(
entries);
// Create a new instance of MessageQueuePermissionEntryCollection and
// use it to retrieve the permission's PermissionEntries property
// value.
MessageQueuePermissionEntryCollection collection =
permission.PermissionEntries;
// Loop through the collection.
foreach (MessageQueuePermissionEntry entry in collection)
{
// Display the property values of each MessageQueuePermissionEntry.
Console.WriteLine("PermissionAccess: {0}", entry.PermissionAccess);
Console.WriteLine("MachineName: {0}", entry.MachineName);
Console.WriteLine("Label: {0}", entry.Label);
Console.WriteLine("Category: {0}", entry.Category.ToString());
}
// </snippet6>
}
// Demonstrates:
// public Void CopyTo (MessageQueuePermissionEntry[] array, Int32 index)
public void CopyToExample()
{
// <snippet5>
// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission();
// Get an instance of MessageQueuePermissionEntryCollection from the
// permission's PermissionEntries property.
MessageQueuePermissionEntryCollection collection =
permission.PermissionEntries;
// Create a new instance of MessageQueuePermissionEntry.
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Receive,
queue.MachineName,
queue.Label,
queue.Category.ToString());
// Add the entry to the collection.
collection.Add(entry);
// Create an array of type MessageQueuePermissionEntry.
MessageQueuePermissionEntry[] entries =
new MessageQueuePermissionEntry[1];
// Copy the collection to index 0 of the array.
collection.CopyTo(entries, 0);
// Show that the array now contains the entry.
Console.WriteLine("entries[0].PermissionAccess: {0}",
entries[0].PermissionAccess);
Console.WriteLine("entries[0].MachineName: {0}",
entries[0].MachineName);
Console.WriteLine("entries[0].Label: {0}", entries[0].Label);
Console.WriteLine("entries[0].Category: {0}",
entries[0].Category.ToString());
// </snippet5>
}
// Demonstrates:
// public Boolean Contains (MessageQueuePermissionEntry value)
public void ContainsExample()
{
// <snippet4>
// Connect to a queue on the local computer.
MessageQueue queue = new MessageQueue(".\\exampleQueue");
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission();
// Get an instance of MessageQueuePermissionEntryCollection from the
// permission's PermissionEntries property.
MessageQueuePermissionEntryCollection collection =
permission.PermissionEntries;
// Create a new instance of MessageQueuePermissionEntry.
MessageQueuePermissionEntry entry = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Receive,
queue.MachineName,
queue.Label,
queue.Category.ToString());
// Add the entry to the collection.
collection.Add(entry);
// Show that the collection contains the entry.
Console.WriteLine("Collection contains first entry (true/false): {0}",
collection.Contains(entry));
// Create another new instance of MessageQueuePermissionEntry.
MessageQueuePermissionEntry newEntry = new MessageQueuePermissionEntry(
MessageQueuePermissionAccess.Send,
queue.MachineName,
queue.Label,
queue.Category.ToString());
// Show that the collection does not contain the new entry.
Console.WriteLine("Collection contains second entry (true/false): {0}",
collection.Contains(newEntry));
// </snippet4>
}
public static bool TryGetPermissions(this MessageQueue queue, string user, out MessageQueueAccessRights?rights)
{
if (!administerGranted)
{
var permission = new MessageQueuePermission(MessageQueuePermissionAccess.Administer, PREFIX_FORMAT_NAME + queue.FormatName);
permission.Demand();
administerGranted = true;
}
var sid = GetSidForUser(user);
try
{
rights = GetPermissions(queue.FormatName, sid);
return(true);
}
catch
{
rights = null;
return(false);
}
}
//-------------------------------------------------
// CMessageQueuePermDialog - Constructor
//
// The constructor takes in a permission that the dialog
// will use to display default values
//-------------------------------------------------
internal CMessageQueuePermDialog(MessageQueuePermission perm) : base()
{
this.Text = CResourceStore.GetString("MessageQueuePermission:PermName");
m_PermControls = new CMessageQueuePermControls(perm, this);
Init();
} // CMessageQueuePermDialog
}// ValidateData
//-------------------------------------------------
// GetCurrentPermission
//
// This builds a permission based on the values of
// the controls
//-------------------------------------------------
internal override IPermission GetCurrentPermission()
{
// Change cells so we get data committed to the grid
m_dgPath.CurrentCell = new DataGridCell(0, 1);
m_dgPath.CurrentCell = new DataGridCell(0, 0);
m_dgOther.CurrentCell = new DataGridCell(0, 1);
m_dgOther.CurrentCell = new DataGridCell(0, 0);
MessageQueuePermission perm = null;
if (m_radUnrestricted.Checked == true)
{
perm = new MessageQueuePermission(PermissionState.Unrestricted);
}
else
{
perm = new MessageQueuePermission(PermissionState.None);
for (int i = 0; i < m_dtPath.Rows.Count; i++)
{
// Make sure we have a permission to add
if (m_dgPath[i, 0] != DBNull.Value && ((String)m_dgPath[i, 0]).Length > 0)
{
String sPath = (String)m_dgPath[i, 0];
String sAccess = (String)m_dgPath[i, 1];
try
{
perm.PermissionEntries.Add(new MessageQueuePermissionEntry(GetAccess(sAccess), sPath));
}
catch (Exception)
{
MessageBox(String.Format(CResourceStore.GetString("MessageQueuePermission:isNotAValidPath"), sPath),
CResourceStore.GetString("MessageQueuePermission:isNotAValidPathTitle"),
MB.ICONEXCLAMATION);
// Move to the cell that has the bad path
m_dgPath.CurrentCell = new DataGridCell(i, 0);
return(null);
}
}
}
for (int i = 0; i < m_dtOther.Rows.Count; i++)
{
// Make sure we have a permission to add
String sMachine = null;
String sCategory = null;
String sLabel = null;
String sAccess = null;
if (m_dgOther[i, 0] != DBNull.Value && ((String)m_dgOther[i, 0]).Length > 0)
{
sMachine = (String)m_dgOther[i, 0];
}
if (m_dgOther[i, 1] != DBNull.Value && ((String)m_dgOther[i, 1]).Length > 0)
{
sCategory = (String)m_dgOther[i, 1];
}
if (m_dgOther[i, 2] != DBNull.Value && ((String)m_dgOther[i, 2]).Length > 0)
{
sLabel = (String)m_dgOther[i, 2];
}
if (sMachine != null || sCategory != null || sLabel != null)
{
sAccess = (String)m_dgOther[i, 3];
perm.PermissionEntries.Add(new MessageQueuePermissionEntry(GetAccess(sAccess), sMachine, sLabel, sCategory));
}
}
}
return(perm);
}// GetCurrentPermission
// Demonstrates the following MessageQueuePermission constructor:
// public #ctor ()
public void CreatePermission1()
{
// Create a new instance of MessageQueuePermission.
MessageQueuePermission permission = new MessageQueuePermission();
}
}// CreateOtherDataTable
//-------------------------------------------------
// PutValuesinPage
//
// Initializes the controls with the provided permission
//-------------------------------------------------
protected override void PutValuesinPage()
{
// Put in the text for the radio buttons
m_radUnrestricted.Text = CResourceStore.GetString("MessageQueuePermission:GrantUnrestrict");
m_radGrantFollowingPermission.Text = CResourceStore.GetString("MessageQueuePermission:GrantFollowing");
MessageQueuePermission perm = (MessageQueuePermission)m_perm;
CheckUnrestricted(perm);
if (!perm.IsUnrestricted())
{
// Run through the list of socket permissions we have to accept connections
IEnumerator enumer = perm.PermissionEntries.GetEnumerator();
while (enumer.MoveNext())
{
MessageQueuePermissionEntry mqpp = (MessageQueuePermissionEntry)enumer.Current;
String sAccess = CResourceStore.GetString("None");
if ((mqpp.PermissionAccess & MessageQueuePermissionAccess.Administer) == MessageQueuePermissionAccess.Administer)
{
sAccess = CResourceStore.GetString("MessageQueuePermission:Administer");
}
else if ((mqpp.PermissionAccess & MessageQueuePermissionAccess.Receive) == MessageQueuePermissionAccess.Receive)
{
sAccess = CResourceStore.GetString("MessageQueuePermission:Receive");
}
else if ((mqpp.PermissionAccess & MessageQueuePermissionAccess.Peek) == MessageQueuePermissionAccess.Peek)
{
sAccess = CResourceStore.GetString("MessageQueuePermission:Peek");
}
else if ((mqpp.PermissionAccess & MessageQueuePermissionAccess.Send) == MessageQueuePermissionAccess.Send)
{
sAccess = CResourceStore.GetString("MessageQueuePermission:Send");
}
else if ((mqpp.PermissionAccess & MessageQueuePermissionAccess.Browse) == MessageQueuePermissionAccess.Browse)
{
sAccess = CResourceStore.GetString("MessageQueuePermission:Browse");
}
DataRow newRow;
// Figure out what type of row we're adding
if (mqpp.Path != null && mqpp.Path.Length > 0)
{
newRow = m_dtPath.NewRow();
newRow["Path"] = mqpp.Path;
newRow["Access"] = new DataGridComboBoxEntry(sAccess);
m_dtPath.Rows.Add(newRow);
}
else
{
newRow = m_dtOther.NewRow();
newRow["Machine"] = mqpp.MachineName;
newRow["Category"] = (mqpp.Category != null)?mqpp.Category:"";
newRow["Label"] = (mqpp.Label != null)?mqpp.Label:"";
newRow["Access"] = new DataGridComboBoxEntry(sAccess);
m_dtOther.Rows.Add(newRow);
}
}
}
// We want at least 1 rows so it looks pretty
while (m_dtPath.Rows.Count < 1)
{
AddEmptyPathRow(m_dtPath);
}
// We want at least 1 rows so it looks pretty
while (m_dtOther.Rows.Count < 1)
{
AddEmptyOtherRow(m_dtOther);
}
}// PutValuesinPage
