Merge pull request #3566 from ntherning/fix-time-zone-issues-on-windows

[mono.git] / mcs / class / corlib / System.Security.AccessControl / SystemAcl.cs

diff --git a/mcs/class/corlib/System.Security.AccessControl/SystemAcl.cs b/mcs/class/corlib/System.Security.AccessControl/SystemAcl.cs
index fe169e680d9968386c0dfe535d2bd3aac1569263..238fe8c904189e0f50d67ae0eaacb2116c01e0d0 100644 (file)
--- a/mcs/class/corlib/System.Security.AccessControl/SystemAcl.cs
+++ b/mcs/class/corlib/System.Security.AccessControl/SystemAcl.cs
@@ -1,10 +1,13 @@
 //
 // System.Security.AccessControl.SystemAcl implementation
 //
-// Author:
+// Authors:
 //     Dick Porter  <dick@ximian.com>
+//     Atsushi Enomoto  <atsushi@ximian.com>
+//     James Bellinger  <jfb@zer7.com>
 //
-// Copyright (C) 2006 Novell, Inc (http://www.novell.com)
+// Copyright (C) 2006-2007 Novell, Inc (http://www.novell.com)
+// Copyright (C) 2012      James Bellinger
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the
@@ -26,32 +29,34 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
-#if NET_2_0
-
 using System.Security.Principal;
 
