package p2p import "fmt" import "net" import "time" import "github.com/romana/rlog" import log "github.com/sirupsen/logrus" import "github.com/deroproject/derosuite/globals" // the connection starts with P2P handshake // send the hand shake func Send_Handshake(connection *Connection) { // first request support flags if connection.Exit { return } Send_SupportFlags_Command(connection) connection.Lock() // lets do handshake var d Node_Data var c CORE_DATA var data_header Levin_Data_Header var levin_header Levin_Header d.Network_UUID = globals.Config.Network_ID d.Peer_ID = (uint64)(time.Now().Unix()) c.Current_Height = chain.Get_Height() c.Cumulative_Difficulty = chain.Get_Difficulty() c.Top_Version = 6 // top block id from the genesis or other block c.Top_ID = chain.Get_Top_ID() ds, _ := d.Serialize() cs, _ := c.Serialize() data_header.Data = ds data_header.Data = append(data_header.Data, cs...) levin_data, _ := data_header.Serialize() levin_header.CB = uint64(len(levin_data)) levin_header.Command = P2P_COMMAND_HANDSHAKE levin_header.ReturnData = true levin_header.Flags = LEVIN_PACKET_REQUEST header_bytes, _ := levin_header.Serialize() connection.Conn.Write(header_bytes) connection.Conn.Write(levin_data) connection.Command_queue.PushBack(uint32(P2P_COMMAND_HANDSHAKE)) connection.Unlock() } // handle P2P_COMMAND_HANDSHAKE, // we must send a response // our response is a boost compatible response which is parseable by old cryptonote daemons func Handle_P2P_Handshake_Command(connection *Connection, i_command_header *Levin_Header, buf []byte) { connection.logger.Infof("Handshake request arrived, we must parse it") // extract peers from our list, and insert them into the response // max 250 peers can be send ( since we are aiming compatibility with old daemons) var reply Node_Data_Response //panic("Handle_P2P_Handshake needs to fixed and tested") reply.NodeData.Network_UUID = globals.Config.Network_ID reply.NodeData.Peer_ID = (uint64)(OUR_PEER_ID) reply.NodeData.Local_time = uint64(time.Now().Unix()) reply.CoreData.Current_Height = chain.Get_Height() reply.CoreData.Cumulative_Difficulty = chain.Get_Difficulty() reply.CoreData.Top_Version = 6 // top block id from the genesis or other block // this data is from the block chain // this data must be the top block that we see till now reply.CoreData.Top_ID = chain.Get_Top_ID() for i := 0; i < 250; i++ { reply.PeerArray = append(reply.PeerArray, Peer_Info{IP: net.IPv4(byte(i), byte(i), byte(i), byte(i)), Port: 0, ID: 0, LastSeen: 0}) } var o_command_header Levin_Header var o_data_header Levin_Data_Header o_data_header.Data, _ = reply.Serialize() data, _ := o_data_header.Serialize() // mark as containing 4 elements data[9] = 0x10 o_command_header.CB = uint64(len(data)) o_command_header.Command = P2P_COMMAND_HANDSHAKE o_command_header.ReturnData = false o_command_header.ReturnCode = 1 // send as good response o_command_header.Flags = LEVIN_PACKET_RESPONSE o_command_header_bytes, _ := o_command_header.Serialize() connection.Conn.Write(o_command_header_bytes) connection.Conn.Write(data) rlog.Tracef(4, "Sending handshake response\n") Handle_P2P_Handshake_Command_Response(connection, i_command_header,buf) // parse incoming response } /* handles response of our p2p command, parses data etc*/ func Handle_P2P_Handshake_Command_Response(connection *Connection, i_command_header *Levin_Header, buf []byte) { var reply Node_Data_Response // deserialize data header var i_data_header Levin_Data_Header // incoming data header err := i_data_header.DeSerialize(buf) if err != nil { connection.logger.WithFields(log.Fields{ "ip": connection.Addr.IP, }).Debugf("Disconnecting client, handshake could not be deserialized") return } if reply.DeSerialize(i_data_header.Data) != nil { logger.WithFields(log.Fields{ "ip": connection.Addr.IP, }).Debugf("Disconnecting client, handshake could not be deserialized") return } if reply.NodeData.Network_UUID != globals.Config.Network_ID { logger.WithFields(log.Fields{ "ip": connection.Addr.IP, "id": reply.NodeData.Network_UUID, }).Debugf("Disconnecting client, Wrong network ID") return } // we need to kick the peer if the height is something specific and peer id is less than ours // TODO right we are not doing it connection.Peer_ID = reply.NodeData.Peer_ID connection.Port = reply.NodeData.Local_Port connection.Last_Height = reply.CoreData.Current_Height connection.Top_Version = uint64(reply.CoreData.Top_Version) connection.Top_ID = reply.CoreData.Top_ID connection.Cumulative_Difficulty = reply.CoreData.Cumulative_Difficulty connection.State = ACTIVE connection.logger.WithFields(log.Fields{ "PeerHeight": reply.CoreData.Current_Height, "Top Version": reply.CoreData.Top_Version, "Top_ID": fmt.Sprintf("%x", reply.CoreData.Top_ID), }).Debugf("Successful Handshake with Peer") // lets check whether we need to resync with this peer if chain.IsLagging(reply.CoreData.Cumulative_Difficulty, reply.CoreData.Current_Height, reply.CoreData.Top_ID) { logger.Debugf("We need to resync with the peer") // set mode to syncronising Send_BC_Notify_Chain_Command(connection) } }