MARKUS

using System;

using System.Collections.Generic;

using System.Globalization;

using System.Net.NetworkInformation;

using System.Security.Cryptography;

using System.Security.Cryptography.Xml;

using System.ServiceModel;

using System.Threading;

using System.Xml;

//using log4net;

using Rhino.Licensing.Discovery;

namespace Rhino.Licensing

{

    /// <summary>

    /// Base license validator.

    /// </summary>

    public abstract class AbstractLicenseValidator

    {

        /// <summary>

        /// License validator logger

        /// </summary>

        //protected static readonly ILog Log = LogManager.GetLogger(typeof(LicenseValidator));

        /// <summary>

        /// Standard Time servers

        /// </summary>

        protected static readonly string[] TimeServers =

        {

            "time.nist.gov",

            "time-nw.nist.gov",

            "time-a.nist.gov",

            "time-b.nist.gov",

            "time-a.timefreq.bldrdoc.gov",

            "time-b.timefreq.bldrdoc.gov",

            "time-c.timefreq.bldrdoc.gov",

            "utcnist.colorado.edu",

            "nist1.datum.com",

            "nist1.dc.certifiedtime.com",

            "nist1.nyc.certifiedtime.com",

            "nist1.sjc.certifiedtime.com"

        };

        private readonly string licenseServerUrl;

        private readonly Guid clientId;

        private readonly string publicKey;

        private readonly Timer nextLeaseTimer;

        private bool disableFutureChecks;

        private bool currentlyValidatingSubscriptionLicense;

        private readonly DiscoveryHost discoveryHost;

        private DiscoveryClient discoveryClient;

        private Guid senderId;

        /// <summary>

        /// Fired when license data is invalidated

        /// </summary>

        public event Action<InvalidationType> LicenseInvalidated;

        /// <summary>

        /// Fired when license is expired

        /// </summary>

        public event Action<DateTime> LicenseExpired;

        /// <summary>

        /// Event that's raised when duplicate licenses are found

        /// </summary>

        public event EventHandler<DiscoveryHost.ClientDiscoveredEventArgs> MultipleLicensesWereDiscovered;

        /// <summary>

        /// Disable the <see cref="ExpirationDate"/> validation with the time servers

        /// </summary>

        public bool DisableTimeServersCheck

        {

            get; set;

        }

        /// <summary>

        /// Gets the expiration date of the license

        /// </summary>

        public DateTime ExpirationDate

        {

            get; private set;

        }

        /// <summary>

        /// Lease timeout

        /// </summary>

        public TimeSpan LeaseTimeout { get; set; }

        /// <summary>

        /// How to behave when using the same license multiple times

        /// </summary>

        public MultipleLicenseUsage MultipleLicenseUsageBehavior { get; set; }

        /// <summary>

        /// Gets or Sets the endpoint address of the subscription service

        /// </summary>

        public string SubscriptionEndpoint

        {

            get; set;

        }

        /// <summary>

        /// Gets the Type of the license

        /// </summary>

        public LicenseType LicenseType

        {

            get; private set;

        }

        /// <summary>

        /// Gets the Id of the license holder

        /// </summary>

        public Guid UserId

        {

            get; private set;

        }

        /// <summary>

        /// Gets the name of the license holder

        /// </summary>

        public string Name

        {

            get; private set;

        }

        /// <summary>

        /// Gets or Sets Floating license support

        /// </summary>

        public bool DisableFloatingLicenses

        {

            get; set;

        }

        /// <summary>

        /// Whether the client discovery server is enabled. This detects duplicate licenses used on the same network.

        /// </summary>

        public bool DiscoveryEnabled { get; private set; }

        /// <summary>

        /// Gets extra license information

        /// </summary>

        public IDictionary<string, string> LicenseAttributes

        {

            get; private set;

        }

        /// <summary>

        /// Gets or Sets the license content

        /// </summary>

        protected abstract string License

        {

            get; set;

        }

        /// <summary>

        /// Creates a license validator with specfied public key.

        /// </summary>

        /// <param name="publicKey">public key</param>

        /// <param name="enableDiscovery">Whether to enable the client discovery server to detect duplicate licenses used on the same network.</param>

        protected AbstractLicenseValidator(string publicKey, bool enableDiscovery = false)

