/// <summary>
/// Selects a common protocol version that both server and client support.
/// </summary>
/// <param name="ClientVersions">List of versions that the client supports. The list is ordered by client's preference.</param>
/// <param name="SelectedCommonVersion">If the function succeeds, this is set to the selected version that both client and server support.</param>
/// <returns>true if the function succeeds, false otherwise.</returns>
public bool GetCommonSupportedVersion(IEnumerable <ByteString> ClientVersions, out SemVer SelectedCommonVersion)
{
log.Trace("()");
SelectedCommonVersion = SemVer.Invalid;
SemVer selectedVersion = SemVer.Invalid;
bool res = false;
foreach (ByteString clVersion in ClientVersions)
{
SemVer version = new SemVer(clVersion);
if (version.Equals(SemVer.V100))
{
SelectedCommonVersion = version;
selectedVersion = version;
res = true;
break;
}
}
if (res)
{
log.Trace("(-):{0},SelectedCommonVersion='{1}'", res, selectedVersion);
}
else
{
log.Trace("(-):{0}", res);
}
return(res);
}
/// <summary>
/// Starts conversation with the server the client is connected to and checks whether the server response contains expected values.
/// </summary>
/// <returns>true if the function succeeds, false otherwise.</returns>
public async Task <bool> StartConversationAsync()
{
log.Trace("()");
PsProtocolMessage requestMessage = CreateStartConversationRequest();
await SendMessageAsync(requestMessage);
PsProtocolMessage responseMessage = await ReceiveMessageAsync();
bool idOk = responseMessage.Id == requestMessage.Id;
bool statusOk = responseMessage.Response.Status == Status.Ok;
bool challengeVerifyOk = VerifyProfileServerChallengeSignature(responseMessage);
SemVer receivedVersion = new SemVer(responseMessage.Response.ConversationResponse.Start.Version);
bool versionOk = receivedVersion.Equals(new SemVer(messageBuilder.Version));
bool pubKeyLenOk = responseMessage.Response.ConversationResponse.Start.PublicKey.Length == 32;
bool challengeOk = responseMessage.Response.ConversationResponse.Start.Challenge.Length == 32;
profileServerKey = responseMessage.Response.ConversationResponse.Start.PublicKey.ToByteArray();
challenge = responseMessage.Response.ConversationResponse.Start.Challenge.ToByteArray();
bool res = idOk && statusOk && challengeVerifyOk && versionOk && pubKeyLenOk && challengeOk;
log.Trace("(-):{0}", res);
return(res);
}
public void EqualsAndGetHashCode(SemVer value1, SemVer value2, bool expected)
{
value1.Equals(value2).Should().Be(expected);
if (expected)
{
value1.GetHashCode().Should().Be(value2.GetHashCode());
}
else
{
value1.GetHashCode().Should().NotBe(value2.GetHashCode());
}
}
/// <summary>
/// Implementation of the test itself.
/// </summary>
/// <returns>true if the test passes, false otherwise.</returns>
public override async Task <bool> RunAsync()
{
IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"];
int ClNonCustomerPort = (int)ArgumentValues["clNonCustomer Port"];
log.Trace("(ServerIp:'{0}',ClNonCustomerPort:{1})", ServerIp, ClNonCustomerPort);
bool res = false;
Passed = false;
ProtocolClient client = new ProtocolClient();
try
{
MessageBuilder mb = client.MessageBuilder;
// Step 1
await client.ConnectAsync(ServerIp, ClNonCustomerPort, true);
Message requestMessage = client.CreateStartConversationRequest();
await client.SendMessageAsync(requestMessage);
Message responseMessage = await client.ReceiveMessageAsync();
// Step 1 Acceptance
bool idOk = responseMessage.Id == requestMessage.Id;
bool statusOk = responseMessage.Response.Status == Status.Ok;
bool verifyChallengeOk = client.VerifyServerChallengeSignature(responseMessage);
SemVer receivedVersion = new SemVer(responseMessage.Response.ConversationResponse.Start.Version);
bool versionOk = receivedVersion.Equals(SemVer.V100);
bool pubKeyLenOk = responseMessage.Response.ConversationResponse.Start.PublicKey.Length == 32;
bool challengeOk = responseMessage.Response.ConversationResponse.Start.Challenge.Length == 32;
Passed = idOk && statusOk && verifyChallengeOk && versionOk && pubKeyLenOk && challengeOk;
res = true;
}
catch (Exception e)
{
log.Error("Exception occurred: {0}", e.ToString());
}
client.Dispose();
log.Trace("(-):{0}", res);
return(res);
}
/// <summary>
/// Starts conversation with the server the client is connected to and checks whether the server response contains expected values.
/// </summary>
/// <returns>true if the function succeeds, false otherwise.</returns>
public async Task <bool> StartConversationAsync()
{
log.Trace("()");
bool res = false;
Message requestMessage = CreateStartConversationRequest();
if (await SendMessageAsync(requestMessage))
{
Message responseMessage = await ReceiveMessageAsync();
if (CheckResponseMessage(requestMessage, responseMessage))
{
try
{
SemVer receivedVersion = new SemVer(responseMessage.Response.ConversationResponse.Start.Version);
bool versionOk = receivedVersion.Equals(new SemVer(MessageBuilder.Version));
bool pubKeyLenOk = responseMessage.Response.ConversationResponse.Start.PublicKey.Length == IdentityBase.IdentifierLength;
bool challengeOk = responseMessage.Response.ConversationResponse.Start.Challenge.Length == ProtocolHelper.ChallengeDataSize;
serverKey = responseMessage.Response.ConversationResponse.Start.PublicKey.ToByteArray();
serverId = Crypto.Sha256(serverKey);
serverChallenge = responseMessage.Response.ConversationResponse.Start.Challenge.ToByteArray();
bool challengeVerifyOk = VerifyServerChallengeSignature(responseMessage);
res = versionOk && pubKeyLenOk && challengeOk && challengeVerifyOk;
}
catch
{
log.Warn("Received unexpected or invalid message.");
}
}
else
{
log.Warn("Received unexpected or invalid message.");
}
}
else
{
log.Warn("Unable to send message.");
}
log.Trace("(-):{0}", res);
return(res);
}
/// <summary>
/// Implementation of the test itself.
/// </summary>
/// <returns>true if the test passes, false otherwise.</returns>
public override async Task <bool> RunAsync()
{
IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"];
int PrimaryPort = (int)ArgumentValues["primary Port"];
log.Trace("(ServerIp:'{0}',PrimaryPort:{1})", ServerIp, PrimaryPort);
bool res = false;
Passed = false;
ProtocolClient clientCallee = new ProtocolClient();
ProtocolClient clientCalleeAppService = new ProtocolClient(0, SemVer.V100, clientCallee.GetIdentityKeys());
ProtocolClient clientCaller = new ProtocolClient();
ProtocolClient clientCallerAppService = new ProtocolClient(0, SemVer.V100, clientCaller.GetIdentityKeys());
try
{
MessageBuilder mbCallee = clientCallee.MessageBuilder;
MessageBuilder mbCalleeAppService = clientCalleeAppService.MessageBuilder;
MessageBuilder mbCaller = clientCaller.MessageBuilder;
MessageBuilder mbCallerAppService = clientCallerAppService.MessageBuilder;
// Step 1
log.Trace("Step 1");
// Get port list.
byte[] pubKeyCallee = clientCallee.GetIdentityKeys().PublicKey;
byte[] identityIdCallee = clientCallee.GetIdentityId();
byte[] pubKeyCaller = clientCaller.GetIdentityKeys().PublicKey;
byte[] identityIdCaller = clientCaller.GetIdentityId();
await clientCallee.ConnectAsync(ServerIp, PrimaryPort, false);
Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>();
bool listPortsOk = await clientCallee.ListServerPorts(rolePorts);
clientCallee.CloseConnection();
// Establish hosting agreement for identity 1.
await clientCallee.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);
bool establishHostingOk = await clientCallee.EstablishHostingAsync();
clientCallee.CloseConnection();
// Check-in and initialize the profile of identity 1.
await clientCallee.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClCustomer], true);
bool checkInOk = await clientCallee.CheckInAsync();
bool initializeProfileOk = await clientCallee.InitializeProfileAsync("Test Identity", null, new GpsLocation(0, 0), null);
// Add application service to the current session.
string serviceName = "Test Service";
bool addAppServiceOk = await clientCallee.AddApplicationServicesAsync(new List <string>() { serviceName });
bool firstIdentityOk = listPortsOk && establishHostingOk && checkInOk && initializeProfileOk && addAppServiceOk;
// Establish hosting agreement for identity 2.
await clientCaller.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);
establishHostingOk = await clientCaller.EstablishHostingAsync();
clientCaller.CloseConnection();
// Check-in and initialize the profile of identity 2.
await clientCaller.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClCustomer], true);
checkInOk = await clientCaller.CheckInAsync();
initializeProfileOk = await clientCaller.InitializeProfileAsync("Test Identity", null, new GpsLocation(0, 0), null);
bool secondIdentityOk = establishHostingOk && checkInOk && initializeProfileOk;
// Step 1 Acceptance
bool step1Ok = firstIdentityOk && secondIdentityOk;
log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");
// Step 2
log.Trace("Step 2");
Message requestMessage = mbCaller.CreateCallIdentityApplicationServiceRequest(identityIdCallee, serviceName);
await clientCaller.SendMessageAsync(requestMessage);
// Step 2 Acceptance
bool step2Ok = true;
log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED");
// Step 3
log.Trace("Step 3");
Message serverRequestMessage = await clientCallee.ReceiveMessageAsync();
byte[] receivedPubKey = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CallerPublicKey.ToByteArray();
bool pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, pubKeyCaller) == 0;
bool serviceNameOk = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.ServiceName == serviceName;
bool incomingCallNotificationOk = pubKeyOk && serviceNameOk;
byte[] calleeToken = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CalleeToken.ToByteArray();
Message serverResponseMessage = mbCallee.CreateIncomingCallNotificationResponse(serverRequestMessage);
await clientCallee.SendMessageAsync(serverResponseMessage);
// Connect to clAppService and send initialization message.
await clientCalleeAppService.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClAppService], true);
Message requestMessageAppServiceCallee = mbCalleeAppService.CreateApplicationServiceSendMessageRequest(calleeToken, null);
await clientCalleeAppService.SendMessageAsync(requestMessageAppServiceCallee);
// Step 3 Acceptance
bool step3Ok = incomingCallNotificationOk;
log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED");
// Step 4
log.Trace("Step 4");
Message responseMessage = await clientCaller.ReceiveMessageAsync();
bool idOk = responseMessage.Id == requestMessage.Id;
bool statusOk = responseMessage.Response.Status == Status.Ok;
byte[] callerToken = responseMessage.Response.ConversationResponse.CallIdentityApplicationService.CallerToken.ToByteArray();
bool callIdentityOk = idOk && statusOk;
// Connect to clAppService and send initialization message.
await clientCallerAppService.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClAppService], true);
Message requestMessageAppServiceCaller = mbCallerAppService.CreateApplicationServiceSendMessageRequest(callerToken, null);
await clientCallerAppService.SendMessageAsync(requestMessageAppServiceCaller);
Message responseMessageAppServiceCaller = await clientCallerAppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCaller.Id == requestMessageAppServiceCaller.Id;
statusOk = responseMessageAppServiceCaller.Response.Status == Status.Ok;
bool initAppServiceMessageOk = idOk && statusOk;
// Step 4 Acceptance
bool step4Ok = callIdentityOk && initAppServiceMessageOk;
log.Trace("Step 4: {0}", step4Ok ? "PASSED" : "FAILED");
// Step 5
log.Trace("Step 5");
Message responseMessageAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCallee.Id == requestMessageAppServiceCallee.Id;
statusOk = responseMessageAppServiceCallee.Response.Status == Status.Ok;
bool typeOk = (responseMessageAppServiceCallee.MessageTypeCase == Message.MessageTypeOneofCase.Response) &&
(responseMessageAppServiceCallee.Response.ConversationTypeCase == Response.ConversationTypeOneofCase.SingleResponse) &&
(responseMessageAppServiceCallee.Response.SingleResponse.ResponseTypeCase == SingleResponse.ResponseTypeOneofCase.ApplicationServiceSendMessage);
bool appServiceSendOk = idOk && statusOk && typeOk;
// Step 5 Acceptance
bool step5Ok = appServiceSendOk;
log.Trace("Step 5: {0}", step5Ok ? "PASSED" : "FAILED");
// Step 6
log.Trace("Step 6");
string callerMessage1 = "Message #1 to callee.";
byte[] messageBytes = Encoding.UTF8.GetBytes(callerMessage1);
requestMessageAppServiceCaller = mbCallerAppService.CreateApplicationServiceSendMessageRequest(callerToken, messageBytes);
uint callerMessage1Id = requestMessageAppServiceCaller.Id;
await clientCallerAppService.SendMessageAsync(requestMessageAppServiceCaller);
string callerMessage2 = "Message #2 to callee.";
messageBytes = Encoding.UTF8.GetBytes(callerMessage2);
requestMessageAppServiceCaller = mbCallerAppService.CreateApplicationServiceSendMessageRequest(callerToken, messageBytes);
uint callerMessage2Id = requestMessageAppServiceCaller.Id;
await clientCallerAppService.SendMessageAsync(requestMessageAppServiceCaller);
string callerMessage3 = "Message #3 to callee.";
messageBytes = Encoding.UTF8.GetBytes(callerMessage3);
requestMessageAppServiceCaller = mbCallerAppService.CreateApplicationServiceSendMessageRequest(callerToken, messageBytes);
uint callerMessage3Id = requestMessageAppServiceCaller.Id;
await clientCallerAppService.SendMessageAsync(requestMessageAppServiceCaller);
// Step 6 Acceptance
bool step6Ok = true;
log.Trace("Step 6: {0}", step6Ok ? "PASSED" : "FAILED");
// Step 8
log.Trace("Step 7");
// Receive message #1.
Message serverRequestAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync();
SemVer receivedVersion = new SemVer(serverRequestAppServiceCallee.Request.SingleRequest.Version);
bool versionOk = receivedVersion.Equals(SemVer.V100);
typeOk = (serverRequestAppServiceCallee.MessageTypeCase == Message.MessageTypeOneofCase.Request) &&
(serverRequestAppServiceCallee.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.SingleRequest) &&
(serverRequestAppServiceCallee.Request.SingleRequest.RequestTypeCase == SingleRequest.RequestTypeOneofCase.ApplicationServiceReceiveMessageNotification);
string receivedMessage = Encoding.UTF8.GetString(serverRequestAppServiceCallee.Request.SingleRequest.ApplicationServiceReceiveMessageNotification.Message.ToByteArray());
bool messageOk = receivedMessage == callerMessage1;
bool receiveMessageOk1 = versionOk && typeOk && messageOk;
// ACK message #1.
Message serverResponseAppServiceCallee = mbCalleeAppService.CreateApplicationServiceReceiveMessageNotificationResponse(serverRequestAppServiceCallee);
await clientCalleeAppService.SendMessageAsync(serverResponseAppServiceCallee);
// Receive message #2.
serverRequestAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync();
receivedVersion = new SemVer(serverRequestAppServiceCallee.Request.SingleRequest.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
typeOk = (serverRequestAppServiceCallee.MessageTypeCase == Message.MessageTypeOneofCase.Request) &&
(serverRequestAppServiceCallee.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.SingleRequest) &&
(serverRequestAppServiceCallee.Request.SingleRequest.RequestTypeCase == SingleRequest.RequestTypeOneofCase.ApplicationServiceReceiveMessageNotification);
receivedMessage = Encoding.UTF8.GetString(serverRequestAppServiceCallee.Request.SingleRequest.ApplicationServiceReceiveMessageNotification.Message.ToByteArray());
messageOk = receivedMessage == callerMessage2;
bool receiveMessageOk2 = versionOk && typeOk && messageOk;
// ACK message #2.
serverResponseAppServiceCallee = mbCalleeAppService.CreateApplicationServiceReceiveMessageNotificationResponse(serverRequestAppServiceCallee);
await clientCalleeAppService.SendMessageAsync(serverResponseAppServiceCallee);
// Send our message #1.
string calleeMessage1 = "Message #1 to CALLER.";
messageBytes = Encoding.UTF8.GetBytes(calleeMessage1);
requestMessageAppServiceCallee = mbCalleeAppService.CreateApplicationServiceSendMessageRequest(calleeToken, messageBytes);
uint calleeMessage1Id = requestMessageAppServiceCallee.Id;
await clientCalleeAppService.SendMessageAsync(requestMessageAppServiceCallee);
// Receive message #3.
serverRequestAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync();
receivedVersion = new SemVer(serverRequestAppServiceCallee.Request.SingleRequest.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
typeOk = (serverRequestAppServiceCallee.MessageTypeCase == Message.MessageTypeOneofCase.Request) &&
(serverRequestAppServiceCallee.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.SingleRequest) &&
(serverRequestAppServiceCallee.Request.SingleRequest.RequestTypeCase == SingleRequest.RequestTypeOneofCase.ApplicationServiceReceiveMessageNotification);
receivedMessage = Encoding.UTF8.GetString(serverRequestAppServiceCallee.Request.SingleRequest.ApplicationServiceReceiveMessageNotification.Message.ToByteArray());
messageOk = receivedMessage == callerMessage3;
bool receiveMessageOk3 = versionOk && typeOk && messageOk;
// ACK message #2.
serverResponseAppServiceCallee = mbCalleeAppService.CreateApplicationServiceReceiveMessageNotificationResponse(serverRequestAppServiceCallee);
await clientCalleeAppService.SendMessageAsync(serverResponseAppServiceCallee);
// Send our message #2.
string calleeMessage2 = "Message #2 to CALLER.";
messageBytes = Encoding.UTF8.GetBytes(calleeMessage2);
requestMessageAppServiceCallee = mbCalleeAppService.CreateApplicationServiceSendMessageRequest(calleeToken, messageBytes);
uint calleeMessage2Id = requestMessageAppServiceCallee.Id;
await clientCalleeAppService.SendMessageAsync(requestMessageAppServiceCallee);
await Task.Delay(3000);
// Step 7 Acceptance
bool step7Ok = receiveMessageOk1 && receiveMessageOk2 && receiveMessageOk3;
log.Trace("Step 7: {0}", step7Ok ? "PASSED" : "FAILED");
// Step 8
log.Trace("Step 8");
// Receive ACK message #1.
responseMessageAppServiceCaller = await clientCallerAppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCaller.Id == callerMessage1Id;
statusOk = responseMessageAppServiceCaller.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessageAppServiceCaller.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
bool receiveAck1Ok = idOk && statusOk && versionOk;
// Receive ACK message #2.
responseMessageAppServiceCaller = await clientCallerAppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCaller.Id == callerMessage2Id;
statusOk = responseMessageAppServiceCaller.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessageAppServiceCaller.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
bool receiveAck2Ok = idOk && statusOk && versionOk;
// Receive message #1 from callee.
Message serverRequestAppServiceCaller = await clientCallerAppService.ReceiveMessageAsync();
receivedVersion = new SemVer(serverRequestAppServiceCaller.Request.SingleRequest.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
typeOk = (serverRequestAppServiceCaller.MessageTypeCase == Message.MessageTypeOneofCase.Request) &&
(serverRequestAppServiceCaller.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.SingleRequest) &&
(serverRequestAppServiceCaller.Request.SingleRequest.RequestTypeCase == SingleRequest.RequestTypeOneofCase.ApplicationServiceReceiveMessageNotification);
receivedMessage = Encoding.UTF8.GetString(serverRequestAppServiceCaller.Request.SingleRequest.ApplicationServiceReceiveMessageNotification.Message.ToByteArray());
messageOk = receivedMessage == calleeMessage1;
receiveMessageOk1 = versionOk && typeOk && messageOk;
// ACK message #1 from callee.
Message serverResponseAppServiceCaller = mbCallerAppService.CreateApplicationServiceReceiveMessageNotificationResponse(serverRequestAppServiceCaller);
await clientCallerAppService.SendMessageAsync(serverResponseAppServiceCaller);
// Receive ACK message #3.
responseMessageAppServiceCaller = await clientCallerAppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCaller.Id == callerMessage3Id;
statusOk = responseMessageAppServiceCaller.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessageAppServiceCaller.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
bool receiveAck3Ok = idOk && statusOk && versionOk;
// Receive message #2 from callee.
serverRequestAppServiceCaller = await clientCallerAppService.ReceiveMessageAsync();
receivedVersion = new SemVer(serverRequestAppServiceCaller.Request.SingleRequest.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
typeOk = (serverRequestAppServiceCaller.MessageTypeCase == Message.MessageTypeOneofCase.Request) &&
(serverRequestAppServiceCaller.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.SingleRequest) &&
(serverRequestAppServiceCaller.Request.SingleRequest.RequestTypeCase == SingleRequest.RequestTypeOneofCase.ApplicationServiceReceiveMessageNotification);
receivedMessage = Encoding.UTF8.GetString(serverRequestAppServiceCaller.Request.SingleRequest.ApplicationServiceReceiveMessageNotification.Message.ToByteArray());
messageOk = receivedMessage == calleeMessage2;
receiveMessageOk2 = versionOk && typeOk && messageOk;
// ACK message #2 from callee.
serverResponseAppServiceCaller = mbCallerAppService.CreateApplicationServiceReceiveMessageNotificationResponse(serverRequestAppServiceCaller);
await clientCallerAppService.SendMessageAsync(serverResponseAppServiceCaller);
// Step 8 Acceptance
bool step8Ok = receiveAck1Ok && receiveAck2Ok && receiveMessageOk1 && receiveAck3Ok && receiveMessageOk2;
log.Trace("Step 8: {0}", step8Ok ? "PASSED" : "FAILED");
// Step 9
log.Trace("Step 9");
// Receive ACK message #1.
responseMessageAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCallee.Id == calleeMessage1Id;
statusOk = responseMessageAppServiceCallee.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessageAppServiceCallee.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
receiveAck1Ok = idOk && statusOk && versionOk;
// Receive ACK message #2.
responseMessageAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCallee.Id == calleeMessage2Id;
statusOk = responseMessageAppServiceCallee.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessageAppServiceCallee.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
receiveAck2Ok = idOk && statusOk && versionOk;
// Step 9 Acceptance
bool step9Ok = receiveAck1Ok && receiveAck2Ok;
log.Trace("Step 9: {0}", step9Ok ? "PASSED" : "FAILED");
Passed = step1Ok && step2Ok && step3Ok && step4Ok && step5Ok && step6Ok && step7Ok && step8Ok && step9Ok;
res = true;
}
catch (Exception e)
{
log.Error("Exception occurred: {0}", e.ToString());
}
clientCallee.Dispose();
clientCalleeAppService.Dispose();
clientCaller.Dispose();
clientCallerAppService.Dispose();
log.Trace("(-):{0}", res);
return(res);
}
/// <summary>
/// Implementation of the test itself.
/// </summary>
/// <returns>true if the test passes, false otherwise.</returns>
public override async Task <bool> RunAsync()
{
IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"];
int ClNonCustomerPort = (int)ArgumentValues["clNonCustomer Port"];
int ClCustomerPort = (int)ArgumentValues["clCustomer Port"];
log.Trace("(ServerIp:'{0}',ClNonCustomerPort:{1},ClCustomerPort:{2})", ServerIp, ClNonCustomerPort, ClCustomerPort);
bool res = false;
Passed = false;
ProtocolClient client = new ProtocolClient();
try
{
MessageBuilder mb = client.MessageBuilder;
byte[] testPubKey = client.GetIdentityKeys().PublicKey;
byte[] testIdentityId = client.GetIdentityId();
// Step 1
await client.ConnectAsync(ServerIp, ClNonCustomerPort, true);
bool establishHostingOk = await client.EstablishHostingAsync();
// Step 1 Acceptance
bool step1Ok = establishHostingOk;
client.CloseConnection();
// Step 2
await client.ConnectAsync(ServerIp, ClCustomerPort, true);
bool checkInOk = await client.CheckInAsync();
Message requestMessage = mb.CreateUpdateProfileRequest(SemVer.V100, "Test Identity", null, new GpsLocation(1, 2), null);
await client.SendMessageAsync(requestMessage);
Message responseMessage = await client.ReceiveMessageAsync();
bool idOk = responseMessage.Id == requestMessage.Id;
bool statusOk = responseMessage.Response.Status == Status.Ok;
bool updateProfileOk = idOk && statusOk;
requestMessage = mb.CreateGetIdentityInformationRequest(testIdentityId);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool isHostedOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsHosted;
bool isOnlineOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsOnline;
byte[] receivedPubKey = responseMessage.Response.SingleResponse.GetIdentityInformation.IdentityPublicKey.ToByteArray();
bool pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, testPubKey) == 0;
SemVer receivedVersion = new SemVer(responseMessage.Response.SingleResponse.GetIdentityInformation.Version);
bool versionOk = receivedVersion.Equals(SemVer.V100);
bool nameOk = responseMessage.Response.SingleResponse.GetIdentityInformation.Name == "Test Identity";
bool extraDataOk = responseMessage.Response.SingleResponse.GetIdentityInformation.ExtraData == "";
bool locationOk = responseMessage.Response.SingleResponse.GetIdentityInformation.Latitude == 1 &&
responseMessage.Response.SingleResponse.GetIdentityInformation.Longitude == 2;
bool getIdentityInfoOk = idOk && statusOk && isHostedOk && isOnlineOk && pubKeyOk && versionOk && nameOk && extraDataOk && locationOk;
byte[] imageData = File.ReadAllBytes(string.Format("images{0}PS04006.jpg", Path.DirectorySeparatorChar));
requestMessage = mb.CreateUpdateProfileRequest(null, "Test Identity Renamed", imageData, new GpsLocation(-1, -2), "a=b");
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool updateProfileOk2 = idOk && statusOk;
requestMessage = mb.CreateGetIdentityInformationRequest(testIdentityId, true, true, false);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
isHostedOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsHosted;
isOnlineOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsOnline;
receivedPubKey = responseMessage.Response.SingleResponse.GetIdentityInformation.IdentityPublicKey.ToByteArray();
pubKeyOk = StructuralComparisons.StructuralComparer.Compare(testPubKey, receivedPubKey) == 0;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.GetIdentityInformation.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
nameOk = responseMessage.Response.SingleResponse.GetIdentityInformation.Name == "Test Identity Renamed";
extraDataOk = responseMessage.Response.SingleResponse.GetIdentityInformation.ExtraData == "a=b";
locationOk = responseMessage.Response.SingleResponse.GetIdentityInformation.Latitude == -1 &&
responseMessage.Response.SingleResponse.GetIdentityInformation.Longitude == -2;
byte[] receivedProfileImage = responseMessage.Response.SingleResponse.GetIdentityInformation.ProfileImage.ToByteArray();
bool profileImageOk = StructuralComparisons.StructuralComparer.Compare(receivedProfileImage, imageData) == 0;
byte[] receivedThumbnailImage = responseMessage.Response.SingleResponse.GetIdentityInformation.ThumbnailImage.ToByteArray();
bool thumbnailImageOk = receivedThumbnailImage.Length > 0;
bool getIdentityInfoOk2 = idOk && statusOk && isHostedOk && isOnlineOk && pubKeyOk && versionOk && nameOk && extraDataOk && locationOk && profileImageOk && thumbnailImageOk;
imageData = new byte[] { };
requestMessage = mb.CreateUpdateProfileRequest(null, null, imageData, null, null);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool updateProfileOk3 = idOk && statusOk;
requestMessage = mb.CreateGetIdentityInformationRequest(testIdentityId, true, true, false);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
isHostedOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsHosted;
isOnlineOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsOnline;
receivedPubKey = responseMessage.Response.SingleResponse.GetIdentityInformation.IdentityPublicKey.ToByteArray();
pubKeyOk = StructuralComparisons.StructuralComparer.Compare(testPubKey, receivedPubKey) == 0;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.GetIdentityInformation.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
nameOk = responseMessage.Response.SingleResponse.GetIdentityInformation.Name == "Test Identity Renamed";
extraDataOk = responseMessage.Response.SingleResponse.GetIdentityInformation.ExtraData == "a=b";
locationOk = responseMessage.Response.SingleResponse.GetIdentityInformation.Latitude == -1 &&
responseMessage.Response.SingleResponse.GetIdentityInformation.Longitude == -2;
receivedProfileImage = responseMessage.Response.SingleResponse.GetIdentityInformation.ProfileImage.ToByteArray();
profileImageOk = receivedProfileImage.Length == 0;
receivedThumbnailImage = responseMessage.Response.SingleResponse.GetIdentityInformation.ThumbnailImage.ToByteArray();
thumbnailImageOk = receivedThumbnailImage.Length == 0;
bool getIdentityInfoOk3 = idOk && statusOk && isHostedOk && isOnlineOk && pubKeyOk && versionOk && nameOk && extraDataOk && locationOk && profileImageOk && thumbnailImageOk;
// Step 2 Acceptance
bool step2Ok = checkInOk && updateProfileOk && getIdentityInfoOk && updateProfileOk2 && getIdentityInfoOk2 && updateProfileOk3 && getIdentityInfoOk3;
Passed = step1Ok && step2Ok;
res = true;
}
catch (Exception e)
{
log.Error("Exception occurred: {0}", e.ToString());
}
client.Dispose();
log.Trace("(-):{0}", res);
return(res);
}
/// <summary>
/// Implementation of the test itself.
/// </summary>
/// <returns>true if the test passes, false otherwise.</returns>
public override async Task <bool> RunAsync()
{
IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"];
int PrimaryPort = (int)ArgumentValues["primary Port"];
log.Trace("(ServerIp:'{0}',PrimaryPort:{1})", ServerIp, PrimaryPort);
bool res = false;
Passed = false;
ProtocolClient clientCallee = new ProtocolClient();
ProtocolClient clientCalleeAppService = new ProtocolClient(0, SemVer.V100, clientCallee.GetIdentityKeys());
ProtocolClient clientCaller = new ProtocolClient();
ProtocolClient clientCallerAppService = new ProtocolClient(0, SemVer.V100, clientCaller.GetIdentityKeys());
try
{
MessageBuilder mbCallee = clientCallee.MessageBuilder;
MessageBuilder mbCalleeAppService = clientCalleeAppService.MessageBuilder;
MessageBuilder mbCaller = clientCaller.MessageBuilder;
MessageBuilder mbCallerAppService = clientCallerAppService.MessageBuilder;
// Step 1
log.Trace("Step 1");
// Get port list.
byte[] pubKeyCallee = clientCallee.GetIdentityKeys().PublicKey;
byte[] identityIdCallee = clientCallee.GetIdentityId();
byte[] pubKeyCaller = clientCaller.GetIdentityKeys().PublicKey;
byte[] identityIdCaller = clientCaller.GetIdentityId();
await clientCallee.ConnectAsync(ServerIp, PrimaryPort, false);
Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>();
bool listPortsOk = await clientCallee.ListServerPorts(rolePorts);
clientCallee.CloseConnection();
// Establish hosting agreement for identity 1.
await clientCallee.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);
bool establishHostingOk = await clientCallee.EstablishHostingAsync();
clientCallee.CloseConnection();
// Check-in and initialize the profile of identity 1.
await clientCallee.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClCustomer], true);
bool checkInOk = await clientCallee.CheckInAsync();
bool initializeProfileOk = await clientCallee.InitializeProfileAsync("Test Identity", null, new GpsLocation(0, 0), null);
// Add application service to the current session.
string serviceName = "Test Service";
bool addAppServiceOk = await clientCallee.AddApplicationServicesAsync(new List <string>() { serviceName });
// Step 1 Acceptance
bool step1Ok = listPortsOk && establishHostingOk && checkInOk && initializeProfileOk && addAppServiceOk;
log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");
// Step 2
log.Trace("Step 2");
await clientCaller.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);
bool verifyIdentityOk = await clientCaller.VerifyIdentityAsync();
Message requestMessage = mbCaller.CreateCallIdentityApplicationServiceRequest(identityIdCallee, serviceName);
await clientCaller.SendMessageAsync(requestMessage);
// Step 2 Acceptance
bool step2Ok = verifyIdentityOk;
log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED");
// Step 3
log.Trace("Step 3");
Message serverRequestMessage = await clientCallee.ReceiveMessageAsync();
byte[] receivedPubKey = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CallerPublicKey.ToByteArray();
bool pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, pubKeyCaller) == 0;
bool serviceNameOk = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.ServiceName == serviceName;
bool incomingCallNotificationOk = pubKeyOk && serviceNameOk;
byte[] calleeToken = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CalleeToken.ToByteArray();
Message serverResponseMessage = mbCallee.CreateIncomingCallNotificationResponse(serverRequestMessage);
await clientCallee.SendMessageAsync(serverResponseMessage);
// Connect to clAppService and send initialization message.
await clientCalleeAppService.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClAppService], true);
Message requestMessageAppServiceCallee = mbCalleeAppService.CreateApplicationServiceSendMessageRequest(calleeToken, null);
await clientCalleeAppService.SendMessageAsync(requestMessageAppServiceCallee);
// Step 3 Acceptance
bool step3Ok = incomingCallNotificationOk;
log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED");
// Step 4
log.Trace("Step 4");
Message responseMessage = await clientCaller.ReceiveMessageAsync();
bool idOk = responseMessage.Id == requestMessage.Id;
bool statusOk = responseMessage.Response.Status == Status.Ok;
byte[] callerToken = responseMessage.Response.ConversationResponse.CallIdentityApplicationService.CallerToken.ToByteArray();
bool callIdentityOk = idOk && statusOk;
// Connect to clAppService and send initialization message.
await clientCallerAppService.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClAppService], true);
Message requestMessageAppServiceCaller = mbCallerAppService.CreateApplicationServiceSendMessageRequest(callerToken, null);
await clientCallerAppService.SendMessageAsync(requestMessageAppServiceCaller);
Message responseMessageAppServiceCaller = await clientCallerAppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCaller.Id == requestMessageAppServiceCaller.Id;
statusOk = responseMessageAppServiceCaller.Response.Status == Status.Ok;
bool initAppServiceMessageOk = idOk && statusOk;
clientCaller.CloseConnection();
// Step 4 Acceptance
bool step4Ok = callIdentityOk && initAppServiceMessageOk;
log.Trace("Step 4: {0}", step4Ok ? "PASSED" : "FAILED");
// Step 5
log.Trace("Step 5");
Message responseMessageAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCallee.Id == requestMessageAppServiceCallee.Id;
statusOk = responseMessageAppServiceCallee.Response.Status == Status.Ok;
bool appServiceSendOk = idOk && statusOk;
// Step 5 Acceptance
bool step5Ok = appServiceSendOk;
log.Trace("Step 5: {0}", step5Ok ? "PASSED" : "FAILED");
// Step 6
log.Trace("Step 6");
bool error = false;
int messagesDelivered = 0;
int messagesSent = 0;
bool disconnectedOk = false;
for (int i = 0; i < 20; i++)
{
try
{
// Caller sends message.
string callerMessage = string.Format("Message #{0} to callee.", i + 1);
byte[] messageBytes = Encoding.UTF8.GetBytes(callerMessage);
requestMessageAppServiceCaller = mbCallerAppService.CreateApplicationServiceSendMessageRequest(callerToken, messageBytes);
await clientCallerAppService.SendMessageAsync(requestMessageAppServiceCaller);
messagesSent++;
// Callee receives message.
Message serverRequestAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync();
SemVer receivedVersion = new SemVer(serverRequestAppServiceCallee.Request.SingleRequest.Version);
bool versionOk = receivedVersion.Equals(SemVer.V100);
bool typeOk = (serverRequestAppServiceCallee.MessageTypeCase == Message.MessageTypeOneofCase.Request) &&
(serverRequestAppServiceCallee.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.SingleRequest) &&
(serverRequestAppServiceCallee.Request.SingleRequest.RequestTypeCase == SingleRequest.RequestTypeOneofCase.ApplicationServiceReceiveMessageNotification);
string receivedMessage = Encoding.UTF8.GetString(serverRequestAppServiceCallee.Request.SingleRequest.ApplicationServiceReceiveMessageNotification.Message.ToByteArray());
bool messageOk = receivedMessage == callerMessage;
bool receiveMessageOk = versionOk && typeOk && messageOk;
if (receiveMessageOk)
{
messagesDelivered++;
log.Trace("Delivery of message #{0} succeeded.", i + 1);
}
else
{
log.Trace("Delivery of message #{0} failed.", i + 1);
error = true;
break;
}
await Task.Delay(10 * 1000);
}
catch
{
log.Trace("Expected exception occurred.");
disconnectedOk = true;
break;
}
}
// Step 6 Acceptance
bool step6Ok = !error && disconnectedOk && (messagesDelivered < 20);
log.Trace("Step 6: {0}", step6Ok ? "PASSED" : "FAILED");
Passed = step1Ok && step2Ok && step3Ok && step4Ok && step5Ok && step6Ok;
res = true;
}
catch (Exception e)
{
log.Error("Exception occurred: {0}", e.ToString());
}
clientCallee.Dispose();
clientCalleeAppService.Dispose();
clientCaller.Dispose();
clientCallerAppService.Dispose();
log.Trace("(-):{0}", res);
return(res);
}
/// <summary>
/// Validates ActivityInformation structure by itself. This function does not touch database and does not validate
/// anything that depends on the context.
/// </summary>
/// <param name="Activity">Description of the activity to validate.</param>
/// <param name="OwnerIdentityPublicKey">Public key of the activity's owner identity.</param>
/// <param name="MessageBuilder">Network message builder of the client who sent this activity description.</param>
/// <param name="RequestMessage">Full request message from client.</param>
/// <param name="ErrorPrefix">Prefix to add to the validation error details.</param>
/// <param name="ErrorResponse">If the function fails, this is filled with error response message that is ready to be sent to the client.</param>
/// <returns>true if the activity information is valid, false otherwise.</returns>
public static bool ValidateActivityInformation(ActivityInformation Activity, byte[] OwnerIdentityPublicKey, ProxMessageBuilder MessageBuilder, ProxProtocolMessage RequestMessage, string ErrorPrefix, out ProxProtocolMessage ErrorResponse)
{
log.Trace("()");
bool res = false;
ErrorResponse = null;
string details = null;
if (Activity == null)
{
Activity = new ActivityInformation();
}
if (Activity.ProfileServerContact == null)
{
Activity.ProfileServerContact = new ServerContactInfo();
}
SemVer version = new SemVer(Activity.Version);
// Currently only supported version is 1.0.0.
if (!version.Equals(SemVer.V100))
{
log.Debug("Unsupported version '{0}'.", version);
details = "version";
}
if (details == null)
{
uint activityId = Activity.Id;
// 0 is not a valid activity identifier.
if (activityId == 0)
{
log.Debug("Invalid activity ID '{0}'.", activityId);
details = "id";
}
}
if (details == null)
{
byte[] pubKey = Activity.OwnerPublicKey.ToByteArray();
bool pubKeyValid = (0 < pubKey.Length) && (pubKey.Length <= ProtocolHelper.MaxPublicKeyLengthBytes) && ByteArrayComparer.Equals(OwnerIdentityPublicKey, pubKey);
if (!pubKeyValid)
{
log.Debug("Invalid public key '{0}' does not match identity public key '{1}'.", pubKey.ToHex(), OwnerIdentityPublicKey.ToHex());
details = "ownerPublicKey";
}
}
if (details == null)
{
ServerContactInfo sci = Activity.ProfileServerContact;
bool networkIdValid = sci.NetworkId.Length == ProtocolHelper.NetworkIdentifierLength;
IPAddress ipAddress = IPAddressExtensions.IpFromBytes(sci.IpAddress.ToByteArray());
bool ipAddressValid = (ipAddress != null) && (Config.Configuration.TestModeEnabled || !ipAddress.IsReservedOrLocal());
bool portValid = (1 <= sci.PrimaryPort) && (sci.PrimaryPort <= 65535);
if (!networkIdValid || !ipAddressValid || !portValid)
{
log.Debug("Profile server contact's network ID is {0}, IP address is {1}, port is {2}.", networkIdValid ? "valid" : "invalid", ipAddressValid ? "valid" : "invalid", portValid ? "valid" : "invalid");
if (!networkIdValid)
{
details = "profileServerContact.networkId";
}
else if (!ipAddressValid)
{
details = "profileServerContact.ipAddress";
}
else if (!portValid)
{
details = "profileServerContact.primaryPort";
}
}
}
if (details == null)
{
string activityType = Activity.Type;
if (activityType == null)
{
activityType = "";
}
int byteLen = Encoding.UTF8.GetByteCount(activityType);
bool activityTypeValid = (0 < byteLen) && (byteLen <= ProxMessageBuilder.MaxActivityTypeLengthBytes);
if (!activityTypeValid)
{
log.Debug("Activity type too long or zero length ({0} bytes, limit is {1}).", byteLen, ProxMessageBuilder.MaxActivityTypeLengthBytes);
details = "type";
}
}
if (details == null)
{
GpsLocation locLat = new GpsLocation(Activity.Latitude, 0);
GpsLocation locLong = new GpsLocation(0, Activity.Longitude);
if (!locLat.IsValid())
{
log.Debug("Latitude '{0}' is not a valid GPS latitude value.", Activity.Latitude);
details = "latitude";
}
else if (!locLong.IsValid())
{
log.Debug("Longitude '{0}' is not a valid GPS longitude value.", Activity.Longitude);
details = "longitude";
}
}
if (details == null)
{
uint precision = Activity.Precision;
bool precisionValid = (0 <= precision) && (precision <= ProxMessageBuilder.MaxLocationPrecision);
if (!precisionValid)
{
log.Debug("Precision '{0}' is not an integer between 0 and {1}.", precision, ProxMessageBuilder.MaxLocationPrecision);
details = "precision";
}
}
if (details == null)
{
DateTime?startTime = ProtocolHelper.UnixTimestampMsToDateTime(Activity.StartTime);
DateTime?expirationTime = ProtocolHelper.UnixTimestampMsToDateTime(Activity.ExpirationTime);
if (startTime == null)
{
log.Debug("Invalid activity start time timestamp '{0}'.", Activity.StartTime);
details = "startTime";
}
else if (expirationTime == null)
{
log.Debug("Invalid activity expiration time timestamp '{0}'.", Activity.ExpirationTime);
details = "expirationTime";
}
else
{
if (startTime > expirationTime)
{
log.Debug("Activity expiration time has to be greater than or equal to its start time.");
details = "expirationTime";
}
else if (expirationTime.Value > DateTime.UtcNow.AddHours(ActivityBase.MaxActivityLifeTimeHours))
{
log.Debug("Activity expiration time {0} is more than {1} hours in the future.", expirationTime.Value.ToString("yyyy-MM-dd HH:mm:ss"), ActivityBase.MaxActivityLifeTimeHours);
details = "expirationTime";
}
}
}
if (details == null)
{
string extraData = Activity.ExtraData;
if (extraData == null)
{
extraData = "";
}
// Extra data is semicolon separated 'key=value' list, max ActivityBase.MaxActivityExtraDataLengthBytes bytes long.
int byteLen = Encoding.UTF8.GetByteCount(extraData);
if (byteLen > ProxMessageBuilder.MaxActivityExtraDataLengthBytes)
{
log.Debug("Extra data too large ({0} bytes, limit is {1}).", byteLen, ProxMessageBuilder.MaxActivityExtraDataLengthBytes);
details = "extraData";
}
}
if (details == null)
{
res = true;
}
else
{
ErrorResponse = MessageBuilder.CreateErrorInvalidValueResponse(RequestMessage, ErrorPrefix + details);
}
log.Trace("(-):{0}", res);
return(res);
}
/// <summary>
/// Implementation of the test itself.
/// </summary>
/// <returns>true if the test passes, false otherwise.</returns>
public override async Task <bool> RunAsync()
{
IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"];
int ClNonCustomerPort = (int)ArgumentValues["clNonCustomer Port"];
int ClCustomerPort = (int)ArgumentValues["clCustomer Port"];
log.Trace("(ServerIp:'{0}',ClNonCustomerPort:{1},ClCustomerPort:{2})", ServerIp, ClNonCustomerPort, ClCustomerPort);
bool res = false;
Passed = false;
ProtocolClient client = new ProtocolClient();
try
{
MessageBuilder mb = client.MessageBuilder;
byte[] testPubKey = client.GetIdentityKeys().PublicKey;
byte[] testIdentityId = client.GetIdentityId();
// Step 1
await client.ConnectAsync(ServerIp, ClNonCustomerPort, true);
bool establishHostingOk = await client.EstablishHostingAsync();
// Step 1 Acceptance
bool step1Ok = establishHostingOk;
client.CloseConnection();
// Step 2
await client.ConnectAsync(ServerIp, ClCustomerPort, true);
bool checkInOk = await client.CheckInAsync();
Message requestMessage = mb.CreateUpdateProfileRequest(SemVer.V100, "Test Identity", null, new GpsLocation(0, 0), null);
await client.SendMessageAsync(requestMessage);
Message responseMessage = await client.ReceiveMessageAsync();
bool idOk = responseMessage.Id == requestMessage.Id;
bool statusOk = responseMessage.Response.Status == Status.Ok;
bool updateProfileOk = idOk && statusOk;
List <string> asList = new List <string>()
{
"a", "b", "c", "d", "a"
};
requestMessage = mb.CreateApplicationServiceAddRequest(asList);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool appServiceAddOk1 = idOk && statusOk;
requestMessage = mb.CreateGetIdentityInformationRequest(testIdentityId, false, false, true);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool isHostedOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsHosted;
bool isOnlineOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsOnline;
byte[] receivedPubKey = responseMessage.Response.SingleResponse.GetIdentityInformation.IdentityPublicKey.ToByteArray();
bool pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, testPubKey) == 0;
SemVer receivedVersion = new SemVer(responseMessage.Response.SingleResponse.GetIdentityInformation.Version);
bool versionOk = receivedVersion.Equals(SemVer.V100);
HashSet <string> expectedAsList = new HashSet <string>(StringComparer.Ordinal)
{
"a", "b", "c", "d"
};
HashSet <string> receivedAsList = new HashSet <string>(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices, StringComparer.Ordinal);
bool appServicesOk = expectedAsList.SetEquals(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices);
bool getIdentityInfoOk1 = idOk && statusOk && isHostedOk && isOnlineOk && pubKeyOk && versionOk && appServicesOk;
asList = new List <string>()
{
"c", "d", "a", "e"
};
requestMessage = mb.CreateApplicationServiceAddRequest(asList);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool appServiceAddOk2 = idOk && statusOk;
requestMessage = mb.CreateGetIdentityInformationRequest(testIdentityId, false, false, true);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
isHostedOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsHosted;
isOnlineOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsOnline;
receivedPubKey = responseMessage.Response.SingleResponse.GetIdentityInformation.IdentityPublicKey.ToByteArray();
pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, testPubKey) == 0;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.GetIdentityInformation.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
expectedAsList = new HashSet <string>(StringComparer.Ordinal)
{
"a", "b", "c", "d", "e"
};
receivedAsList = new HashSet <string>(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices, StringComparer.Ordinal);
appServicesOk = expectedAsList.SetEquals(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices);
bool getIdentityInfoOk2 = idOk && statusOk && isHostedOk && isOnlineOk && pubKeyOk && versionOk && appServicesOk;
requestMessage = mb.CreateApplicationServiceRemoveRequest("a");
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool appServiceRemoveOk3 = idOk && statusOk;
requestMessage = mb.CreateGetIdentityInformationRequest(testIdentityId, false, false, true);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
isHostedOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsHosted;
isOnlineOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsOnline;
receivedPubKey = responseMessage.Response.SingleResponse.GetIdentityInformation.IdentityPublicKey.ToByteArray();
pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, testPubKey) == 0;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.GetIdentityInformation.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
expectedAsList = new HashSet <string>(StringComparer.Ordinal)
{
"b", "c", "d", "e"
};
receivedAsList = new HashSet <string>(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices, StringComparer.Ordinal);
appServicesOk = expectedAsList.SetEquals(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices);
bool getIdentityInfoOk3 = idOk && statusOk && isHostedOk && isOnlineOk && pubKeyOk && versionOk && appServicesOk;
requestMessage = mb.CreateApplicationServiceRemoveRequest("a");
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.ErrorNotFound;
bool appServiceRemoveOk4 = idOk && statusOk;
requestMessage = mb.CreateGetIdentityInformationRequest(testIdentityId, false, false, true);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
isHostedOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsHosted;
isOnlineOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsOnline;
receivedPubKey = responseMessage.Response.SingleResponse.GetIdentityInformation.IdentityPublicKey.ToByteArray();
pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, testPubKey) == 0;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.GetIdentityInformation.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
expectedAsList = new HashSet <string>(StringComparer.Ordinal)
{
"b", "c", "d", "e"
};
receivedAsList = new HashSet <string>(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices, StringComparer.Ordinal);
appServicesOk = expectedAsList.SetEquals(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices);
bool getIdentityInfoOk4 = idOk && statusOk && isHostedOk && isOnlineOk && pubKeyOk && versionOk && appServicesOk;
asList = new List <string>()
{
"d", "1234567890-1234567890-1234567890-1234567890", "a", "e"
};
requestMessage = mb.CreateApplicationServiceAddRequest(asList);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.ErrorInvalidValue;
bool detailsOk = responseMessage.Response.Details == "serviceNames[1]";
bool appServiceAddOk5 = idOk && statusOk && detailsOk;
requestMessage = mb.CreateGetIdentityInformationRequest(testIdentityId, false, false, true);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
isHostedOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsHosted;
isOnlineOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsOnline;
receivedPubKey = responseMessage.Response.SingleResponse.GetIdentityInformation.IdentityPublicKey.ToByteArray();
pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, testPubKey) == 0;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.GetIdentityInformation.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
expectedAsList = new HashSet <string>(StringComparer.Ordinal)
{
"b", "c", "d", "e"
};
receivedAsList = new HashSet <string>(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices, StringComparer.Ordinal);
appServicesOk = expectedAsList.SetEquals(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices);
bool getIdentityInfoOk5 = idOk && statusOk && isHostedOk && isOnlineOk && pubKeyOk && versionOk && appServicesOk;
asList = new List <string>()
{
"a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "a10"
};
requestMessage = mb.CreateApplicationServiceAddRequest(asList);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool appServiceAddOk6 = idOk && statusOk;
asList = new List <string>()
{
"b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8", "b9", "b10"
};
requestMessage = mb.CreateApplicationServiceAddRequest(asList);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool appServiceAddOk7 = idOk && statusOk;
requestMessage = mb.CreateGetIdentityInformationRequest(testIdentityId, false, false, true);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
isHostedOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsHosted;
isOnlineOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsOnline;
receivedPubKey = responseMessage.Response.SingleResponse.GetIdentityInformation.IdentityPublicKey.ToByteArray();
pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, testPubKey) == 0;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.GetIdentityInformation.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
expectedAsList = new HashSet <string>(StringComparer.Ordinal)
{
"b", "c", "d", "e", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "a10", "b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8", "b9", "b10"
};
receivedAsList = new HashSet <string>(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices, StringComparer.Ordinal);
appServicesOk = expectedAsList.SetEquals(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices);
bool getIdentityInfoOk7 = idOk && statusOk && isHostedOk && isOnlineOk && pubKeyOk && versionOk && appServicesOk;
asList = new List <string>()
{
"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10", "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8", "e9", "e10"
};
requestMessage = mb.CreateApplicationServiceAddRequest(asList);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.ErrorQuotaExceeded;
bool appServiceAddOk8 = idOk && statusOk;
requestMessage = mb.CreateGetIdentityInformationRequest(testIdentityId, false, false, true);
await client.SendMessageAsync(requestMessage);
responseMessage = await client.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
isHostedOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsHosted;
isOnlineOk = responseMessage.Response.SingleResponse.GetIdentityInformation.IsOnline;
receivedPubKey = responseMessage.Response.SingleResponse.GetIdentityInformation.IdentityPublicKey.ToByteArray();
pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, testPubKey) == 0;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.GetIdentityInformation.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
expectedAsList = new HashSet <string>(StringComparer.Ordinal)
{
"b", "c", "d", "e", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "a10", "b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8", "b9", "b10"
};
receivedAsList = new HashSet <string>(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices, StringComparer.Ordinal);
appServicesOk = expectedAsList.SetEquals(responseMessage.Response.SingleResponse.GetIdentityInformation.ApplicationServices);
bool getIdentityInfoOk8 = idOk && statusOk && isHostedOk && isOnlineOk && pubKeyOk && versionOk && appServicesOk;
// Step 2 Acceptance
bool step2Ok = checkInOk && updateProfileOk && appServiceAddOk1 && getIdentityInfoOk1 && appServiceAddOk2 && getIdentityInfoOk2 && appServiceRemoveOk3 &&
getIdentityInfoOk3 && appServiceRemoveOk4 && getIdentityInfoOk4 && appServiceAddOk5 && getIdentityInfoOk5 && appServiceAddOk6 && appServiceAddOk7 &&
getIdentityInfoOk7 && appServiceAddOk8 && getIdentityInfoOk8;
Passed = step1Ok && step2Ok;
res = true;
}
catch (Exception e)
{
log.Error("Exception occurred: {0}", e.ToString());
}
client.Dispose();
log.Trace("(-):{0}", res);
return(res);
}
/// <summary>
/// Implementation of the test itself.
/// </summary>
/// <returns>true if the test passes, false otherwise.</returns>
public override async Task <bool> RunAsync()
{
IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"];
int PrimaryPort = (int)ArgumentValues["primary Port"];
log.Trace("(ServerIp:'{0}',PrimaryPort:{1})", ServerIp, PrimaryPort);
bool res = false;
Passed = false;
ProtocolClient clientPrimary = new ProtocolClient();
ProtocolClient clientSecondary = new ProtocolClient();
try
{
MessageBuilder mbPrimary = clientPrimary.MessageBuilder;
MessageBuilder mbSecondary = clientSecondary.MessageBuilder;
// Step 1
log.Trace("Step 1");
// Get port list.
await clientPrimary.ConnectAsync(ServerIp, PrimaryPort, false);
Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>();
bool listPortsOk = await clientPrimary.ListServerPorts(rolePorts);
clientPrimary.CloseConnection();
// Establish hosting agreement for primary client.
await clientPrimary.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);
bool establishHostingOk = await clientPrimary.EstablishHostingAsync("Primary");
clientPrimary.CloseConnection();
// Check in primary client.
await clientPrimary.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClCustomer], true);
bool checkInOk = await clientPrimary.CheckInAsync();
bool primaryOk = establishHostingOk && checkInOk;
// Establish hosting agreement for secondary client.
await clientSecondary.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);
establishHostingOk = await clientSecondary.EstablishHostingAsync("Primary");
clientSecondary.CloseConnection();
// Check in secondary client.
await clientSecondary.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClCustomer], true);
checkInOk = await clientSecondary.CheckInAsync();
bool secondaryOk = establishHostingOk && checkInOk;
// Create card issuers.
CardIssuers = new List <ProtocolClient>();
for (int i = 0; i < IssuerCount; i++)
{
ProtocolClient profileClient = new ProtocolClient();
CardIssuers.Add(profileClient);
}
// Step 1 Acceptance
bool step1Ok = listPortsOk && primaryOk && secondaryOk;
log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");
// Step 2
log.Trace("Step 2");
SignedCards = new List <SignedRelationshipCard>();
CardApplications = new List <CardApplicationInformation>();
// Just to make it easy to follow the test specification.
ProtocolClient Identity1 = CardIssuers[0];
ProtocolClient Identity2 = CardIssuers[1];
ProtocolClient Identity3 = CardIssuers[2];
ProtocolClient Identity4 = CardIssuers[3];
ProtocolClient Identity5 = CardIssuers[4];
log.Trace("Identity1 ID: {0}", Crypto.ToHex(Identity1.GetIdentityId()));
log.Trace("Identity2 ID: {0}", Crypto.ToHex(Identity2.GetIdentityId()));
log.Trace("Identity3 ID: {0}", Crypto.ToHex(Identity3.GetIdentityId()));
log.Trace("Identity4 ID: {0}", Crypto.ToHex(Identity4.GetIdentityId()));
log.Trace("Identity5 ID: {0}", Crypto.ToHex(Identity5.GetIdentityId()));
byte[] primaryPubKey = clientPrimary.GetIdentityKeys().PublicKey;
string type = "Card Type A";
DateTime validFrom = ProtocolHelper.UnixTimestampMsToDateTime(1479220556000);
DateTime validTo = ProtocolHelper.UnixTimestampMsToDateTime(2479220556000);
SignedRelationshipCard signedCard = Identity1.IssueRelationshipCard(primaryPubKey, type, validFrom, validTo);
SignedCards.Add(signedCard);
byte[] applicationId = new byte[] { 1 };
CardApplicationInformation cardApplication = clientPrimary.CreateRelationshipCardApplication(applicationId, signedCard);
CardApplications.Add(cardApplication);
Message requestMessage = mbPrimary.CreateAddRelatedIdentityRequest(cardApplication, signedCard);
await clientPrimary.SendMessageAsync(requestMessage);
Message responseMessage = await clientPrimary.ReceiveMessageAsync();
bool idOk = responseMessage.Id == requestMessage.Id;
bool statusOk = responseMessage.Response.Status == Status.Ok;
bool req1Ok = idOk && statusOk;
type = "Card Type A";
validFrom = ProtocolHelper.UnixTimestampMsToDateTime(1479220556000);
validTo = ProtocolHelper.UnixTimestampMsToDateTime(1479220557000);
signedCard = Identity1.IssueRelationshipCard(primaryPubKey, type, validFrom, validTo);
SignedCards.Add(signedCard);
applicationId = new byte[] { 2 };
cardApplication = clientPrimary.CreateRelationshipCardApplication(applicationId, signedCard);
CardApplications.Add(cardApplication);
requestMessage = mbPrimary.CreateAddRelatedIdentityRequest(cardApplication, signedCard);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool req2Ok = idOk && statusOk;
type = "Card Type A";
validFrom = ProtocolHelper.UnixTimestampMsToDateTime(1479220556000);
validTo = ProtocolHelper.UnixTimestampMsToDateTime(2479220556000);
signedCard = Identity2.IssueRelationshipCard(primaryPubKey, type, validFrom, validTo);
SignedCards.Add(signedCard);
applicationId = new byte[] { 3 };
cardApplication = clientPrimary.CreateRelationshipCardApplication(applicationId, signedCard);
CardApplications.Add(cardApplication);
requestMessage = mbPrimary.CreateAddRelatedIdentityRequest(cardApplication, signedCard);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool req3Ok = idOk && statusOk;
type = "Card Type A";
validFrom = ProtocolHelper.UnixTimestampMsToDateTime(2479220555000);
validTo = ProtocolHelper.UnixTimestampMsToDateTime(2479220556000);
signedCard = Identity2.IssueRelationshipCard(primaryPubKey, type, validFrom, validTo);
SignedCards.Add(signedCard);
applicationId = new byte[] { 4 };
cardApplication = clientPrimary.CreateRelationshipCardApplication(applicationId, signedCard);
CardApplications.Add(cardApplication);
requestMessage = mbPrimary.CreateAddRelatedIdentityRequest(cardApplication, signedCard);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool req4Ok = idOk && statusOk;
type = "Card Type B";
validFrom = ProtocolHelper.UnixTimestampMsToDateTime(1479220556000);
validTo = ProtocolHelper.UnixTimestampMsToDateTime(2479220556000);
signedCard = Identity3.IssueRelationshipCard(primaryPubKey, type, validFrom, validTo);
SignedCards.Add(signedCard);
applicationId = new byte[] { 5 };
cardApplication = clientPrimary.CreateRelationshipCardApplication(applicationId, signedCard);
CardApplications.Add(cardApplication);
requestMessage = mbPrimary.CreateAddRelatedIdentityRequest(cardApplication, signedCard);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool req5Ok = idOk && statusOk;
type = "Card Type B";
validFrom = ProtocolHelper.UnixTimestampMsToDateTime(1479220556000);
validTo = ProtocolHelper.UnixTimestampMsToDateTime(2479220556000);
signedCard = Identity4.IssueRelationshipCard(primaryPubKey, type, validFrom, validTo);
SignedCards.Add(signedCard);
applicationId = new byte[] { 6 };
cardApplication = clientPrimary.CreateRelationshipCardApplication(applicationId, signedCard);
CardApplications.Add(cardApplication);
requestMessage = mbPrimary.CreateAddRelatedIdentityRequest(cardApplication, signedCard);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool req6Ok = idOk && statusOk;
type = "Card Type C";
validFrom = ProtocolHelper.UnixTimestampMsToDateTime(1479220556000);
validTo = ProtocolHelper.UnixTimestampMsToDateTime(2479220556000);
signedCard = Identity4.IssueRelationshipCard(primaryPubKey, type, validFrom, validTo);
SignedCards.Add(signedCard);
applicationId = new byte[] { 7 };
cardApplication = clientPrimary.CreateRelationshipCardApplication(applicationId, signedCard);
CardApplications.Add(cardApplication);
requestMessage = mbPrimary.CreateAddRelatedIdentityRequest(cardApplication, signedCard);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool req7Ok = idOk && statusOk;
type = "Card Type C";
validFrom = ProtocolHelper.UnixTimestampMsToDateTime(1479220556000);
validTo = ProtocolHelper.UnixTimestampMsToDateTime(2479220556000);
signedCard = Identity4.IssueRelationshipCard(primaryPubKey, type, validFrom, validTo);
SignedCards.Add(signedCard);
applicationId = new byte[] { 8 };
cardApplication = clientPrimary.CreateRelationshipCardApplication(applicationId, signedCard);
CardApplications.Add(cardApplication);
requestMessage = mbPrimary.CreateAddRelatedIdentityRequest(cardApplication, signedCard);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool req8Ok = idOk && statusOk;
type = "Other";
validFrom = ProtocolHelper.UnixTimestampMsToDateTime(1479220556000);
validTo = ProtocolHelper.UnixTimestampMsToDateTime(2479220556000);
signedCard = Identity5.IssueRelationshipCard(primaryPubKey, type, validFrom, validTo);
SignedCards.Add(signedCard);
applicationId = new byte[] { 9 };
cardApplication = clientPrimary.CreateRelationshipCardApplication(applicationId, signedCard);
CardApplications.Add(cardApplication);
requestMessage = mbPrimary.CreateAddRelatedIdentityRequest(cardApplication, signedCard);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool req9Ok = idOk && statusOk;
// Step 2 Acceptance
bool step2Ok = req1Ok && req2Ok && req3Ok && req4Ok && req5Ok && req6Ok && req7Ok && req8Ok && req9Ok;
log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED");
// Step 3
log.Trace("Step 3");
byte[] secondaryPubKey = clientSecondary.GetIdentityKeys().PublicKey;
type = "Card Type A";
validFrom = ProtocolHelper.UnixTimestampMsToDateTime(1479220556000);
validTo = ProtocolHelper.UnixTimestampMsToDateTime(2479220556000);
signedCard = Identity1.IssueRelationshipCard(secondaryPubKey, type, validFrom, validTo);
SignedCards.Add(signedCard);
applicationId = new byte[] { 1 };
cardApplication = clientSecondary.CreateRelationshipCardApplication(applicationId, signedCard);
CardApplications.Add(cardApplication);
requestMessage = mbSecondary.CreateAddRelatedIdentityRequest(cardApplication, signedCard);
await clientSecondary.SendMessageAsync(requestMessage);
responseMessage = await clientSecondary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool req10Ok = idOk && statusOk;
// Step 3 Acceptance
bool step3Ok = req10Ok;
log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED");
// Step 4
log.Trace("Step 4");
byte[] primaryClientId = clientPrimary.GetIdentityId();
requestMessage = mbSecondary.CreateGetIdentityRelationshipsInformationRequest(primaryClientId, true, null, null);
await clientSecondary.SendMessageAsync(requestMessage);
responseMessage = await clientSecondary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
SemVer receivedVersion = new SemVer(responseMessage.Response.SingleResponse.Version);
bool versionOk = receivedVersion.Equals(SemVer.V100);
HashSet <int> numberList = new HashSet <int>()
{
1, 2, 3, 4, 5, 6, 7, 8, 9
};
bool relationshipsOk = CheckRelationships(numberList, responseMessage.Response.SingleResponse.GetIdentityRelationshipsInformation.Relationships);
req1Ok = idOk && statusOk && versionOk && relationshipsOk;
requestMessage = mbSecondary.CreateGetIdentityRelationshipsInformationRequest(primaryClientId, false, null, null);
await clientSecondary.SendMessageAsync(requestMessage);
responseMessage = await clientSecondary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
numberList = new HashSet <int>()
{
1, 3, 5, 6, 7, 8, 9
};
relationshipsOk = CheckRelationships(numberList, responseMessage.Response.SingleResponse.GetIdentityRelationshipsInformation.Relationships);
req2Ok = idOk && statusOk && versionOk && relationshipsOk;
requestMessage = mbSecondary.CreateGetIdentityRelationshipsInformationRequest(primaryClientId, true, "*", null);
await clientSecondary.SendMessageAsync(requestMessage);
responseMessage = await clientSecondary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
numberList = new HashSet <int>()
{
1, 2, 3, 4, 5, 6, 7, 8, 9
};
relationshipsOk = CheckRelationships(numberList, responseMessage.Response.SingleResponse.GetIdentityRelationshipsInformation.Relationships);
req3Ok = idOk && statusOk && versionOk && relationshipsOk;
requestMessage = mbSecondary.CreateGetIdentityRelationshipsInformationRequest(primaryClientId, true, "**", null);
await clientSecondary.SendMessageAsync(requestMessage);
responseMessage = await clientSecondary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
numberList = new HashSet <int>()
{
1, 2, 3, 4, 5, 6, 7, 8, 9
};
relationshipsOk = CheckRelationships(numberList, responseMessage.Response.SingleResponse.GetIdentityRelationshipsInformation.Relationships);
req4Ok = idOk && statusOk && versionOk && relationshipsOk;
requestMessage = mbSecondary.CreateGetIdentityRelationshipsInformationRequest(primaryClientId, true, "Card*", null);
await clientSecondary.SendMessageAsync(requestMessage);
responseMessage = await clientSecondary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
numberList = new HashSet <int>()
{
1, 2, 3, 4, 5, 6, 7, 8
};
relationshipsOk = CheckRelationships(numberList, responseMessage.Response.SingleResponse.GetIdentityRelationshipsInformation.Relationships);
req5Ok = idOk && statusOk && versionOk && relationshipsOk;
requestMessage = mbSecondary.CreateGetIdentityRelationshipsInformationRequest(primaryClientId, true, "*Type A", null);
await clientSecondary.SendMessageAsync(requestMessage);
responseMessage = await clientSecondary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
numberList = new HashSet <int>()
{
1, 2, 3, 4
};
relationshipsOk = CheckRelationships(numberList, responseMessage.Response.SingleResponse.GetIdentityRelationshipsInformation.Relationships);
req6Ok = idOk && statusOk && versionOk && relationshipsOk;
requestMessage = mbSecondary.CreateGetIdentityRelationshipsInformationRequest(primaryClientId, true, "*Type *", null);
await clientSecondary.SendMessageAsync(requestMessage);
responseMessage = await clientSecondary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
numberList = new HashSet <int>()
{
1, 2, 3, 4, 5, 6, 7, 8
};
relationshipsOk = CheckRelationships(numberList, responseMessage.Response.SingleResponse.GetIdentityRelationshipsInformation.Relationships);
req7Ok = idOk && statusOk && versionOk && relationshipsOk;
requestMessage = mbSecondary.CreateGetIdentityRelationshipsInformationRequest(primaryClientId, true, null, Identity1.GetIdentityId());
await clientSecondary.SendMessageAsync(requestMessage);
responseMessage = await clientSecondary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
numberList = new HashSet <int>()
{
1, 2
};
relationshipsOk = CheckRelationships(numberList, responseMessage.Response.SingleResponse.GetIdentityRelationshipsInformation.Relationships);
req8Ok = idOk && statusOk && versionOk && relationshipsOk;
requestMessage = mbSecondary.CreateGetIdentityRelationshipsInformationRequest(primaryClientId, true, "*C", Identity4.GetIdentityId());
await clientSecondary.SendMessageAsync(requestMessage);
responseMessage = await clientSecondary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
numberList = new HashSet <int>()
{
7, 8
};
relationshipsOk = CheckRelationships(numberList, responseMessage.Response.SingleResponse.GetIdentityRelationshipsInformation.Relationships);
req9Ok = idOk && statusOk && versionOk && relationshipsOk;
// Step 4 Acceptance
bool step4Ok = req1Ok && req2Ok && req3Ok && req4Ok && req5Ok && req6Ok && req7Ok && req8Ok && req9Ok;
log.Trace("Step 4: {0}", step4Ok ? "PASSED" : "FAILED");
// Step 5
log.Trace("Step 5");
applicationId = new byte[] { 2 };
requestMessage = mbPrimary.CreateRemoveRelatedIdentityRequest(applicationId);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool removeRelation1Ok = idOk && statusOk;
applicationId = new byte[] { 4 };
requestMessage = mbPrimary.CreateRemoveRelatedIdentityRequest(applicationId);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
bool removeRelation2Ok = idOk && statusOk;
requestMessage = mbPrimary.CreateGetIdentityRelationshipsInformationRequest(primaryClientId, true, "*Type a*", null);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
numberList = new HashSet <int>()
{
1, 3
};
relationshipsOk = CheckRelationships(numberList, responseMessage.Response.SingleResponse.GetIdentityRelationshipsInformation.Relationships);
req1Ok = idOk && statusOk && versionOk && relationshipsOk;
byte[] partId = new byte[10];
Array.Copy(primaryClientId, partId, partId.Length);
requestMessage = mbPrimary.CreateGetIdentityRelationshipsInformationRequest(partId, true, "*Type a*", null);
await clientPrimary.SendMessageAsync(requestMessage);
responseMessage = await clientPrimary.ReceiveMessageAsync();
idOk = responseMessage.Id == requestMessage.Id;
statusOk = responseMessage.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessage.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
relationshipsOk = responseMessage.Response.SingleResponse.GetIdentityRelationshipsInformation.Relationships.Count == 0;
req1Ok = idOk && statusOk && versionOk && relationshipsOk;
// Step 5 Acceptance
bool step5Ok = removeRelation1Ok && removeRelation2Ok && req1Ok && req2Ok;
log.Trace("Step 5: {0}", step5Ok ? "PASSED" : "FAILED");
Passed = step1Ok && step2Ok && step3Ok && step4Ok && step5Ok;
res = true;
}
catch (Exception e)
{
log.Error("Exception occurred: {0}", e.ToString());
}
clientPrimary.Dispose();
clientSecondary.Dispose();
if (CardIssuers != null)
{
for (int i = 0; i < IssuerCount; i++)
{
if (CardIssuers[i] != null)
{
CardIssuers[i].Dispose();
}
}
}
log.Trace("(-):{0}", res);
return(res);
}
/// <summary>
/// Checks whether AddRelatedIdentityRequest request is valid.
/// </summary>
/// <param name="Client">Client that sent the request.</param>
/// <param name="AddRelatedIdentityRequest">Client's request message to validate.</param>
/// <param name="MessageBuilder">Client's network message builder.</param>
/// <param name="RequestMessage">Full request message from client.</param>
/// <param name="ErrorResponse">If the function fails, this is filled with error response message that is ready to be sent to the client.</param>
/// <returns>true if the profile update request can be applied, false otherwise.</returns>
public static bool ValidateAddRelatedIdentityRequest(IncomingClient Client, AddRelatedIdentityRequest AddRelatedIdentityRequest, PsMessageBuilder MessageBuilder, PsProtocolMessage RequestMessage, out PsProtocolMessage ErrorResponse)
{
log.Trace("()");
bool res = false;
ErrorResponse = null;
string details = null;
if (AddRelatedIdentityRequest == null)
{
AddRelatedIdentityRequest = new AddRelatedIdentityRequest();
}
if (AddRelatedIdentityRequest.CardApplication == null)
{
AddRelatedIdentityRequest.CardApplication = new CardApplicationInformation();
}
if (AddRelatedIdentityRequest.SignedCard == null)
{
AddRelatedIdentityRequest.SignedCard = new SignedRelationshipCard();
}
if (AddRelatedIdentityRequest.SignedCard.Card == null)
{
AddRelatedIdentityRequest.SignedCard.Card = new RelationshipCard();
}
CardApplicationInformation cardApplication = AddRelatedIdentityRequest.CardApplication;
SignedRelationshipCard signedCard = AddRelatedIdentityRequest.SignedCard;
RelationshipCard card = signedCard.Card;
byte[] applicationId = cardApplication.ApplicationId.ToByteArray();
byte[] cardId = card.CardId.ToByteArray();
if ((applicationId.Length == 0) || (applicationId.Length > RelatedIdentity.CardIdentifierLength))
{
log.Debug("Card application ID is invalid.");
details = "cardApplication.applicationId";
}
if (details == null)
{
byte[] appCardId = cardApplication.CardId.ToByteArray();
if (!ByteArrayComparer.Equals(cardId, appCardId))
{
log.Debug("Card IDs in application card and relationship card do not match.");
details = "cardApplication.cardId";
}
}
if (details == null)
{
if (card.ValidFrom > card.ValidTo)
{
log.Debug("Card validFrom field is greater than validTo field.");
details = "signedCard.card.validFrom";
}
else
{
DateTime?cardValidFrom = ProtocolHelper.UnixTimestampMsToDateTime(card.ValidFrom);
DateTime?cardValidTo = ProtocolHelper.UnixTimestampMsToDateTime(card.ValidTo);
if (cardValidFrom == null)
{
log.Debug("Card validFrom value '{0}' is not a valid timestamp.", card.ValidFrom);
details = "signedCard.card.validFrom";
}
else if (cardValidTo == null)
{
log.Debug("Card validTo value '{0}' is not a valid timestamp.", card.ValidTo);
details = "signedCard.card.validTo";
}
}
}
if (details == null)
{
byte[] issuerPublicKey = card.IssuerPublicKey.ToByteArray();
bool pubKeyValid = (0 < issuerPublicKey.Length) && (issuerPublicKey.Length <= ProtocolHelper.MaxPublicKeyLengthBytes);
if (!pubKeyValid)
{
log.Debug("Issuer public key has invalid length {0} bytes.", issuerPublicKey.Length);
details = "signedCard.card.issuerPublicKey";
}
}
if (details == null)
{
byte[] recipientPublicKey = card.RecipientPublicKey.ToByteArray();
if (!ByteArrayComparer.Equals(recipientPublicKey, Client.PublicKey))
{
log.Debug("Caller is not recipient of the card.");
details = "signedCard.card.recipientPublicKey";
}
}
if (details == null)
{
if (!Client.MessageBuilder.VerifySignedConversationRequestBodyPart(RequestMessage, cardApplication.ToByteArray(), Client.PublicKey))
{
log.Debug("Caller is not recipient of the card.");
ErrorResponse = Client.MessageBuilder.CreateErrorInvalidSignatureResponse(RequestMessage);
details = "";
}
}
if (details == null)
{
SemVer cardVersion = new SemVer(card.Version);
if (!cardVersion.Equals(SemVer.V100))
{
log.Debug("Card version is invalid or not supported.");
details = "signedCard.card.version";
}
}
if (details == null)
{
if (Encoding.UTF8.GetByteCount(card.Type) > PsMessageBuilder.MaxRelationshipCardTypeLengthBytes)
{
log.Debug("Card type is too long.");
details = "signedCard.card.type";
}
}
if (details == null)
{
RelationshipCard emptyIdCard = new RelationshipCard()
{
CardId = ProtocolHelper.ByteArrayToByteString(new byte[RelatedIdentity.CardIdentifierLength]),
Version = card.Version,
IssuerPublicKey = card.IssuerPublicKey,
RecipientPublicKey = card.RecipientPublicKey,
Type = card.Type,
ValidFrom = card.ValidFrom,
ValidTo = card.ValidTo
};
byte[] hash = Crypto.Sha256(emptyIdCard.ToByteArray());
if (!ByteArrayComparer.Equals(hash, cardId))
{
log.Debug("Card ID '{0}' does not match its hash '{1}'.", cardId.ToHex(64), hash.ToHex());
details = "signedCard.card.cardId";
}
}
if (details == null)
{
byte[] issuerSignature = signedCard.IssuerSignature.ToByteArray();
byte[] issuerPublicKey = card.IssuerPublicKey.ToByteArray();
if (!Ed25519.Verify(issuerSignature, cardId, issuerPublicKey))
{
log.Debug("Issuer signature is invalid.");
details = "signedCard.issuerSignature";
}
}
if (details == null)
{
res = true;
}
else
{
if (ErrorResponse == null)
{
ErrorResponse = MessageBuilder.CreateErrorInvalidValueResponse(RequestMessage, details);
}
}
log.Trace("(-):{0}", res);
return(res);
}
/// <summary>
/// Checks whether a profile information is valid.
/// </summary>
/// <param name="Profile">Profile information to check.</param>
/// <param name="IdentityPublicKey">Public key of the profile's identity.</param>
/// <param name="MessageBuilder">Client's network message builder.</param>
/// <param name="RequestMessage">Full request message from client.</param>
/// <param name="ErrorPrefix">Prefix to add to the validation error details.</param>
/// <param name="ErrorResponse">If the function fails, this is filled with error response message that is ready to be sent to the client.</param>
/// <returns>true if the signed profile information is valid, false otherwise.</returns>
public static bool ValidateProfileInformation(ProfileInformation Profile, byte[] IdentityPublicKey, PsMessageBuilder MessageBuilder, PsProtocolMessage RequestMessage, string ErrorPrefix, out PsProtocolMessage ErrorResponse)
{
log.Trace("()");
bool res = false;
ErrorResponse = null;
string details = null;
if (Profile == null)
{
Profile = new ProfileInformation();
}
SemVer version = new SemVer(Profile.Version);
// Currently only supported version is 1.0.0.
if (!version.Equals(SemVer.V100))
{
log.Debug("Unsupported version '{0}'.", version);
details = "version";
}
if (details == null)
{
byte[] pubKey = Profile.PublicKey.ToByteArray();
bool pubKeyValid = (0 < pubKey.Length) && (pubKey.Length <= ProtocolHelper.MaxPublicKeyLengthBytes) && ByteArrayComparer.Equals(IdentityPublicKey, pubKey);
if (!pubKeyValid)
{
log.Debug("Invalid public key '{0}' does not match identity public key '{1}'.", pubKey.ToHex(), IdentityPublicKey.ToHex());
details = "publicKey";
}
}
if (details == null)
{
int typeSize = Encoding.UTF8.GetByteCount(Profile.Type);
bool typeValid = (0 < typeSize) && (typeSize <= IdentityBase.MaxProfileTypeLengthBytes);
if (!typeValid)
{
log.Debug("Invalid type size in bytes {0}.", typeSize);
details = "type";
}
}
if (details == null)
{
int nameSize = Encoding.UTF8.GetByteCount(Profile.Name);
bool nameValid = (0 < nameSize) && (nameSize <= IdentityBase.MaxProfileNameLengthBytes);
if (!nameValid)
{
log.Debug("Invalid name size in bytes {0}.", nameSize);
details = "name";
}
}
if (details == null)
{
GpsLocation locLat = new GpsLocation(Profile.Latitude, 0);
if (!locLat.IsValid())
{
log.Debug("Invalid latitude {0}.", Profile.Latitude);
details = "latitude";
}
}
if (details == null)
{
GpsLocation locLon = new GpsLocation(0, Profile.Longitude);
if (!locLon.IsValid())
{
log.Debug("Invalid longitude {0}.", Profile.Longitude);
details = "longitude";
}
}
if (details == null)
{
int extraDataSize = Encoding.UTF8.GetByteCount(Profile.ExtraData);
bool extraDataValid = extraDataSize <= IdentityBase.MaxProfileExtraDataLengthBytes;
if (!extraDataValid)
{
log.Debug("Invalid extraData size in bytes {0}.", extraDataSize);
details = "extraData";
}
}
if (details == null)
{
bool profileImageHashValid = (Profile.ProfileImageHash.Length == 0) || (Profile.ProfileImageHash.Length == ProtocolHelper.HashLengthBytes);
if (!profileImageHashValid)
{
log.Debug("Invalid profile image hash size {0} bytes.", Profile.ProfileImageHash.Length);
details = "profileImageHash";
}
}
if (details == null)
{
bool thumbnailImageHashValid = (Profile.ThumbnailImageHash.Length == 0) || (Profile.ThumbnailImageHash.Length == ProtocolHelper.HashLengthBytes);
if (!thumbnailImageHashValid)
{
log.Debug("Invalid thumbnail image hash size {0} bytes.", Profile.ThumbnailImageHash.Length);
details = "thumbnailImageHash";
}
}
if (details == null)
{
res = true;
}
else
{
ErrorResponse = MessageBuilder.CreateErrorInvalidValueResponse(RequestMessage, ErrorPrefix + details);
}
log.Trace("(-):{0}", res);
return(res);
}
/// <summary>
/// Compares this activity to other activity and returns list of changed properties.
/// </summary>
/// <param name="Other">Other activity to compare to.</param>
/// <returns>Bit mask information about which properties are different.</returns>
public ActivityChange CompareChangeTo(ActivityBase Other)
{
ActivityChange res = ActivityChange.None;
SemVer thisVersion = new SemVer(this.Version);
SemVer otherVersion = new SemVer(Other.Version);
if (!thisVersion.Equals(otherVersion))
{
res |= ActivityChange.Version;
}
if (this.ActivityId != Other.ActivityId)
{
res |= ActivityChange.ActivityId;
}
if (!ByteArrayComparer.Equals(this.OwnerIdentityId, Other.OwnerIdentityId))
{
res |= ActivityChange.OwnerIdentityId;
}
if (!ByteArrayComparer.Equals(this.OwnerPublicKey, Other.OwnerPublicKey))
{
res |= ActivityChange.OwnerPublicKey;
}
if (!ByteArrayComparer.Equals(this.OwnerProfileServerId, Other.OwnerProfileServerId))
{
res |= ActivityChange.OwnerProfileServerId;
}
if (!ByteArrayComparer.Equals(this.OwnerProfileServerIpAddress, Other.OwnerProfileServerIpAddress))
{
res |= ActivityChange.OwnerProfileServerIpAddress;
}
if (this.OwnerProfileServerPrimaryPort != Other.OwnerProfileServerPrimaryPort)
{
res |= ActivityChange.OwnerProfileServerPrimaryPort;
}
if (this.Type != Other.Type)
{
res |= ActivityChange.Type;
}
if (this.LocationLatitude != Other.LocationLatitude)
{
res |= ActivityChange.LocationLatitude;
}
if (this.LocationLongitude != Other.LocationLongitude)
{
res |= ActivityChange.LocationLongitude;
}
if (this.PrecisionRadius != Other.PrecisionRadius)
{
res |= ActivityChange.PrecisionRadius;
}
if (this.StartTime != Other.StartTime)
{
res |= ActivityChange.StartTime;
}
if (this.ExpirationTime != Other.ExpirationTime)
{
res |= ActivityChange.ExpirationTime;
}
if (this.ExtraData != Other.ExtraData)
{
res |= ActivityChange.ExtraData;
}
return(res);
}
/// <summary>
/// Implementation of the test itself.
/// </summary>
/// <returns>true if the test passes, false otherwise.</returns>
public override async Task <bool> RunAsync()
{
IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"];
int PrimaryPort = (int)ArgumentValues["primary Port"];
log.Trace("(ServerIp:'{0}',PrimaryPort:{1})", ServerIp, PrimaryPort);
bool res = false;
Passed = false;
ProtocolClient clientCallee = new ProtocolClient();
ProtocolClient clientCalleeAppService = new ProtocolClient(0, SemVer.V100, clientCallee.GetIdentityKeys());
ProtocolClient clientCaller1 = new ProtocolClient();
ProtocolClient clientCaller1AppService = new ProtocolClient(0, SemVer.V100, clientCaller1.GetIdentityKeys());
ProtocolClient clientCaller2 = new ProtocolClient();
ProtocolClient clientCaller2AppService = new ProtocolClient(0, SemVer.V100, clientCaller2.GetIdentityKeys());
try
{
MessageBuilder mbCallee = clientCallee.MessageBuilder;
MessageBuilder mbCalleeAppService = clientCalleeAppService.MessageBuilder;
MessageBuilder mbCaller1 = clientCaller1.MessageBuilder;
MessageBuilder mbCaller1AppService = clientCaller1AppService.MessageBuilder;
MessageBuilder mbCaller2 = clientCaller2.MessageBuilder;
MessageBuilder mbCaller2AppService = clientCaller2AppService.MessageBuilder;
// Step 1
log.Trace("Step 1");
byte[] pubKeyCallee = clientCallee.GetIdentityKeys().PublicKey;
byte[] identityIdCallee = clientCallee.GetIdentityId();
byte[] pubKeyCaller1 = clientCaller1.GetIdentityKeys().PublicKey;
byte[] identityIdCaller1 = clientCaller1.GetIdentityId();
byte[] pubKeyCaller2 = clientCaller2.GetIdentityKeys().PublicKey;
byte[] identityIdCaller2 = clientCaller2.GetIdentityId();
// Get port list.
await clientCallee.ConnectAsync(ServerIp, PrimaryPort, false);
Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>();
bool listPortsOk = await clientCallee.ListServerPorts(rolePorts);
clientCallee.CloseConnection();
// Establish hosting agreement for identity 1.
await clientCallee.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);
bool establishHostingOk = await clientCallee.EstablishHostingAsync();
clientCallee.CloseConnection();
// Check-in and initialize the profile of identity 1.
await clientCallee.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClCustomer], true);
bool checkInOk = await clientCallee.CheckInAsync();
bool initializeProfileOk = await clientCallee.InitializeProfileAsync("Test Identity", null, new GpsLocation(0, 0), null);
// Add application service to the current session.
string serviceName = "Test Service";
bool addAppServiceOk = await clientCallee.AddApplicationServicesAsync(new List <string>() { serviceName });
// Step 1 Acceptance
bool step1Ok = listPortsOk && establishHostingOk && checkInOk && initializeProfileOk && addAppServiceOk;
log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");
// Step 2
log.Trace("Step 2");
await clientCaller1.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);
bool verifyIdentityOk1 = await clientCaller1.VerifyIdentityAsync();
Message requestMessage = mbCaller1.CreateCallIdentityApplicationServiceRequest(identityIdCallee, serviceName);
uint initMessageCaller1Id = requestMessage.Id;
await clientCaller1.SendMessageAsync(requestMessage);
await clientCaller2.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);
bool verifyIdentityOk2 = await clientCaller2.VerifyIdentityAsync();
requestMessage = mbCaller2.CreateCallIdentityApplicationServiceRequest(identityIdCallee, serviceName);
uint initMessageCaller2Id = requestMessage.Id;
await clientCaller2.SendMessageAsync(requestMessage);
// Step 2 Acceptance
bool step2Ok = verifyIdentityOk1 && verifyIdentityOk2;
log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED");
// Step 3
log.Trace("Step 3");
Message serverRequestMessage = await clientCallee.ReceiveMessageAsync();
// What we received now can actually be either notification about caller1 or caller2, we do not know.
// So we have to check, which one is it before we proceed.
byte[] receivedPubKey = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CallerPublicKey.ToByteArray();
bool isCaller1 = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, pubKeyCaller1) == 0;
bool isCaller2 = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, pubKeyCaller2) == 0;
bool pubKeyOk = isCaller1 || isCaller2;
bool serviceNameOk = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.ServiceName == serviceName;
bool incomingCallNotificationOk1 = pubKeyOk && serviceNameOk;
byte[] calleeToken1 = null;
byte[] calleeToken2 = null;
if (isCaller1)
{
calleeToken1 = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CalleeToken.ToByteArray();
}
else
{
calleeToken2 = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CalleeToken.ToByteArray();
}
Message serverResponseMessage = mbCallee.CreateIncomingCallNotificationResponse(serverRequestMessage);
await clientCallee.SendMessageAsync(serverResponseMessage);
serverRequestMessage = await clientCallee.ReceiveMessageAsync();
// This time, it has to be the other caller
receivedPubKey = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CallerPublicKey.ToByteArray();
if (isCaller1)
{
pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, pubKeyCaller2) == 0;
}
else
{
pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, pubKeyCaller1) == 0;
}
serviceNameOk = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.ServiceName == serviceName;
bool incomingCallNotificationOk2 = pubKeyOk && serviceNameOk;
if (isCaller1)
{
calleeToken2 = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CalleeToken.ToByteArray();
}
else
{
calleeToken1 = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CalleeToken.ToByteArray();
}
serverResponseMessage = mbCallee.CreateIncomingCallNotificationResponse(serverRequestMessage);
await clientCallee.SendMessageAsync(serverResponseMessage);
// Connect to clAppService and send initialization message.
await clientCalleeAppService.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClAppService], true);
Message requestMessageAppServiceCallee = mbCalleeAppService.CreateApplicationServiceSendMessageRequest(calleeToken1, null);
await clientCalleeAppService.SendMessageAsync(requestMessageAppServiceCallee);
// Step 3 Acceptance
bool step3Ok = incomingCallNotificationOk1 && incomingCallNotificationOk2;
log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED");
// Step 4
log.Trace("Step 4");
Message responseMessage = await clientCaller1.ReceiveMessageAsync();
bool idOk = responseMessage.Id == initMessageCaller1Id;
bool statusOk = responseMessage.Response.Status == Status.Ok;
byte[] callerToken = responseMessage.Response.ConversationResponse.CallIdentityApplicationService.CallerToken.ToByteArray();
bool callIdentityOk = idOk && statusOk;
// Connect to clAppService and send initialization message.
await clientCaller1AppService.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClAppService], true);
Message requestMessageAppServiceCaller = mbCaller1AppService.CreateApplicationServiceSendMessageRequest(callerToken, null);
await clientCaller1AppService.SendMessageAsync(requestMessageAppServiceCaller);
Message responseMessageAppServiceCaller = await clientCaller1AppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCaller.Id == requestMessageAppServiceCaller.Id;
statusOk = responseMessageAppServiceCaller.Response.Status == Status.Ok;
bool initAppServiceMessageOk = idOk && statusOk;
// Step 4 Acceptance
bool step4Ok = callIdentityOk && initAppServiceMessageOk;
log.Trace("Step 4: {0}", step4Ok ? "PASSED" : "FAILED");
// Step 5
log.Trace("Step 5");
Message responseMessageAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCallee.Id == requestMessageAppServiceCallee.Id;
statusOk = responseMessageAppServiceCallee.Response.Status == Status.Ok;
bool typeOk = (responseMessageAppServiceCallee.MessageTypeCase == Message.MessageTypeOneofCase.Response) &&
(responseMessageAppServiceCallee.Response.ConversationTypeCase == Response.ConversationTypeOneofCase.SingleResponse) &&
(responseMessageAppServiceCallee.Response.SingleResponse.ResponseTypeCase == SingleResponse.ResponseTypeOneofCase.ApplicationServiceSendMessage);
bool appServiceSendOk = idOk && statusOk && typeOk;
// Step 5 Acceptance
bool step5Ok = appServiceSendOk;
log.Trace("Step 5: {0}", step5Ok ? "PASSED" : "FAILED");
// Step 6
log.Trace("Step 6");
string caller1Message1 = "Message #1 to callee.";
byte[] messageBytes = Encoding.UTF8.GetBytes(caller1Message1);
requestMessageAppServiceCaller = mbCaller1AppService.CreateApplicationServiceSendMessageRequest(callerToken, messageBytes);
uint callerMessage1Id = requestMessageAppServiceCaller.Id;
await clientCaller1AppService.SendMessageAsync(requestMessageAppServiceCaller);
// Step 6 Acceptance
bool step6Ok = true;
log.Trace("Step 6: {0}", step6Ok ? "PASSED" : "FAILED");
// Step 7
log.Trace("Step 7");
// Receive message #1.
Message serverRequestAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync();
SemVer receivedVersion = new SemVer(serverRequestAppServiceCallee.Request.SingleRequest.Version);
bool versionOk = receivedVersion.Equals(SemVer.V100);
typeOk = (serverRequestAppServiceCallee.MessageTypeCase == Message.MessageTypeOneofCase.Request) &&
(serverRequestAppServiceCallee.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.SingleRequest) &&
(serverRequestAppServiceCallee.Request.SingleRequest.RequestTypeCase == SingleRequest.RequestTypeOneofCase.ApplicationServiceReceiveMessageNotification);
string receivedMessage = Encoding.UTF8.GetString(serverRequestAppServiceCallee.Request.SingleRequest.ApplicationServiceReceiveMessageNotification.Message.ToByteArray());
bool messageOk = receivedMessage == caller1Message1;
bool receiveMessageOk = versionOk && typeOk && messageOk;
// ACK message #1.
Message serverResponseAppServiceCallee = mbCalleeAppService.CreateApplicationServiceReceiveMessageNotificationResponse(serverRequestAppServiceCallee);
await clientCalleeAppService.SendMessageAsync(serverResponseAppServiceCallee);
// Send second intialization message
await Task.Delay(3000);
requestMessageAppServiceCallee = mbCalleeAppService.CreateApplicationServiceSendMessageRequest(calleeToken2, null);
await clientCalleeAppService.SendMessageAsync(requestMessageAppServiceCallee);
Message responseAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync();
idOk = responseAppServiceCallee.Id == requestMessageAppServiceCallee.Id;
statusOk = responseAppServiceCallee.Response.Status == Status.ErrorNotFound;
bool secondInitOk = idOk && statusOk;
// Step 7 Acceptance
bool step7Ok = secondInitOk;
log.Trace("Step 7: {0}", step7Ok ? "PASSED" : "FAILED");
// Step 8
log.Trace("Step 8");
// Receive init message response.
bool initMessageOk = false;
bool disconnectOk = false;
try
{
Message initMessageResponseAppServiceCaller2 = await clientCaller2AppService.ReceiveMessageAsync();
idOk = initMessageResponseAppServiceCaller2.Id == initMessageCaller2Id;
statusOk = initMessageResponseAppServiceCaller2.Response.Status == Status.ErrorNotFound;
initMessageOk = idOk && statusOk;
}
catch
{
log.Trace("Expected exception occurred.");
disconnectOk = true;
}
// Step 8 Acceptance
bool step8Ok = initMessageOk || disconnectOk;
log.Trace("Step 8: {0}", step8Ok ? "PASSED" : "FAILED");
// Step 9
log.Trace("Step 9");
// Receive ACK message #1.
responseMessageAppServiceCaller = await clientCaller1AppService.ReceiveMessageAsync();
idOk = responseMessageAppServiceCaller.Id == callerMessage1Id;
statusOk = responseMessageAppServiceCaller.Response.Status == Status.Ok;
receivedVersion = new SemVer(responseMessageAppServiceCaller.Response.SingleResponse.Version);
versionOk = receivedVersion.Equals(SemVer.V100);
bool receiveAckOk = idOk && statusOk && versionOk;
// Step 9 Acceptance
bool step9Ok = receiveAckOk;
log.Trace("Step 9: {0}", step9Ok ? "PASSED" : "FAILED");
Passed = step1Ok && step2Ok && step3Ok && step4Ok && step5Ok && step6Ok && step7Ok && step8Ok && step9Ok;
res = true;
}
catch (Exception e)
{
log.Error("Exception occurred: {0}", e.ToString());
}
clientCallee.Dispose();
clientCalleeAppService.Dispose();
clientCaller1.Dispose();
clientCaller1AppService.Dispose();
clientCaller2.Dispose();
clientCaller2AppService.Dispose();
log.Trace("(-):{0}", res);
return(res);
}
