示例#1
0
        private void RemovePeerFromDictionaries(PeerData peer, string reason)
        {
            if (peer != null)
            {
                if (PeersTx.ContainsKey(peer.SubnetworkIP))
                {
                    PeersTx.Remove(peer.SubnetworkIP);
                }
                if (PeersRxSupport.ContainsKey(peer.GetSupportEndpoint()))
                {
                    PeersRxSupport.Remove(peer.GetSupportEndpoint());
                }
                if (PeersRxTransmission.ContainsKey(peer.GetSupportEndpoint()))
                {
                    PeersRxTransmission.Remove(peer.GetTransmissionEndpoint());
                }

                OnPeerListChanged(this, new PeerListChangedEventArgs(PeersRxSupport.Values.ToArray()));
                if (reason != null)
                {
                    Logger.Instance.LogMsg("Usunięto użytkownika (" + reason + "): " + peer.ToString());
                }
                else
                {
                    Logger.Instance.LogMsg("Usunięto użytkownika: " + peer.ToString());
                }
            }
        }
        private void addOrUpdatePeerToRoster(JObject peerData)
        {
            Debug.WriteLine("addOrUpdatePeerToRoster " + peerData);

            string serverId = (string)peerData["id"];

            PeerData peer = null;

            if (_roster.ContainsKey(serverId))
            {
                peer = _roster[serverId];
            }
            else
            {
                peer = new PeerData();
            }

            peer.name       = (string)peerData["name"];
            peer.localIntId = serverId.GetHashCode();
            peer.online     = (bool)peerData["online"];
            peer.serverId   = (string)peerData["id"];
            peer.token      = (string)peerData["token"];
            peer.type       = (string)peerData["type"];
            peer.user       = (string)peerData["user"];

            if (!_roster.ContainsKey(serverId))
            {
                _roster.Add(peer.serverId, peer);
                _localIntIdsToServerIds.Add(peer.localIntId, peer.serverId);

                RaiseOnPeerConnected(peer.localIntId, peer.user);
            }
        }
        public override async Task <bool> SendToPeer(int peerId, string message)
        {
            Debug.WriteLine("SympleSignaller:SendToPeer string: " + peerId + " " + message);

            Debug.Assert(IsConnected());

            if (!IsConnected())
            {
                return(false);
            }

            if (_localIntIdsToServerIds.ContainsKey(peerId))
            {
                string peerServerId = _localIntIdsToServerIds[peerId];

                PeerData recipientPeerData = _roster[peerServerId];

                Debug.WriteLine("original message: " + message);

                JObject parameters = new JObject();
                parameters["to"]           = peerDataToJObject(recipientPeerData);
                parameters["type"]         = "message";
                parameters["misc_message"] = message; // TODO: not doing anything meaningful with the "BYE" message that PeerCC sends

                send(parameters);
                return(true);
            }
            else
            {
                Debug.WriteLine("attempted SendToPeer on unknown peer id " + peerId);
                throw new NotImplementedException();
            }

            throw new NotImplementedException();
        }
示例#4
0
        private void onConnect(long peerId)
        {
            Debug.Assert(!peerToCodec.ContainsKey(peerId));

            var data = new PeerData();

            peerToCodec[peerId] = data;
            Global.RoomPID.Tell(new RoomCmdEnter {
                peerId = peerId
            });

            data.codec.FrameCb = frame =>
            {
                try
                {
                    var msg = PBSerializer.Deserialize(typeDb, frame);
                    Global.RoomPID.Tell(new RoomCmdMsg {
                        msg = msg, peerId = peerId
                    });
                }
                catch (Exception e)
                {
                    this.Fatal(e.ToString());
                }
            };
        }
        private void SocketOnAnnounced(object resObj)
        {
            Debug.WriteLine("TODO: SocketOnAnnounced");

            JObject res = (JObject)resObj;

            if ((int)res["status"] != 200)
            {
                // authentication error
                RaiseOnServerConnectionFailure();
                return;
            }

            JObject myPeerData = (JObject)res["data"];

            Debug.WriteLine("myPeerData: " + myPeerData.ToString());

            string serverId = (string)myPeerData["id"];

            addOrUpdatePeerToRoster(myPeerData);
            _myPeerData = _roster[serverId];



            JObject sendPresenceParams = new JObject();

            sendPresenceParams["probe"] = true;
            this.sendPresence(sendPresenceParams);

            _socket.On(Socket.EVENT_MESSAGE, SocketOnMessage);

            RaiseOnSignedIn();
        }
