1 files changed, 66 insertions, 10 deletions
diff --git a/src/DotNetOpenId/XriIdentifier.cs b/src/DotNetOpenId/XriIdentifier.cs
index a82913d..129f8fa 100644
--- a/src/DotNetOpenId/XriIdentifier.cs
+++ b/src/DotNetOpenId/XriIdentifier.cs
@@ -8,14 +8,26 @@ using System.IO;
 using System.Xml;
 
 namespace DotNetOpenId {
-	class XriIdentifier : Identifier {
+	/// <summary>
+	/// An XRI style of OpenID Identifier.
+	/// </summary>
+	[Serializable]
+	public sealed class XriIdentifier : Identifier {
 		internal static readonly char[] GlobalContextSymbols = { '=', '@', '+', '$', '!' };
 		const string xriScheme = "xri://";
 
-		public XriIdentifier(string xri) {
+		internal XriIdentifier(string xri) : this(xri, false) { }
+		internal XriIdentifier(string xri, bool requireSsl)
+			: base(requireSsl) {
 			if (!IsValidXri(xri))
 				throw new FormatException(string.Format(CultureInfo.CurrentCulture,
 					Strings.InvalidXri, xri));
+			xriResolverProxy = xriResolverProxyTemplate;
+			if (requireSsl) {
+				// Indicate to xri.net that we require SSL to be used for delegated resolution
+				// of community i-names.
+				xriResolverProxy += ";https=true";
+			}
 			OriginalXri = xri;
 			CanonicalXri = canonicalizeXri(xri);
 		}
@@ -23,17 +35,18 @@ namespace DotNetOpenId {
 		/// <summary>
 		/// The original XRI supplied to the constructor.
 		/// </summary>
-		public string OriginalXri { get; private set; }
+		internal string OriginalXri { get; private set; }
 		/// <summary>
 		/// The canonical form of the XRI string.
 		/// </summary>
-		public string CanonicalXri { get; private set; }
+		internal string CanonicalXri { get; private set; }
 
 		/// <summary>
 		/// Tests whether a given string represents a valid XRI format.
 		/// </summary>
 		internal static bool IsValidXri(string xri) {
 			if (string.IsNullOrEmpty(xri)) throw new ArgumentNullException("xri");
+			xri = xri.Trim();
 			// TODO: better validation code here
 			return xri.IndexOfAny(GlobalContextSymbols) == 0
 				|| xri.StartsWith("(", StringComparison.Ordinal)
@@ -44,40 +57,83 @@ namespace DotNetOpenId {
 		/// Takes any valid form of XRI string and returns the canonical form of the same XRI.
 		/// </summary>
 		static string canonicalizeXri(string xri) {
+			xri = xri.Trim();
 			if (xri.StartsWith(xriScheme, StringComparison.OrdinalIgnoreCase))
 				xri = xri.Substring(xriScheme.Length);
 			return xri;
 		}
 
-		const string xriResolverProxy = "http://xri.net/{0}?_xrd_r=application/xrds%2Bxml;sep=false";
+		/// <summary>
+		/// The magic URL that will provide us an XRDS document for a given XRI identifier.
+		/// </summary>
+		/// <remarks>
+		/// We use application/xrd+xml instead of application/xrds+xml because it gets
+		/// xri.net to automatically give us exactly the right XRD element for community i-names
+		/// automatically, saving us having to choose which one to use out of the result.
+		/// The ssl=true parameter tells the proxy resolver to accept only SSL connections
+		/// when resolving community i-names.
+		/// </remarks>
+		const string xriResolverProxyTemplate = "https://xri.net/{0}?_xrd_r=application/xrd%2Bxml;sep=false";
+		readonly string xriResolverProxy;
 		/// <summary>
 		/// Resolves the XRI to a URL from which an XRDS document may be downloaded.
 		/// </summary>
-		protected virtual Uri XrdsUrl {
+		private Uri XrdsUrl {
 			get {
-				return new Uri(string.Format(CultureInfo.InvariantCulture, 
+				return new Uri(string.Format(CultureInfo.InvariantCulture,
 					xriResolverProxy, this));
 			}
 		}
 
 		XrdsDocument downloadXrds() {
 			var xrdsResponse = UntrustedWebRequest.Request(XrdsUrl);
-			return new XrdsDocument(XmlReader.Create(xrdsResponse.ResponseStream));
+			XrdsDocument doc = new XrdsDocument(XmlReader.Create(xrdsResponse.ResponseStream));
+			if (!doc.IsXrdResolutionSuccessful) {
+				throw new OpenIdException(Strings.XriResolutionFailed);
+			}
+			return doc;
+		}
+
+		internal override IEnumerable<ServiceEndpoint> Discover() {
+			return downloadXrds().CreateServiceEndpoints(this);
+		}
+
+		/// <summary>
+		/// Performs discovery on THIS identifier, but generates <see cref="ServiceEndpoint"/>
+		/// instances that treat another given identifier as the user-supplied identifier.
+		/// </summary>
+		internal IEnumerable<ServiceEndpoint> Discover(XriIdentifier userSuppliedIdentifier) {
+			return downloadXrds().CreateServiceEndpoints(userSuppliedIdentifier);
 		}
 
-		internal override ServiceEndpoint Discover() {
-			return downloadXrds().CreateServiceEndpoint(this);
+		internal override Identifier TrimFragment() {
+			return this;
 		}
 
+		internal override bool TryRequireSsl(out Identifier secureIdentifier) {
+			secureIdentifier = IsDiscoverySecureEndToEnd ? this : new XriIdentifier(this, true);
+			return true;
+		}
+
+		/// <summary>
+		/// Tests equality between this XRI and another XRI.
+		/// </summary>
 		public override bool Equals(object obj) {
 			XriIdentifier other = obj as XriIdentifier;
 			if (other == null) return false;
 			return this.CanonicalXri == other.CanonicalXri;
 		}
+
+		/// <summary>
+		/// Returns the hash code of this XRI.
+		/// </summary>
 		public override int GetHashCode() {
 			return CanonicalXri.GetHashCode();
 		}
 
+		/// <summary>
+		/// Returns the canonical string form of the XRI.
+		/// </summary>
 		public override string ToString() {
 			return CanonicalXri;
 		}