protected override void Given()
            {
                var handshakeResponse = new HandshakeResponse
                {
                    Ok           = true,
                    WebSocketUrl = "some-valid-url"
                };

                GetMockFor <IHandshakeClient>()
                .Setup(x => x.FirmShake(SlackKey))
                .ReturnsAsync(handshakeResponse);

                Connection = new SlackConnectionStub();
                SlackFactoryStub.Create_Value = Connection;

                GetMockFor <IConnectionFactory>()
                .Setup(x => x.CreateHandshakeClient())
                .Returns(GetMockFor <IHandshakeClient>().Object);

                ProxySettings = new ProxySettings("hi", "you", "ok?");
                GetMockFor <IConnectionFactory>()
                .Setup(x => x.CreateWebSocketClient(handshakeResponse.WebSocketUrl, ProxySettings))
                .Returns(GetMockFor <IWebSocketClient>().Object);

                GetMockFor <IWebSocketClient>()
                .Setup(x => x.Connect())
                .Returns(Task.Factory.StartNew(() => { }));
            }
Пример #2
0
        private Dictionary <string, SlackChatHub> GetChatHubs(HandshakeResponse handshakeResponse)
        {
            var hubs = new Dictionary <string, SlackChatHub>();

            foreach (Channel channel in handshakeResponse.Channels.Where(x => !x.IsArchived))
            {
                if (channel.IsMember)
                {
                    hubs.Add(channel.Id, _cachedDataProvider.GetChatHub(channel));
                }
            }

            foreach (Group group in handshakeResponse.Groups.Where(x => !x.IsArchived))
            {
                if (group.Members.Any(x => x == handshakeResponse.Self.Id))
                {
                    var users = new List <User>();
                    foreach (var userId in group.Members)
                    {
                        users.Add(handshakeResponse.Users.FirstOrDefault(x => x.Id == userId));
                    }
                    var usersName = users.Select(x => x?.Name);
                    hubs.Add(group.Id, _cachedDataProvider.GetChatHub(group, usersName?.ToArray()));
                }
            }

            foreach (Im im in handshakeResponse.Ims)
            {
                User user     = handshakeResponse.Users.FirstOrDefault(x => x.Id == im.User);
                var  userName = user?.Name;
                hubs.Add(im.Id, _cachedDataProvider.GetChatHub(im, userName));
            }

            return(hubs);
        }
Пример #3
0
        private Dictionary <string, SlackUser> GenerateUsers(HandshakeResponse handshakeResponse)
        {
            var users = new Dictionary <string, SlackUser>();

            foreach (var user in handshakeResponse.Users)
            {
                var slackUser = new SlackUser
                {
                    Id    = user.Id,
                    Name  = user.Name,
                    IsBot = false,
                    Icons = user.Profile?.Icons
                };
                users.Add(user.Id, slackUser);
            }

            foreach (var bot in handshakeResponse.Bots)
            {
                var slackUser = new SlackUser
                {
                    Id    = bot.Id,
                    Name  = bot.Name,
                    IsBot = true,
                    Icons = bot.Icons
                };
                users.Add(bot.Id, slackUser);
            }

            return(users);
        }
        public void Constructor_InitializesPropertiesForError()
        {
            var response = new HandshakeResponse(MessageResponseCode.Error, protocolVersion: null);

            Assert.Equal(MessageResponseCode.Error, response.ResponseCode);
            Assert.Null(response.ProtocolVersion);
        }
        public void Constructor_InitializesPropertiesForSuccess()
        {
            var response = new HandshakeResponse(MessageResponseCode.Success, _version);

            Assert.Equal(MessageResponseCode.Success, response.ResponseCode);
            Assert.Equal(_version, response.ProtocolVersion);
        }