        {

            LeaseTimeout = TimeSpan.FromMinutes(5);

            LicenseAttributes = new Dictionary<string, string>();

            nextLeaseTimer = new Timer(LeaseLicenseAgain);

            this.publicKey = publicKey;

            DiscoveryEnabled = enableDiscovery;

            if (DiscoveryEnabled)

            {

                senderId = Guid.NewGuid();

                discoveryHost = new DiscoveryHost();

                discoveryHost.ClientDiscovered += DiscoveryHostOnClientDiscovered;

                discoveryHost.Start();

            }

        }

        /// <summary>

        /// Creates a license validator using the client information

        /// and a service endpoint address to validate the license.

        /// </summary>

        protected AbstractLicenseValidator(string publicKey, string licenseServerUrl, Guid clientId)

            : this(publicKey)

        {

            this.licenseServerUrl = licenseServerUrl;

            this.clientId = clientId;

        }

        private void LeaseLicenseAgain(object state)

        {

            var client = discoveryClient;

            if (client != null)

                client.PublishMyPresence();

            if (HasExistingLicense())

                return;

            RaiseLicenseInvalidated();

        }

        private void RaiseLicenseInvalidated()

        {

            var licenseInvalidated = LicenseInvalidated;

            if (licenseInvalidated == null)

                throw new InvalidOperationException("License was invalidated, but there is no one subscribe to the LicenseInvalidated event");

            licenseInvalidated(LicenseType == LicenseType.Floating ? InvalidationType.CannotGetNewLicense :

                                                                     InvalidationType.TimeExpired);

        }

        private void RaiseMultipleLicenseDiscovered(DiscoveryHost.ClientDiscoveredEventArgs args)

        {

            var onMultipleLicensesWereDiscovered = MultipleLicensesWereDiscovered;

            if (onMultipleLicensesWereDiscovered != null)

            {

                onMultipleLicensesWereDiscovered(this, args);

            }

        }

        private void DiscoveryHostOnClientDiscovered(object sender, DiscoveryHost.ClientDiscoveredEventArgs clientDiscoveredEventArgs)

        {

            if (senderId == clientDiscoveredEventArgs.SenderId) // we got our own notification, ignore it

                return;

            if (UserId != clientDiscoveredEventArgs.UserId) // another license, we don't care

                return;

            // same user id, different senders

            switch (MultipleLicenseUsageBehavior)

            {

                case MultipleLicenseUsage.AllowForSameUser:

                    if (Environment.UserName == clientDiscoveredEventArgs.UserName)

                        return;

                    break;

            }

            RaiseLicenseInvalidated();

            RaiseMultipleLicenseDiscovered(clientDiscoveredEventArgs);

        }

        /// <summary>

        /// Validates loaded license

        /// </summary>

        public virtual void AssertValidLicense()

        {

            LicenseAttributes.Clear();

            if (HasExistingLicense())

            {

                if (DiscoveryEnabled)

                {

                    discoveryClient = new DiscoveryClient(senderId, UserId, Environment.MachineName, Environment.UserName);

                    discoveryClient.PublishMyPresence();

                }

                return;

            }

            //Log.WarnFormat("Could not validate existing license\r\n{0}", License);

            throw new LicenseNotFoundException();

        }

        private bool HasExistingLicense()

        {

            try

            {

                if (TryLoadingLicenseValuesFromValidatedXml() == false)

                {

                    //Log.WarnFormat("Failed validating license:\r\n{0}", License);

                    return false;

                }

                //Log.InfoFormat("License expiration date is {0}", ExpirationDate);

                bool result;

                if (LicenseType == LicenseType.Subscription)

                {

                    result = ValidateSubscription();

                }

                else

                {

                    result = DateTime.UtcNow < ExpirationDate;

                }

                if (result &&

                    !DisableTimeServersCheck)

                {

                    ValidateUsingNetworkTime();

                }

                if (!result)

                {

                    if (LicenseExpired == null)

                        throw new LicenseExpiredException("Expiration Date : " + ExpirationDate);

                    DisableFutureChecks();

                    LicenseExpired(ExpirationDate);

                }

                return true;

            }

            catch (RhinoLicensingException)

            {

                throw;

            }

            catch (Exception)

            {

                return false;

            }

        }

        private bool ValidateSubscription()

        {

            if ((ExpirationDate - DateTime.UtcNow).TotalDays > 4)

                return true;

            if (currentlyValidatingSubscriptionLicense)

                return DateTime.UtcNow < ExpirationDate;

            if (SubscriptionEndpoint == null)

                throw new InvalidOperationException("Subscription endpoints are not supported for this license validator");

            try

            {

                TryGettingNewLeaseSubscription();

            }

            catch (Exception e)

            {

                //Log.Error("Could not re-lease subscription license", e);

                throw new Exception("Could not re-lease subscription license", e);

            }

            return ValidateWithoutUsingSubscriptionLeasing();

        }

