server: Client -> Peer

server/peer.go

@@ -0,0 +1,129 @@
+package server
+
+import (
+	"encoding/binary"
+	"fmt"
+	"log"
+	"net"
+
+	"github.com/CPunch/GopenFusion/db"
+	"github.com/CPunch/GopenFusion/protocol"
+)
+
+const (
+	USE_E = iota
+	USE_FE
+)
+
+type PeerHandler interface {
+	HandlePacket(client *Peer, typeID uint32, pkt *protocol.Packet)
+	Connect(client *Peer)
+	Disconnect(client *Peer)
+}
+
+type Peer struct {
+	E_key     []byte
+	FE_key    []byte
+	SzID      string
+	AccountID int
+	Player    *db.Player
+	handler   PeerHandler
+	conn      net.Conn
+	alive     bool
+	whichKey  int
+}
+
+func NewPeer(handler PeerHandler, conn net.Conn) *Peer {
+	return &Peer{
+		E_key:     []byte(protocol.DEFAULT_KEY),
+		FE_key:    nil,
+		SzID:      "",
+		AccountID: -1,
+		Player:    nil,
+		handler:   handler,
+		conn:      conn,
+		alive:     true,
+		whichKey:  USE_E,
+	}
+}
+
+func (client *Peer) Send(data interface{}, typeID uint32) {
+	// encode
+	pkt := protocol.NewPacket(make([]byte, 0))
+	pkt.Encode(data)
+	log.Printf("Sending %#v, sizeof: %d", data, len(pkt.Buf))
+
+	// write packet size
+	tmp := make([]byte, 4)
+	binary.LittleEndian.PutUint32(tmp, uint32(len(pkt.Buf)+4))
+	if _, err := client.conn.Write(tmp); err != nil {
+		panic(fmt.Errorf("[FATAL] failed to write packet size! %v", err))
+	}
+
+	// prepend the typeID to the packet body
+	binary.LittleEndian.PutUint32(tmp, uint32(typeID))
+	tmp = append(tmp, pkt.Buf...)
+
+	// encrypt typeID & body
+	switch client.whichKey {
+	case USE_E:
+		protocol.EncryptData(tmp, client.E_key)
+	case USE_FE:
+		protocol.EncryptData(tmp, client.FE_key)
+	}
+
+	// write packet body
+	if _, err := client.conn.Write(tmp); err != nil {
+		panic(fmt.Errorf("[FATAL] failed to write packet body! %v", err))
+	}
+}
+
+func (client *Peer) Kill() {
+	if !client.alive {
+		return
+	}
+
+	client.alive = false
+	client.conn.Close()
+	client.handler.Disconnect(client)
+}
+
+func (client *Peer) ClientHandler() {
+	defer func() {
+		if err := recover(); err != nil {
+			log.Printf("Client %p panic'd! %v", client, err)
+		}
+		client.Kill()
+	}()
+
+	tmp := make([]byte, 4, protocol.CN_PACKET_BUFFER_SIZE)
+	for {
+		// read packet size
+		if _, err := client.conn.Read(tmp); err != nil {
+			panic(fmt.Errorf("[FATAL] failed to read packet size! %v", err))
+		}
+		sz := int(binary.LittleEndian.Uint32(tmp))
+
+		// client should never send a packet size outside of this range
+		if sz > protocol.CN_PACKET_BUFFER_SIZE || sz < 4 {
+			panic(fmt.Errorf("[FATAL] malicious packet size received! %d", sz))
+		}
+
+		// read packet body
+		if _, err := client.conn.Read(tmp[:sz]); err != nil {
+			panic(fmt.Errorf("[FATAL] failed to read packet body! %v", err))
+		}
+
+		// decrypt && grab typeID
+		protocol.DecryptData(tmp[:sz], client.E_key)
+		typeID := uint32(binary.LittleEndian.Uint32(tmp[:4]))
+
+		// dispatch packet
+		log.Printf("Got packet ID: %x, with a sizeof: %d\n", typeID, sz)
+		pkt := protocol.NewPacket(tmp[4:sz])
+		client.handler.HandlePacket(client, typeID, pkt)
+
+		// reset tmp
+		tmp = tmp[:4]
+	}
+}