示例#6
0
        private void StartDriver(Subnetwork subnetwork, uint localIP, string UserName)
        {
            CurrentSubnetwork = subnetwork;
            IP = localIP;
            BroadcastAddress = subnetwork.Address | ~(subnetwork.CIDR.GetMaskFromCIDR());

            Me = new PeerData(
                UserName,
                localIP,
                LocalEndpointSupport.Address.IPToInt(),
                LocalEndpointSupport.Port,
                LocalEndpointTransmission.Port,
                KeyExchange.GetPublicKey()
                );
            AddPeerToDictionaries(Me);

            try
            {
                Driver.SetFilter(subnetwork.Address, subnetwork.CIDR.GetMaskFromCIDR(), localIP);
                InterfaceConfig.AddIP(localIP, subnetwork.CIDR.GetMaskFromCIDR());
                Driver.StartReading(ProcessReceivedDriverData);

                DriverStarted = true;
                OnConnected(this, null);
            }
            catch
            {
                _Connected = false;
                throw;
            }
        }
        public static void AddOrUpdate(PeerData contact)
        {
            var exists           = PeerDataContainer.Containers.Any(s => s.Key == contact.UserId);
            var contactContainer = exists
                ? PeerDataContainer.Containers[contact.UserId]
                : PeerDataContainer.CreateContainer(contact.UserId, ApplicationDataCreateDisposition.Always);

            contactContainer.Values.AddOrUpdate(nameof(PeerData.Name), contact.Name);
            contactContainer.Values.AddOrUpdate(nameof(PeerData.Avatar), contact.Avatar);
            contactContainer.Values.AddOrUpdate(nameof(PeerData.IsOnline), contact.IsOnline);
        }
示例#8
0
        internal bool Connect(PeerData peerData)
        {
            Logger.GetLog().Debug("次のピアに接続します: " + peerData.PeerId + "(" + peerData.Address + ":" + peerData.Port + ")");

            this.PeerData = peerData;
            bool result = socket.Connect(peerData.Address, peerData.Port);

            Logger.GetLog().Debug("接続結果: " + result);

            return(result);
        }
示例#9
0
        private void AddPeerToDictionaries(PeerData peer)
        {
            if (peer != null)
            {
                PeersTx.Add(peer.SubnetworkIP, peer);
                PeersRxSupport.Add(peer.GetSupportEndpoint(), peer);
                PeersRxTransmission.Add(peer.GetTransmissionEndpoint(), peer);

                OnPeerListChanged(this, new PeerListChangedEventArgs(PeersRxSupport.Values.ToArray()));
                Logger.Instance.LogMsg("Dodano użytkownika: " + peer.ToString());
            }
        }
        public SympleSignaller() : base()
        {
            _myPeerData = new PeerData();

            _roster = new Dictionary <string, PeerData>();
            _localIntIdsToServerIds = new Dictionary <int, string>();

            // comment these out if not needed
            Messenger.AddListener <string>(SympleLog.LogTrace, OnLog);
            Messenger.AddListener <string>(SympleLog.LogDebug, OnLog);
            Messenger.AddListener <string>(SympleLog.LogInfo, OnLog);
            Messenger.AddListener <string>(SympleLog.LogError, OnLog);
        }
        private JObject peerDataToJObject(PeerData pd)
        {
            JObject p = new JObject();

            p["user"]   = pd.user;
            p["name"]   = pd.name;
            p["type"]   = pd.type;
            p["token"]  = pd.token;
            p["id"]     = pd.serverId;
            p["online"] = pd.online;

            return(p);
        }
