We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Security.Policy \ EvidenceEnumerator

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  16. //
  17. // Evidence.cs
  18. //
  19. // Use this class to keep a list of evidence associated with an Assembly
  20. //
  22. namespace System.Security.Policy
  23. {
  24.    
  25.     using System;
  26.     using System.Collections;
  27.     using System.IO;
  28.     using System.Configuration.Assemblies;
  29.     using System.Reflection;
  30.     using System.Runtime.InteropServices;
  31.     using System.Runtime.Remoting;
  32.     using System.Runtime.Serialization;
  33.     using System.Security.Util;
  34.     using System.Security.Permissions;
  35.     using System.Runtime.Serialization.Formatters.Binary;
  36.    
  37.     [Serializable()]
  38.     [System.Runtime.InteropServices.ComVisible(true)]
  39.     public sealed class Evidence : ICollection
  40.     {
  41.         private IList m_hostList;
  42.         private IList m_assemblyList;
  43.         private bool m_locked;
  44.        
  45.         public Evidence()
  46.         {
  47.             m_hostList = null;
  48.             m_assemblyList = null;
  49.             m_locked = false;
  50.         }
  51.        
  52.         public Evidence(Evidence evidence)
  53.         {
  54.             if (evidence == null)
  55.                 return;
  56.            
  57.             m_locked = false;
  58.             Merge(evidence);
  59.         }
  60.        
  61.         public Evidence(object[] hostEvidence, object[] assemblyEvidence)
  62.         {
  63.             m_locked = false;
  64.            
  65.             if (hostEvidence != null) {
  66.                 this.m_hostList = ArrayList.Synchronized(new ArrayList(hostEvidence));
  67.             }
  68.            
  69.             if (assemblyEvidence != null) {
  70.                 this.m_assemblyList = ArrayList.Synchronized(new ArrayList(assemblyEvidence));
  71.             }
  72.         }
  73.        
  74.         internal Evidence(char[] buffer)
  75.         {
  76.             int position = 0;
  77.             while (position < buffer.Length) {
  78.                 switch (buffer[position++]) {
  79.                     case BuiltInEvidenceHelper.idApplicationDirectory:
  80.                        
  81.                         {
  82.                             IBuiltInEvidence ad = new ApplicationDirectory();
  83.                             position = ad.InitFromBuffer(buffer, position);
  84.                             AddAssembly(ad);
  85.                             break;
  86.                         }
  88.                         break;
  89.                     case BuiltInEvidenceHelper.idStrongName:
  90.                        
  91.                         {
  92.                             IBuiltInEvidence sn = new StrongName();
  93.                             position = sn.InitFromBuffer(buffer, position);
  94.                             AddHost(sn);
  95.                             break;
  96.                         }
  98.                         break;
  99.                     case BuiltInEvidenceHelper.idZone:
  100.                        
  101.                         {
  102.                             IBuiltInEvidence z = new Zone();
  103.                             position = z.InitFromBuffer(buffer, position);
  104.                             AddHost(z);
  105.                             break;
  106.                         }
  108.                         break;
  109.                     case BuiltInEvidenceHelper.idUrl:
  110.                        
  111.                         {
  112.                             IBuiltInEvidence u = new Url();
  113.                             position = u.InitFromBuffer(buffer, position);
  114.                             AddHost(u);
  115.                             break;
  116.                         }
  118.                         break;
  119.                     case BuiltInEvidenceHelper.idSite:
  120.                        
  121.                         {
  122.                             IBuiltInEvidence s = new Site();
  123.                             position = s.InitFromBuffer(buffer, position);
  124.                             AddHost(s);
  125.                             break;
  126.                         }
  128.                         break;
  129.                     case BuiltInEvidenceHelper.idPermissionRequestEvidence:
  130.                        
  131.                         {
  132.                             IBuiltInEvidence pre = new PermissionRequestEvidence();
  133.                             position = pre.InitFromBuffer(buffer, position);
  134.                             AddHost(pre);
  135.                             break;
  136.                         }
  138.                         break;
  139.                     case BuiltInEvidenceHelper.idGac:
  140.                        
  141.                         {
  142.                             IBuiltInEvidence g = new GacInstalled();
  143.                             position = g.InitFromBuffer(buffer, position);
  144.                             AddHost(g);
  145.                             break;
  146.                         }
  148.                         break;
  149.                     default:
  150.                         throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup"));
  151.                         break;
  152.                 }
  153.                 // switch
  154.             }
  155.             // while
  156.         }
  157.        
  158.         public void AddHost(object id)
  159.         {
  160.             if (m_hostList == null)
  161.                 m_hostList = ArrayList.Synchronized(new ArrayList());
  162.            
  163.             if (m_locked)
  164.                 new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
  165.            
  166.             m_hostList.Add(id);
  167.         }
  168.        
  169.         public void AddAssembly(object id)
  170.         {
  171.             if (m_assemblyList == null)
  172.                 m_assemblyList = ArrayList.Synchronized(new ArrayList());
  173.            
  174.             m_assemblyList.Add(id);
  175.         }
  176.        
  177.         public bool Locked {
  178.             get { return m_locked; }
  179.            
  180.             set {
  181.                 if (!value) {
  182.                     new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
  183.                    
  184.                     m_locked = false;
  185.                 }
  186.                 else {
  187.                     m_locked = true;
  188.                 }
  189.             }
  190.         }
  191.        
  192.         public void Merge(Evidence evidence)
  193.         {
  194.             IEnumerator enumerator;
  195.            
  196.             if (evidence == null)
  197.                 return;
  198.            
  199.             if (evidence.m_hostList != null) {
  200.                 if (m_hostList == null)
  201.                     m_hostList = ArrayList.Synchronized(new ArrayList());
  202.                
  203.                 if (evidence.m_hostList.Count != 0 && this.m_locked)
  204.                     new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
  205.                
  206.                 enumerator = evidence.m_hostList.GetEnumerator();
  207.                 while (enumerator.MoveNext()) {
  208.                     m_hostList.Add(enumerator.Current);
  209.                 }
  210.             }
  211.            
  212.             if (evidence.m_assemblyList != null) {
  213.                 if (m_assemblyList == null)
  214.                     m_assemblyList = ArrayList.Synchronized(new ArrayList());
  215.                
  216.                 enumerator = evidence.m_assemblyList.GetEnumerator();
  217.                 while (enumerator.MoveNext()) {
  218.                     m_assemblyList.Add(enumerator.Current);
  219.                 }
  220.             }
  221.         }
  222.        
  223.         // Same as merge, except only one instance of any one evidence type is
  224.         // allowed. When duplicates are found, the evidence in the input
  225.         // argument will have priority.
  226.         internal void MergeWithNoDuplicates(Evidence evidence)
  227.         {
  228.             IEnumerator oldEnumerator;
  229.             IEnumerator newEnumerator;
  230.            
  231.             if (evidence == null)
  232.                 return;
  233.            
  234.             if (evidence.m_hostList != null) {
  235.                 if (m_hostList == null)
  236.                     m_hostList = ArrayList.Synchronized(new ArrayList());
  237.                
  238.                 newEnumerator = evidence.m_hostList.GetEnumerator();
  239.                 while (newEnumerator.MoveNext()) {
  240.                     Type newItemType = newEnumerator.Current.GetType();
  241.                     oldEnumerator = m_hostList.GetEnumerator();
  242.                     while (oldEnumerator.MoveNext()) {
  243.                         if (oldEnumerator.Current.GetType() == newItemType) {
  244.                             m_hostList.Remove(oldEnumerator.Current);
  245.                             break;
  246.                         }
  247.                     }
  248.                     m_hostList.Add(newEnumerator.Current);
  249.                 }
  250.             }
  251.            
  252.             if (evidence.m_assemblyList != null) {
  253.                 if (m_assemblyList == null)
  254.                     m_assemblyList = ArrayList.Synchronized(new ArrayList());
  255.                
  256.                 newEnumerator = evidence.m_assemblyList.GetEnumerator();
  257.                 while (newEnumerator.MoveNext()) {
  258.                     Type newItemType = newEnumerator.Current.GetType();
  259.                     oldEnumerator = m_assemblyList.GetEnumerator();
  260.                     while (oldEnumerator.MoveNext()) {
  261.                         if (oldEnumerator.Current.GetType() == newItemType) {
  262.                             m_assemblyList.Remove(oldEnumerator.Current);
  263.                             break;
  264.                         }
  265.                     }
  266.                     m_assemblyList.Add(newEnumerator.Current);
  267.                 }
  268.             }
  269.         }
  270.        
  271.         // ICollection implementation
  272.         public void CopyTo(Array array, int index)
  273.         {
  274.             int currentIndex = index;
  275.            
  276.             if (m_hostList != null) {
  277.                 m_hostList.CopyTo(array, currentIndex);
  278.                 currentIndex += m_hostList.Count;
  279.             }
  280.            
  281.             if (m_assemblyList != null) {
  282.                 m_assemblyList.CopyTo(array, currentIndex);
  283.             }
  284.         }
  285.        
  286.         public IEnumerator GetHostEnumerator()
  287.         {
  288.             if (m_hostList == null)
  289.                 m_hostList = ArrayList.Synchronized(new ArrayList());
  290.            
  291.             return m_hostList.GetEnumerator();
  292.         }
  293.        
  294.         public IEnumerator GetAssemblyEnumerator()
  295.         {
  296.             if (m_assemblyList == null)
  297.                 m_assemblyList = ArrayList.Synchronized(new ArrayList());
  298.            
  299.             return m_assemblyList.GetEnumerator();
  300.         }
  301.        
  302.         public IEnumerator GetEnumerator()
  303.         {
  304.             return new EvidenceEnumerator(this);
  305.         }
  306.        
  307.         public int Count {
  308.             get { return (m_hostList != null ? m_hostList.Count : 0) + (m_assemblyList != null ? m_assemblyList.Count : 0); }
  309.         }
  310.        
  311.         public object SyncRoot {
  312.             get { return this; }
  313.         }
  314.        
  315.         public bool IsSynchronized {
  316.             get { return false; }
  317.         }
  318.        
  319.         public bool IsReadOnly {
  320.             get { return false; }
  321.         }
  322.        
  323.         internal Evidence Copy()
  324.         {
  325.            
  326.             // Try the fast way. Will only work if all evidence components implement IBuiltInEvidence
  327.             char[] serEvidence = PolicyManager.MakeEvidenceArray(this, true);
  328.             if (serEvidence != null) {
  329.                 return new Evidence(serEvidence);
  330.             }
  331.            
  332.             // Use the general purpose formatter
  333.             new PermissionSet(true).Assert();
  334.            
  335.             MemoryStream stream = new MemoryStream();
  336.            
  337.             BinaryFormatter formatter = new BinaryFormatter();
  338.            
  339.             formatter.Serialize(stream, this);
  340.            
  341.             stream.Position = 0;
  342.            
  343.             return (Evidence)formatter.Deserialize(stream);
  344.         }
  345.        
  346.         internal Evidence ShallowCopy()
  347.         {
  348.             Evidence evidence = new Evidence();
  349.            
  350.             IEnumerator enumerator;
  351.            
  352.             enumerator = this.GetHostEnumerator();
  353.            
  354.             while (enumerator.MoveNext()) {
  355.                 evidence.AddHost(enumerator.Current);
  356.             }
  357.            
  358.             enumerator = this.GetAssemblyEnumerator();
  359.            
  360.             while (enumerator.MoveNext()) {
  361.                 evidence.AddAssembly(enumerator.Current);
  362.             }
  363.            
  364.             return evidence;
  365.         }
  366.        
  367.         [ComVisible(false)]
  368.         public void Clear()
  369.         {
  370.             m_hostList = null;
  371.             m_assemblyList = null;
  372.         }
  373.        
  374.         [ComVisible(false)]
  375.         public void RemoveType(Type t)
  376.         {
  377.             int i;
  378.             for (i = 0; i < (m_hostList == null ? 0 : m_hostList.Count); i++) {
  379.                 if (m_hostList[i].GetType() == t)
  380.                     m_hostList.RemoveAt(i--);
  381.             }
  382.             for (i = 0; i < (m_assemblyList == null ? 0 : m_assemblyList.Count); i++) {
  383.                 if (m_assemblyList[i].GetType() == t)
  384.                     m_assemblyList.RemoveAt(i--);
  385.             }
  386.         }
  387.        
  388.         [ComVisible(false)]
  389.         public override bool Equals(object obj)
  390.         {
  391.             Evidence other = obj as Evidence;
  392.            
  393.             if (other == null)
  394.                 return false;
  395.            
  396.             if (this.m_hostList != null && other.m_hostList != null) {
  397.                 if (this.m_hostList.Count != other.m_hostList.Count)
  398.                     return false;
  399.                
  400.                 int count = this.m_hostList.Count;
  401.                 for (int i = 0; i < count; ++i) {
  402.                     bool found = false;
  403.                    
  404.                     for (int j = 0; j < count; ++j) {
  405.                         if (Object.Equals(this.m_hostList[i], other.m_hostList[j])) {
  406.                             found = true;
  407.                             break;
  408.                         }
  409.                     }
  410.                    
  411.                     if (!found)
  412.                         return false;
  413.                 }
  414.             }
  415.             else if (this.m_hostList != null || other.m_hostList != null) {
  416.                 return false;
  417.             }
  418.            
  419.             if (this.m_assemblyList != null && other.m_assemblyList != null) {
  420.                 if (this.m_assemblyList.Count != other.m_assemblyList.Count)
  421.                     return false;
  422.                
  423.                 int count = this.m_assemblyList.Count;
  424.                 for (int i = 0; i < count; ++i) {
  425.                     bool found = false;
  426.                    
  427.                     for (int j = 0; j < count; ++j) {
  428.                         if (Object.Equals(m_assemblyList[i], other.m_assemblyList[j])) {
  429.                             found = true;
  430.                             break;
  431.                         }
  432.                     }
  433.                    
  434.                     if (!found)
  435.                         return false;
  436.                 }
  437.             }
  438.             else if (this.m_assemblyList != null || other.m_assemblyList != null) {
  439.                 return false;
  440.             }
  441.            
  442.             return true;
  443.         }
  444.        
  445.         [ComVisible(false)]
  446.         public override int GetHashCode()
  447.         {
  448.             int accumulator = 0;
  449.            
  450.             if (this.m_hostList != null) {
  451.                 int count = this.m_hostList.Count;
  452.                 for (int i = 0; i < count; ++i) {
  453.                     accumulator = accumulator ^ this.m_hostList[i].GetHashCode();
  454.                 }
  455.             }
  456.            
  457.             if (this.m_assemblyList != null) {
  458.                 int count = this.m_assemblyList.Count;
  459.                 for (int i = 0; i < count; ++i) {
  460.                     accumulator = accumulator ^ this.m_assemblyList[i].GetHashCode();
  461.                 }
  462.             }
  463.            
  464.             return accumulator;
  465.         }
  466.        
  467.         internal object FindType(Type t)
  468.         {
  469.             int i;
  470.             for (i = 0; i < (m_hostList == null ? 0 : m_hostList.Count); i++) {
  471.                 if (m_hostList[i].GetType() == t)
  472.                     return m_hostList[i];
  473.             }
  474.             for (i = 0; i < (m_assemblyList == null ? 0 : m_assemblyList.Count); i++) {
  475.                 if (m_assemblyList[i].GetType() == t)
  476.                     return m_hostList[i];
  477.             }
  478.             return null;
  479.         }
  480.     }
  481.    
  482.     sealed class EvidenceEnumerator : IEnumerator
  483.     {
  484.         private bool m_first;
  485.         private Evidence m_evidence;
  486.         private IEnumerator m_enumerator;
  487.        
  488.         public EvidenceEnumerator(Evidence evidence)
  489.         {
  490.             this.m_evidence = evidence;
  491.             Reset();
  492.         }
  493.        
  494.         public bool MoveNext()
  495.         {
  496.             if (m_enumerator == null) {
  497.                 return false;
  498.             }
  499.            
  500.             if (!m_enumerator.MoveNext()) {
  501.                 if (m_first) {
  502.                     m_enumerator = m_evidence.GetAssemblyEnumerator();
  503.                     m_first = false;
  504.                     if (m_enumerator != null)
  505.                         return m_enumerator.MoveNext();
  506.                     else
  507.                         return false;
  508.                 }
  509.                 else {
  510.                     return false;
  511.                 }
  512.             }
  513.             return true;
  514.         }
  515.        
  516.         public object Current {
  517.             get {
  518.                 if (m_enumerator == null)
  519.                     return null;
  520.                 else
  521.                     return m_enumerator.Current;
  522.             }
  523.         }
  524.        
  525.         public void Reset()
  526.         {
  527.             this.m_first = true;
  528.            
  529.             if (m_evidence != null) {
  530.                 m_enumerator = m_evidence.GetHostEnumerator();
  531.             }
  532.             else {
  533.                 m_enumerator = null;
  534.             }
  535.         }
  536.     }
  537. }

Developer Fusion