Example #1
0
        private void handleHandshakeRequest(LevinProtocol.Command cmd)
        {
            COMMAND_HANDSHAKE.request req = new COMMAND_HANDSHAKE.request();
            if (!LevinProtocol.decode <COMMAND_HANDSHAKE.request>(cmd.buf, req))
            {
                throw new System.Exception("Failed to decode COMMAND_HANDSHAKE request");
            }

            m_node.handleNodeData(req.node_data, m_context);
            m_readQueue.Enqueue(new P2pMessage({ cmd.command, LevinProtocol.encode(req.payload_data) })); // enqueue payload info
Example #2
0
        public bool readCommand(LevinProtocol.Command cmd)
        {
            if (stopped)
            {
                throw InterruptedException();
            }

            EventLock lk     = new EventLock(readEvent);
            bool      result = new LevinProtocol(connection).readCommand(cmd);

            lastReadTime = Clock.now();
            return(result);
        }
Example #3
0
        public bool processIncomingHandshake()
        {
            LevinProtocol.Command cmd = new LevinProtocol.Command();
            if (!m_context.readCommand(cmd))
            {
                throw new System.Exception("Connection unexpectedly closed");
            }

            if (cmd.command == COMMAND_HANDSHAKE.ID)
            {
                handleHandshakeRequest(cmd);
                return(true);
            }

            if (cmd.command == COMMAND_PING.ID)
            {
                COMMAND_PING.response resp = new CryptoNote.COMMAND_PING.response(PING_OK_RESPONSE_STATUS_TEXT, m_node.getPeerId());
                m_context.writeMessage(makeReply(COMMAND_PING.ID, LevinProtocol.encode(resp), GlobalMembers.LEVIN_PROTOCOL_RETCODE_SUCCESS));
                return(false);
            }

            throw new System.Exception("Unexpected command: " + Convert.ToString(cmd.command));
        }
Example #4
0
        // IP2pConnection
        public override void read(ref P2pMessage message)
        {
            if (m_readQueue.Count > 0)
            {
                message = std::move(m_readQueue.Peek());
                m_readQueue.Dequeue();
                return;
            }

            for (;;)
            {
                LevinProtocol.Command cmd = new LevinProtocol.Command();
                if (!m_context.readCommand(cmd))
                {
                    throw InterruptedException();
                }

//C++ TO C# CONVERTER TODO TASK: The following line was determined to be a copy assignment (rather than a reference assignment) - this should be verified and a 'CopyFrom' method should be created:
//ORIGINAL LINE: message.type = cmd.command;
                message.type.CopyFrom(cmd.command);

                if (cmd.command == COMMAND_HANDSHAKE.ID)
                {
                    handleHandshakeResponse(cmd, message);
                    break;
                }
                else if (cmd.command == COMMAND_TIMED_SYNC.ID)
                {
                    handleTimedSync(cmd);
                }
                else
                {
                    message.data = std::move(cmd.buf);
                    break;
                }
            }
        }