Пример #6
0
        public static void ClientFinish(TlsConnection connection, int length)
        {
            Log.Info("Recv ClientFinish");

            var sha256        = SHA256.Create();
            var handshakeData = connection.HandshakeMessages.GetRange(0, connection.HandshakeMessages.Count - length - 4).ToArray();
            var handshakeHash = sha256.ComputeHash(handshakeData);

            var prfClient = new PseudoRandomFunction(connection.MasterSecretBytes, "client finished", handshakeHash);

            byte[] clientVerifyData = prfClient.GenerateBytes(12);

            byte[] data = connection.Buffer.Read(12);
            for (uint i = 0; i < 12; i++)
            {
                if (clientVerifyData[i] != data[i])
                {
                    Log.Error("Invalid ClientFinish!");
                    return;
                }
            }

            HandshakeResponse.ServerChangeCipherSpec(connection);
            connection.SendEncrypted = true;
            HandshakeResponse.ServerServerFinish(connection);
        }
            protected override void Given()
            {
                HandshakeResponse = new HandshakeResponse
                {
                    Ok   = true,
                    Self = new Detail {
                        Id = "my-id", Name = "my-name"
                    },
                    Team = new Detail {
                        Id = "team-id", Name = "team-name"
                    },
                    Users = new[]
                    {
                        new User {
                            Id = "user-1-id", Name = "user-1-name"
                        },
                        new User {
                            Id = "user-2-id", Name = "user-2-name"
                        },
                    },
                    Channels = new[]
                    {
                        new Channel {
                            Id = "i-am-a-channel", Name = "channel-name", IsMember = true
                        }
                    },
                    Groups = new[]
                    {
                        new Group {
                            Id = "i-am-a-group", Name = "group-name", Members = new [] { "my-id" }
                        },
                    },
                    Ims = new[]
                    {
                        new Im {
                            Id = "i-am-a-im", User = "******"
                        }
                    },
                    WebSocketUrl = "some-valid-url"
                };

                GetMockFor <IHandshakeClient>()
                .Setup(x => x.FirmShake(SlackKey))
                .ReturnsAsync(HandshakeResponse);

                Connection = new SlackConnectionStub();
                SlackFactoryStub.Create_Value = Connection;

                GetMockFor <IConnectionFactory>()
                .Setup(x => x.CreateHandshakeClient())
                .Returns(GetMockFor <IHandshakeClient>().Object);

                GetMockFor <IConnectionFactory>()
                .Setup(x => x.CreateWebSocketClient(HandshakeResponse.WebSocketUrl, null))
                .Returns(GetMockFor <IWebSocketClient>().Object);

                GetMockFor <IWebSocketClient>()
                .Setup(x => x.Connect())
                .Returns(Task.Factory.StartNew(() => { }));
            }
