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

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

Developer Fusion