/// <summary>
/// Process a new response from the license server.
/// This data will be used for computing future policy decisions. The
/// following parameters are processed:
/// <ul>
/// <li>VT: the timestamp that the client should consider the response valid until</li>
/// <li>GT: the timestamp that the client should ignore retry errors until</li>
/// <li>GR: the number of retry errors that the client should ignore</li>
/// </ul>
/// </summary>
/// <param name="response">
/// the result from validating the server response
/// </param>
/// <param name="rawData">
/// the raw server response data
/// </param>
public void ProcessServerResponse(PolicyServerResponse response, ResponseData rawData)
{
// Update retry counter
this.RetryCount = response == PolicyServerResponse.Retry ? this.RetryCount + 1 : 0;
switch (response)
{
case PolicyServerResponse.Licensed:
// Update server policy data
Dictionary <string, string> extras;
if (!PolicyExtensions.TryDecodeExtras(rawData.Extra, out extras))
{
Debug.WriteLine("Invalid syntax error while decoding extras data from server.");
}
else
{
this.SetValidityTimestamp(extras.ContainsKey("VT") ? extras["VT"] : DefaultValidityTimestamp);
this.SetRetryUntil(extras.ContainsKey("GT") ? extras["GT"] : DefaultRetryUntil);
this.SetMaxRetries(extras.ContainsKey("GR") ? extras["GR"] : DefaultMaxRetries);
}
break;
case PolicyServerResponse.NotLicensed:
this.SetValidityTimestamp(DefaultValidityTimestamp);
this.SetRetryUntil(DefaultRetryUntil);
this.SetMaxRetries(DefaultMaxRetries);
break;
}
this.LastResponse = response;
this.preferences.Commit();
}
/// <summary>
/// Set the last validity timestamp (VT) received from the server and add to
/// preferences. You must manually call PreferenceObfuscator.commit() to
/// commit these changes to disk.
/// </summary>
/// <param name="timestamp">
/// the VT string received
/// </param>
private void SetValidityTimestamp(string timestamp)
{
long t;
if (!long.TryParse(timestamp, out t))
{
// No response or not parsable, expire in one minute.
System.Diagnostics.Debug.WriteLine("License validity timestamp (VT) missing, caching for a minute");
t = PolicyExtensions.GetCurrentMilliseconds() + PolicyExtensions.MillisPerMinute;
}
this.ValidityTimestamp = t;
}
/// <summary>
/// Process a new response from the license server.
/// We call this to guarantee that we fetch a fresh policy from the
/// server. This is to be used if the URL is invalid.
/// This data will be used for computing future policy decisions.
/// The following parameters are processed:
/// <ul>
/// <li>VT: the timestamp that the client should consider the response valid until</li>
/// <li>GT: the timestamp that the client should ignore retry errors until</li>
/// <li>GR: the number of retry errors that the client should ignore</li>
/// </ul>
/// </summary>
/// <param name="response">
/// the result from validating the server response
/// </param>
/// <param name="rawData">
/// the raw server response data
/// </param>
public void ProcessServerResponse(PolicyServerResponse response, ResponseData rawData)
{
// Update retry counter
if (response == PolicyServerResponse.Retry)
{
this.RetryCount = this.RetryCount + 1;
}
else
{
this.RetryCount = 0;
}
if (response == PolicyServerResponse.Licensed)
{
// Update server policy data
var extras = new Dictionary <string, string>();
try
{
extras = PolicyExtensions.DecodeExtras(rawData.Extra);
}
catch (Exception)
{
Debug.WriteLine("Invalid syntax error while decoding extras data from server.");
}
// If no response or not parseable, expire in one minute.
this.ValidityTimestamp = PolicyExtensions.GetCurrentMilliseconds() + PolicyExtensions.MillisPerMinute;
foreach (var pair in extras)
{
this.ProcessResponseExtra(pair);
}
}
else if (response == PolicyServerResponse.NotLicensed)
{
// Clear out stale policy data
this.ValidityTimestamp = 0;
this.RetryUntil = 0;
this.MaxRetries = 0;
}
this.LastResponse = response;
this.obfuscator.Commit();
}
/// <summary>
/// This implementation allows access if either:
/// <ol>
/// <li>a LICENSED response was received within the validity period</li>
/// <li>
/// a RETRY response was received in the last minute, and we are under
/// the RETRY count or in the RETRY period.
/// </li>
/// </ol>
/// </summary>
/// <returns>
/// The allow access.
/// </returns>
public virtual bool AllowAccess()
{
bool allowed = false;
long ts = PolicyExtensions.GetCurrentMilliseconds();
if (this.LastResponse == PolicyServerResponse.Licensed)
{
// Check if the LICENSED response occurred within the validity timeout and is still valid.
allowed = ts <= this.ValidityTimestamp;
}
else if (this.LastResponse == PolicyServerResponse.Retry &&
ts < this.LastResponseTime + PolicyExtensions.MillisPerMinute)
{
// Only allow access if we are within the retry period or we haven't used up our max retries.
allowed = ts <= this.RetryUntil || this.RetryCount <= this.MaxRetries;
}
return(allowed);
}
/// <summary>
/// Process a new response from the license server.
/// This data will be used for computing future policy decisions. The
/// following parameters are processed:
/// <ul>
/// <li>VT: the timestamp that the client should consider the response valid until</li>
/// <li>GT: the timestamp that the client should ignore retry errors until</li>
/// <li>GR: the number of retry errors that the client should ignore</li>
/// </ul>
/// </summary>
/// <param name="response">
/// the result from validating the server response
/// </param>
/// <param name="rawData">
/// the raw server response data
/// </param>
public virtual void ProcessServerResponse(PolicyServerResponse response, ResponseData rawData)
{
// Update retry counter
this.RetryCount = response == PolicyServerResponse.Retry ? this.RetryCount + 1 : 0;
switch (response)
{
case PolicyServerResponse.Licensed:
// Update server policy data
Dictionary <string, string> extras;
if (!PolicyExtensions.TryDecodeExtras(rawData.Extra, out extras))
{
Debug.WriteLine("Invalid syntax error while decoding extras data from server.");
}
// If no response or not parseable, expire in one minute.
this.ValidityTimestamp = PolicyExtensions.GetCurrentMilliseconds() + PolicyExtensions.MillisPerMinute;
foreach (var pair in extras)
{
this.ProcessResponseExtra(pair);
}
break;
case PolicyServerResponse.NotLicensed:
this.ValidityTimestamp = Preferences.DefaultValidityTimestamp;
this.RetryUntil = Preferences.DefaultRetryUntil;
this.MaxRetries = Preferences.DefaultMaxRetries;
break;
}
this.LastResponse = response;
this.Obfuscator.Commit();
}
/// <summary>
/// This implementation allows access if either:
/// <ol>
/// <li>a LICENSED response was received within the validity period</li>
/// <li>
/// a RETRY response was received in the last minute, and we
/// are under the RETRY count or in the RETRY period.
/// </li>
/// </ol>
/// </summary>
/// <returns>
/// True if access is allowed, otherwise false.
/// </returns>
public bool AllowAccess()
{
long ts = PolicyExtensions.GetCurrentMilliseconds();
if (this.LastResponse == PolicyServerResponse.Licensed)
{
// Check if the LICENSED response occurred within the validity
// timeout.
if (ts <= this.ValidityTimestamp)
{
// Cached LICENSED response is still valid.
return(true);
}
}
else if (this.LastResponse == PolicyServerResponse.Retry &&
ts < this.LastResponseTime + PolicyExtensions.MillisPerMinute)
{
// Only allow access if we are within the retry period or we
// haven't used up our max retries.
return(ts <= this.RetryUntil || this.RetryCount <= this.MaxRetries);
}
return(false);
}