major refactoring; started DB

- DB work has started in db. this will be a direct port of the OpenFusion DB format.
- LoginServer is now less of a dummy. You can create and login to accounts, and create a character to go through the tutorial with.
- config.go will host some commonly changed variables.
- protocol: fixed a bug relating to arrays being ignored while encoding packets

server/client.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 ClientHandler interface {
+	HandlePacket(client *Client, typeID uint32, pkt *protocol.Packet)
+	Connect(client *Client)
+	Disconnect(client *Client)
+}
+
+type Client struct {
+	E_key     []byte
+	FE_key    []byte
+	SzID      string
+	AccountID int
+	Player    *db.Player
+	handler   ClientHandler
+	conn      net.Conn
+	alive     bool
+	whichKey  int
+}
+
+func NewClient(handler ClientHandler, conn net.Conn) *Client {
+	return &Client{
+		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 *Client) 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 *Client) Kill() {
+	if !client.alive {
+		return
+	}
+
+	client.alive = false
+	client.conn.Close()
+	client.handler.Disconnect(client)
+}
+
+func (client *Client) 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]
+	}
+}

server/login.go

@@ -0,0 +1,171 @@
+package server
+
+import (
+	"encoding/binary"
+	"fmt"
+	"time"
+
+	"github.com/CPunch/GopenFusion/config"
+	"github.com/CPunch/GopenFusion/db"
+	"github.com/CPunch/GopenFusion/protocol"
+	"github.com/CPunch/GopenFusion/util"
+)
+
+const (
+	LOGIN_DATABASE_ERROR                        = 0
+	LOGIN_ID_DOESNT_EXIST                       = 1
+	LOGIN_ID_AND_PASSWORD_DO_NOT_MATCH          = 2
+	LOGIN_ID_ALREADY_IN_USE                     = 3
+	LOGIN_ERROR                                 = 4
+	LOGIN_CLIENT_VERSION_OUTDATED               = 6
+	LOGIN_YOU_ARE_NOT_AN_AUTHORIZED_BETA_TESTER = 7
+	LOGIN_AUTHENTICATION_CONNECTION_ERROR       = 8
+	LOGIN_UPDATED_EUALA_REQUIRED                = 9
+)
+
+func (server *LoginServer) AcceptLogin(client *Client, SzID string, IClientVerC int32, ISlotNum int8, data []protocol.SP_LS2CL_REP_CHAR_INFO) {
+	client.SzID = SzID
+
+	resp := &protocol.SP_LS2CL_REP_LOGIN_SUCC{
+		SzID:          SzID,
+		ICharCount:    int8(len(data)),
+		ISlotNum:      ISlotNum,
+		IPaymentFlag:  1,
+		IOpenBetaFlag: 0,
+		UiSvrTime:     uint64(time.Now().Unix()),
+	}
+
+	client.Send(resp, protocol.P_LS2CL_REP_LOGIN_SUCC)
+	client.E_key = protocol.CreateNewKey(
+		resp.UiSvrTime,
+		uint64(resp.ICharCount+1),
+		uint64(resp.ISlotNum+1),
+	)
+	client.FE_key = protocol.CreateNewKey(
+		binary.LittleEndian.Uint64([]byte(protocol.DEFAULT_KEY)),
+		uint64(IClientVerC),
+		1,
+	)
+
+	// send characters (if any)
+	for i := 0; i < len(data); i++ {
+		client.Send(&data[i], protocol.P_LS2CL_REP_CHAR_INFO)
+	}
+}
+
+func (server *LoginServer) Login(client *Client, pkt *protocol.Packet) {
+	var loginPkt protocol.SP_CL2LS_REQ_LOGIN
+	pkt.Decode(&loginPkt)
+
+	SendError := func(e int32) {
+		client.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 client.AccountID != -1 {
+		SendError(LOGIN_ERROR)
+		panic(fmt.Errorf("Out of order P_CL2LS_REQ_LOGIN!"))
+	}
+
+	// attempt login
+	account, err := db.TryLogin(db.DefaultDB, loginPkt.SzID, loginPkt.SzPassword)
+	if err == db.LoginErrorInvalidID {
+		// this is the default behavior, auto create the account if the ID isn't in use
+		account, err = db.NewAccount(db.DefaultDB, loginPkt.SzID, loginPkt.SzPassword)
+		if err != nil {
+			// respond with a dummy login error packet so the client doesn't get softlocked
+			SendError(LOGIN_DATABASE_ERROR)
+			panic(err)
+		}
+	} else if err == db.LoginErrorInvalidPassword {
+		// respond with invalid password
+		SendError(LOGIN_ID_AND_PASSWORD_DO_NOT_MATCH)
+		return
+	} else if err != nil { // wtf?
+		SendError(LOGIN_DATABASE_ERROR)
+		panic(err)
+	}
+
+	// grab player data
+	client.AccountID = account.AccountID
+	plrs, err := db.DefaultDB.GetPlayers(account.AccountID)
+	if err != nil {
+		SendError(LOGIN_DATABASE_ERROR)
+		panic(err)
+	}
+
+	// build character list
+	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{
+			ISlot:      int8(plr.Slot),
+			ILevel:     int16(plr.Level),
+			SPC_Style:  PCStyle,
+			SPC_Style2: PCStyle2,
+			IX:         int32(plr.XCoordinate),
+			IY:         int32(plr.YCoordinate),
+			IZ:         int32(plr.ZCoordinate),
+		}
+
+		AEquip, err := db.DefaultDB.GetPlayerInventorySlots(plr.PlayerID, 0, config.AEQUIP_COUNT-1)
+		if err != nil {
+			SendError(LOGIN_DATABASE_ERROR)
+			panic(err)
+		}
+
+		copy(info.AEquip[:], AEquip)
+		charInfo = append(charInfo, info)
+	}
+
+	server.AcceptLogin(client, loginPkt.SzID, loginPkt.IClientVerC, 1, charInfo)
+}
+
+func (server *LoginServer) SaveCharacterName(client *Client, pkt *protocol.Packet) {
+	var charPkt protocol.SP_CL2LS_REQ_SAVE_CHAR_NAME
+	pkt.Decode(&charPkt)
+
+	if client.AccountID == -1 {
+		client.Send(&protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_FAIL{}, protocol.P_LS2CL_REP_SAVE_CHAR_NAME_FAIL)
+		panic(fmt.Errorf("Out of order P_LS2CL_REP_SAVE_CHAR_NAME_FAIL!"))
+	}
+
+	PlayerID, err := db.DefaultDB.NewPlayer(client.AccountID, charPkt.SzFirstName, charPkt.SzLastName, int(charPkt.ISlotNum))
+	if err != nil {
+		client.Send(&protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_FAIL{}, protocol.P_LS2CL_REP_SAVE_CHAR_NAME_FAIL)
+		panic(err)
+	}
+
+	client.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 (server *LoginServer) CharacterCreate(client *Client, pkt *protocol.Packet) {
+	var charPkt protocol.SP_CL2LS_REQ_CHAR_CREATE
+	pkt.Decode(&charPkt)
+
+	if err := db.DefaultDB.FinishPlayer(&charPkt, client.AccountID); err != nil {
+		panic(err)
+	}
+
+	plr, err := db.DefaultDB.GetPlayer(int(charPkt.PCStyle.IPC_UID))
+	if err != nil {
+		panic(err)
+	}
+
+	PCStyle, PCStyle2 := util.Player2PCStyle(plr)
+	client.Send(&protocol.SP_LS2CL_REP_CHAR_CREATE_SUCC{
+		ILevel:     int16(plr.Level),
+		SPC_Style:  PCStyle,
+		SPC_Style2: PCStyle2,
+		SOn_Item:   protocol.SOnItem{ /*TODO*/ },
+	}, protocol.P_LS2CL_REP_CHAR_CREATE_SUCC)
+}

server/loginserver.go

@@ -4,14 +4,15 @@ import (
 	"fmt"
 	"log"
 	"net"
+	"sync"
 
 	"github.com/CPunch/GopenFusion/protocol"
 )
 
 type LoginServer struct {
-	listener   net.Listener
-	clients    map[*protocol.Client]bool
-	unregister chan *protocol.Client
+	listener net.Listener
+	clients  map[*Client]bool
+	lock     sync.Mutex
 }
 
 func NewLoginServer() *LoginServer {
@@ -21,9 +22,8 @@ func NewLoginServer() *LoginServer {
 	}
 
 	return &LoginServer{
-		listener:   listener,
-		clients:    make(map[*protocol.Client]bool),
-		unregister: make(chan *protocol.Client),
+		listener: listener,
+		clients:  make(map[*Client]bool),
 	}
 }
 
@@ -31,33 +31,22 @@ func (server *LoginServer) Start() {
 	log.Print("Server hosted on 127.0.0.1:23000")
 
 	for {
-		select {
-		case client := <-server.unregister:
-			delete(server.clients, client)
-			fmt.Printf("Client %p disconnected\n", client)
-		default:
-			conn, err := server.listener.Accept()
-			if err != nil {
-				log.Println("Connection error: ", err)
-				return
-			}
-
-			client := protocol.NewClient(server, conn)
-			server.clients[client] = true
-			fmt.Printf("Client %p connected\n", client)
-			go client.ClientHandler()
+		conn, err := server.listener.Accept()
+		if err != nil {
+			log.Println("Connection error: ", err)
+			return
 		}
+
+		client := NewClient(server, conn)
+		server.Connect(client)
+		go client.ClientHandler()
 	}
 }
 
-func (server *LoginServer) HandlePacket(client *protocol.Client, typeID uint32, pkt *protocol.Packet) {
+func (server *LoginServer) HandlePacket(client *Client, typeID uint32, pkt *protocol.Packet) {
 	switch typeID {
 	case protocol.P_CL2LS_REQ_LOGIN:
-		var loginPkt protocol.SP_CL2LS_REQ_LOGIN
-		pkt.Decode(&loginPkt)
-
-		// TODO: for now, we're a dummy server
-		client.AcceptLogin(loginPkt.SzID, loginPkt.IClientVerC, 1, []protocol.SP_LS2CL_REP_CHAR_INFO{})
+		server.Login(client, pkt)
 	case protocol.P_CL2LS_REQ_CHECK_CHAR_NAME:
 		var charPkt protocol.SP_CL2LS_REQ_CHECK_CHAR_NAME
 		pkt.Decode(&charPkt)
@@ -67,21 +56,24 @@ func (server *LoginServer) HandlePacket(client *protocol.Client, typeID uint32,
 			SzLastName:  charPkt.SzLastName,
 		}, protocol.P_LS2CL_REP_CHECK_CHAR_NAME_SUCC)
 	case protocol.P_CL2LS_REQ_SAVE_CHAR_NAME:
-		var charPkt protocol.SP_CL2LS_REQ_SAVE_CHAR_NAME
-		pkt.Decode(&charPkt)
-
-		client.Send(&protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_SUCC{
-			IPC_UID:     1,
-			ISlotNum:    charPkt.ISlotNum,
-			IGender:     charPkt.IGender,
-			SzFirstName: charPkt.SzFirstName,
-			SzLastName:  charPkt.SzLastName,
-		}, protocol.P_LS2CL_REP_SAVE_CHAR_NAME_SUCC)
+		server.SaveCharacterName(client, pkt)
+	case protocol.P_CL2LS_REQ_CHAR_CREATE:
+		server.CharacterCreate(client, pkt)
 	default:
 		log.Printf("[WARN] unsupported packet ID: %x\n", typeID)
 	}
 }
 
-func (server *LoginServer) Disconnect(client *protocol.Client) {
-	server.unregister <- client
+func (server *LoginServer) Disconnect(client *Client) {
+	server.lock.Lock()
+	delete(server.clients, client)
+	fmt.Printf("Client %p disconnected\n", client)
+	server.lock.Unlock()
+}
+
+func (server *LoginServer) Connect(client *Client) {
+	server.lock.Lock()
+	server.clients[client] = true
+	fmt.Printf("Client %p connected\n", client)
+	server.lock.Unlock()
 }