Esempio n. 1
0
        public static Dictionary <string, string> ReceiveMessage(bool enc = false)
        {
            ASCIIEncoding ascii = new ASCIIEncoding();

            byte[] bytes    = new byte[20480];
            int    bytesRec = conn.Receive(bytes);
            string jsonData = Encoding.UTF8.GetString(bytes, 0, bytesRec);

            Dictionary <string, string> message = new Dictionary <string, string>();

            if (enc == false)
            {
                message = JsonConvert.DeserializeObject <Dictionary <string, string> >(jsonData);
            }
            else
            {
                List <string> jsonEnc     = JsonConvert.DeserializeObject <List <string> >(jsonData);
                string        jsonMessage = EncryptionManager.Decrypt(jsonEnc[0], KeyGenerator.SecretKey, jsonEnc[1]);
                message = JsonConvert.DeserializeObject <Dictionary <string, string> >(jsonMessage);
            }

            return(message);
        }
Esempio n. 2
0
        public static void RecvLoop()
        {
            ASCIIEncoding ascii = new ASCIIEncoding();

            byte[] bytes = new byte[20480];
            try
            {
                Queue netQueue = new Queue();

                while (receiving == true)
                {
                    int    bytesRec = conn.Receive(bytes);
                    string jsonData = Encoding.UTF8.GetString(bytes, 0, bytesRec);
                    netQueue.Clear();

                    if (jsonData.Length > 0)
                    {
                        if (jsonData[0].Equals('[') && jsonData[(jsonData.Length - 1)].Equals(']'))
                        {
                            netQueue.Enqueue(jsonData);
                        }
                        else
                        {
                            string incompleteMessage = jsonData;
                            bool   messageComplete   = false;
                            while (messageComplete == false)
                            {
                                bytesRec = conn.Receive(bytes);
                                jsonData = Encoding.UTF8.GetString(bytes, 0, bytesRec);
                                if (jsonData[(jsonData.Length - 1)].Equals(']'))
                                {
                                    messageComplete    = true;
                                    incompleteMessage += jsonData;

                                    netQueue.Enqueue(incompleteMessage);
                                }
                                else
                                {
                                    incompleteMessage += jsonData;
                                }
                            }
                        }
                    }



                    foreach (string netMessage in netQueue)
                    {
                        List <string> encryptedData = JsonConvert.DeserializeObject <List <string> >(netMessage);

                        jsonData = EncryptionManager.Decrypt(encryptedData[0], KeyGenerator.SecretKey, encryptedData[1]);

                        Dictionary <string, string> message = JsonConvert.DeserializeObject <Dictionary <string, string> >(jsonData);


                        switch (message["messagetype"])
                        {
                        case "serverData":
                        {
                            Net.serverInfo.Handle(message);
                        }
                        break;

                        case "outboundMessage":
                        {
                            Net.outboundMessage.Handle(message);
                        }
                        break;

                        case "channelUpdate":
                        {
                            Net.channelUpdate.Handle(message);
                        }
                        break;

                        case "userlistUpdate":
                        {
                            // Placeholder
                        }
                        break;

                        case "channelHistory":
                        {
                            Net.channelHistory.Handle(message);
                        }
                        break;

                        case "additionalHistory":
                        {
                            Net.additionalHistory.Handle(message);
                        }
                        break;

                        case "commandData":
                        {
                            Net.commandData.Handle(message);
                        }
                        break;

                        case "connectionTerminated":
                        {
                            Net.connectionTerminated.Handle(message);
                        }
                        break;

                        case "errorOccured":
                        {
                            MessageBox.Show("Error - " + message["data"]);
                        }
                        break;

                        default:
                        {
                            MessageBox.Show("Error - Unknown messagetype received");
                        }
                        break;
                        }
                    }
                }
            }
            catch (System.Net.Sockets.SocketException)
            {
                if (receiving == true)
                {
                    //MessageBox.Show("Error - Connection Lost"); // annoying while developing
                    NetworkManager.serverInfo.Clear();
                    Disconnect();
                    VisualManager.SystemMessage("Error - Connection Lost");
                }
            }
        }