Пример #8
0
        private async Task <IWebSocketClient> GetWebSocket(HandshakeResponse handshakeResponse, ProxySettings proxySettings)
        {
            var webSocketClient = _connectionFactory.CreateWebSocketClient(handshakeResponse.WebSocketUrl, proxySettings);
            await webSocketClient.Connect();

            return(webSocketClient);
        }
        /// <summary>
        /// 分组命令
        /// </summary>
        /// <param name="response">握手返回值</param>
        /// <param name="secrets">密码列表</param>
        /// <param name="groupNumber">当前组数量 从1 开始</param>
        public GroupingCommandRequest(HandshakeResponse response, List <UInt64> secrets, int groupNumber, shareAction1 s1, shareAction2 s2) : base(response, s1, s2)
        {
            this.dataBelong = 0;
            this.number     = groupNumber;
            this.dotPwoer   = secrets.Count();
            var           baseOffset = (groupNumber - 1) * 4;
            var           maxOffset  = baseOffset + 4;
            List <UInt64> secretsInt = new List <UInt64>();

            if (baseOffset + 4 >= secrets.Count())
            {
                maxOffset = secrets.Count();
            }
            for (int i = baseOffset; i < maxOffset; i++)
            {
                secretsInt.Add(secrets[i]);
            }
            if (secretsInt.Count() < 4)
            {
                var count = secretsInt.Count();
                for (int i = 0; i < 4 - count; i++)
                {
                    secretsInt.Add(0);
                }
            }
            this.request += secretsInt[0] << 48;
            this.request += secretsInt[1] << 32;
            this.request += secretsInt[2] << 16;
            this.request += secretsInt[3];
        }
        public async Task should_return_expected_connection()
        {
            // given
            var handshakeResponse = new HandshakeResponse
            {
                Ok   = true,
                Self = new Detail {
                    Id = "my-id", Name = "my-name"
                },
                WebSocketUrl = _webSocketUrl
            };

            _handshakeClient
            .Setup(x => x.FirmShake(_slackKey))
            .ReturnsAsync(handshakeResponse);

            var expectedConnection = new Mock <ISlackConnection>().Object;

            _slackConnectionFactory
            .Setup(x => x.Create(It.IsAny <ConnectionInformation>()))
            .ReturnsAsync(expectedConnection);

            // when
            var result = await _slackConnector.Connect(_slackKey);

            // then
            result.ShouldBe(expectedConnection);
        }
        public async Task should_initialise_connection_with_expected_users_details()
        {
            // given
            var handshakeResponse = new HandshakeResponse
            {
                Ok    = true,
                Users = new[]
                {
                    new User {
                        Id = "user-1-id", Name = "user-1-name"
                    },
                    new User {
                        Id = "user-2-id", Name = "user-2-name"
                    },
                },
                WebSocketUrl = _webSocketUrl
            };

            _handshakeClient
            .Setup(x => x.FirmShake(_slackKey))
            .ReturnsAsync(handshakeResponse);

            // when
            await _slackConnector.Connect(_slackKey);

            // then
            _slackConnectionFactory
            .Verify(x => x.Create(It.Is((ConnectionInformation p) => p.Users.Count == 2)), Times.Once);
            _slackConnectionFactory
            .Verify(x => x.Create(It.Is((ConnectionInformation p) => p.Users["user-1-id"].Name == "user-1-name")), Times.Once);
            _slackConnectionFactory
            .Verify(x => x.Create(It.Is((ConnectionInformation p) => p.Users["user-2-id"].Name == "user-2-name")), Times.Once);
        }
Пример #12
0
        public async Task should_not_contain_channels_that_are_archived_and_bot_is_not_a_member_off()
        {
            // given
            var handshakeResponse = new HandshakeResponse
            {
                Ok       = true,
                Channels = new[]
                {
                    new Channel
                    {
                        Id         = "Id1",
                        Name       = "Name1",
                        IsArchived = false,
                        IsMember   = false
                    }
                }
            };

            _handshakeClient
            .Setup(x => x.FirmShake(It.IsAny <string>()))
            .ReturnsAsync(handshakeResponse);

            // when
            await _slackConnector.Connect("something");

            // then
            _slackConnectionFactory
            .Verify(x => x.Create(It.Is((ConnectionInformation p) => p.SlackChatHubs.Count == 0)), Times.Once);
        }
Пример #13
0
        public async Task <ISlackConnection> Connect(string slackKey)
        {
            if (string.IsNullOrEmpty(slackKey))
            {
                throw new ArgumentNullException(nameof(slackKey));
            }

            var handshakeClient = this._connectionFactory.CreateHandshakeClient();
            HandshakeResponse handshakeResponse = await handshakeClient.FirmShake(slackKey);

            if (!handshakeResponse.Ok)
            {
                throw new HandshakeException(handshakeResponse.Error);
            }

            Dictionary <string, SlackUser> users = this.GenerateUsers(handshakeResponse.Users);

            var connectionInfo = new ConnectionInformation
            {
                SlackKey = slackKey,
                Self     = new ContactDetails {
                    Id = handshakeResponse.Self.Id, Name = handshakeResponse.Self.Name
                },
                Team = new ContactDetails {
                    Id = handshakeResponse.Team.Id, Name = handshakeResponse.Team.Name
                },
                Users         = users,
                SlackChatHubs = this.GetChatHubs(handshakeResponse, users.Values.ToArray()),
                WebSocket     = await this._connectionFactory.CreateWebSocketClient(handshakeResponse.WebSocketUrl, null)
            };

            var connection = await this._slackConnectionFactory.Create(connectionInfo);

            return(connection);
        }
        public async Task should_initialise_connection_with_expected_self_details()
        {
            // given
            var handshakeResponse = new HandshakeResponse
            {
                Ok   = true,
                Self = new Detail {
                    Id = "my-id", Name = "my-name"
                },
                WebSocketUrl = _webSocketUrl
            };

            _handshakeClient
            .Setup(x => x.FirmShake(_slackKey))
            .ReturnsAsync(handshakeResponse);

            // when
            await _slackConnector.Connect(_slackKey);

            // then
            _slackConnectionFactory
            .Verify(x => x.Create(It.Is((ConnectionInformation p) => p.Self.Id == handshakeResponse.Self.Id)), Times.Once);
            _slackConnectionFactory
            .Verify(x => x.Create(It.Is((ConnectionInformation p) => p.Self.Name == handshakeResponse.Self.Name)), Times.Once);
        }
