示例#1
0
        /// <summary>
        ///     Opens a stream for clients to connect and send objects to.
        ///     Server sends back an object if needed depending on received object.
        /// </summary>
        /// <param name="client"></param>
        private static void TcpHandler(object client)
        {
            var clientIp = "";
            try
            {
                var tcpClient = (TcpClient)client;
                var stream = tcpClient.GetStream();
                clientIp = ((IPEndPoint)tcpClient.Client.RemoteEndPoint).Address.ToString();

                Logger.Info("Connected client: {0}, TTL: {1}, Protocol: {2}",
                    clientIp,
                    tcpClient.Client.Ttl,
                    tcpClient.Client.ProtocolType);

                if (!ObjectHandler.CheckUserAuthentication(stream, clientIp))
                    tcpClient.Close();

                while (tcpClient.Connected)
                {
                    var receivedMessage = new MyMessage();
                    // Reads input message from the client
                    stream.Read(receivedMessage.Data, 0, receivedMessage.Data.Length);
                    // Unpacks the object for inspection
                    var receivedObject = Serializer.Deserialize(receivedMessage);

                    var logout = receivedObject as string;
                    if (logout == "Logout")
                    {
                        break;
                    }
                    receivedMessage = ObjectHandler.HandleObject(receivedObject);
                    stream.Write(receivedMessage.Data, 0, receivedMessage.Data.Length);
                }
                Logger.Info("Client: {0} disconnected.\n", clientIp);
                stream.Close();
                tcpClient.Close();
            }
            catch (InvalidCastException invalidCastException)
            {
                Logger.Info("InvalidCastException: " + invalidCastException.Message);
            }
            catch (EndOfStreamException endOfStreamException)
            {
                Logger.Info("EndOfStreamException: " + endOfStreamException.Message);
            }
            catch (IOException ioException)
            {
                Logger.Info("IOException: " + ioException.Message);
            }
            catch (SocketException socketException)
            {
                Logger.Info("SocketException: " + socketException.Message);
            }
            finally
            {
                Person tPerson;
                Users.TryRemove(clientIp, out tPerson);
            }
        }
示例#2
0
 /// <summary>
 ///     Reads the stream with data from server
 /// </summary>
 /// <returns>Received object from server</returns>
 public static object ReceiveFromServer()
 {
     var recmsg = new MyMessage();
     //if (MainStream.DataAvailable)
     MainStream.Read(recmsg.Data, 0, recmsg.Data.Length);
     var receivedObject = Serializer.Deserialize(recmsg);
     Logger.Info($"{((IPEndPoint)MainTcpClient.Client.RemoteEndPoint).Address}: Receiving {receivedObject.GetType()} from server");
     return receivedObject;
 }
示例#3
0
 public static object Deserialize(MyMessage message)
 {
     try
     {
         using (var memoryStream = new MemoryStream(message.Data))
             return new BinaryFormatter().Deserialize(memoryStream);
     }
     catch (SerializationException serializationException)
     {
         return "SerializationException: " + serializationException.Message;
     }
 }
示例#4
0
        private static void TcpHandler(object client)
        {
            var mClient = (TcpClient)client;
            var stream = mClient.GetStream();

            var mm = new MyMessage();
            // Reads input message from the client
            var message = new byte[4096];
            stream.Read(message, 0, message.Length);
            mm.Data = message;
            var obj = Serializer.Deserialize(mm);
            if (obj is Diver)
                //GetDiverObject(diverEtt as Diver);

            stream.Close();
            mClient.Close();
        }
示例#5
0
 public static bool CheckUserAuthentication(NetworkStream stream, string ipAdress)
 {
     lock (NetworkHandler.Users)
     {
         try
         {
             Person person = null;
             var loginMsg = new MyMessage();
             stream.Read(loginMsg.Data, 0, loginMsg.Data.Length);
             var loginInfo = Serializer.Deserialize(loginMsg) as string;
             var str = loginInfo?.Split(';');
             if (str?[0] == "LI")
             {
                 Logger.Info("Client Authentication. Validating username {0}.", str[1]);
                 var validate = DbHandler.LoginCheck(str[1], str[2]);
                 person = validate as Person;
                 if (person != null)
                 {
                     Logger.Info("IP: " + ipAdress + " linked with " + person);
                     NetworkHandler.Users.TryAdd(ipAdress, person);
                 }
                 if (validate is string)
                 {
                     if ((string)validate == "WI")
                         loginMsg = Serializer.Serialize("Fel användarnamn eller lösenord.");
                 }
                 else
                     loginMsg = Serializer.Serialize(validate);
             }
             stream.Write(loginMsg.Data, 0, loginMsg.Data.Length);
             if (person != null)
                 return true;
         }
         catch (IndexOutOfRangeException indexOutOfRangeException)
         {
             Logger.Info("IndexOutOfRangeException: " + indexOutOfRangeException.Message);
         }
         return false;
     }
 }