        private bool ValidateWithoutUsingSubscriptionLeasing()

        {

            currentlyValidatingSubscriptionLicense = true;

            try

            {

                return HasExistingLicense();

            }

            finally

            {

                currentlyValidatingSubscriptionLicense = false;

            }

        }

        private void TryGettingNewLeaseSubscription()

        {

            var service = ChannelFactory<ISubscriptionLicensingService>.CreateChannel(new BasicHttpBinding(), new EndpointAddress(SubscriptionEndpoint));

            try

            {

                var newLicense = service.LeaseLicense(License);

                TryOverwritingWithNewLicense(newLicense);

            }

            finally

            {

                var communicationObject = service as ICommunicationObject;

                if (communicationObject != null)

                {

                    try

                    {

                        communicationObject.Close(TimeSpan.FromMilliseconds(200));

                    }

                    catch

                    {

                        communicationObject.Abort();

                    }

                }

            }

        }

        /// <summary>

        /// Loads the license file.

        /// </summary>

        /// <param name="newLicense"></param>

        /// <returns></returns>

        protected bool TryOverwritingWithNewLicense(string newLicense)

        {

            if (string.IsNullOrEmpty(newLicense))

                return false;

            try

            {

                var xmlDocument = new XmlDocument();

                xmlDocument.LoadXml(newLicense);

            }

            catch (Exception e)

            {

                // Log.Error("New license is not valid XML\r\n" + newLicense, e);

                System.Diagnostics.Debug.WriteLine("New license is not valid XML\r\n" + newLicense, e);

                //throw new Exception("New license is not valid XML\r\n" + newLicense, e);

                return false;

            }

            License = newLicense;

            return true;

        }

        private void ValidateUsingNetworkTime()

        {

            if (!NetworkInterface.GetIsNetworkAvailable())

                return;

            var sntp = new SntpClient(GetTimeServers());

            sntp.BeginGetDate(time =>

            {

                if (time > ExpirationDate)

                    RaiseLicenseInvalidated();

            }

            , () =>

            {

                /* ignored */

            });

        }

        /// <summary>

        /// Extension point to return different time servers

        /// </summary>

        /// <returns></returns>

        protected virtual string[] GetTimeServers()

        {

            return TimeServers;

        }

        /// <summary>

        /// Removes existing license from the machine.

        /// </summary>

        public virtual void RemoveExistingLicense()

        {

        }

        /// <summary>

        /// Loads license data from validated license file.

        /// </summary>

        /// <returns></returns>

        public bool TryLoadingLicenseValuesFromValidatedXml()

        {

            try

            {

                var doc = new XmlDocument();

                doc.LoadXml(License);

                if (TryGetValidDocument(publicKey, doc) == false)

                {

                    //Log.WarnFormat("Could not validate xml signature of:\r\n{0}", License);

                    return false;

                }

                if (doc.FirstChild == null)

                {

                    //Log.WarnFormat("Could not find first child of:\r\n{0}", License);

                    return false;

                }

                if (doc.SelectSingleNode("/floating-license") != null)

                {

                    var node = doc.SelectSingleNode("/floating-license/license-server-public-key/text()");

                    if (node == null)

                    {

                        //Log.WarnFormat("Invalid license, floating license without license server public key:\r\n{0}", License);

                        throw new InvalidOperationException(

                            "Invalid license file format, floating license without license server public key");

                    }

                    return ValidateFloatingLicense(node.InnerText);

                }

                var result = ValidateXmlDocumentLicense(doc);

                if (result && disableFutureChecks == false)

                {

                    nextLeaseTimer.Change(LeaseTimeout, LeaseTimeout);

                }

                return result;

            }

            catch (RhinoLicensingException)

            {

                throw;

            }

            catch (Exception e)

            {

                //Log.Error("Could not validate license", e);

                System.Diagnostics.Debug.WriteLine("Could not validate license", e);

                return false;

            }

        }

        private bool ValidateFloatingLicense(string publicKeyOfFloatingLicense)