Пример #15
0
        public async Task should_not_contain_archived_groups()
        {
            // given
            var handshakeResponse = new HandshakeResponse
            {
                Ok     = true,
                Groups = new[]
                {
                    new Group
                    {
                        Id         = "group-id",
                        Name       = "group-name",
                        IsArchived = true
                    }
                }
            };

            _handshakeClient
            .Setup(x => x.FirmShake(It.IsAny <string>()))
            .ReturnsAsync(handshakeResponse);

            // when
            await _slackConnector.Connect("something");

            // then
            _slackConnectionFactory
            .Verify(x => x.Create(It.Is((ConnectionInformation p) => p.SlackChatHubs.Count == 0)), Times.Once);
        }
Пример #16
0
        public async Task should_call_expected_url_with_given_slack_key()
        {
            // given
            const string slackKey = "I-is-da-key-yeah";

            var expectedResponse = new HandshakeResponse
            {
                Ok           = true,
                WebSocketUrl = "some-url"
            };

            _httpTest.RespondWithJson(expectedResponse);

            // when
            var result = await _handshakeClient.FirmShake(slackKey);

            // then
            _responseVerifierMock.Verify(x => x.VerifyResponse(Looks.Like(expectedResponse)));
            _httpTest
            .ShouldHaveCalled(ClientConstants.SlackApiHost.AppendPathSegment(FlurlHandshakeClient.HANDSHAKE_PATH))
            .WithQueryParamValue("token", slackKey)
            .Times(1);

            result.ToExpectedObject().ShouldEqual(expectedResponse);
        }
Пример #17
0
        public void Write(IContext context, object msg)
        {
            HttpResponse response = msg as HttpResponse;

            if (response != null)
            {
                bool isContinue = true;
                if (_config.StatusListener != null && response.Status != 200)
                {
                    isContinue = _config.StatusListener(response);
                }
                if (isContinue)
                {
                    response.KeepAlive = _keepalive;
                    if (_config.DisableGzip)
                    {
                        response.Gzip = false;
                    }
                    HttpResponseEncoder.WriteResponse(response);
                    context.FirePreWrite(msg);
                }
            }
            else
            {
                HandshakeResponse websockethandshake = msg as HandshakeResponse;
                if (websockethandshake != null)
                {
                    HttpResponseEncoder.WriteWebSocketHandshakeResponse(websockethandshake);
                    //升级协议为websocket
                    _source.SetState(new WebSocketState(context, _source, _config));
                }
                context.FirePreWrite(msg);
            }
        }
        public void HandleResponse_SecondResponseIsIgnored()
        {
            using (var test = new OutboundRequestContextTest())
            {
                var payload       = new HandshakeResponse(MessageResponseCode.Error, protocolVersion: null);
                var firstResponse = MessageUtilities.Create(
                    test.Request.RequestId,
                    MessageType.Response,
                    test.Request.Method,
                    payload);

                test.Context.HandleResponse(firstResponse);

                var response = test.Context.CompletionTask.Result;

                payload = new HandshakeResponse(MessageResponseCode.Success, ProtocolConstants.CurrentVersion);
                var secondResponse = MessageUtilities.Create(
                    test.Request.RequestId,
                    MessageType.Response,
                    test.Request.Method,
                    payload);

                test.Context.HandleResponse(secondResponse);

                Assert.Same(response, test.Context.CompletionTask.Result);
            }
        }