示例#12
0
        private void EncryptAndSendTransmissionPacket(byte[] data, PeerData peer)
        {
            byte[] encryptedData = Encryption.Encrypt(data, peer.KeyIndex);

            if (encryptedData != null)
            {
                UdpTransmission.Send(encryptedData, encryptedData.Length, peer.GetTransmissionEndpoint());

                Stats.ULBytes += (ulong)data.Length;
                Stats.ULPackets++;
                peer.Stats.ULBytes += (ulong)data.Length;
                peer.Stats.ULPackets++;
            }
        }
示例#13
0
        private Task InitiateNewUser(PeerData peer, uint subnetworkIP)
        {
            return(Task.Run(() =>
            {
                // pakiet dla nowego użytkownika
                UdpNewPeerPacket packet = new UdpNewPeerPacket(
                    peer.Name,
                    subnetworkIP,
                    true,
                    PeersRxSupport.Values.ToArray(),
                    CurrentSubnetwork
                    );

                byte[] data = GetSerializedBytes <UdpNewPeerPacket>(packet);

                ReceivedConfirmation = new ManualResetEvent(false);
                NewPeer = peer;
                int retryCounter = 0;
                while (retryCounter++ < ConnectionRetries && !CancelToken.IsCancellationRequested)
                {
                    UdpSupport.Send(data, data.Length, peer.GetSupportEndpoint());
                    if (ReceivedConfirmation.WaitOne(2000))
                    {
                        break;
                    }
                }
                NewPeer = null;
                if (retryCounter > ConnectionRetries)
                {
                    throw new NewClientNotReachedException("Czas wywołania minął!", null);
                }
                if (!CancelToken.IsCancellationRequested)
                {
                    return;
                }

                // pakiet dla pozostałych
                packet = new UdpNewPeerPacket(
                    null,
                    0,
                    false,
                    new PeerData[1] {
                    peer
                },
                    null
                    );
                Broadcast <UdpNewPeerPacket>(packet);
            }));
        }
        public override async Task <bool> SignOut()
        {
            Debug.WriteLine("SympleSignaller:SignOut");

            if (_socket != null)
            {
                _socket.Disconnect();
                _socket.Close();
                _socket = null;
            }

            _roster.Clear();
            _localIntIdsToServerIds.Clear();
            _myPeerData = new PeerData();

            return(true);
        }
示例#15
0
        public async void AddPeer(string ConnectionString, uint SubnetworkIP)
        {
            if (!_Connected)
            {
                OnAddedPeer(this, new AddedPeerEventArgs(false, new InvalidOperationException("Żadne połączenie nie jest obecnie otwarte.")));
                return;
            }

            if ((SubnetworkIP & CurrentSubnetwork.CIDR.GetMaskFromCIDR()) != CurrentSubnetwork.Address)
            {
                OnAddedPeer(this, new AddedPeerEventArgs(false, new InvalidOperationException("Wybrany adres IP jest spoza zakresu możliwych adresów w tej sieci.")));
                return;
            }

            foreach (uint ip in PeersTx.Keys)
            {
                if (ip == SubnetworkIP)
                {
                    OnAddedPeer(this, new AddedPeerEventArgs(false, new InvalidOperationException("Wybrany adres IP jest już przypisany do innego użytkownika. Proszę wybrać inny.")));
                    return;
                }
            }

            if (ConnectionString.IndexOf(URI) > -1)
            {
                ConnectionString = ConnectionString.Remove(ConnectionString.IndexOf(URI), URI.Length + 1);
            }

            PeerData peer = null;

            try
            {
                Base64PeerData peerData = Base64PeerData.GetBase64PeerData(ConnectionString);
                peer = PeerData.GetDataFromBase64PeerData(peerData, SubnetworkIP);

                await InitiateNewUser(peer, SubnetworkIP);

                OnAddedPeer(this, new AddedPeerEventArgs(true, null));
            }
            catch (Exception ex)
            {
                RemovePeerFromDictionaries(peer, null);
                OnAddedPeer(this, new AddedPeerEventArgs(false, ex));
            }
        }