-namespace System.Security.AccessControl {
+namespace System.Security.AccessControl
+{
        public sealed class SystemAcl : CommonAcl
        {
                public SystemAcl (bool isContainer, bool isDS, int capacity)
+                       : base (isContainer, isDS, capacity)
                {
                }
                
                public SystemAcl (bool isContainer, bool isDS, RawAcl rawAcl)
+                       : base (isContainer, isDS, rawAcl)
                {
                }
                
-               public SystemAcl (bool isContainer, bool isDS, byte revision,
-                                 int capacity)
+               public SystemAcl (bool isContainer, bool isDS, byte revision, int capacity)
+                       : base (isContainer, isDS, revision, capacity)
                {
                }
-               
+
                public void AddAudit (AuditFlags auditFlags,
                                      SecurityIdentifier sid, int accessMask,
                                      InheritanceFlags inheritanceFlags,
                                      PropagationFlags propagationFlags)
                {
-                       throw new NotImplementedException ();
+                       AddAce (AceQualifier.SystemAudit, sid, accessMask,
+                               inheritanceFlags, propagationFlags, auditFlags);
                }
                
                public void AddAudit (AuditFlags auditFlags,
@@ -62,9 +67,17 @@ namespace System.Security.AccessControl {
                                      Guid objectType,
                                      Guid inheritedObjectType)
                {
-                       throw new NotImplementedException ();
+                       AddAce (AceQualifier.SystemAudit, sid, accessMask,
+                               inheritanceFlags, propagationFlags, auditFlags,
+                               objectFlags, objectType, inheritedObjectType);
                }
-               
+
+               public void AddAudit (SecurityIdentifier sid, ObjectAuditRule rule)
+               {
+                       AddAudit (rule.AuditFlags, sid, rule.AccessMask, rule.InheritanceFlags, rule.PropagationFlags, rule.ObjectFlags, rule.ObjectType, rule.InheritedObjectType);
+               }
+
+               [MonoTODO]
                public bool RemoveAudit (AuditFlags auditFlags,
                                         SecurityIdentifier sid,
                                         int accessMask,
@@ -74,6 +87,7 @@ namespace System.Security.AccessControl {
                        throw new NotImplementedException ();
                }
                
+               [MonoTODO]
                public bool RemoveAudit (AuditFlags auditFlags,
                                         SecurityIdentifier sid,
                                         int accessMask,
@@ -85,14 +99,21 @@ namespace System.Security.AccessControl {
                {
                        throw new NotImplementedException ();
                }
-               
+
+               public bool RemoveAudit (SecurityIdentifier sid, ObjectAuditRule rule)
+               {
+                       return RemoveAudit (rule.AuditFlags, sid, rule.AccessMask, rule.InheritanceFlags, rule.PropagationFlags, rule.ObjectFlags, rule.ObjectType, rule.InheritedObjectType);
+               }
+
                public void RemoveAuditSpecific (AuditFlags auditFlags,
                                                 SecurityIdentifier sid,
                                                 int accessMask,
                                                 InheritanceFlags inheritanceFlags,
                                                 PropagationFlags propagationFlags)
                {
-                       throw new NotImplementedException ();
+                       RemoveAceSpecific (AceQualifier.SystemAudit, sid, accessMask,
+                                          inheritanceFlags, propagationFlags, auditFlags);
+
                }
                
                public void RemoveAuditSpecific (AuditFlags auditFlags,
@@ -104,16 +125,25 @@ namespace System.Security.AccessControl {
                                                 Guid objectType,
                                                 Guid inheritedObjectType)
                {
-                       throw new NotImplementedException ();
+                       RemoveAceSpecific (AceQualifier.SystemAudit, sid, accessMask,
+                                          inheritanceFlags, propagationFlags, auditFlags,
+                                          objectFlags, objectType, inheritedObjectType);
+
                }
-               
+
+               public void RemoveAuditSpecific (SecurityIdentifier sid, ObjectAuditRule rule)
+               {
+                       RemoveAuditSpecific (rule.AuditFlags, sid, rule.AccessMask, rule.InheritanceFlags, rule.PropagationFlags, rule.ObjectFlags, rule.ObjectType, rule.InheritedObjectType);
+               }
+
                public void SetAudit (AuditFlags auditFlags,
                                      SecurityIdentifier sid,
                                      int accessMask,
                                      InheritanceFlags inheritanceFlags,
                                      PropagationFlags propagationFlags)
                {
-                       throw new NotImplementedException ();
+                       SetAce (AceQualifier.SystemAudit, sid, accessMask,
+                               inheritanceFlags, propagationFlags, auditFlags);
                }
                
                public void SetAudit (AuditFlags auditFlags,
@@ -125,9 +155,46 @@ namespace System.Security.AccessControl {
                                      Guid objectType,
                                      Guid inheritedObjectType)
                {
-                       throw new NotImplementedException ();
+                       SetAce (AceQualifier.SystemAudit, sid, accessMask,
+                               inheritanceFlags, propagationFlags, auditFlags,
+                               objectFlags, objectType, inheritedObjectType);
+               }
+
+               public void SetAudit (SecurityIdentifier sid, ObjectAuditRule rule)
+               {
+                       SetAudit (rule.AuditFlags, sid, rule.AccessMask, rule.InheritanceFlags, rule.PropagationFlags, rule.ObjectFlags, rule.ObjectType, rule.InheritedObjectType);
+               }
+
+               internal override void ApplyCanonicalSortToExplicitAces ()
+               {
+                       int explicitCount = GetCanonicalExplicitAceCount ();
+                       ApplyCanonicalSortToExplicitAces (0, explicitCount);
+               }
+               
+               internal override int GetAceInsertPosition (AceQualifier aceQualifier)
+               {
+                       return 0;
+               }
+               
+               internal override bool IsAceMeaningless (GenericAce ace)
+               {
+                       if (base.IsAceMeaningless (ace)) return true;
+                       if (!IsValidAuditFlags (ace.AuditFlags)) return true;
+                       
+                       QualifiedAce qace = ace as QualifiedAce;
+                       if (null != qace) {
+                               if (!(AceQualifier.SystemAudit == qace.AceQualifier ||
+                                     AceQualifier.SystemAlarm == qace.AceQualifier)) return true;
+                       }
+                       
+                       return false;
+               }
+               
+               static bool IsValidAuditFlags (AuditFlags auditFlags)
+               {
+                       return auditFlags != AuditFlags.None &&
+                              auditFlags == ((AuditFlags.Success|AuditFlags.Failure) & auditFlags);
                }
        }
 }
 
-#endif