Пример #19
0
        public async Task <ISlackConnection> Connect(string slackKey, ProxySettings proxySettings = null)
        {
            if (string.IsNullOrEmpty(slackKey))
            {
                throw new ArgumentNullException(nameof(slackKey));
            }

            var handshakeClient = _connectionFactory.CreateHandshakeClient();
            HandshakeResponse handshakeResponse = await handshakeClient.FirmShake(slackKey);

            if (!handshakeResponse.Ok)
            {
                throw new HandshakeException(handshakeResponse.Error);
            }

            var connectionInfo = new ConnectionInformation
            {
                SlackKey = slackKey,
                Self     = new ContactDetails {
                    Id = handshakeResponse.Self.Id, Name = handshakeResponse.Self.Name
                },
                Team = new ContactDetails {
                    Id = handshakeResponse.Team.Id, Name = handshakeResponse.Team.Name
                },
                Users         = GenerateUsers(handshakeResponse.Users),
                SlackChatHubs = GetChatHubs(handshakeResponse),
                WebSocket     = await GetWebSocket(handshakeResponse, proxySettings)
            };

            return(_slackConnectionFactory.Create(connectionInfo));
        }
Пример #20
0
        private Dictionary <string, SlackChatHub> GetChatHubs(HandshakeResponse handshakeResponse, SlackUser[] users)
        {
            var hubs = new Dictionary <string, SlackChatHub>();

            foreach (Channel channel in handshakeResponse.Channels.Where(x => !x.IsArchived))
            {
                if (channel.IsMember)
                {
                    var newChannel = channel.ToChatHub();
                    hubs.Add(channel.Id, newChannel);
                }
            }

            foreach (Group group in handshakeResponse.Groups.Where(x => !x.IsArchived))
            {
                if ((group.Members ?? new string[0]).Any(x => x == handshakeResponse.Self.Id))
                {
                    var newGroup = group.ToChatHub();
                    hubs.Add(group.Id, newGroup);
                }
            }

            foreach (Im im in handshakeResponse.Ims)
            {
                hubs.Add(im.Id, im.ToChatHub(users));
            }

            return(hubs);
        }
        public async Task should_initialise_connection_with_websocket_and_return_expected_connection()
        {
            // given
            var handshakeResponse = new HandshakeResponse
            {
                Ok           = true,
                WebSocketUrl = _webSocketUrl
            };

            _handshakeClient
            .Setup(x => x.FirmShake(_slackKey))
            .ReturnsAsync(handshakeResponse);

            var expectedConnection = new Mock <ISlackConnection>().Object;

            _slackConnectionFactory
            .Setup(x => x.Create(It.IsAny <ConnectionInformation>()))
            .ReturnsAsync(expectedConnection);

            // when
            var result = await _slackConnector.Connect(_slackKey);

            // then
            result.ShouldBe(expectedConnection);

            _slackConnectionFactory
            .Verify(x => x.Create(It.Is((ConnectionInformation p) => p.WebSocket == _webSocketClient.Object)), Times.Once);
            _connectionFactory.Verify(x => x.CreateWebSocketClient(_webSocketUrl));
        }
Пример #22
0
        public async Task CloseAsync()
        {
            ThrowIfNotStarted();

            Logger.LogInformation("Closing socket connection.");

            try
            {
                State = ReadyState.Closing;

                //don't receive anything from underlying socket anymore
                _pingPongSubscription.Dispose();
                _messageSubscription.Dispose();
                _disconnectSubscription.Dispose();

                //clean anything set during socket startup/run time
                _packetId         = -1;
                _currentHandshake = null;
                _sentPingPackets.Clear();

                //finally stop the socket
                await _socket.StopOrFail(WebSocketCloseStatus.NormalClosure, string.Empty);
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, "Error while stopping socket.");
                throw;
            }
            finally
            {
                Logger.LogInformation("Socket connection closed.");
                State = ReadyState.Closed;
            }
        }
 public PushScoreCommandRequest(HandshakeResponse response, shareAction1 s1, shareAction2 s2, long problemNumber, String answer) : base(response, s1, s2)
 {
     this.dataBelong         = 64;
     this.number             = 130;
     this.dotPwoer           = SubVoteDisplayAction.GetSubVoteDisplayAction(answer);
     this.request            = SubVoteDisplayAction.GetDisplayData(answer);
     this.handshakeSecretKey = 2;
 }
        internal void SendAuthChallenge(string challenge)
        {
            HandshakeResponse handshakeResponse = new HandshakeResponse(HttpStatusCode.Unauthorized);

            handshakeResponse.Headers["WWW-Authenticate"] = challenge;
            this._stream.WriteHandshake(handshakeResponse);
            this._request = this._stream.ReadHandshake <HandshakeRequest>(new Func <string[], HandshakeRequest>(HandshakeRequest.Parse), 15000);
        }