示例#16
0
        public bool Connect(PeerData peerData)
        {
            Peer peer = new Peer(this);

            peer.Closed   += new EventHandler(Peer_Closed);
            peer.ReadLine += new EventHandler <ReadLineEventArgs>(Peer_ReadLine);
            peer.PeerId   += () => { return(PeerId()); };

            bool result = peer.Connect(peerData);

            if (result)
            {
                peerList.Add(peer);
                ConnectionsChanged(this, EventArgs.Empty);
            }

            return(result);
        }
示例#17
0
        private void ProcessReceivedDriverData(byte[] data)
        {
            if (data.Length < 20)
            {
                return;
            }
            uint sendTo = BitConverter.ToUInt32(data, 16).InvertBytes();

            PeerData peer = null;

            if (sendTo == BroadcastAddress)
            {
                BroadcastTransmissionPacket(data);
            }
            else if (PeersTx.TryGetValue(sendTo, out peer))
            {
                EncryptAndSendTransmissionPacket(data, peer);
            }
        }
示例#18
0
        private void NegotiateKey(PeerData peer, UdpKeyNegotiationPacket packet)
        {
            if (!peer.KeyExchangeInProgress)
            {
                UdpKeyNegotiationPacket negoPacket = new UdpKeyNegotiationPacket(
                    KeyExchange.GetKeyMaterial(),
                    KeyExchange.GetDSASignature()
                    );
                SendPacket <UdpKeyNegotiationPacket>(negoPacket, peer.GetSupportEndpoint());
            }

            if (packet != null)
            {
                Encryption.DeleteKeyIfInStore(peer.KeyIndex);
                peer.KeyIndex = Encryption.AddKeyToStore(
                    KeyExchange.GetDerivedKey(packet.KeyMaterial, packet.DSASignature, peer.PublicKey)
                    );
                peer.KeyExchangeInProgress = false;
            }
            else
            {
                peer.KeyExchangeInProgress = true;
            }
        }
