EnvironmentPermission.cs

//
// System.Security.Permissions.EnvironmentPermission.cs
//
// Authors:
//	Tim Coleman <tim@timcoleman.com>
//	Sebastien Pouliot  <sebastien@ximian.com>
//
// Copyright (C) 2002, Tim Coleman
// Portions Copyright (C) 2003 Motus Technologies (http://www.motus.com)
// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.Collections;
using System.Runtime.InteropServices;
using System.Text;

namespace SSMono.Security.Permissions
	{
	[ComVisible (true)]
	[Serializable]
	public sealed class EnvironmentPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
		{
		#region Fields

		private const int version = 1;

//		EnvironmentPermissionAccess flags;
		private PermissionState _state;
		private ArrayList readList;
		private ArrayList writeList;

		#endregion // Fields

		#region Constructors

		public EnvironmentPermission (PermissionState state)
			: base ()
			{
			_state = CheckPermissionState (state, true);
			readList = new ArrayList ();
			writeList = new ArrayList ();
			}

		public EnvironmentPermission (EnvironmentPermissionAccess flag, string pathList)
			: base ()
			{
			readList = new ArrayList ();
			writeList = new ArrayList ();
			SetPathList (flag, pathList);
			}

		#endregion // Constructors

		#region Methods

		public void AddPathList (EnvironmentPermissionAccess flag, string pathList)
			{
			if (pathList == null)
				throw new ArgumentNullException ("pathList");

			string[] paths;
			switch (flag)
				{
				case EnvironmentPermissionAccess.AllAccess:
					paths = pathList.Split (';');
					foreach (string path in paths)
						{
						if (!readList.Contains (path))
							readList.Add (path);
						if (!writeList.Contains (path))
							writeList.Add (path);
						}
					break;
				case EnvironmentPermissionAccess.NoAccess:
					// ??? unit tests doesn't show removal using NoAccess ???
					break;
				case EnvironmentPermissionAccess.Read:
					paths = pathList.Split (';');
					foreach (string path in paths)
						{
						if (!readList.Contains (path))
							readList.Add (path);
						}
					break;
				case EnvironmentPermissionAccess.Write:
					paths = pathList.Split (';');
					foreach (string path in paths)
						{
						if (!writeList.Contains (path))
							writeList.Add (path);
						}
					break;
				default:
					ThrowInvalidFlag (flag, false);
					break;
				}
			}

		public override IPermission Copy ()
			{
			EnvironmentPermission ep = new EnvironmentPermission (_state);
			string path = GetPathList (EnvironmentPermissionAccess.Read);
			if (path != null)
				ep.SetPathList (EnvironmentPermissionAccess.Read, path);
			path = GetPathList (EnvironmentPermissionAccess.Write);
			if (path != null)
				ep.SetPathList (EnvironmentPermissionAccess.Write, path);
			return ep;
			}

		public override void FromXml (SecurityElement esd)
			{
			// General validation in CodeAccessPermission
			CheckSecurityElement (esd, "esd", version, version);
			// Note: we do not (yet) care about the return value 
			// as we only accept version 1 (min/max values)

			if (IsUnrestricted (esd))
				_state = PermissionState.Unrestricted;

			string read = esd.Attribute ("Read");
			if ((read != null) && (read.Length > 0))
				SetPathList (EnvironmentPermissionAccess.Read, read);

			string write = esd.Attribute ("Write");
			if ((write != null) && (write.Length > 0))
				SetPathList (EnvironmentPermissionAccess.Write, write);
			}

		public string GetPathList (EnvironmentPermissionAccess flag)
			{
			switch (flag)
				{
				case EnvironmentPermissionAccess.AllAccess:
				case EnvironmentPermissionAccess.NoAccess:
					ThrowInvalidFlag (flag, true);
					break;
				case EnvironmentPermissionAccess.Read:
					return GetPathList (readList);
				case EnvironmentPermissionAccess.Write:
					return GetPathList (writeList);
				default:
					ThrowInvalidFlag (flag, false);
					break;
				}
			return null; // never reached
			}

		public override IPermission Intersect (IPermission target)
			{
			EnvironmentPermission ep = Cast (target);
			if (ep == null)
				return null;

			if (IsUnrestricted ())
				return ep.Copy ();
			if (ep.IsUnrestricted ())
				return Copy ();

			int n = 0;
			EnvironmentPermission result = new EnvironmentPermission (PermissionState.None);
			string readTarget = ep.GetPathList (EnvironmentPermissionAccess.Read);
			if (readTarget != null)
				{
				string[] targets = readTarget.Split (';');
				foreach (string t in targets)
					{
					if (readList.Contains (t))
						{
						result.AddPathList (EnvironmentPermissionAccess.Read, t);
						n++;
						}
					}
				}

			string writeTarget = ep.GetPathList (EnvironmentPermissionAccess.Write);
			if (writeTarget != null)
				{
				string[] targets = writeTarget.Split (';');
				foreach (string t in targets)
					{
					if (writeList.Contains (t))
						{
						result.AddPathList (EnvironmentPermissionAccess.Write, t);
						n++;
						}
					}
				}
			return ((n > 0) ? result : null);
			}

		public override bool IsSubsetOf (IPermission target)
			{
			EnvironmentPermission ep = Cast (target);
			if (ep == null)
				return false;

			if (IsUnrestricted ())
				return ep.IsUnrestricted ();
			else if (ep.IsUnrestricted ())
				return true;

			foreach (string s in readList)
				{
				if (!ep.readList.Contains (s))
					return false;
				}

			foreach (string s in writeList)
				{
				if (!ep.writeList.Contains (s))
					return false;
				}

			return true;
			}

		public bool IsUnrestricted ()
			{
			return (_state == PermissionState.Unrestricted);
			}

		public void SetPathList (EnvironmentPermissionAccess flag, string pathList)
			{
			if (pathList == null)
				throw new ArgumentNullException ("pathList");
			string[] paths;
			switch (flag)
				{
				case EnvironmentPermissionAccess.AllAccess:
					readList.Clear ();
					writeList.Clear ();
					paths = pathList.Split (';');
					foreach (string path in paths)
						{
						readList.Add (path);
						writeList.Add (path);
						}
					break;
				case EnvironmentPermissionAccess.NoAccess:
					// ??? unit tests doesn't show removal using NoAccess ???
					break;
				case EnvironmentPermissionAccess.Read:
					readList.Clear ();
					paths = pathList.Split (';');
					foreach (string path in paths)
						readList.Add (path);
					break;
				case EnvironmentPermissionAccess.Write:
					writeList.Clear ();
					paths = pathList.Split (';');
					foreach (string path in paths)
						writeList.Add (path);
					break;
				default:
					ThrowInvalidFlag (flag, false);
					break;
				}
			}

		public override SecurityElement ToXml ()
			{
			SecurityElement se = Element (version);

			if (_state == PermissionState.Unrestricted)
				se.AddAttribute ("Unrestricted", "true");
			else
				{
				string path = GetPathList (EnvironmentPermissionAccess.Read);
				if (path != null)
					se.AddAttribute ("Read", path);
				path = GetPathList (EnvironmentPermissionAccess.Write);
				if (path != null)
					se.AddAttribute ("Write", path);
				}
			return se;
			}

		public override IPermission Union (IPermission other)
			{
			EnvironmentPermission ep = Cast (other);
			if (ep == null)
				return Copy ();

			if (IsUnrestricted () || ep.IsUnrestricted ())
				return new EnvironmentPermission (PermissionState.Unrestricted);

			if (IsEmpty () && ep.IsEmpty ())
				return null;

			EnvironmentPermission result = (EnvironmentPermission)Copy ();
			string path = ep.GetPathList (EnvironmentPermissionAccess.Read);
			if (path != null)
				result.AddPathList (EnvironmentPermissionAccess.Read, path);
			path = ep.GetPathList (EnvironmentPermissionAccess.Write);
			if (path != null)
				result.AddPathList (EnvironmentPermissionAccess.Write, path);
			return result;
			}

		// IBuiltInPermission
		int IBuiltInPermission.GetTokenIndex ()
			{
			return (int)BuiltInToken.Environment;
			}

		// helpers

		private bool IsEmpty ()
			{
			return ((_state == PermissionState.None) && (readList.Count == 0) && (writeList.Count == 0));
			}

		private EnvironmentPermission Cast (IPermission target)
			{
			if (target == null)
				return null;

			EnvironmentPermission ep = (target as EnvironmentPermission);
			if (ep == null)
				ThrowInvalidPermission (target, typeof(EnvironmentPermission));

			return ep;
			}

		internal void ThrowInvalidFlag (EnvironmentPermissionAccess flag, bool context)
			{
			string msg = null;
			if (context)
				msg = Locale.GetText ("Unknown flag '{0}'.");
			else
				msg = Locale.GetText ("Invalid flag '{0}' in this context.");
			throw new ArgumentException (String.Format (msg, flag), "flag");
			}

		private string GetPathList (ArrayList list)
			{
			if (IsUnrestricted ())
				return String.Empty;
			if (list.Count == 0)
				return String.Empty;
			StringBuilder sb = new StringBuilder ();
			foreach (string path in list)
				{
				sb.Append (path);
				sb.Append (";");
				}

			string result = sb.ToString ();
			// remove last ';'
			int n = result.Length;
			if (n > 0)
				return result.Substring (0, n - 1);

			return String.Empty;
			}

		#endregion // Methods
		}
	}