Пример #25
0
        public void JsonSerialization_ReturnsCorrectJson()
        {
            var response = new HandshakeResponse(MessageResponseCode.Success, _version);

            var json = TestUtilities.Serialize(response);

            Assert.Equal("{\"ResponseCode\":\"Success\",\"ProtocolVersion\":\"1.0.0\"}", json);
        }
        internal void SendAuthChallenge(string challenge)
        {
            var res = new HandshakeResponse(HttpStatusCode.Unauthorized);

            res.Headers ["WWW-Authenticate"] = challenge;
            _stream.WriteHandshake(res);
            _request = _stream.ReadHandshake <HandshakeRequest> (HandshakeRequest.Parse, 15000);
        }
        public ActionResult <HandshakeResponse> Handshake()
        {
            var response = new HandshakeResponse
            {
                UploadId = Guid.NewGuid()
            };

            return(Ok(response));
        }
Пример #28
0
        public void SendHandshakeResponse(ClientConnectionInfo connection, HandshakeResponseCode responseCode)
        {
            var handShakeResponse = new HandshakeResponse
            {
                ResponseCode = responseCode
            };

            DefaultSend(connection, handShakeResponse.Create(), ChannelID.Handshaking, true);
        }
Пример #29
0
        /// <summary>
        /// Websocket 握手输出
        /// </summary>
        /// <param name="response"></param>
        public static void WriteWebSocketHandshakeResponse(HandshakeResponse response)
        {
            HeaderBuilder builder = HeaderBuilder.NewResonse(101, "Switching Protocols");

            builder.Add("Upgrade", "websocket");
            builder.Add("Connection", "Upgrade");
            builder.Add("Sec-WebSocket-Accept", response.CreateResponseKey());
            builder.Add("Server", Utility.PRODUCT_NAME);
            response.Stream.WriteBytes(builder.ToByteArray());
        }
Пример #30
0
        public static Byte[] Decrypt(Byte[] list, HandshakeResponse hand)
        {
            List <Byte> finlist = new List <byte>();

            for (int i = 4; i < 20; i++)
            {
                finlist.Add(list[i]);
            }
            return(Decrypt(finlist, list[3], list[2]));
        }
 internal void SendAuthChallenge (string challenge)
 {
   var res = new HandshakeResponse (HttpStatusCode.Unauthorized);
   res.Headers ["WWW-Authenticate"] = challenge;
   _stream.WriteHandshake (res);
   _request = _stream.ReadHandshake<HandshakeRequest> (HandshakeRequest.Parse, 15000);
 }
Пример #32
0
 static HandshakeResponse()
 {
     Accepted = new HandshakeResponse(true);
     Rejected = new HandshakeResponse(false);
 }