示例#19
0
    void Update()
    {
        int              recHostId;
        int              recConnectionId;
        int              dataSize;
        byte             error;
        NetworkEventType recData = NetworkTransport.Receive(out recHostId, out recConnectionId, out channelId, recBuffer, recBuffer.Length, out dataSize, out error);

        switch (recData)
        {
        case NetworkEventType.Nothing:
            break;

        case NetworkEventType.ConnectEvent:
            Debug.Log("Connected");
            CreateProcessManager(recConnectionId);
            MemoryStream sendstream2 = new MemoryStream();
            sendstream2.WriteByte(MESSAGE_GET_PEERS);
            new BinaryFormatter().Serialize(sendstream2, localProcessManager.peerId);
            byte[] b2 = sendstream2.ToArray();
            NetworkTransport.Send(hostId, recConnectionId, channelId, b2, b2.Length, out error);
            break;

        case NetworkEventType.DataEvent:
            //Debug.Log ("DATA "+dataSize);
            MemoryStream stream = new MemoryStream(recBuffer, 0, dataSize);
            byte         type   = (byte)stream.ReadByte();
            switch (type)
            {
            case MESSAGE_PROCESS_LIST:
                Dictionary <int, ProcessData> processes = (Dictionary <int, ProcessData>) new BinaryFormatter().Deserialize(stream);
                playerProcessManagers[recConnectionId].UpdateProcesses(processes);
                break;

            case MESSAGE_KILL_PROCESS:
                int processId = (int)new BinaryFormatter().Deserialize(stream);
                KillLocalProcess(processId);
                break;

            case MESSAGE_GET_PEERS:
                Debug.LogError("Send peer list");
                int remotePeerId = (int)new BinaryFormatter().Deserialize(stream);
                foreach (KeyValuePair <int, PlayerProcessManager> player in playerProcessManagers)
                {
                    if (remotePeerId == player.Value.peerId)
                    {
                        Debug.LogError("Duplicate connection " + recConnectionId + " with player " + player.Key + " detected, disconnect");
                        NetworkTransport.Disconnect(hostId, recConnectionId, out error);
                    }
                }
                playerProcessManagers[recConnectionId].peerId = remotePeerId;
                Dictionary <int, PeerData> peers = new Dictionary <int, PeerData>();
                foreach (KeyValuePair <int, PlayerProcessManager> player in playerProcessManagers)
                {
                    if (player.Key == 0)
                    {
                        continue;                                     // ignore local player
                    }
                    if (player.Key == recConnectionId)
                    {
                        continue;                                                   // ignore remote player
                    }
                    PeerData peer = new PeerData();
                    UnityEngine.Networking.Types.NetworkID network;
                    UnityEngine.Networking.Types.NodeID    dstNode;
                    NetworkTransport.GetConnectionInfo(hostId, player.Key, out peer.address, out peer.port, out network, out dstNode, out error);
                    peers.Add(player.Key, peer);
                }
                MemoryStream sendstream = new MemoryStream();
                sendstream.WriteByte(MESSAGE_PEERS);
                new BinaryFormatter().Serialize(sendstream, peers);
                byte[] b = sendstream.ToArray();
                NetworkTransport.Send(hostId, recConnectionId, channelId, b, b.Length, out error);
                break;

            case MESSAGE_PEERS:
                Debug.LogError("Recieve peer list");
                Dictionary <int, PeerData> remotepeers = (Dictionary <int, PeerData>) new BinaryFormatter().Deserialize(stream);
                foreach (KeyValuePair <int, PeerData> peer in remotepeers)
                {
                    Debug.LogError("Connect to peer: " + peer.Value.address + ":" + peer.Value.port);
                    NetworkTransport.Connect(hostId, peer.Value.address, peer.Value.port, 0, out error);
                }
                break;
            }
            break;

        case NetworkEventType.DisconnectEvent:
            Debug.Log("Disconnected");
            DestroyProcessManager(recConnectionId);
            break;
        }

        if (Input.GetKeyDown(KeyCode.C))
        {
            StartClient();
        }
    }
        private void SocketOnMessage(object msg)
        {
            Messenger.Broadcast(SympleLog.LogTrace, "SocketOnMessage: " + msg);

            JObject m = (JObject)msg;

            string mType = (string)m["type"];

            switch (mType)
            {
            case "message":
                break;

            case "command":
                break;

            case "event":
                break;

            case "presence":

                JObject remotePeerData = (JObject)m["data"];     // data about another peer that has been updated or removed

                bool remotePeerOnline = (bool)remotePeerData["online"];

                if (remotePeerOnline)
                {
                    addOrUpdatePeerToRoster(remotePeerData);
                }
                else
                {
                    string remotePeerServerId = (string)remotePeerData["id"];
                    removePeerFromRoster(remotePeerServerId);
                }

                if (m["probe"] != null && (bool)m["probe"] == true)
                {
                    JObject presenceTo = new JObject();
                    presenceTo["to"] = Symple.parseAddress(m["from"].ToString())["id"];

                    this.sendPresence(presenceTo);
                }
                break;

            default:
                m["type"] = m["type"] ?? "message";
                break;
            }

            if (m["from"].Type != JTokenType.String)
            {
                Messenger.Broadcast(SympleLog.LogError, "symple:client: invalid sender address: " + m);
                return;
            }

            // replace the from attribute with the full peer object.
            // this will only work for peer messages, not server messages.

            string mFrom = (string)m["from"];

            Messenger.Broadcast(SympleLog.LogTrace, "looking up rpeer in roster, mFrom = " + mFrom + "...");

            var addr = Symple.parseAddress(mFrom);

            Debug.WriteLine("addr " + addr);
            mFrom = (string)addr["id"] ?? mFrom;

            if (_roster.ContainsKey(mFrom))
            {
                PeerData rpeerData = _roster[mFrom];

                Messenger.Broadcast(SympleLog.LogTrace, "found rpeerData: " + rpeerData);
                m["from"] = peerDataToJObject(rpeerData);
            }
            else
            {
                Messenger.Broadcast(SympleLog.LogDebug, "symple:client: got message from unknown peer: " + m);
            }

            // Dispatch to the application
            SignallerOnMessage(mType, m);
        }
        private Dictionary <int, string> _localIntIdsToServerIds; // maps local int ids to server ids


        private void SignallerOnMessage(string mType, JObject m)
        {
            Debug.WriteLine("SignallerOnMessage " + mType + " " + m);

            // here we process what the webrtccontext would normally do when a new message comes in.
            // so we adjust the message and pass it on to the Conductor.

            string fromServerId;

            var mFromObj = m["from"] as JObject;

            if (mFromObj != null)
            {
                fromServerId = (string)mFromObj["id"];
            }
            else
            {
                fromServerId = (string)m["from"]; // string instead of json object
            }

            JObject parsedAddress = Symple.parseAddress(fromServerId); // handle case where "from" is name|id

            fromServerId = (string)parsedAddress["id"] ?? fromServerId;


            if (_roster.ContainsKey(fromServerId))
            {
                PeerData fromPd         = _roster[fromServerId];
                int      fromLocalIntId = fromPd.localIntId;

                if (m["offer"] != null)
                {
                    Debug.WriteLine("incoming offer message");

                    JObject messageForConductor = (JObject)m["offer"];

                    RaiseOnMessageFromPeer(fromLocalIntId, messageForConductor.ToString(Formatting.None));
                }
                else if (m["answer"] != null)
                {
                    Debug.WriteLine("incoming answer message");

                    JObject messageForConductor = (JObject)m["answer"];

                    RaiseOnMessageFromPeer(fromLocalIntId, messageForConductor.ToString(Formatting.None));
                }
                else if (m["candidate"] != null)
                {
                    Debug.WriteLine("incoming candidate message");

                    JObject messageForConductor = (JObject)m["candidate"];

                    RaiseOnMessageFromPeer(fromLocalIntId, messageForConductor.ToString(Formatting.None));
                }
                else if (mType == "presence")
                {
                    // the presence messages are handled earlier in the signalling code, so at this point, do nothing with them.
                }
                else if (m["message"] != null)
                {
                    JObject messageForConductor = m; // send the entire raw message! the "message" format will route it correctly

                    RaiseOnMessageFromPeer(fromLocalIntId, messageForConductor.ToString(Formatting.None));
                }
                else
                {
                    // the content of the message is unrecognized by the signaller
                    Debug.WriteLine("TODO: incoming misc message of type " + m["type"]);
                }
            }
            else
            {
                Debug.WriteLine("received message from unknown sender " + fromServerId);
            }
        }
 private string buildAddress(PeerData pd)
 {
     return(Symple.buildAddress(peerDataToJObject(pd)));
 }
        public override async Task <bool> SendToPeer(int peerId, IJsonValue json)
        {
            Debug.WriteLine("SympleSignaller:SendToPeer json: " + peerId + " " + json);

            Debug.Assert(IsConnected());

            if (!IsConnected())
            {
                return(false);
            }


            if (_localIntIdsToServerIds.ContainsKey(peerId))
            {
                string peerServerId = _localIntIdsToServerIds[peerId];

                PeerData recipientPeerData = _roster[peerServerId];

                Debug.WriteLine("original IJsonValue: " + json);

                JObject jsonMessage = JObject.Parse(json.Stringify());

                Debug.WriteLine("after conversion to JObject: " + jsonMessage);

                if (jsonMessage["sdp"] != null)
                {
                    JObject sessionDesc = jsonMessage;

                    JObject parameters = new JObject();
                    parameters["to"]   = peerDataToJObject(recipientPeerData);
                    parameters["type"] = "message";

                    string jsonMessageType = (string)jsonMessage["type"];

                    if (jsonMessageType == "offer")
                    {
                        parameters["offer"] = sessionDesc;
                    }
                    else if (jsonMessageType == "answer")
                    {
                        parameters["answer"] = sessionDesc;
                    }
                    else
                    {
                        Debug.WriteLine("unknown jsonMessageType for sdp: " + jsonMessageType);
                        throw new NotImplementedException();
                    }



                    send(parameters);
                    return(true);
                }

                if (jsonMessage["candidate"] != null)
                {
                    JObject candidateObj = jsonMessage;

                    JObject parameters = new JObject();
                    parameters["to"]        = peerDataToJObject(recipientPeerData);
                    parameters["type"]      = "message";
                    parameters["candidate"] = candidateObj;

                    send(parameters);
                    return(true);
                }

                if (jsonMessage["message"] != null)
                {
                    // sending a misc. message to the peer.

                    var msgObj = jsonMessage["message"]; // note that we go down one level here

                    JObject parameters = new JObject();
                    parameters["to"]      = peerDataToJObject(recipientPeerData);
                    parameters["type"]    = "message";
                    parameters["message"] = msgObj;

                    send(parameters);
                    return(true);
                }

                Debug.WriteLine("unknown message of type " + jsonMessage);
                throw new NotImplementedException();
            }
            else
            {
                Debug.WriteLine("attempted SendToPeer on unknown peer id " + peerId);
                throw new NotImplementedException();
            }
        }
