/// <summary>
/// Recieves passive verification
/// </summary>
/// <param name="message"></param>
internal static void ReceivePassiveVerification(NetIncomingMessage message)
{
try
{
var result = Handshake.FinishHandshakeFromPassive(message);
// Finished!
}
catch (Lidgren.Network.Authentication.NetSRP.HandShakeException ex)
{
ExceptionHandle(message, ex.Message);
return;
}
(message.SenderConnection.Tag as Handshake).MarkHandshakeAsSucceeded();
OnSucces.Invoke("Authentication completed!");
}
/// <summary>
/// Receives active party verification
/// </summary>
/// <param name="message"></param>
internal static void ReceiveActiveVerification(NetIncomingMessage message)
{
try
{
var verification = Handshake.FinishHandshakeFromActive(message);
}
catch (Lidgren.Network.Authentication.NetSRP.HandShakeException ex)
{
ExceptionHandle(message, ex.Message);
return;
}
var result = Create(message.SenderConnection, Handshake.Contents.Verification, 21);
(message.SenderConnection.Tag as Handshake).WriteSRPVerification(result);
message.SenderConnection.SendMessage(result, NetDeliveryMethod.ReliableUnordered, 0);
// Finished!
(message.SenderConnection.Tag as Handshake).MarkHandshakeAsSucceeded();
OnSucces.Invoke("Authentication completed!");
}
/// <summary>
/// Handles incoming messages
/// </summary>
/// <param name="message"></param>
public static Handshake.Contents IncomingMessage(NetIncomingMessage message)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
var reasonByte = message.ReadByte();
var reason = (Handshake.Contents)reasonByte;
#if DEBUG
Console.WriteLine(">> Got handshake {0} <<", reason);
#endif
var handshake = message.SenderConnection.Tag as Handshake;
switch (reason)
{
case Handshake.Contents.Succes:
OnSucces.Invoke("Authentication complete!");
return(reason);
case Handshake.Contents.Error:
OnError.Invoke(message.ReadString());
return(reason);
case Handshake.Contents.Denied:
OnDenied.Invoke(message.ReadString());
return(reason);
}
if (handshake == null) // Server
{
switch (reason)
{
case Handshake.Contents.Username:
ReceiveAuthenticate(message);
break;
default:
// Can't happen!
throw new Lidgren.Network.Authentication.NetSRP.HandShakeException("Handshake not initialized when receiving " + reason.ToString() + " from client");
}
return(reason);
}
switch (handshake.HandshakeState)
{
case Handshake.State.Expired:
case Handshake.State.Denied:
case Handshake.State.NotInitialized: // Server
switch (reason)
{
case Handshake.Contents.Username:
ReceiveAuthenticate(message);
break;
default:
// Can't happen!
throw new Lidgren.Network.Authentication.NetSRP.HandShakeException("Handshake not initialized when receiving " + reason.ToString() + " from client");
}
break;
case Handshake.State.Succeeded:
return(Handshake.Contents.Succes);
case Handshake.State.Requesting: // Client
switch (reason)
{
case Handshake.Contents.Password:
ReceiveResponse(message);
break;
case Handshake.Contents.Expired:
Authenticate(message.SenderConnection, handshake.Username, handshake.UserData);
break;
default:
// Can't happen!
throw new Lidgren.Network.Authentication.NetSRP.HandShakeException("Expected response but received: " + reason.ToString() + " from server");
}
break;
case Handshake.State.Responding: // Server
switch (reason)
{
case Handshake.Contents.Verification:
ReceiveActiveVerification(message);
break;
case Handshake.Contents.Expired:
ReceiveFromExpired(message);
break;
default:
// Can't happen!
throw new Lidgren.Network.Authentication.NetSRP.HandShakeException("Expected verification but received: " + reason.ToString() + " from client ");
}
break;
case Handshake.State.Verificating: // Client
switch (reason)
{
case Handshake.Contents.Expired:
Authenticate(message.SenderConnection, handshake.Username, handshake.UserData);
break;
case Handshake.Contents.Verification:
ReceivePassiveVerification(message);
break;
default:
// Can't happen!
throw new Lidgren.Network.Authentication.NetSRP.HandShakeException("Expected completion but received: " + reason.ToString() + " from server ");
}
break;
default:
throw new Lidgren.Network.Authentication.NetSRP.HandShakeException("Expected nothing but received: " + reason.ToString());
}
if (handshake.HandshakeState == Handshake.State.Succeeded)
{
return(Handshake.Contents.Succes);
}
return(reason);
}
return(Handshake.Contents.None);
}
public async Task <ApiOutput <T> > ProcessApi <T>(string url, HttpMethod method, object input, ApiSucces succesModel = default)
{
var jsonStr = JsonConvert.SerializeObject(input);
var content = new StringContent(jsonStr, Encoding.UTF8, "application/json");
HttpResponseMessage response = null;
if (method == HttpMethod.Post)
{
response = await _httpClient.PostAsync(url, content);
}
else if (method == HttpMethod.Put)
{
response = await _httpClient.PutAsync(url, content);
}
else if (method == HttpMethod.Get)
{
url = SetParamsToUrl(url, input);
response = await _httpClient.GetAsync(url);
}
else if (method == HttpMethod.Delete)
{
url = SetParamsToUrl(url, input);
response = await _httpClient.DeleteAsync(url);
}
var outputString = await response.Content.ReadAsStringAsync();
var output = JsonConvert.DeserializeObject <ApiOutput <T> >(outputString, new JsonSerializerSettings()
{
DefaultValueHandling = DefaultValueHandling.Ignore
});
if (output == null)
{
var error = new ApiError()
{
Message = "Service unvaliable",
StatusCode = System.Net.HttpStatusCode.ServiceUnavailable
};
if (OnError != null)
{
OnError.Invoke(error);
}
}
else if (!response.IsSuccessStatusCode)
{
if (OnError != null)
{
output.Error.StatusCode = response.StatusCode;
OnError.Invoke(output.Error);
}
}
else
{
if (OnSucces != null)
{
OnSucces.Invoke(succesModel);
}
}
return(output);
}