Пример #33
0
    private void ServerMessageReceived(NetworkClient senderClient, int messageType, ByteString messageContent)
    {
      Debug.Log("Server message Type={0} Size={1}.", messageType, messageContent.Length);

      switch (messageType) {
        /* Handshake request. */
        case MessageType.ClientHandshakeRequest: {
            HandshakeRequest request = HandshakeRequest.Parser.ParseFrom(messageContent);
            senderClient.UpdatePublicKey(request.Key);

            PublicKey serverPublic = this.ServerKey;
            if (serverPublic == null) {
              Debug.Error("Server public key is invalid.");
              return;
            }

            HandshakeResponse response = new HandshakeResponse();
            response.Key = serverPublic;
            senderClient.SendMessage(MessageType.ClientHandshakeResponse, response);
          }
          break;

        /* Authorization request. */
        case MessageType.AuthorizationRequest: {
            AuthorizationRequest request = AuthorizationRequest.Parser.ParseFrom(messageContent);
            senderClient.Profile.UpdateProfile(request);

            AuthorizationResponse response = new AuthorizationResponse();
            response.ServerName = this.m_serverConfig.ServerName;
            senderClient.SendMessage(MessageType.AuthorizationResponse, response);

            Task.Run(() => {
              ContactUpdate contactUpdate = new ContactUpdate();
              contactUpdate.Add.Add(senderClient.ContactClient);

              foreach (NetworkClient connectedClient in this.m_connectedClients) {
                if (connectedClient.ClientId == senderClient.ClientId) continue;

                Debug.Log("Sending contact update to ClientId={0}.", connectedClient.ClientId);
                connectedClient.SendMessage(MessageType.ContactUpdate, contactUpdate);
              }
            });
          }
          break;

        /* Contact list update. */
        case MessageType.ContactUpdateRequest: {
            ContactUpdateRequest request = ContactUpdateRequest.Parser.ParseFrom(messageContent);
            ContactUpdate contactUpdate = new ContactUpdate();

            List<long> clientList = request.Clients.ToList();
            foreach (NetworkClient connectedClient in this.m_connectedClients) {
              // if (connectedClient.ClientId == senderClient.ClientId) continue;
              if (!connectedClient.Profile.Valid) continue;

              if (clientList.Contains(connectedClient.ClientId)) {
                Debug.Log("Client {0} has got ClientId={1}.", senderClient.ClientId, connectedClient.ClientId);
                clientList.Remove(connectedClient.ClientId);
              }
              else {
                Debug.Log("Client {0} requires ClientId={1}.", senderClient.ClientId, connectedClient.ClientId);
                contactUpdate.Add.Add(connectedClient.ContactClient);
              }
            }

            Debug.Log("Trash clients count={0}.", clientList.Count);
            if (clientList.Count > 0) {
              contactUpdate.Remove.Add(clientList);
            }
            senderClient.SendMessage(MessageType.ContactUpdate, contactUpdate);
          }
          break;

        case MessageType.ContactUpdateChangeRequest: {
            ContactUpdateChangeRequest clientRequestedChange = ContactUpdateChangeRequest.Parser.ParseFrom(messageContent);
            var senderProfile = senderClient.Profile;

            if (senderProfile.Name != clientRequestedChange.Name || senderProfile.Surname != clientRequestedChange.Surname) {
              Debug.Log("Updating client data. This is not implemented on the client side. ;)");
            }
            else if(senderProfile.Status != clientRequestedChange.Online) {
              senderProfile.Status = clientRequestedChange.Online;

              ContactUpdateStatus statusUpdate = new ContactUpdateStatus();
              statusUpdate.Online = clientRequestedChange.Online;
              statusUpdate.ClientId = senderClient.ClientId;

              foreach (NetworkClient connectedClient in this.m_connectedClients) {
                // if (connectedClient.ClientId == senderClient.ClientId) continue;

                Debug.Log("Sending status update to ClientId={0}.", connectedClient.ClientId);
                connectedClient.SendMessage(MessageType.ContactUpdateStatus, statusUpdate);
              }
            }
          }
          break;

        /* Client Public Key request. */
        case MessageType.MessageClientPublicRequest: {
            MessageRequestClientPublic requestMessage = MessageRequestClientPublic.Parser.ParseFrom(messageContent);
            PublicKey responseKey = null;

            foreach (NetworkClient connectedClient in this.m_connectedClients) {
              if (connectedClient.ClientId == requestMessage.ClientId) {
                responseKey = connectedClient.ClientPublic;
              }
            }

            if (responseKey != null) {
              MessageResponseClientPublic responseMessage = new MessageResponseClientPublic();
              responseMessage.ClientId = requestMessage.ClientId;
              responseMessage.Key = responseKey;

              senderClient.SendMessage(MessageType.MessageClientPublicResponse, responseMessage);
            }
            else 
              Debug.Warn("ClientId={0} has invalid public key.");
          }
          break;
      }
    }