示例#24
0
 public bool Connect(PeerData peer)
 {
     return(peerManager.Connect(peer));
 }
示例#25
0
        void OnPubNubMessage(string message)
        {
            string[] splitMessage    = message.Trim().Substring(1, message.Length - 2).Split(new char[] { ',' });
            string   peerDataMessage = splitMessage[0].Trim().Substring(1, splitMessage[0].Trim().Length - 2);
            //string peerMessageId = splitMessage[1].Trim().Substring(1, splitMessage[1].Trim().Length - 2);
            //string room = splitMessage[2].Trim().Substring(1, splitMessage[2].Trim().Length - 2);



            PeerData peerData = new PeerData(peerDataMessage);

            // If you are on the same device then you have to do this for it to work
            if (peerData.localIp == localIp && peerData.externalIp == externalIp)
            {
                peerData.localIp = "127.0.0.1";
            }


            // From me, ignore
            if (peerData.pubNubUniqueId == pubnub.SessionUUID)
            {
                return;
            }

            if (udpClient == null)
            {
                return;
            }

            // From someone else


            // First time we have heard from them
            if (!uniqueIdsPubNubSeen.Contains(peerData.pubNubUniqueId))
            {
                uniqueIdsPubNubSeen.Add(peerData.pubNubUniqueId);
                udpClient.Send(new byte[10], 10, new IPEndPoint(IPAddress.Parse(peerData.externalIp), peerData.externalPort));
                udpClient.Send(new byte[10], 10, new IPEndPoint(IPAddress.Parse(peerData.localIp), peerData.localPort)); // This is if they are on a LAN, we will try both because why not
                pubnub.Publish <string>(channelName, (new PeerData(localPort, externalPort, localIp, externalIp, pubnub.SessionUUID)).ToString(), OnPubNubTheyGotMessage, OnPubNubMessageFailed);
            }
            // Second time we have heard from them, after then we don't care because we are connected
            else if (!connectedPeers.ContainsKey(peerData.pubNubUniqueId))
            {
                IPEndPoint endPoint      = new IPEndPoint(IPAddress.Parse(peerData.externalIp), peerData.externalPort);
                IPEndPoint endPointLocal = new IPEndPoint(IPAddress.Parse(peerData.localIp), peerData.localPort);
                //bool isOnLan = IsLanIP(IPAddress.Parse(peerData.externalIp)); TODO, this would be nice to test for
                bool    isOnLan = true;
                P2PPeer peer    = new P2PPeer(peerData.localIp, peerData.externalIp, peerData.localPort, peerData.externalPort, this, isOnLan);
                lock (peerLock)
                {
                    connectedPeers.Add(peerData.pubNubUniqueId, peer);
                }



                udpClient.Send(new byte[10], 10, endPoint);
                udpClient.Send(new byte[10], 10, endPointLocal); // This is if they are on a LAN

                pubnub.Publish <string>(channelName, (new PeerData(localPort, externalPort, localIp, externalIp, pubnub.SessionUUID)).ToString(), OnPubNubTheyGotMessage, OnPubNubMessageFailed);
                if (OnNewPeerConnection != null)
                {
                    OnNewPeerConnection(peer);
                }
            }
        }