        {

            if (DisableFloatingLicenses)

            {

               // Log.Warn("Floating licenses have been disabled");

                System.Diagnostics.Debug.WriteLine("Floating licenses have been disabled");

                return false;

            }

            if (licenseServerUrl == null)

            {

                //Log.Warn("Could not find license server url");

                throw new InvalidOperationException("Floating license encountered, but licenseServerUrl was not set");

            }

            var success = false;

            var licensingService = ChannelFactory<ILicensingService>.CreateChannel(new WSHttpBinding(), new EndpointAddress(licenseServerUrl));

            try

            {

                   var leasedLicense = licensingService.LeaseLicense(

                    Environment.MachineName,

                    Environment.UserName,

                    clientId);

                ((ICommunicationObject)licensingService).Close();

                success = true;

                if (leasedLicense == null)

                {

                    //Log.WarnFormat("Null response from license server: {0}", licenseServerUrl);

                    throw new FloatingLicenseNotAvailableException();

                }

                var doc = new XmlDocument();

                doc.LoadXml(leasedLicense);

                if (TryGetValidDocument(publicKeyOfFloatingLicense, doc) == false)

                {

                    //Log.WarnFormat("Could not get valid license from floating license server {0}", licenseServerUrl);

                    throw new FloatingLicenseNotAvailableException();

                }

                var validLicense = ValidateXmlDocumentLicense(doc);

                if (validLicense)

                {

                    //setup next lease

                    var time = (ExpirationDate.AddMinutes(-5) - DateTime.UtcNow);

                    System.Diagnostics.Debug.WriteLine("Will lease license again at {0}", time);

                    //Log.DebugFormat("Will lease license again at {0}", time);

                    if (disableFutureChecks == false)

                        nextLeaseTimer.Change(time, time);

                }

                return validLicense;

            }

            finally

            {

                if (success == false)

                    ((ICommunicationObject)licensingService).Abort();

            }

        }

        internal bool ValidateXmlDocumentLicense(XmlDocument doc)

        {

            var id = doc.SelectSingleNode("/license/@id");

            if (id == null)

            {

                //Log.WarnFormat("Could not find id attribute in license:\r\n{0}", License);

                return false;

            }

            UserId = new Guid(id.Value);

            var date = doc.SelectSingleNode("/license/@expiration");

            if (date == null)

            {

                //Log.WarnFormat("Could not find expiration in license:\r\n{0}", License);

                return false;

            }

            ExpirationDate = DateTime.ParseExact(date.Value, "yyyy-MM-ddTHH:mm:ss.fffffff", CultureInfo.InvariantCulture);

            var licenseType = doc.SelectSingleNode("/license/@type");

            if (licenseType == null)

            {

                //Log.WarnFormat("Could not find license type in {0}", licenseType);

                return false;

            }

            LicenseType = (LicenseType)Enum.Parse(typeof(LicenseType), licenseType.Value);

            var name = doc.SelectSingleNode("/license/name/text()");

            if (name == null)

            {

                //Log.WarnFormat("Could not find licensee's name in license:\r\n{0}", License);

                return false;

            }

            Name = name.Value;

            var license = doc.SelectSingleNode("/license");

            foreach (XmlAttribute attrib in license.Attributes)

            {

                if (attrib.Name == "type" || attrib.Name == "expiration" || attrib.Name == "id")

                    continue;

                LicenseAttributes[attrib.Name] = attrib.Value;

            }

            return true;

        }

        private bool TryGetValidDocument(string licensePublicKey, XmlDocument doc)

        {

            var rsa = new RSACryptoServiceProvider();

            rsa.FromXmlString(licensePublicKey);

            var nsMgr = new XmlNamespaceManager(doc.NameTable);

            nsMgr.AddNamespace("sig", "http://www.w3.org/2000/09/xmldsig#");

            var signedXml = new SignedXml(doc);

            var sig = (XmlElement)doc.SelectSingleNode("//sig:Signature", nsMgr);

            if (sig == null)

            {

                //Log.WarnFormat("Could not find this signature node on license:\r\n{0}", License);

                return false;

            }

            signedXml.LoadXml(sig);

            return signedXml.CheckSignature(rsa);

        }

        /// <summary>

        /// Disables further license checks for the session.

        /// </summary>

        public void DisableFutureChecks()

        {

            disableFutureChecks = true;

            nextLeaseTimer.Dispose();

        }

        /// <summary>

        /// Options for detecting multiple licenses

        /// </summary>

        public enum MultipleLicenseUsage

        {

            /// <summary>

            /// Deny if multiple licenses are used

            /// </summary>

            Deny,

            /// <summary>

            /// Only allow if it is running for the same user

            /// </summary>

            AllowForSameUser

        }

    }

}