db/players.go

@@ -178,7 +178,7 @@ func (db *DBHandler) GetPlayer(PlayerID int) (*Player, error) {
 			&plr.SkywayLocationFlag, &plr.CurrentMissionID, &plr.FirstUseFlag,
 			&plr.Body, &plr.EyeColor, &plr.FaceStyle, &plr.Gender, &plr.HairColor, &plr.HairStyle,
 			&plr.Height, &plr.SkinColor); err != nil {
-			return nil, err
+			panic(err)
 		}
 	}
 

protocol/packet.go

@@ -4,6 +4,7 @@ import (
 	"encoding/binary"
 	"fmt"
 	"io"
+	"log"
 	"reflect"
 	"strconv"
 	"unicode/utf16"
@@ -15,23 +16,69 @@ import (
 */
 
 type Packet struct {
-	readWriter io.ReadWriter
+	ByteOrder binary.ByteOrder
+	Buf       []byte
 }
 
-func NewPacket(readWriter io.ReadWriter) Packet {
+func NewPacket(buf []byte) *Packet {
-	return Packet{
+	pkt := &Packet{
-		readWriter: readWriter,
+		ByteOrder: binary.LittleEndian,
+		Buf:       buf,
 	}
+	return pkt
 }
 
-func (pkt Packet) encodeStructField(field reflect.StructField, value reflect.Value) error {
+func (pkt *Packet) writeRaw(data []byte) {
-	// log.Printf("Encoding '%s'", field.Name)
+	pkt.Buf = append(pkt.Buf, data...)
+}
+
+func (pkt *Packet) Write(data []byte) (int, error) {
+	pkt.writeRaw(data)
+
+	if len(pkt.Buf) > CN_PACKET_BUFFER_SIZE {
+		return 0, fmt.Errorf("Failed to write to packet, invalid size!")
+	}
+
+	return len(data), nil
+}
+
+func (pkt *Packet) writeByte(data byte) {
+	pkt.Write([]byte{data})
+}
+
+func (pkt *Packet) readRaw(data []byte) (int, error) {
+	sz := copy(data, pkt.Buf)
+	pkt.Buf = pkt.Buf[sz:]
+
+	if sz != len(data) {
+		return sz, io.EOF
+	}
+
+	return sz, nil
+}
+
+func (pkt *Packet) Read(data []byte) (int, error) {
+	if len(data) > len(pkt.Buf) {
+		return 0, fmt.Errorf("Failed to read from packet, invalid size!")
+	}
+
+	return pkt.readRaw(data)
+}
+
+func (pkt *Packet) readByte() byte {
+	data := pkt.Buf[0]
+	pkt.Buf = pkt.Buf[1:]
+	return data
+}
+
+func (pkt *Packet) encodeStructField(field reflect.StructField, value reflect.Value) {
+	log.Printf("Encoding '%s'", field.Name)
 
 	switch field.Type.Kind() {
 	case reflect.String: // all strings in fusionfall packets are encoded as utf16, we'll need to encode it
 		sz, err := strconv.Atoi(field.Tag.Get("size"))
 		if err != nil {
-			return fmt.Errorf("Failed to grab string 'size' tag!!")
+			panic(fmt.Errorf("Failed to grab string 'size' tag!!"))
 		}
 
 		buf16 := utf16.Encode([]rune(value.String()))
@@ -42,36 +89,27 @@ func (pkt Packet) encodeStructField(field reflect.StructField, value reflect.Val
 			buf16 = buf16[:sz]
 		} else {
 			// grow
-			// TODO: probably a better way to do this?
 			for len(buf16) < sz {
 				buf16 = append(buf16, 0)
 			}
 		}
 
 		// write
-		if err := binary.Write(pkt.readWriter, binary.LittleEndian, buf16); err != nil {
+		binary.Write(pkt, pkt.ByteOrder, buf16)
-			return err
-		}
 	default:
-		if err := pkt.Encode(value.Interface()); err != nil {
+		pkt.Encode(value.Addr().Interface())
-			return err
-		}
 	}
 
 	// write padding bytes
 	pad, err := strconv.Atoi(field.Tag.Get("pad"))
 	if err == nil {
 		for i := 0; i < pad; i++ {
-			if _, err := pkt.readWriter.Write([]byte{0}); err != nil {
+			pkt.writeByte(0)
-				return err
 		}
 	}
-	}
-
-	return nil
 }
 
-func (pkt Packet) Encode(data interface{}) error {
+func (pkt *Packet) Encode(data interface{}) {
 	rv := reflect.Indirect(reflect.ValueOf(data))
 
 	switch rv.Kind() {
@@ -79,34 +117,26 @@ func (pkt Packet) Encode(data interface{}) error {
 		// walk through each struct fields
 		sz := rv.NumField()
 		for i := 0; i < sz; i++ {
-			if err := pkt.encodeStructField(rv.Type().Field(i), rv.Field(i)); err != nil {
+			pkt.encodeStructField(rv.Type().Field(i), rv.Field(i))
-				return err
-			}
 		}
 	default:
 		// we pass everything else to go's binary package
-		if err := binary.Write(pkt.readWriter, binary.LittleEndian, data); err != nil {
+		binary.Write(pkt, pkt.ByteOrder, data)
-			return err
 	}
-	}
-
-	return nil
 }
 
-func (pkt Packet) decodeStructField(field reflect.StructField, value reflect.Value) error {
+func (pkt *Packet) decodeStructField(field reflect.StructField, value reflect.Value) {
-	// log.Printf("Decoding '%s'", field.Name)
+	log.Printf("Decoding '%s'", field.Name)
 
 	switch field.Type.Kind() {
 	case reflect.String: // all strings in fusionfall packets are encoded as utf16, we'll need to decode it
 		sz, err := strconv.Atoi(field.Tag.Get("size"))
 		if err != nil {
-			return fmt.Errorf("Failed to grab string 'size' tag!!")
+			panic(fmt.Errorf("Failed to grab string 'size' tag!!"))
 		}
 
 		buf16 := make([]uint16, sz)
-		if err := binary.Read(pkt.readWriter, binary.LittleEndian, buf16); err != nil {
+		binary.Read(pkt, pkt.ByteOrder, buf16)
-			return err
-		}
 
 		// find null terminator
 		var realSize int
@@ -118,25 +148,19 @@ func (pkt Packet) decodeStructField(field reflect.StructField, value reflect.Val
 
 		value.SetString(string(utf16.Decode(buf16[:realSize])))
 	default:
-		if err := pkt.Decode(value.Addr().Interface()); err != nil {
+		pkt.Decode(value.Addr().Interface())
-			return err
-		}
 	}
 
-	// consume padding bytes
+	// read padding bytes
 	pad, err := strconv.Atoi(field.Tag.Get("pad"))
 	if err == nil {
 		for i := 0; i < pad; i++ {
-			if _, err := pkt.readWriter.Read([]byte{0}); err != nil {
+			pkt.readByte()
-				return err
 		}
 	}
-	}
-
-	return nil
 }
 
-func (pkt Packet) Decode(data interface{}) error {
+func (pkt *Packet) Decode(data interface{}) {
 	rv := reflect.Indirect(reflect.ValueOf(data))
 
 	switch rv.Kind() {
@@ -144,15 +168,9 @@ func (pkt Packet) Decode(data interface{}) error {
 		// walk through each struct fields
 		sz := rv.NumField()
 		for i := 0; i < sz; i++ {
-			if err := pkt.decodeStructField(rv.Type().Field(i), rv.Field(i)); err != nil {
+			pkt.decodeStructField(rv.Type().Field(i), rv.Field(i))
-				return err
-			}
 		}
 	default:
-		if err := binary.Read(pkt.readWriter, binary.LittleEndian, data); err != nil {
+		binary.Read(pkt, pkt.ByteOrder, data)
-			return err
 	}
-	}
-
-	return nil
 }

protocol/pool/pool.go

@@ -1,19 +0,0 @@
-package pool
-
-import (
-	"bytes"
-	"sync"
-)
-
-var allocator = sync.Pool{
-	New: func() any { return new(bytes.Buffer) },
-}
-
-func Get() *bytes.Buffer {
-	return allocator.Get().(*bytes.Buffer)
-}
-
-func Put(buf *bytes.Buffer) {
-	buf.Reset()
-	allocator.Put(buf)
-}

server/login.go

@@ -23,10 +23,10 @@ const (
 	LOGIN_UPDATED_EUALA_REQUIRED                = 9
 )
 
-func (server *LoginServer) AcceptLogin(peer *Peer, SzID string, IClientVerC int32, ISlotNum int8, data []protocol.SP_LS2CL_REP_CHAR_INFO) error {
+func (server *LoginServer) AcceptLogin(peer *Peer, SzID string, IClientVerC int32, ISlotNum int8, data []protocol.SP_LS2CL_REP_CHAR_INFO) {
 	peer.SzID = SzID
 
-	resp := protocol.SP_LS2CL_REP_LOGIN_SUCC{
+	resp := &protocol.SP_LS2CL_REP_LOGIN_SUCC{
 		SzID:          SzID,
 		ICharCount:    int8(len(data)),
 		ISlotNum:      ISlotNum,
@@ -35,11 +35,8 @@ func (server *LoginServer) AcceptLogin(peer *Peer, SzID string, IClientVerC int3
 		UiSvrTime:     uint64(time.Now().Unix()),
 	}
 
-	if err := peer.Send(protocol.P_LS2CL_REP_LOGIN_SUCC, resp); err != nil {
-		return err
-	}
-
 	// swap keys
+	peer.Send(resp, protocol.P_LS2CL_REP_LOGIN_SUCC)
 	peer.E_key = protocol.CreateNewKey(
 		resp.UiSvrTime,
 		uint64(resp.ICharCount+1),
@@ -53,29 +50,25 @@ func (server *LoginServer) AcceptLogin(peer *Peer, SzID string, IClientVerC int3
 
 	// send characters (if any)
 	for i := 0; i < len(data); i++ {
-		if err := peer.Send(protocol.P_LS2CL_REP_CHAR_INFO, &data[i]); err != nil {
+		peer.Send(&data[i], protocol.P_LS2CL_REP_CHAR_INFO)
-			return err
 	}
-	}
-
-	return nil
 }
 
-func (server *LoginServer) Login(peer *Peer, pkt protocol.Packet) error {
+func (server *LoginServer) Login(peer *Peer, pkt *protocol.Packet) {
 	var loginPkt protocol.SP_CL2LS_REQ_LOGIN
 	pkt.Decode(&loginPkt)
 
 	SendError := func(e int32) {
-		peer.Send(protocol.P_LS2CL_REP_LOGIN_FAIL, protocol.SP_LS2CL_REP_LOGIN_FAIL{
+		peer.Send(&protocol.SP_LS2CL_REP_LOGIN_FAIL{
 			IErrorCode: e,
 			SzID:       loginPkt.SzID,
-		})
+		}, protocol.P_LS2CL_REP_LOGIN_FAIL)
 	}
 
 	// client is resending a login packet??
 	if peer.AccountID != -1 {
 		SendError(LOGIN_ERROR)
-		return fmt.Errorf("Out of order P_CL2LS_REQ_LOGIN!")
+		panic(fmt.Errorf("Out of order P_CL2LS_REQ_LOGIN!"))
 	}
 
 	// attempt login
@@ -86,15 +79,15 @@ func (server *LoginServer) Login(peer *Peer, pkt protocol.Packet) error {
 		if err != nil {
 			// respond with a dummy login error packet so the client doesn't get softlocked
 			SendError(LOGIN_DATABASE_ERROR)
-			return err
+			panic(err)
 		}
 	} else if err == db.LoginErrorInvalidPassword {
 		// respond with invalid password
 		SendError(LOGIN_ID_AND_PASSWORD_DO_NOT_MATCH)
-		return nil
+		return
 	} else if err != nil { // wtf?
 		SendError(LOGIN_DATABASE_ERROR)
-		return err
+		panic(err)
 	}
 
 	// grab player data
@@ -102,11 +95,11 @@ func (server *LoginServer) Login(peer *Peer, pkt protocol.Packet) error {
 	plrs, err := db.DefaultDB.GetPlayers(account.AccountID)
 	if err != nil {
 		SendError(LOGIN_DATABASE_ERROR)
-		return err
+		panic(err)
 	}
 
 	// build character list
-	charInfo := make([]protocol.SP_LS2CL_REP_CHAR_INFO, 0, 4)
+	charInfo := make([]protocol.SP_LS2CL_REP_CHAR_INFO, 0)
 	for _, plr := range plrs {
 		PCStyle, PCStyle2 := util.Player2PCStyle(&plr)
 		info := protocol.SP_LS2CL_REP_CHAR_INFO{
@@ -122,50 +115,50 @@ func (server *LoginServer) Login(peer *Peer, pkt protocol.Packet) error {
 		AEquip, err := db.DefaultDB.GetPlayerInventorySlots(plr.PlayerID, 0, config.AEQUIP_COUNT-1)
 		if err != nil {
 			SendError(LOGIN_DATABASE_ERROR)
-			return err
+			panic(err)
 		}
 
 		copy(info.AEquip[:], AEquip)
 		charInfo = append(charInfo, info)
 	}
 
-	return server.AcceptLogin(peer, loginPkt.SzID, loginPkt.IClientVerC, 1, charInfo)
+	server.AcceptLogin(peer, loginPkt.SzID, loginPkt.IClientVerC, 1, charInfo)
 }
 
-func (server *LoginServer) CheckCharacterName(peer *Peer, pkt protocol.Packet) error {
+func (server *LoginServer) CheckCharacterName(peer *Peer, pkt *protocol.Packet) {
 	var charPkt protocol.SP_CL2LS_REQ_CHECK_CHAR_NAME
 	pkt.Decode(&charPkt)
 
 	// just auto accept, client resends this data later
-	return peer.Send(protocol.P_LS2CL_REP_CHECK_CHAR_NAME_SUCC, protocol.SP_LS2CL_REP_CHECK_CHAR_NAME_SUCC{
+	peer.Send(&protocol.SP_LS2CL_REP_CHECK_CHAR_NAME_SUCC{
 		SzFirstName: charPkt.SzFirstName,
 		SzLastName:  charPkt.SzLastName,
-	})
+	}, protocol.P_LS2CL_REP_CHECK_CHAR_NAME_SUCC)
 }
 
-func (server *LoginServer) SaveCharacterName(peer *Peer, pkt protocol.Packet) error {
+func (server *LoginServer) SaveCharacterName(peer *Peer, pkt *protocol.Packet) {
 	var charPkt protocol.SP_CL2LS_REQ_SAVE_CHAR_NAME
 	pkt.Decode(&charPkt)
 
 	if peer.AccountID == -1 {
-		peer.Send(protocol.P_LS2CL_REP_SAVE_CHAR_NAME_FAIL, protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_FAIL{})
+		peer.Send(&protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_FAIL{}, protocol.P_LS2CL_REP_SAVE_CHAR_NAME_FAIL)
-		return fmt.Errorf("Out of order P_LS2CL_REP_SAVE_CHAR_NAME_FAIL!")
+		panic(fmt.Errorf("Out of order P_LS2CL_REP_SAVE_CHAR_NAME_FAIL!"))
 	}
 
 	// TODO: sanity check SzFirstName && SzLastName
 	PlayerID, err := db.DefaultDB.NewPlayer(peer.AccountID, charPkt.SzFirstName, charPkt.SzLastName, int(charPkt.ISlotNum))
 	if err != nil {
-		peer.Send(protocol.P_LS2CL_REP_SAVE_CHAR_NAME_FAIL, protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_FAIL{})
+		peer.Send(&protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_FAIL{}, protocol.P_LS2CL_REP_SAVE_CHAR_NAME_FAIL)
-		return err
+		panic(err)
 	}
 
-	return peer.Send(protocol.P_LS2CL_REP_SAVE_CHAR_NAME_SUCC, protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_SUCC{
+	peer.Send(&protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_SUCC{
 		IPC_UID:     int64(PlayerID),
 		ISlotNum:    charPkt.ISlotNum,
 		IGender:     charPkt.IGender,
 		SzFirstName: charPkt.SzFirstName,
 		SzLastName:  charPkt.SzLastName,
-	})
+	}, protocol.P_LS2CL_REP_SAVE_CHAR_NAME_SUCC)
 }
 
 func validateCharacterCreation(character *protocol.SP_CL2LS_REQ_CHAR_CREATE) bool {
@@ -194,64 +187,58 @@ func validateCharacterCreation(character *protocol.SP_CL2LS_REQ_CHAR_CREATE) boo
 	return true
 }
 
-func SendFail(peer *Peer) error {
+func (server *LoginServer) CharacterCreate(peer *Peer, pkt *protocol.Packet) {
-	if err := peer.Send(protocol.P_LS2CL_REP_SHARD_SELECT_FAIL, protocol.SP_LS2CL_REP_SHARD_SELECT_FAIL{
-		IErrorCode: 2,
-	}); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (server *LoginServer) CharacterCreate(peer *Peer, pkt protocol.Packet) error {
 	var charPkt protocol.SP_CL2LS_REQ_CHAR_CREATE
 	pkt.Decode(&charPkt)
 
 	if !validateCharacterCreation(&charPkt) {
-		return SendFail(peer)
+		peer.Send(&protocol.SP_LS2CL_REP_SHARD_SELECT_FAIL{IErrorCode: 2}, protocol.P_LS2CL_REP_SHARD_SELECT_FAIL)
+		panic(fmt.Errorf("invalid SP_CL2LS_REQ_CHAR_CREATE!"))
 	}
 
 	if err := db.DefaultDB.FinishPlayer(&charPkt, peer.AccountID); err != nil {
-		return SendFail(peer)
+		peer.Send(&protocol.SP_LS2CL_REP_SHARD_SELECT_FAIL{IErrorCode: 2}, protocol.P_LS2CL_REP_SHARD_SELECT_FAIL)
+		panic(err)
 	}
 
 	plr, err := db.DefaultDB.GetPlayer(int(charPkt.PCStyle.IPC_UID))
 	if err != nil {
-		return SendFail(peer)
+		peer.Send(&protocol.SP_LS2CL_REP_SHARD_SELECT_FAIL{IErrorCode: 2}, protocol.P_LS2CL_REP_SHARD_SELECT_FAIL)
+		panic(err)
 	}
 
 	PCStyle, PCStyle2 := util.Player2PCStyle(plr)
-	return peer.Send(protocol.P_LS2CL_REP_CHAR_CREATE_SUCC, protocol.SP_LS2CL_REP_CHAR_CREATE_SUCC{
+	peer.Send(&protocol.SP_LS2CL_REP_CHAR_CREATE_SUCC{
 		ILevel:     int16(plr.Level),
 		SPC_Style:  PCStyle,
 		SPC_Style2: PCStyle2,
 		SOn_Item:   charPkt.SOn_Item, // if items were faked, we don't really care since the db only stores the sanitized fields
-	})
+	}, protocol.P_LS2CL_REP_CHAR_CREATE_SUCC)
 }
 
-func (server *LoginServer) CharacterDelete(peer *Peer, pkt protocol.Packet) error {
+func (server *LoginServer) CharacterDelete(peer *Peer, pkt *protocol.Packet) {
 	var charPkt protocol.SP_CL2LS_REQ_CHAR_DELETE
 	pkt.Decode(&charPkt)
 
 	slot, err := db.DefaultDB.DeletePlayer(int(charPkt.IPC_UID), peer.AccountID)
 	if err != nil {
-		return SendFail(peer)
+		peer.Send(&protocol.SP_LS2CL_REP_SHARD_SELECT_FAIL{IErrorCode: 2}, protocol.P_LS2CL_REP_SHARD_SELECT_FAIL)
+		panic(err)
 	}
 
-	return peer.Send(protocol.P_LS2CL_REP_CHAR_DELETE_SUCC, protocol.SP_LS2CL_REP_CHAR_DELETE_SUCC{
+	peer.Send(&protocol.SP_LS2CL_REP_CHAR_DELETE_SUCC{
 		ISlotNum: int8(slot),
-	})
+	}, protocol.P_LS2CL_REP_CHAR_DELETE_SUCC)
 }
 
-func (server *LoginServer) FinishTutorial(peer *Peer, pkt protocol.Packet) error {
+func (server *LoginServer) FinishTutorial(peer *Peer, pkt *protocol.Packet) {
 	var charPkt protocol.SP_CL2LS_REQ_SAVE_CHAR_TUTOR
 	pkt.Decode(&charPkt)
 
 	if err := db.DefaultDB.FinishTutorial(int(charPkt.IPC_UID), peer.AccountID); err != nil {
-		return SendFail(peer)
+		peer.Send(&protocol.SP_LS2CL_REP_SHARD_SELECT_FAIL{IErrorCode: 2}, protocol.P_LS2CL_REP_SHARD_SELECT_FAIL)
+		panic(err)
 	}
 
 	// no response
-	return nil
 }

server/loginserver.go

@@ -8,11 +8,8 @@ import (
 	"github.com/CPunch/gopenfusion/protocol"
 )
 
-type PacketHandler func(peer *Peer, pkt protocol.Packet) error
-
 type LoginServer struct {
 	listener  net.Listener
-	packetHandlers map[uint32]PacketHandler
 	peers     map[*Peer]bool
 	peersLock sync.Mutex
 }
@@ -23,32 +20,10 @@ func NewLoginServer() *LoginServer {
 		log.Fatal(err)
 	}
 
-	loginServer := &LoginServer{
+	return &LoginServer{
 		listener: listener,
-		packetHandlers: make(map[uint32]PacketHandler),
 		peers:    make(map[*Peer]bool),
 	}
-
-	loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_LOGIN, loginServer.Login)
-	loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_CHECK_CHAR_NAME, loginServer.CheckCharacterName)
-	loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_SAVE_CHAR_NAME, loginServer.SaveCharacterName)
-	loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_CHAR_CREATE, loginServer.CharacterCreate)
-	// loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_CHAR_SELECT, func(_ *Peer, _ protocol.Packet) error { /* stubbed */ return nil })
-	loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_CHAR_DELETE, loginServer.CharacterDelete)
-	// loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_SHARD_SELECT, func(_ *Peer, _ protocol.Packet) error { /* stubbed */ return nil })
-	// loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_SHARD_LIST_INFO, func(_ *Peer, _ protocol.Packet) error { /* stubbed */ return nil })
-	// loginServer.RegisterPacketHandler(protocol.P_CL2LS_CHECK_NAME_LIST, func(_ *Peer, _ protocol.Packet) error { /* stubbed */ return nil })
-	loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_SAVE_CHAR_TUTOR, loginServer.FinishTutorial)
-	// loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_PC_EXIT_DUPLICATE, func(_ *Peer, _ protocol.Packet) error { /* stubbed */ return nil })
-	// loginServer.RegisterPacketHandler(protocol.P_CL2LS_REP_LIVE_CHECK, func(_ *Peer, _ protocol.Packet) error { /* stubbed */ return nil })
-	// loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_CHANGE_CHAR_NAME, func(_ *Peer, _ protocol.Packet) error { /* stubbed */ return nil })
-	// loginServer.RegisterPacketHandler(protocol.P_CL2LS_REQ_SERVER_SELECT, func(_ *Peer, _ protocol.Packet) error { /* stubbed */ return nil })
-
-	return loginServer
-}
-
-func (server *LoginServer) RegisterPacketHandler(typeID uint32, hndlr PacketHandler) {
-	server.packetHandlers[typeID] = hndlr
 }
 
 func (server *LoginServer) Start() {
@@ -63,20 +38,43 @@ func (server *LoginServer) Start() {
 
 		client := NewPeer(server, conn)
 		server.Connect(client)
-		go client.Handler()
+		go client.ClientHandler()
 	}
 }
 
-func (server *LoginServer) HandlePacket(peer *Peer, typeID uint32, pkt protocol.Packet) error {
+func (server *LoginServer) HandlePacket(peer *Peer, typeID uint32, pkt *protocol.Packet) {
-	if hndlr, ok := server.packetHandlers[typeID]; ok {
+	switch typeID {
-		if err := hndlr(peer, pkt); err != nil {
+	case protocol.P_CL2LS_REQ_LOGIN:
-			return err
+		server.Login(peer, pkt)
-		}
+	case protocol.P_CL2LS_REQ_CHECK_CHAR_NAME:
-	} else {
+		server.CheckCharacterName(peer, pkt)
+	case protocol.P_CL2LS_REQ_SAVE_CHAR_NAME:
+		server.SaveCharacterName(peer, pkt)
+	case protocol.P_CL2LS_REQ_CHAR_CREATE:
+		server.CharacterCreate(peer, pkt)
+	case protocol.P_CL2LS_REQ_CHAR_SELECT:
+		/* stubbed */
+	case protocol.P_CL2LS_REQ_CHAR_DELETE:
+		server.CharacterDelete(peer, pkt)
+	case protocol.P_CL2LS_REQ_SHARD_SELECT:
+		/* stubbed */
+	case protocol.P_CL2LS_REQ_SHARD_LIST_INFO:
+		/* stubbed */
+	case protocol.P_CL2LS_CHECK_NAME_LIST:
+		/* stubbed */
+	case protocol.P_CL2LS_REQ_SAVE_CHAR_TUTOR:
+		server.FinishTutorial(peer, pkt)
+	case protocol.P_CL2LS_REQ_PC_EXIT_DUPLICATE:
+		/* stubbed */
+	case protocol.P_CL2LS_REP_LIVE_CHECK:
+		/* stubbed */
+	case protocol.P_CL2LS_REQ_CHANGE_CHAR_NAME:
+		/* stubbed */
+	case protocol.P_CL2LS_REQ_SERVER_SELECT:
+		/* stubbed */
+	default:
 		log.Printf("[WARN] unsupported packet ID: %x\n", typeID)
 	}
-
-	return nil
 }
 
 func (server *LoginServer) Disconnect(peer *Peer) {

server/peer.go

@@ -3,13 +3,11 @@ package server
 import (
 	"encoding/binary"
 	"fmt"
-	"io"
 	"log"
 	"net"
 
 	"github.com/CPunch/gopenfusion/db"
 	"github.com/CPunch/gopenfusion/protocol"
-	"github.com/CPunch/gopenfusion/protocol/pool"
 )
 
 const (
@@ -18,7 +16,7 @@ const (
 )
 
 type PeerHandler interface {
-	HandlePacket(client *Peer, typeID uint32, pkt protocol.Packet) error
+	HandlePacket(client *Peer, typeID uint32, pkt *protocol.Packet)
 	Connect(client *Peer)
 	Disconnect(client *Peer)
 }
@@ -49,100 +47,83 @@ func NewPeer(handler PeerHandler, conn net.Conn) *Peer {
 	}
 }
 
-func (peer *Peer) Send(typeID uint32, data ...interface{}) error {
+func (client *Peer) Send(data interface{}, typeID uint32) {
-	buf := pool.Get()
+	// encode
-	defer pool.Put(buf) // always return the buffer to the pool
+	pkt := protocol.NewPacket(make([]byte, 0))
-
+	pkt.Encode(data)
-	// body start
+	log.Printf("Sending %#v, sizeof: %d", data, len(pkt.Buf))
-	pkt := protocol.NewPacket(buf)
-
-	// encode type id
-	if err := pkt.Encode(uint32(typeID)); err != nil {
-		return err
-	}
-
-	// encode data
-	for _, trailer := range data {
-		if err := pkt.Encode(trailer); err != nil {
-			return err
-		}
-	}
-
-	// encrypt body
-	switch peer.whichKey {
-	case USE_E:
-		protocol.EncryptData(buf.Bytes(), peer.E_key)
-	case USE_FE:
-		protocol.EncryptData(buf.Bytes(), peer.FE_key)
-	}
 
 	// write packet size
-	if err := binary.Write(peer.conn, binary.LittleEndian, uint32(buf.Len())); err != nil {
+	tmp := make([]byte, 4)
-		return err
+	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
-	log.Printf("Sending %#v, sizeof: %d", data, buf.Len())
+	if _, err := client.conn.Write(tmp); err != nil {
-	if _, err := peer.conn.Write(buf.Bytes()); err != nil {
+		panic(fmt.Errorf("[FATAL] failed to write packet body! %v", err))
-		return fmt.Errorf("[FATAL] failed to write packet body! %v", err)
 	}
-
-	return nil
 }
 
-func (peer *Peer) Kill() {
+func (client *Peer) Kill() {
-	if !peer.alive {
+	if !client.alive {
 		return
 	}
 
-	peer.alive = false
+	client.alive = false
-	peer.conn.Close()
+	client.conn.Close()
-	peer.handler.Disconnect(peer)
+	client.handler.Disconnect(client)
 }
 
-func (peer *Peer) Handler() {
+func (client *Peer) ClientHandler() {
-	defer peer.Kill()
+	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, the goroutine spends most of it's time parked here
+		// read packet size
-		var sz uint32
+		if _, err := client.conn.Read(tmp); err != nil {
-		if err := binary.Read(peer.conn, binary.LittleEndian, &sz); err != nil {
+			panic(fmt.Errorf("[FATAL] failed to read packet size! %v", err))
-			log.Printf("[FATAL] failed to read packet size! %v\n", err)
-			return
 		}
+		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 {
-			log.Printf("[FATAL] malicious packet size received! %d", sz)
+			panic(fmt.Errorf("[FATAL] malicious packet size received! %d", sz))
-			return
 		}
 
 		// read packet body
-		buf := pool.Get()
+		if _, err := client.conn.Read(tmp[:sz]); err != nil {
-		if _, err := buf.ReadFrom(io.LimitReader(peer.conn, int64(sz))); err != nil {
+			panic(fmt.Errorf("[FATAL] failed to read packet body! %v", err))
-			log.Printf("[FATAL] failed to read packet body! %v", err)
-			return
 		}
 
-		// decrypt
+		// decrypt && grab typeID
-		protocol.DecryptData(buf.Bytes(), peer.E_key)
+		protocol.DecryptData(tmp[:sz], client.E_key)
-		pkt := protocol.NewPacket(buf)
+		typeID := uint32(binary.LittleEndian.Uint32(tmp[:4]))
-
-		// create packet && read typeID
-		var typeID uint32
-		if err := pkt.Decode(&typeID); err != nil {
-			log.Printf("[FATAL] failed to read packet type! %v", err)
-			return
-		}
 
 		// dispatch packet
 		log.Printf("Got packet ID: %x, with a sizeof: %d\n", typeID, sz)
-		if err := peer.handler.HandlePacket(peer, typeID, pkt); err != nil {
+		pkt := protocol.NewPacket(tmp[4:sz])
-			log.Printf("[FATAL] %v", err)
+		client.handler.HandlePacket(client, typeID, pkt)
-			return
-		}
 
-		// restore buffer to pool
+		// reset tmp
-		pool.Put(buf)
+		tmp = tmp[:4]
 	}
 }