示例#26
0
        private void ProcessUdpPacket(CommPacket packet, IPEndPoint ep)
        {
            PeerData peer = null;

            if (packet is UdpConnectingConfirmation)
            {
                AddPeerToDictionaries(NewPeer);
                if (ReceivedConfirmation != null)
                {
                    ReceivedConfirmation.Set();
                }
            }
            else if (packet is UdpNewPeerPacket)
            {
                UdpNewPeerPacket newPeerPacket = packet as UdpNewPeerPacket;
                if (newPeerPacket.RecipientIsNew && AwaitingExternalConnection)
                {
                    AwaitingExternalConnection = false;
                    AddPeersToDictionaries(newPeerPacket.Peers);

                    StartDriver(newPeerPacket.SubnetworkData, newPeerPacket.SubnetworkIP, newPeerPacket.Name);
                    OnConnected(this, null);

                    UdpConnectingConfirmation confirmPacket = new UdpConnectingConfirmation();
                    SendPacket <UdpConnectingConfirmation>(confirmPacket, ep);

                    Thread.Sleep(100);
                    NegotiateKey(PeersRxSupport[ep], null);
                }
                else
                {
                    if (newPeerPacket.Peers != null && !newPeerPacket.RecipientIsNew)
                    {
                        if (newPeerPacket.Peers.Length != 0)
                        {
                            AddPeerToDictionaries(newPeerPacket.Peers[0]);
                            NegotiateKey(peer, null);
                        }
                    }
                }
            }
            else if (packet is UdpKeyNegotiationPacket)
            {
                if (!PeersRxSupport.TryGetValue(ep, out peer))
                {
                    peer = NewPeer;
                }
                NegotiateKey(peer, packet as UdpKeyNegotiationPacket);
            }
            else if (packet is UdpGoodbye)
            {
                RemovePeerFromDictionaries(PeersRxSupport[ep], "goodbye");
            }
            else if (packet is UdpHeartbeat)
            {
                if (PeersRxSupport.TryGetValue(ep, out peer))
                {
                    peer.Heartbeat();
                }
            }
        }