示例#6
0
        /// <summary>
        ///     Handles the unpacked objects
        /// </summary>
        /// <param name="obj">Received object</param>
        public static MyMessage HandleObject(object obj)
        {
            var returnMessage = new MyMessage();

            try
            {
                var diver = obj as Diver;
                if (diver != null)
                {
                    DbHandler.InsertDiver(diver);
                    const string returnString = "Diver inserted!\n";
                    returnMessage = Serializer.Serialize(returnString);
                }

                var dive = obj as Dive;
                if (dive != null)
                {
                    CompetitionHandler.SetCurrentDive(dive);
                    string returnString = $"Current active dive = {dive}!\n";
                    returnMessage = Serializer.Serialize(returnString);
                }

                var assessment = obj as Assessment;
                if (assessment != null)
                {
                    CompetitionHandler.AddAssessment(assessment);
                    returnMessage = Serializer.Serialize("Assessment done.\n");
                }

                var operationCode = obj as string;
                if (operationCode != null)
                {
                    returnMessage = OperationCodeHandler((string)obj);
                }

                var competition = obj as Competition;
                if (competition != null)
                {
                    DbHandler.InsertCompetition(competition);
                    const string returnString = "Competition inserted!\n";
                    returnMessage = Serializer.Serialize(returnString);
                }

                var referee = obj as Referee;
                if (referee != null)
                {
                    DbHandler.InsertReferee(referee);
                    const string returnString = "Referee inserted!\n";
                    returnMessage = Serializer.Serialize(returnString);
                }
            }
            catch (ArgumentNullException argumentNullException)
            {
                var str = "ArgumentNullException: " + argumentNullException.Message;
                Logger.Debug(str);
                returnMessage = Serializer.Serialize(str);
            }
            finally
            {
                Logger.Info("Serialized message length: {0}\n", returnMessage.Data.Length);
            }
            return returnMessage;
        }
示例#7
0
        /// <summary>
        ///     Hanterar operationskoder. Skickar tillbaka ett objekt beroende på kod.
        /// </summary>
        /// <param name="obj">Operationskod</param>
        /// <param name="stream">
        /// </param>
        private static MyMessage OperationCodeHandler(string obj)
        {
            var messageOut = new MyMessage();
            try
            {
                Logger.Info($"Executing operationcode: {obj}");
                object tempObject;
                switch (obj)
                {
                    case "GetDivers": // Hämtar diver-lista
                        tempObject = DbHandler.GetDivers();
                        messageOut = Serializer.Serialize(tempObject);
                        break;

                    case "GetLeaderList":
                        messageOut = Serializer.Serialize(CompetitionHandler.ActiveCompetition.ListDiver);
                        break;

                    case "GetDiveTypes":
                        tempObject = DbHandler.GetDiveTypes();
                        messageOut = Serializer.Serialize(tempObject);
                        break;

                    case "GetReferees": // Hämta referee-lista
                        tempObject = DbHandler.GetReferees();
                        messageOut = Serializer.Serialize(tempObject);
                        break;

                    case "GetCompetitions": // Hämtar competition-lista
                        tempObject = DbHandler.GetAvailableCompetitions();
                        messageOut = Serializer.Serialize(tempObject);
                        break;

                    case "IsCurrentDiveDone":   // Hämtar och uppdaterar admins lokala CurrentDive
                        tempObject = CompetitionHandler.CurrentDiveComplete();
                        if ((bool)tempObject)
                        {
                            CompetitionHandler.CurrentDive.CalculateTotalPoints();
                            CompetitionHandler.SendCurrentDiveToDatabaseAndUpdateActiveCompetition();
                        }
                        messageOut = Serializer.Serialize(CompetitionHandler.CurrentDive);
                        break;

                    case "CompetitionComplete":
                        CompetitionHandler.ActiveCompetition = null;
                        messageOut = Serializer.Serialize("Competition Complete");
                        break;

                    default:
                        if (obj[0] == 'G' && obj[1] == 'C' && obj[2] == 'D') // Hämtar CurrentDive
                        {
                            Dive currentDive = null;
                            var userId = int.Parse(obj.Remove(0, 4));

                            if (CompetitionHandler.ActiveCompetition != null)
                            {
                                foreach (var referee in CompetitionHandler.ActiveCompetition.ListReferee)
                                {
                                    if (referee.Id == userId)
                                    {
                                        currentDive = CompetitionHandler.CurrentDive;
                                        Logger.Info("Returning the current dive to referee with id: " + referee.Id);
                                        break;
                                    }
                                }
                            }
                            messageOut = Serializer.Serialize(currentDive);
                        }
                        else if (obj[0] == 'S' && obj[1] == 'C') // Startar competition
                        {
                            var id = int.Parse(obj.Remove(0, 3));
                            CompetitionHandler.SetCompetition(DbHandler.StartCompetition(id));
                            var activeDivesList = CompetitionHandler.GetAllDives();
                            messageOut = Serializer.Serialize(activeDivesList);
                        }
                        else if (obj[0] == 'G' && obj[1] == 'C' && obj[2] == 'C') // Hämtar pågående tävling
                        {
                            var id = int.Parse(obj.Remove(0, 4));
                            var competition = new Competition();
                            if (CompetitionHandler.ActiveCompetition != null)
                            {
                                foreach (var referee in CompetitionHandler.ActiveCompetition.ListReferee)
                                {
                                    if (referee.Id == id)
                                    {
                                        competition = CompetitionHandler.ActiveCompetition;
                                        Logger.Info("Returning the active competition to referee with id: " + referee.Id);
                                        break;
                                    }
                                }
                            }
                            messageOut = Serializer.Serialize(competition);
                        }
                        break;
                }
            }
            catch (ArgumentNullException nullException)
            {
                var str = nullException.Message;
                Logger.Error("ArgumentNullException: " + str);
                messageOut = Serializer.Serialize(str);
            }
            catch (NullReferenceException nullReferenceException)
            {
                var str = nullReferenceException.Message;
                Logger.Error("NullReferenceException: " + str);
                messageOut = Serializer.Serialize(str);
            }
            return messageOut;
        }