Example #1
0
        static void HandlePacket(long id, Packet packet)
        {
            var          info      = clients[id];
            var          formatter = new BinaryFormatter();
            MemoryStream stream    = new MemoryStream(packet.Data, 0, packet.DataLength);

            switch (packet.MessageType)
            {
            case MessageType.AUTH_REQUEST: {
                Debug.Assert(info.Authenticated == false);
                var msg = (AuthRequest)formatter.Deserialize(stream);
                info.Authenticated = true;
                info.Name          = msg.Name;

                var reply = new AuthReply()
                {
                    Id = id,
                };
                var sendPacket = info.ToPacket(reply);
                info.Socket.GetStream().Write(sendPacket.ToBytes());

                Console.WriteLine("Login {0}", info.Name);
            }
            break;
            }
        }
Example #2
0
        public override Task <AuthReply> Login(AuthRequest request, ServerCallContext context)
        {
            AuthReply authReply = new AuthReply();

            authReply.Token = "result token";

            return(Task.FromResult(authReply));
        }
        public override Task <AuthReply> Authentication(AuthRequest request, ServerCallContext context)
        {
            // invalid accountname
            if (request.AccountName == null || request.AccountName.Length < 3)
            {
                Log.Warn($"{request.AccountName} is invalid!");
                return(Task.FromResult(new AuthReply()
                {
                    RequestState = false
                }));
            }

            var user = _registredUsers.Values.ToList().Find(p => p.AccountName == request.AccountName);

            // already authentificated accounts
            if (user != null)
            {
                if (user.Peer.Equals(context.Peer))
                {
                    Log.Warn($"{request.AccountName} is already registred, with the same peer!");
                    return(Task.FromResult(new AuthReply {
                        RequestState = false
                    }));
                }

                // TODO same account with a new connection
                Log.Warn($"{request.AccountName} is already registred, with a different peer!");
                return(Task.FromResult(new AuthReply {
                    RequestState = false
                }));
            }

            var sessionId = NextSessionIndex;
            var userInfo  = new UserDataInfo
            {
                Peer        = context.Peer,
                Token       = Helper.ComputeSha256Hash(sessionId + request.AccountName + context.Peer),
                SessionId   = sessionId,
                AccountName = request.AccountName,
                UserState   = UserState.None,
                GameId      = -1,
                DeckType    = DeckType.None,
                DeckData    = string.Empty,
                PlayerState = PlayerState.None,
                PlayerId    = -1
            };


            // failed registration
            if (!_registredUsers.TryAdd(userInfo.Token, userInfo))
            {
                Log.Warn($"failed to register user with account {request.AccountName}!");
                return(Task.FromResult(new AuthReply {
                    RequestState = false
                }));
            }

            Log.Info($"Successfully registred user with account {request.AccountName}!");

            var reply = new AuthReply
            {
                RequestState   = true,
                RequestMessage = string.Empty,
                SessionId      = userInfo.SessionId,
                SessionToken   = userInfo.Token
            };

            return(Task.FromResult(reply));
        }