// 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