public static EventLogPermission GetEventLogPermission()
{
EventLogPermission permission = new EventLogPermission();
EventLogPermissionEntry entry = new EventLogPermissionEntry(EventLogPermissionAccess.Administer, ".");
permission.PermissionEntries.Add(entry);
return permission;
}
/// <include file='doc\EventLogPermissionEntryCollection.uex' path='docs/doc[@for="EventLogPermissionEntryCollection.EventLogPermissionEntryCollection"]/*' />
///<internalonly/>
internal EventLogPermissionEntryCollection(EventLogPermission owner, ResourcePermissionBaseEntry[] entries)
{
this.owner = owner;
for (int index = 0; index < entries.Length; ++index)
{
this.InnerList.Add(new EventLogPermissionEntry(entries[index]));
}
}
internal EventLogPermissionEntryCollection(EventLogPermission owner, ResourcePermissionBaseEntry[] entries)
{
this.owner = owner;
for (int i = 0; i < entries.Length; i++)
{
base.InnerList.Add(new EventLogPermissionEntry(entries[i]));
}
}
internal EventLogPermissionEntryCollection(EventLogPermission owner, ResourcePermissionBaseEntry[] entries)
{
this.owner = owner;
for (int i = 0; i < entries.Length; i++)
{
base.InnerList.Add(new EventLogPermissionEntry(entries[i]));
}
}
internal EventLogPermissionEntryCollection (EventLogPermission owner)
{
this.owner = owner;
ResourcePermissionBaseEntry[] entries = owner.GetEntries ();
if (entries.Length > 0) {
foreach (ResourcePermissionBaseEntry entry in entries) {
EventLogPermissionAccess elpa = (EventLogPermissionAccess) entry.PermissionAccess;
EventLogPermissionEntry elpe = new EventLogPermissionEntry (elpa, entry.PermissionAccessPath [0]);
// we don't want to add them (again) to the base class
InnerList.Add (elpe);
}
}
}
internal EventLogPermissionEntryCollection(EventLogPermission owner)
{
this.owner = owner;
ResourcePermissionBaseEntry[] entries = owner.GetEntries();
if (entries.Length > 0)
{
foreach (ResourcePermissionBaseEntry entry in entries)
{
EventLogPermissionAccess elpa = (EventLogPermissionAccess)entry.PermissionAccess;
EventLogPermissionEntry elpe = new EventLogPermissionEntry(elpa, entry.PermissionAccessPath [0]);
// we don't want to add them (again) to the base class
InnerList.Add(elpe);
}
}
}
/// <summary>
/// Logs message.
/// </summary>
/// <param name="message">A message to log.</param>
/// <param name="source">Name of the event source to log to.</param>
/// <param name="entryType">The type of entry to log.</param>
public static void Log(String message, String source, EventLogEntryType entryType)
{
// Use one source
// source = ConfigurationManager.AppSettings["EventLogSource"];
EventLogPermission eventLogPermission = new EventLogPermission(EventLogPermissionAccess.Administer, ".");
eventLogPermission.PermitOnly();
if (!EventLog.SourceExists(source))
{
EventLog.CreateEventSource(source, "Application");
}
EventLog.WriteEntry(source, message, entryType);
Writer.WriteLine(string.Format("LOGGED: {0}", message));
}
public void PermissionState_Unrestricted ()
{
PermissionState ps = PermissionState.Unrestricted;
EventLogPermission elp = new EventLogPermission (ps);
Assert.AreEqual (0, elp.PermissionEntries.Count, "PermissionEntries");
Assert.IsTrue (elp.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = elp.ToXml ();
// only class and version are present
Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "Xml-Unrestricted");
Assert.IsNull (se.Children, "Xml-Children");
EventLogPermission copy = (EventLogPermission)elp.Copy ();
Assert.IsFalse (Object.ReferenceEquals (elp, copy), "ReferenceEquals");
Assert.AreEqual (elp.PermissionEntries.Count, copy.PermissionEntries.Count, "copy-PermissionEntries");
Assert.AreEqual (elp.IsUnrestricted (), copy.IsUnrestricted (), "copy-IsUnrestricted ()");
}
public void Union_Null ()
{
EventLogPermission elp = new EventLogPermission (PermissionState.None);
elp.PermissionEntries.Add (new EventLogPermissionEntry (EventLogPermissionAccess.None, "localhost"));
// Union with null is a simple copy
EventLogPermission union = (EventLogPermission)elp.Union (null);
Assert.IsNotNull (elp.PermissionEntries.Count, "Count");
}
/// <devdoc>
/// </devdoc>
public void EndInit() {
string currentMachineName = this.machineName;
EventLogPermission permission = new EventLogPermission(EventLogPermissionAccess.Write, currentMachineName);
permission.Demand();
boolFlags[Flag_initializing] = false;
if (boolFlags[Flag_monitoring])
StartListening(currentMachineName, GetLogName(currentMachineName));
}
public void PermissionState_Bad ()
{
PermissionState ps = (PermissionState)77;
EventLogPermission elp = new EventLogPermission (ps);
Assert.IsFalse (elp.IsUnrestricted (), "IsUnrestricted");
}
public void FromXml_NoVersion ()
{
EventLogPermission elp = new EventLogPermission (PermissionState.None);
SecurityElement se = elp.ToXml ();
SecurityElement w = new SecurityElement (se.Tag);
w.AddAttribute ("class", se.Attribute ("class"));
elp.FromXml (w);
}
public void FromXml_NoClass ()
{
EventLogPermission elp = new EventLogPermission (PermissionState.None);
SecurityElement se = elp.ToXml ();
SecurityElement w = new SecurityElement (se.Tag);
w.AddAttribute ("version", se.Attribute ("version"));
elp.FromXml (w);
// doesn't even care of the class attribute presence
}
public void FromXml_WrongTagCase ()
{
EventLogPermission elp = new EventLogPermission (PermissionState.None);
SecurityElement se = elp.ToXml ();
se.Tag = "IPERMISSION"; // instead of IPermission
elp.FromXml (se);
// note: normally IPermission classes (in corlib) DO care about the
// IPermission tag
}
public void Union_BadPermission ()
{
EventLogPermission elp1 = new EventLogPermission (PermissionState.Unrestricted);
elp1.Union (new SecurityPermission (SecurityPermissionFlag.Assertion));
}
public void Intersect_Null ()
{
EventLogPermission elp = new EventLogPermission (PermissionState.None);
// No intersection with null
Assert.IsNull (elp.Intersect (null), "None N null");
}
public void Copy ()
{
foreach (EventLogPermissionAccess elpa in AllAccess) {
EventLogPermission elp = new EventLogPermission (PermissionState.None);
EventLogPermissionEntry elpe = new EventLogPermissionEntry (elpa, elpa.ToString ());
elp.PermissionEntries.Add (elpe);
EventLogPermission copy = (EventLogPermission)elp.Copy ();
Assert.AreEqual (1, copy.PermissionEntries.Count, "Count==1");
Assert.AreEqual (elpa, elp.PermissionEntries [0].PermissionAccess, elpa.ToString ());
}
}
public void PermissionEntries ()
{
EventLogPermissionAccess elpa = EventLogPermissionAccess.None;
EventLogPermission elp = new EventLogPermission (elpa, "localhost");
EventLogPermissionEntryCollection elpec = elp.PermissionEntries;
Assert.AreEqual (1, elpec.Count, "Count==1");
EventLogPermissionEntry elpe = new EventLogPermissionEntry (EventLogPermissionAccess.Browse, "*");
elp.PermissionEntries.Add (elpe);
Assert.AreEqual (2, elpec.Count, "Count==2");
// remove (same instance)
elp.PermissionEntries.Remove (elpe);
Assert.AreEqual (1, elpec.Count, "Count==1 (b)");
// remove different instance (doesn't work)
elpe = new EventLogPermissionEntry (EventLogPermissionAccess.None, "localhost");
Assert.AreEqual (1, elpec.Count, "Count==1");
}
public void EventLogPermissionAccesss_Bad ()
{
EventLogPermissionAccess elpa = (EventLogPermissionAccess)Int32.MinValue;
EventLogPermission elp = new EventLogPermission (elpa, "localhost");
Assert.AreEqual (1, elp.PermissionEntries.Count, "Count");
Assert.AreEqual ((EventLogPermissionAccess)Int32.MinValue, elp.PermissionEntries [0].PermissionAccess, "PermissionAccess");
}
public void Constructor_MachineName_Null ()
{
EventLogPermission elp = new EventLogPermission (EventLogPermissionAccess.None, null);
}
public void Constructor_PermissionEntries_Null ()
{
EventLogPermission elp = new EventLogPermission (null);
}
public void Union_Self ()
{
foreach (EventLogPermissionAccess elpa in AllAccess)
{
EventLogPermission elp = new EventLogPermission (PermissionState.None);
elp.PermissionEntries.Add (new EventLogPermissionEntry (elpa, elpa.ToString ()));
EventLogPermission union = (EventLogPermission)elp.Union (elp);
Assert.IsFalse (union.IsUnrestricted (), "IsUnrestricted " + elpa.ToString ());
Assert.AreEqual (1, union.PermissionEntries.Count, "Count " + elpa.ToString ());
}
}
public void Union_Unrestricted ()
{
// Union with unrestricted is unrestricted
EventLogPermission elp1 = new EventLogPermission (PermissionState.Unrestricted);
foreach (EventLogPermissionAccess elpa in AllAccess) {
EventLogPermission elp2 = new EventLogPermission (PermissionState.None);
elp2.PermissionEntries.Add (new EventLogPermissionEntry (elpa, elpa.ToString ()));
EventLogPermission union = (EventLogPermission)elp1.Union (elp2);
Assert.IsTrue (union.IsUnrestricted (), "target.IsUnrestricted " + elpa.ToString ());
Assert.AreEqual (0, union.PermissionEntries.Count, "target.Count " + elpa.ToString ());
union = (EventLogPermission)elp2.Union (elp1);
Assert.IsTrue (union.IsUnrestricted (), "source.IsUnrestricted " + elpa.ToString ());
Assert.AreEqual (0, union.PermissionEntries.Count, "source.Count " + elpa.ToString ());
}
}
public void Intersect_None ()
{
EventLogPermission elp1 = new EventLogPermission (PermissionState.None);
EventLogPermission elp2 = new EventLogPermission (PermissionState.None);
// 1. None N None
EventLogPermission result = (EventLogPermission)elp1.Intersect (elp2);
Assert.IsNull (result, "Empty N Empty");
// 2. None N Entry
elp2.PermissionEntries.Add (new EventLogPermissionEntry (EventLogPermissionAccess.None, "localhost"));
result = (EventLogPermission)elp1.Intersect (elp2);
Assert.IsNull (result, "Empty N Entry");
// 3. Entry N None
result = (EventLogPermission)elp2.Intersect (elp1);
Assert.IsNull (result, "Entry N Empty");
}
public void FromXml_Null ()
{
EventLogPermission elp = new EventLogPermission (PermissionState.None);
elp.FromXml (null);
}
public void Intersect_Unrestricted ()
{
// Intersection with unrestricted == Copy
// a. source (this) is unrestricted
EventLogPermission elp1 = new EventLogPermission (PermissionState.Unrestricted);
EventLogPermission elp2 = new EventLogPermission (PermissionState.None);
// 1. Unrestricted N None
EventLogPermission result = (EventLogPermission)elp1.Intersect (elp2);
Assert.IsFalse (result.IsUnrestricted (), "(Unrestricted N None).IsUnrestricted");
Assert.AreEqual (0, result.PermissionEntries.Count, "(Unrestricted N None).Count");
// 2. None N Unrestricted
result = (EventLogPermission)elp2.Intersect (elp1);
Assert.IsFalse (result.IsUnrestricted (), "(None N Unrestricted).IsUnrestricted");
Assert.AreEqual (0, result.PermissionEntries.Count, "(None N Unrestricted).Count");
// 3. Unrestricted N Unrestricted
result = (EventLogPermission)elp1.Intersect (elp1);
Assert.IsTrue (result.IsUnrestricted (), "(Unrestricted N Unrestricted).IsUnrestricted");
Assert.AreEqual (0, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");
// 4. Unrestricted N Entry
elp2.PermissionEntries.Add (new EventLogPermissionEntry (EventLogPermissionAccess.None, "localhost"));
result = (EventLogPermission)elp1.Intersect (elp2);
Assert.IsFalse (result.IsUnrestricted (), "(Unrestricted N Entry).IsUnrestricted");
Assert.AreEqual (1, result.PermissionEntries.Count, "(Unrestricted N Entry).Count");
// 5. Entry N Unrestricted
result = (EventLogPermission)elp2.Intersect (elp1);
Assert.IsFalse (result.IsUnrestricted (), "(Entry N Unrestricted).IsUnrestricted");
Assert.AreEqual (1, result.PermissionEntries.Count, "(Entry N Unrestricted).Count");
// 6. Unrestricted N Unrestricted
elp1.PermissionEntries.Add (new EventLogPermissionEntry (EventLogPermissionAccess.None, "localhost"));
result = (EventLogPermission)elp1.Intersect (elp1);
Assert.IsTrue (result.IsUnrestricted (), "(Unrestricted N Unrestricted).IsUnrestricted");
Assert.AreEqual (1, result.PermissionEntries.Count, "(Unrestricted N Unrestricted).Count");
}
public void FromXml_WrongClass ()
{
EventLogPermission elp = new EventLogPermission (PermissionState.None);
SecurityElement se = elp.ToXml ();
SecurityElement w = new SecurityElement (se.Tag);
w.AddAttribute ("class", "Wrong" + se.Attribute ("class"));
w.AddAttribute ("version", se.Attribute ("version"));
elp.FromXml (w);
// doesn't care of the class name at that stage
// anyway the class has already be created so...
}
// Constructor.
internal EventLogPermissionEntryCollection(EventLogPermission perm)
{
this.perm = perm;
}
public void FromXml_WrongVersion ()
{
EventLogPermission elp = new EventLogPermission (PermissionState.None);
SecurityElement se = elp.ToXml ();
se.Attributes.Remove ("version");
se.Attributes.Add ("version", "2");
elp.FromXml (se);
}
public void IsSubset_Self ()
{
foreach (EventLogPermissionAccess elpa in AllAccess) {
EventLogPermission elp = new EventLogPermission (PermissionState.None);
elp.PermissionEntries.Add (new EventLogPermissionEntry (elpa, elpa.ToString ()));
Assert.IsTrue (elp.IsSubsetOf (elp), elpa.ToString ());
}
}
public void IsSubset_Unrestricted ()
{
// IsSubset with unrestricted
// a. source (this) is unrestricted -> target is never a subset
// b. destination (target) is unrestricted -> source is always a subset
EventLogPermission elp1 = new EventLogPermission (PermissionState.Unrestricted);
foreach (EventLogPermissionAccess elpa in AllAccess) {
EventLogPermission elp2 = new EventLogPermission (PermissionState.None);
elp2.PermissionEntries.Add (new EventLogPermissionEntry (elpa, elpa.ToString ()));
Assert.IsFalse (elp1.IsSubsetOf (elp2), "target " + elpa.ToString ());
Assert.IsTrue (elp2.IsSubsetOf (elp1), "source " + elpa.ToString ());
}
Assert.IsTrue (elp1.IsSubsetOf (elp1), "Unrestricted.IsSubsetOf(Unrestricted)");
}
// "special" behavior inherited from ResourceBasePermission
// [ExpectedException (typeof (ArgumentException))]
public void IsSubsetOf_BadPermission ()
{
EventLogPermission elp1 = new EventLogPermission (PermissionState.Unrestricted);
Assert.IsFalse (elp1.IsSubsetOf (new SecurityPermission (SecurityPermissionFlag.Assertion)));
}
public void IsSubset_Null ()
{
EventLogPermission elp = new EventLogPermission (PermissionState.None);
#if NET_2_0
Assert.IsTrue (elp.IsSubsetOf (null), "null");
#else
Assert.IsFalse (elp.IsSubsetOf (null), "null");
#endif
}
private void Close(string currentMachineName) {
EventLogPermission permission = new EventLogPermission(EventLogPermissionAccess.Write, currentMachineName);
permission.Demand();
Debug.WriteLineIf(CompModSwitches.EventLog.TraceVerbose, "EventLog::Close");
//Trace("Close", "Closing the event log");
if (readHandle != null) {
try {
readHandle.Close();
}
catch (IOException) {
throw SharedUtils.CreateSafeWin32Exception();
}
readHandle = null;
//Trace("Close", "Closed read handle");
Debug.WriteLineIf(CompModSwitches.EventLog.TraceVerbose, "EventLog::Close: closed read handle");
}
if (writeHandle != null) {
try {
writeHandle.Close();
}
catch (IOException) {
throw SharedUtils.CreateSafeWin32Exception();
}
writeHandle = null;
//Trace("Close", "Closed write handle");
Debug.WriteLineIf(CompModSwitches.EventLog.TraceVerbose, "EventLog::Close: closed write handle");
}
if (boolFlags[Flag_monitoring])
StopRaisingEvents(/*currentMachineName,*/ GetLogName(currentMachineName));
if (messageLibraries != null) {
foreach (SafeLibraryHandle handle in messageLibraries.Values)
handle.Close();
messageLibraries = null;
}
boolFlags[Flag_sourceVerified] = false;
}