示例#27
0
        private void NetworkTransmissionDataCallout(IAsyncResult result)
        {
            IPEndPoint ep = new IPEndPoint(IPAddress.Any, 0);

            try
            {
                byte[] data = null;
                data = UdpTransmission.EndReceive(result, ref ep);

                if (data == null || data.Length == 0)
                {
                    return;
                }

                PeerData peer = null;
                if (PeersRxTransmission.TryGetValue(ep, out peer))
                {
                    byte[] decryptedData = Encryption.Decrypt(data, peer.KeyIndex);
                    if (decryptedData == null)
                    {
                        Logger.Instance.LogError("Odrzucono niepoprawny pakiet (niezgodność skrótów). Użytkownik: " + peer.Name);
                    }
                    else
                    {
                        Driver.WriteData(decryptedData);

                        Stats.DLBytes += (ulong)decryptedData.Length;
                        Stats.DLPackets++;
                        peer.Stats.DLBytes += (ulong)decryptedData.Length;
                        peer.Stats.DLPackets++;
                    }
                }

                if (_Connected)
                {
                    UdpTransmission.BeginReceive(NetworkTransmissionDataCallout, null);
                }
                else
                {
                    UdpTransmission.Close();
                }
            }
            catch (Exception ex)
            {
                if (ex is SocketException)
                {
                    int code = ((SocketException)ex).ErrorCode;
                    if (code != 10060 && code != 10004)
                    {
                        MessageBox.Show(
                            "Błąd połączenia: " + ex.Message,
                            "Błąd",
                            MessageBoxButton.OK,
                            MessageBoxImage.Error
                            );
                        Logger.Instance.LogException(ex);
                        Disconnect();
                    }
                }

                if (!(ex is ObjectDisposedException))
                {
                    Logger.Instance.LogException(ex);
                }

                if (_Connected)
                {
                    UdpTransmission.BeginReceive(NetworkTransmissionDataCallout, null);
                }
                else
                {
                    UdpTransmission.Close();
                }
            }
        }