added db to handlerTable

server/channelserver/chat_commands.go

@@ -51,16 +51,16 @@ func executeCommand(s *Session, input string) error {
 }
 
 func ban(s *Session, args []string) error {
+	db, err := db.GetDB()
+	if err != nil {
+		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
+	}
+
 	if !s.isOp() {
 		s.sendMessage(t("commands.no_op", v{}))
 		return nil
 	}
 
-	database, err := db.GetDB()
-	if err != nil {
-		return err
-	}
-
 	if len(args) < 1 {
 		s.sendMessage(t("commands.ban.error.syntax", v{"prefix": config.GetConfig().CommandPrefix}))
 		return nil
@@ -83,14 +83,14 @@ func ban(s *Session, args []string) error {
 
 	var uid uint32
 	var uname string
-	err = database.QueryRow(`SELECT id, username FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, cid).Scan(&uid, &uname)
+	err = db.QueryRow(`SELECT id, username FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, cid).Scan(&uid, &uname)
 	if err == nil {
 		if expiry.IsZero() {
-			database.Exec(`INSERT INTO bans VALUES ($1)
+			db.Exec(`INSERT INTO bans VALUES ($1)
                  				ON CONFLICT (user_id) DO UPDATE SET expires=NULL`, uid)
 			s.sendMessage(t("commands.ban.success.permanent", v{"username": uname}))
 		} else {
-			database.Exec(`INSERT INTO bans VALUES ($1, $2)
+			db.Exec(`INSERT INTO bans VALUES ($1, $2)
                  				ON CONFLICT (user_id) DO UPDATE SET expires=$2`, uid, expiry)
 			s.sendMessage(t("commands.ban.success.temporary", v{"username": uname, "expiry": expiry.Format(time.DateTime)}))
 		}
@@ -102,14 +102,13 @@ func ban(s *Session, args []string) error {
 }
 
 func timer(s *Session, _ []string) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
-		return err
+		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-
 	var state bool
-	database.QueryRow(`SELECT COALESCE(timer, false) FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&state)
+	db.QueryRow(`SELECT COALESCE(timer, false) FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&state)
-	database.Exec(`UPDATE users u SET timer=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, !state, s.CharID)
+	db.Exec(`UPDATE users u SET timer=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, !state, s.CharID)
 	if state {
 		s.sendMessage(t("commands.timer.disabled", v{}))
 	} else {
@@ -119,20 +118,19 @@ func timer(s *Session, _ []string) error {
 }
 
 func psn(s *Session, args []string) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
-		return err
+		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-
 	if len(args) < 1 {
 		s.sendMessage(t("commands.psn.error.syntax", v{"prefix": config.GetConfig().CommandPrefix}))
 		return nil
 	}
 
 	var exists int
-	database.QueryRow(`SELECT count(*) FROM users WHERE psn_id = $1`, args[1]).Scan(&exists)
+	db.QueryRow(`SELECT count(*) FROM users WHERE psn_id = $1`, args[1]).Scan(&exists)
 	if exists == 0 {
-		_, err = database.Exec(`UPDATE users u SET psn_id=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, args[1], s.CharID)
+		_, err := db.Exec(`UPDATE users u SET psn_id=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, args[1], s.CharID)
 		if err == nil {
 			s.sendMessage(t("commands.psn.success", v{"psn": args[1]}))
 		} else {
@@ -220,18 +218,17 @@ func kqf(s *Session, args []string) error {
 }
 
 func rights(s *Session, args []string) error {
+	db, err := db.GetDB()
+	if err != nil {
+		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
+	}
 	if len(args) < 1 {
 		s.sendMessage(t("commands.rights.error.syntax", v{"prefix": config.GetConfig().CommandPrefix}))
 		return nil
 	}
 
-	database, err := db.GetDB()
-	if err != nil {
-		return err
-	}
-
 	r, _ := strconv.Atoi(args[0])
-	_, err = database.Exec("UPDATE users u SET rights=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", r, s.CharID)
+	_, err = db.Exec("UPDATE users u SET rights=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", r, s.CharID)
 	if err != nil {
 		return err
 	}
@@ -241,16 +238,15 @@ func rights(s *Session, args []string) error {
 }
 
 func course(s *Session, args []string) error {
+	db, err := db.GetDB()
+	if err != nil {
+		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
+	}
 	if len(args) < 1 {
 		s.sendMessage(t("commands.course.error.syntax", v{"prefix": config.GetConfig().CommandPrefix}))
 		return nil
 	}
 
-	database, err := db.GetDB()
-	if err != nil {
-		return err
-	}
-
 	for _, course := range mhfcourse.Courses() {
 		for _, alias := range course.Aliases() {
 			if strings.ToLower(args[1]) == strings.ToLower(alias) {
@@ -273,11 +269,11 @@ func course(s *Session, args []string) error {
 						delta = uint32(math.Pow(2, float64(course.ID)))
 						s.sendMessage(t("commands.course.enabled", v{"course": course.Aliases()[0]}))
 					}
-					err = database.QueryRow("SELECT rights FROM users u INNER JOIN characters c ON u.id = c.user_id WHERE c.id = $1", s.CharID).Scan(&rightsInt)
+					err := db.QueryRow("SELECT rights FROM users u INNER JOIN characters c ON u.id = c.user_id WHERE c.id = $1", s.CharID).Scan(&rightsInt)
 					if err != nil {
 						return err
 					} else {
-						_, err = database.Exec("UPDATE users u SET rights=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", rightsInt+delta, s.CharID)
+						_, err = db.Exec("UPDATE users u SET rights=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", rightsInt+delta, s.CharID)
 						if err != nil {
 							return err
 						}
@@ -369,13 +365,12 @@ func teleport(s *Session, args []string) error {
 }
 
 func discord(s *Session, _ []string) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
-		return err
+		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-
 	var _token string
-	err = database.QueryRow(`SELECT discord_token FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&_token)
+	err = db.QueryRow(`SELECT discord_token FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&_token)
 	if err != nil {
 		randToken := make([]byte, 4)
 		_, err = rand.Read(randToken)
@@ -383,7 +378,7 @@ func discord(s *Session, _ []string) error {
 			return err
 		}
 		_token = fmt.Sprintf("%x-%x", randToken[:2], randToken[2:])
-		_, err = database.Exec(`UPDATE users u SET discord_token = $1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, _token, s.CharID)
+		_, err = db.Exec(`UPDATE users u SET discord_token = $1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, _token, s.CharID)
 		if err != nil {
 			return err
 		}

server/channelserver/handlers.go

@@ -22,6 +22,7 @@ import (
 	"erupe-ce/utils/byteframe"
 	"math/bits"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
@@ -34,12 +35,14 @@ func stubEnumerateNoResults(s *Session, ackHandle uint32) {
 }
 
 func updateRights(s *Session) {
-	rightsInt := uint32(2)
+	db, err := db.GetDB()
-	database, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	database.QueryRow("SELECT rights FROM users u INNER JOIN characters c ON u.id = c.user_id WHERE c.id = $1", s.CharID).Scan(&rightsInt)
+
+	rightsInt := uint32(2)
+
+	db.QueryRow("SELECT rights FROM users u INNER JOIN characters c ON u.id = c.user_id WHERE c.id = $1", s.CharID).Scan(&rightsInt)
 	s.courses, rightsInt = mhfcourse.GetCourseStruct(rightsInt)
 	update := &mhfpacket.MsgSysUpdateRight{
 		ClientRespAckHandle: 0,
@@ -50,23 +53,23 @@ func updateRights(s *Session) {
 	s.QueueSendMHF(update)
 }
 
-func handleMsgHead(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgHead(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysExtendThreshold(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysExtendThreshold(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	// No data aside from header, no resp required.
 }
 
-func handleMsgSysEnd(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysEnd(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	// No data aside from header, no resp required.
 }
 
-func handleMsgSysNop(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysNop(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	// No data aside from header, no resp required.
 }
 
-func handleMsgSysAck(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysAck(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysTerminalLog(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysTerminalLog(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysTerminalLog)
 	for i := range pkt.Entries {
 		s.Server.logger.Info("SysTerminalLog",
@@ -84,15 +87,12 @@ func handleMsgSysTerminalLog(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgSysLogin(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysLogin(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysLogin)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if !config.GetConfig().DebugOptions.DisableTokenCheck {
 		var token string
-		err := database.QueryRow("SELECT token FROM sign_sessions ss INNER JOIN public.users u on ss.user_id = u.id WHERE token=$1 AND ss.id=$2 AND u.id=(SELECT c.user_id FROM characters c WHERE c.id=$3)", pkt.LoginTokenString, pkt.LoginTokenNumber, pkt.CharID0).Scan(&token)
+		err := db.QueryRow("SELECT token FROM sign_sessions ss INNER JOIN public.users u on ss.user_id = u.id WHERE token=$1 AND ss.id=$2 AND u.id=(SELECT c.user_id FROM characters c WHERE c.id=$3)", pkt.LoginTokenString, pkt.LoginTokenNumber, pkt.CharID0).Scan(&token)
 		if err != nil {
 			s.rawConn.Close()
 			s.Logger.Warn(fmt.Sprintf("Invalid login token, offending CID: (%d)", pkt.CharID0))
@@ -108,22 +108,22 @@ func handleMsgSysLogin(s *Session, p mhfpacket.MHFPacket) {
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(uint32(gametime.TimeAdjusted().Unix())) // Unix timestamp
 
-	_, err = database.Exec("UPDATE servers SET current_players=$1 WHERE server_id=$2", len(s.Server.sessions), s.Server.ID)
+	_, err := db.Exec("UPDATE servers SET current_players=$1 WHERE server_id=$2", len(s.Server.sessions), s.Server.ID)
 	if err != nil {
 		panic(err)
 	}
 
-	_, err = database.Exec("UPDATE sign_sessions SET server_id=$1, char_id=$2 WHERE token=$3", s.Server.ID, s.CharID, s.token)
+	_, err = db.Exec("UPDATE sign_sessions SET server_id=$1, char_id=$2 WHERE token=$3", s.Server.ID, s.CharID, s.token)
 	if err != nil {
 		panic(err)
 	}
 
-	_, err = database.Exec("UPDATE characters SET last_login=$1 WHERE id=$2", gametime.TimeAdjusted().Unix(), s.CharID)
+	_, err = db.Exec("UPDATE characters SET last_login=$1 WHERE id=$2", gametime.TimeAdjusted().Unix(), s.CharID)
 	if err != nil {
 		panic(err)
 	}
 
-	_, err = database.Exec("UPDATE users u SET last_character=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)", s.CharID)
+	_, err = db.Exec("UPDATE users u SET last_character=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)", s.CharID)
 	if err != nil {
 		panic(err)
 	}
@@ -135,12 +135,15 @@ func handleMsgSysLogin(s *Session, p mhfpacket.MHFPacket) {
 	s.Server.BroadcastMHF(&mhfpacket.MsgSysInsertUser{CharID: s.CharID}, s)
 }
 
-func handleMsgSysLogout(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysLogout(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	logoutPlayer(s)
 }
 
 func logoutPlayer(s *Session) {
-
+	db, err := db.GetDB()
+	if err != nil {
+		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
+	}
 	s.Server.Lock()
 	if _, exists := s.Server.sessions[s.rawConn]; exists {
 		delete(s.Server.sessions, s.rawConn)
@@ -166,23 +169,20 @@ func logoutPlayer(s *Session) {
 			}
 		}
 	}
-	database, err := db.GetDB()
+
-	if err != nil {
+	_, err = db.Exec("UPDATE sign_sessions SET server_id=NULL, char_id=NULL WHERE token=$1", s.token)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	_, err = database.Exec("UPDATE sign_sessions SET server_id=NULL, char_id=NULL WHERE token=$1", s.token)
 	if err != nil {
 		panic(err)
 	}
 
-	_, err = database.Exec("UPDATE servers SET current_players=$1 WHERE server_id=$2", len(s.Server.sessions), s.Server.ID)
+	_, err = db.Exec("UPDATE servers SET current_players=$1 WHERE server_id=$2", len(s.Server.sessions), s.Server.ID)
 	if err != nil {
 		panic(err)
 	}
 
 	var timePlayed int
 	var sessionTime int
-	_ = database.QueryRow("SELECT time_played FROM characters WHERE id = $1", s.CharID).Scan(&timePlayed)
+	_ = db.QueryRow("SELECT time_played FROM characters WHERE id = $1", s.CharID).Scan(&timePlayed)
 	sessionTime = int(gametime.TimeAdjusted().Unix()) - int(s.sessionStart)
 	timePlayed += sessionTime
 
@@ -190,15 +190,15 @@ func logoutPlayer(s *Session) {
 	if mhfcourse.CourseExists(30, s.courses) {
 		rpGained = timePlayed / 900
 		timePlayed = timePlayed % 900
-		database.Exec("UPDATE characters SET cafe_time=cafe_time+$1 WHERE id=$2", sessionTime, s.CharID)
+		db.Exec("UPDATE characters SET cafe_time=cafe_time+$1 WHERE id=$2", sessionTime, s.CharID)
 	} else {
 		rpGained = timePlayed / 1800
 		timePlayed = timePlayed % 1800
 	}
 
-	database.Exec("UPDATE characters SET time_played = $1 WHERE id = $2", timePlayed, s.CharID)
+	db.Exec("UPDATE characters SET time_played = $1 WHERE id = $2", timePlayed, s.CharID)
 
-	database.Exec(`UPDATE guild_characters SET treasure_hunt=NULL WHERE character_id=$1`, s.CharID)
+	db.Exec(`UPDATE guild_characters SET treasure_hunt=NULL WHERE character_id=$1`, s.CharID)
 
 	if s.stage == nil {
 		return
@@ -231,14 +231,14 @@ func logoutPlayer(s *Session) {
 	saveData.Save(s)
 }
 
-func handleMsgSysSetStatus(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysSetStatus(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysPing(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysPing(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysPing)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgSysTime(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysTime(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	resp := &mhfpacket.MsgSysTime{
 		GetRemoteTime: false,
 		Timestamp:     uint32(gametime.TimeAdjusted().Unix()), // JP timezone
@@ -247,7 +247,7 @@ func handleMsgSysTime(s *Session, p mhfpacket.MHFPacket) {
 	s.notifyRavi()
 }
 
-func handleMsgSysIssueLogkey(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysIssueLogkey(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysIssueLogkey)
 
 	// Make a random log key for this session.
@@ -269,12 +269,9 @@ func handleMsgSysIssueLogkey(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgSysRecordLog(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysRecordLog(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysRecordLog)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if config.GetConfig().ClientID == config.ZZ {
 		bf := byteframe.NewByteFrameFromBytes(pkt.Data)
 		bf.Seek(32, 0)
@@ -282,7 +279,7 @@ func handleMsgSysRecordLog(s *Session, p mhfpacket.MHFPacket) {
 		for i := 0; i < 176; i++ {
 			val = bf.ReadUint8()
 			if val > 0 && mhfmon.Monsters[i].Large {
-				database.Exec(`INSERT INTO kill_logs (character_id, monster, quantity, timestamp) VALUES ($1, $2, $3, $4)`, s.CharID, i, val, gametime.TimeAdjusted())
+				db.Exec(`INSERT INTO kill_logs (character_id, monster, quantity, timestamp) VALUES ($1, $2, $3, $4)`, s.CharID, i, val, gametime.TimeAdjusted())
 			}
 		}
 	}
@@ -291,9 +288,9 @@ func handleMsgSysRecordLog(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgSysEcho(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysEcho(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysLockGlobalSema(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysLockGlobalSema(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysLockGlobalSema)
 	var sgid string
 	for _, channel := range s.Server.Channels {
@@ -316,24 +313,24 @@ func handleMsgSysLockGlobalSema(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgSysUnlockGlobalSema(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysUnlockGlobalSema(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysUnlockGlobalSema)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgSysUpdateRight(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysUpdateRight(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysAuthQuery(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysAuthQuery(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysAuthTerminal(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysAuthTerminal(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysRightsReload(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysRightsReload(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysRightsReload)
 	updateRights(s)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfTransitMessage(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfTransitMessage(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfTransitMessage)
 
 	local := false
@@ -582,40 +579,40 @@ func handleMsgMhfTransitMessage(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgCaExchangeItem(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgCaExchangeItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfServerCommand(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfServerCommand(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfAnnounce(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAnnounce(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAnnounce)
 	s.Server.BroadcastRaviente(pkt.IPAddress, pkt.Port, pkt.StageID, pkt.Data.ReadUint8())
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfSetLoginwindow(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfSetLoginwindow(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysTransBinary(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysTransBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysCollectBinary(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysCollectBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysGetState(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysGetState(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysSerialize(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysSerialize(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysEnumlobby(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysEnumlobby(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysEnumuser(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysEnumuser(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysInfokyserver(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysInfokyserver(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfGetCaUniqueID(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfGetCaUniqueID(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfTransferItem(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfTransferItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfTransferItem)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfEnumeratePrice(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumeratePrice(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumeratePrice)
 	bf := byteframe.NewByteFrame()
 	var lbPrices []struct {
@@ -780,21 +777,22 @@ func handleMsgMhfEnumeratePrice(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfEnumerateOrder(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateOrder(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateOrder)
 	stubEnumerateNoResults(s, pkt.AckHandle)
 }
 
-func handleMsgMhfGetExtraInfo(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfGetExtraInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
 func userGetItems(s *Session) []mhfitem.MHFItemStack {
-	var data []byte
+	db, err := db.GetDB()
-	var items []mhfitem.MHFItemStack
-	database, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	database.QueryRow(`SELECT item_box FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&data)
+	var data []byte
+	var items []mhfitem.MHFItemStack
+
+	db.QueryRow(`SELECT item_box FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&data)
 	if len(data) > 0 {
 		box := byteframe.NewByteFrameFromBytes(data)
 		numStacks := box.ReadUint16()
@@ -806,7 +804,7 @@ func userGetItems(s *Session) []mhfitem.MHFItemStack {
 	return items
 }
 
-func handleMsgMhfEnumerateUnionItem(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateUnionItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateUnionItem)
 	items := userGetItems(s)
 	bf := byteframe.NewByteFrame()
@@ -814,41 +812,35 @@ func handleMsgMhfEnumerateUnionItem(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfUpdateUnionItem(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUpdateUnionItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateUnionItem)
 	newStacks := mhfitem.DiffItemStacks(userGetItems(s), pkt.UpdatedItems)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec(`UPDATE users u SET item_box=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, mhfitem.SerializeWarehouseItems(newStacks), s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec(`UPDATE users u SET item_box=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, mhfitem.SerializeWarehouseItems(newStacks), s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfGetCogInfo(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfGetCogInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfCheckWeeklyStamp(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfCheckWeeklyStamp(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfCheckWeeklyStamp)
 	var total, redeemed, updated uint16
 	var lastCheck time.Time
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow(fmt.Sprintf("SELECT %s_checked FROM stamps WHERE character_id=$1", pkt.StampType), s.CharID).Scan(&lastCheck)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow(fmt.Sprintf("SELECT %s_checked FROM stamps WHERE character_id=$1", pkt.StampType), s.CharID).Scan(&lastCheck)
 	if err != nil {
 		lastCheck = gametime.TimeAdjusted()
-		database.Exec("INSERT INTO stamps (character_id, hl_checked, ex_checked) VALUES ($1, $2, $2)", s.CharID, gametime.TimeAdjusted())
+		db.Exec("INSERT INTO stamps (character_id, hl_checked, ex_checked) VALUES ($1, $2, $2)", s.CharID, gametime.TimeAdjusted())
 	} else {
-		database.Exec(fmt.Sprintf(`UPDATE stamps SET %s_checked=$1 WHERE character_id=$2`, pkt.StampType), gametime.TimeAdjusted(), s.CharID)
+		db.Exec(fmt.Sprintf(`UPDATE stamps SET %s_checked=$1 WHERE character_id=$2`, pkt.StampType), gametime.TimeAdjusted(), s.CharID)
 	}
 
 	if lastCheck.Before(gametime.TimeWeekStart()) {
-		database.Exec(fmt.Sprintf("UPDATE stamps SET %s_total=%s_total+1 WHERE character_id=$1", pkt.StampType, pkt.StampType), s.CharID)
+		db.Exec(fmt.Sprintf("UPDATE stamps SET %s_total=%s_total+1 WHERE character_id=$1", pkt.StampType, pkt.StampType), s.CharID)
 		updated = 1
 	}
 
-	database.QueryRow(fmt.Sprintf("SELECT %s_total, %s_redeemed FROM stamps WHERE character_id=$1", pkt.StampType, pkt.StampType), s.CharID).Scan(&total, &redeemed)
+	db.QueryRow(fmt.Sprintf("SELECT %s_total, %s_redeemed FROM stamps WHERE character_id=$1", pkt.StampType, pkt.StampType), s.CharID).Scan(&total, &redeemed)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint16(total)
 	bf.WriteUint16(redeemed)
@@ -859,19 +851,16 @@ func handleMsgMhfCheckWeeklyStamp(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfExchangeWeeklyStamp(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfExchangeWeeklyStamp(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfExchangeWeeklyStamp)
 	var total, redeemed uint16
 	var tktStack mhfitem.MHFItemStack
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if pkt.Unk1 == 10 { // Yearly Sub Ex
-		database.QueryRow("UPDATE stamps SET hl_total=hl_total-48, hl_redeemed=hl_redeemed-48 WHERE character_id=$1 RETURNING hl_total, hl_redeemed", s.CharID).Scan(&total, &redeemed)
+		db.QueryRow("UPDATE stamps SET hl_total=hl_total-48, hl_redeemed=hl_redeemed-48 WHERE character_id=$1 RETURNING hl_total, hl_redeemed", s.CharID).Scan(&total, &redeemed)
 		tktStack = mhfitem.MHFItemStack{Item: mhfitem.MHFItem{ItemID: 2210}, Quantity: 1}
 	} else {
-		database.QueryRow(fmt.Sprintf("UPDATE stamps SET %s_redeemed=%s_redeemed+8 WHERE character_id=$1 RETURNING %s_total, %s_redeemed", pkt.StampType, pkt.StampType, pkt.StampType, pkt.StampType), s.CharID).Scan(&total, &redeemed)
+		db.QueryRow(fmt.Sprintf("UPDATE stamps SET %s_redeemed=%s_redeemed+8 WHERE character_id=$1 RETURNING %s_total, %s_redeemed", pkt.StampType, pkt.StampType, pkt.StampType, pkt.StampType), s.CharID).Scan(&total, &redeemed)
 		if pkt.StampType == "hl" {
 			tktStack = mhfitem.MHFItemStack{Item: mhfitem.MHFItem{ItemID: 1630}, Quantity: 5}
 		} else {
@@ -890,16 +879,17 @@ func handleMsgMhfExchangeWeeklyStamp(s *Session, p mhfpacket.MHFPacket) {
 }
 
 func getGoocooData(s *Session, cid uint32) [][]byte {
-	var goocoo []byte
+	db, err := db.GetDB()
-	var goocoos [][]byte
-	database, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
+	var goocoo []byte
+	var goocoos [][]byte
+
 	for i := 0; i < 5; i++ {
-		err := database.QueryRow(fmt.Sprintf("SELECT goocoo%d FROM goocoo WHERE id=$1", i), cid).Scan(&goocoo)
+		err = db.QueryRow(fmt.Sprintf("SELECT goocoo%d FROM goocoo WHERE id=$1", i), cid).Scan(&goocoo)
 		if err != nil {
-			database.Exec("INSERT INTO goocoo (id) VALUES ($1)", s.CharID)
+			db.Exec("INSERT INTO goocoo (id) VALUES ($1)", s.CharID)
 			return goocoos
 		}
 		if err == nil && goocoo != nil {
@@ -909,7 +899,7 @@ func getGoocooData(s *Session, cid uint32) [][]byte {
 	return goocoos
 }
 
-func handleMsgMhfEnumerateGuacot(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateGuacot(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateGuacot)
 	bf := byteframe.NewByteFrame()
 	goocoos := getGoocooData(s, s.CharID)
@@ -921,15 +911,12 @@ func handleMsgMhfEnumerateGuacot(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfUpdateGuacot(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUpdateGuacot(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateGuacot)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	for _, goocoo := range pkt.Goocoos {
 		if goocoo.Data1[0] == 0 {
-			database.Exec(fmt.Sprintf("UPDATE goocoo SET goocoo%d=NULL WHERE id=$1", goocoo.Index), s.CharID)
+			db.Exec(fmt.Sprintf("UPDATE goocoo SET goocoo%d=NULL WHERE id=$1", goocoo.Index), s.CharID)
 		} else {
 			bf := byteframe.NewByteFrame()
 			bf.WriteUint32(goocoo.Index)
@@ -941,7 +928,7 @@ func handleMsgMhfUpdateGuacot(s *Session, p mhfpacket.MHFPacket) {
 			}
 			bf.WriteUint8(uint8(len(goocoo.Name)))
 			bf.WriteBytes(goocoo.Name)
-			database.Exec(fmt.Sprintf("UPDATE goocoo SET goocoo%d=$1 WHERE id=$2", goocoo.Index), bf.Data(), s.CharID)
+			db.Exec(fmt.Sprintf("UPDATE goocoo SET goocoo%d=$1 WHERE id=$2", goocoo.Index), bf.Data(), s.CharID)
 			dumpSaveData(s, bf.Data(), fmt.Sprintf("goocoo-%d", goocoo.Index))
 		}
 	}
@@ -958,15 +945,12 @@ type Scenario struct {
 	CategoryID uint8
 }
 
-func handleMsgMhfInfoScenarioCounter(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfInfoScenarioCounter(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfInfoScenarioCounter)
 	var scenarios []Scenario
 	var scenario Scenario
-	database, err := db.GetDB()
+
-	if err != nil {
+	scenarioData, err := db.Queryx("SELECT scenario_id, category_id FROM scenario_counter")
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	scenarioData, err := database.Queryx("SELECT scenario_id, category_id FROM scenario_counter")
 	if err != nil {
 		scenarioData.Close()
 		s.Logger.Error("Failed to get scenario counter info from db", zap.Error(err))
@@ -1002,20 +986,17 @@ func handleMsgMhfInfoScenarioCounter(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfGetEtcPoints(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetEtcPoints(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetEtcPoints)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var dailyTime time.Time
-	_ = database.QueryRow("SELECT COALESCE(daily_time, $2) FROM characters WHERE id = $1", s.CharID, time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)).Scan(&dailyTime)
+	_ = db.QueryRow("SELECT COALESCE(daily_time, $2) FROM characters WHERE id = $1", s.CharID, time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)).Scan(&dailyTime)
 	if gametime.TimeAdjusted().After(dailyTime) {
-		database.Exec("UPDATE characters SET bonus_quests = 0, daily_quests = 0 WHERE id=$1", s.CharID)
+		db.Exec("UPDATE characters SET bonus_quests = 0, daily_quests = 0 WHERE id=$1", s.CharID)
 	}
 
 	var bonusQuests, dailyQuests, promoPoints uint32
-	_ = database.QueryRow(`SELECT bonus_quests, daily_quests, promo_points FROM characters WHERE id = $1`, s.CharID).Scan(&bonusQuests, &dailyQuests, &promoPoints)
+	_ = db.QueryRow(`SELECT bonus_quests, daily_quests, promo_points FROM characters WHERE id = $1`, s.CharID).Scan(&bonusQuests, &dailyQuests, &promoPoints)
 	resp := byteframe.NewByteFrame()
 	resp.WriteUint8(3) // Maybe a count of uint32(s)?
 	resp.WriteUint32(bonusQuests)
@@ -1024,7 +1005,7 @@ func handleMsgMhfGetEtcPoints(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfUpdateEtcPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUpdateEtcPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateEtcPoint)
 
 	var column string
@@ -1036,23 +1017,20 @@ func handleMsgMhfUpdateEtcPoint(s *Session, p mhfpacket.MHFPacket) {
 	case 2:
 		column = "promo_points"
 	}
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var value int16
-	err = database.QueryRow(fmt.Sprintf(`SELECT %s FROM characters WHERE id = $1`, column), s.CharID).Scan(&value)
+	err := db.QueryRow(fmt.Sprintf(`SELECT %s FROM characters WHERE id = $1`, column), s.CharID).Scan(&value)
 	if err == nil {
 		if value+pkt.Delta < 0 {
-			database.Exec(fmt.Sprintf(`UPDATE characters SET %s = 0 WHERE id = $1`, column), s.CharID)
+			db.Exec(fmt.Sprintf(`UPDATE characters SET %s = 0 WHERE id = $1`, column), s.CharID)
 		} else {
-			database.Exec(fmt.Sprintf(`UPDATE characters SET %s = %s + $1 WHERE id = $2`, column, column), pkt.Delta, s.CharID)
+			db.Exec(fmt.Sprintf(`UPDATE characters SET %s = %s + $1 WHERE id = $2`, column, column), pkt.Delta, s.CharID)
 		}
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfStampcardStamp(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfStampcardStamp(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfStampcardStamp)
 
 	rewards := []struct {
@@ -1086,11 +1064,8 @@ func handleMsgMhfStampcardStamp(s *Session, p mhfpacket.MHFPacket) {
 	}
 	var stamps, rewardTier, rewardUnk uint16
 	reward := mhfitem.MHFItemStack{Item: mhfitem.MHFItem{}}
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.QueryRow(`UPDATE characters SET stampcard = stampcard + $1 WHERE id = $2 RETURNING stampcard`, pkt.Stamps, s.CharID).Scan(&stamps)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.QueryRow(`UPDATE characters SET stampcard = stampcard + $1 WHERE id = $2 RETURNING stampcard`, pkt.Stamps, s.CharID).Scan(&stamps)
 	bf.WriteUint16(stamps - pkt.Stamps)
 	bf.WriteUint16(stamps)
 
@@ -1113,16 +1088,16 @@ func handleMsgMhfStampcardStamp(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfStampcardPrize(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfStampcardPrize(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfUnreserveSrg(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUnreserveSrg(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUnreserveSrg)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfKickExportForce(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfKickExportForce(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfGetEarthStatus(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetEarthStatus(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetEarthStatus)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(uint32(gametime.TimeWeekStart().Unix())) // Start
@@ -1143,9 +1118,9 @@ func handleMsgMhfGetEarthStatus(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfRegistSpabiTime(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfRegistSpabiTime(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfGetEarthValue(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetEarthValue(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetEarthValue)
 	type EarthValues struct {
 		Value []uint32
@@ -1182,9 +1157,9 @@ func handleMsgMhfGetEarthValue(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckEarthSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfDebugPostValue(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfDebugPostValue(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfGetRandFromTable(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetRandFromTable(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetRandFromTable)
 	bf := byteframe.NewByteFrame()
 	for i := uint16(0); i < pkt.Results; i++ {
@@ -1193,7 +1168,7 @@ func handleMsgMhfGetRandFromTable(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfGetSenyuDailyCount(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetSenyuDailyCount(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetSenyuDailyCount)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint16(0)
@@ -1251,7 +1226,7 @@ type Seibattle struct {
 	CurResult        []SeibattleCurResult
 }
 
-func handleMsgMhfGetSeibattle(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetSeibattle(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetSeibattle)
 	var data []*byteframe.ByteFrame
 	seibattle := Seibattle{
@@ -1339,16 +1314,16 @@ func handleMsgMhfGetSeibattle(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckEarthSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfPostSeibattle(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPostSeibattle(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPostSeibattle)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfGetDailyMissionMaster(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfGetDailyMissionMaster(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfGetDailyMissionPersonal(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfGetDailyMissionPersonal(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfSetDailyMissionPersonal(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfSetDailyMissionPersonal(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
 func equipSkinHistSize() int {
 	size := 3200
@@ -1361,15 +1336,12 @@ func equipSkinHistSize() int {
 	return size
 }
 
-func handleMsgMhfGetEquipSkinHist(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetEquipSkinHist(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetEquipSkinHist)
 	size := equipSkinHistSize()
 	var data []byte
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT COALESCE(skin_hist::bytea, $2::bytea) FROM characters WHERE id = $1", s.CharID, make([]byte, size)).Scan(&data)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT COALESCE(skin_hist::bytea, $2::bytea) FROM characters WHERE id = $1", s.CharID, make([]byte, size)).Scan(&data)
 	if err != nil {
 		s.Logger.Error("Failed to load skin_hist", zap.Error(err))
 		data = make([]byte, size)
@@ -1377,15 +1349,12 @@ func handleMsgMhfGetEquipSkinHist(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfUpdateEquipSkinHist(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUpdateEquipSkinHist(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateEquipSkinHist)
 	size := equipSkinHistSize()
 	var data []byte
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT COALESCE(skin_hist, $2) FROM characters WHERE id = $1", s.CharID, make([]byte, size)).Scan(&data)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT COALESCE(skin_hist, $2) FROM characters WHERE id = $1", s.CharID, make([]byte, size)).Scan(&data)
 	if err != nil {
 		s.Logger.Error("Failed to get skin_hist", zap.Error(err))
 		s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
@@ -1399,28 +1368,25 @@ func handleMsgMhfUpdateEquipSkinHist(s *Session, p mhfpacket.MHFPacket) {
 	bitInByte := bit % 8
 	data[startByte+byteInd] |= bits.Reverse8(1 << uint(bitInByte))
 	dumpSaveData(s, data, "skinhist")
-	database.Exec("UPDATE characters SET skin_hist=$1 WHERE id=$2", data, s.CharID)
+	db.Exec("UPDATE characters SET skin_hist=$1 WHERE id=$2", data, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfGetUdShopCoin(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdShopCoin(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdShopCoin)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(0)
 	s.DoAckSimpleSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfUseUdShopCoin(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfUseUdShopCoin(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfGetEnhancedMinidata(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetEnhancedMinidata(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetEnhancedMinidata)
 	// this looks to be the detailed chunk of information you can pull up on players in town
 	var data []byte
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT minidata FROM characters WHERE id = $1", pkt.CharID).Scan(&data)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT minidata FROM characters WHERE id = $1", pkt.CharID).Scan(&data)
 	if err != nil {
 		s.Logger.Error("Failed to load minidata")
 		data = make([]byte, 1)
@@ -1428,21 +1394,18 @@ func handleMsgMhfGetEnhancedMinidata(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfSetEnhancedMinidata(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSetEnhancedMinidata(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSetEnhancedMinidata)
 	dumpSaveData(s, pkt.RawDataPayload, "minidata")
-	database, err := db.GetDB()
+
-	if err != nil {
+	_, err := db.Exec("UPDATE characters SET minidata=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	_, err = database.Exec("UPDATE characters SET minidata=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
 	if err != nil {
 		s.Logger.Error("Failed to save minidata", zap.Error(err))
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfGetLobbyCrowd(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetLobbyCrowd(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	// this requests a specific server's population but seems to have been
 	// broken at some point on live as every example response across multiple
 	// servers sends back the exact same information?
@@ -1457,15 +1420,12 @@ type TrendWeapon struct {
 	WeaponID   uint16
 }
 
-func handleMsgMhfGetTrendWeapon(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetTrendWeapon(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetTrendWeapon)
 	trendWeapons := [14][3]TrendWeapon{}
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	for i := uint8(0); i < 14; i++ {
-		rows, err := database.Query(`SELECT weapon_id FROM trend_weapons WHERE weapon_type=$1 ORDER BY count DESC LIMIT 3`, i)
+		rows, err := db.Query(`SELECT weapon_id FROM trend_weapons WHERE weapon_type=$1 ORDER BY count DESC LIMIT 3`, i)
 		if err != nil {
 			continue
 		}
@@ -1492,13 +1452,10 @@ func handleMsgMhfGetTrendWeapon(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfUpdateUseTrendWeaponLog(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUpdateUseTrendWeaponLog(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateUseTrendWeaponLog)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec(`INSERT INTO trend_weapons (weapon_id, weapon_type, count) VALUES ($1, $2, 1) ON CONFLICT (weapon_id) DO
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec(`INSERT INTO trend_weapons (weapon_id, weapon_type, count) VALUES ($1, $2, 1) ON CONFLICT (weapon_id) DO
 		UPDATE SET count = trend_weapons.count+1`, pkt.WeaponID, pkt.WeaponType)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }

server/channelserver/handlers_achievement.go

@@ -3,9 +3,10 @@ package channelserver
 import (
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
-	"erupe-ce/utils/db"
 	"fmt"
 	"io"
+
+	"github.com/jmoiron/sqlx"
 )
 
 var achievementCurves = [][]int32{
@@ -85,21 +86,18 @@ func GetAchData(id uint8, score int32) Achievement {
 	return ach
 }
 
-func handleMsgMhfGetAchievement(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetAchievement(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetAchievement)
 
 	var exists int
-	database, err := db.GetDB()
+
+	err := db.QueryRow("SELECT id FROM achievements WHERE id=$1", pkt.CharID).Scan(&exists)
 	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
+		db.Exec("INSERT INTO achievements (id) VALUES ($1)", pkt.CharID)
-	}
-	err = database.QueryRow("SELECT id FROM achievements WHERE id=$1", pkt.CharID).Scan(&exists)
-	if err != nil {
-		database.Exec("INSERT INTO achievements (id) VALUES ($1)", pkt.CharID)
 	}
 
 	var scores [33]int32
-	err = database.QueryRow("SELECT * FROM achievements WHERE id=$1", pkt.CharID).Scan(&scores[0],
+	err = db.QueryRow("SELECT * FROM achievements WHERE id=$1", pkt.CharID).Scan(&scores[0],
 		&scores[0], &scores[1], &scores[2], &scores[3], &scores[4], &scores[5], &scores[6], &scores[7], &scores[8],
 		&scores[9], &scores[10], &scores[11], &scores[12], &scores[13], &scores[14], &scores[15], &scores[16],
 		&scores[17], &scores[18], &scores[19], &scores[20], &scores[21], &scores[22], &scores[23], &scores[24],
@@ -144,34 +142,31 @@ func handleMsgMhfGetAchievement(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfSetCaAchievementHist(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSetCaAchievementHist(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSetCaAchievementHist)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfResetAchievement(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfResetAchievement(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfAddAchievement(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAddAchievement(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAddAchievement)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var exists int
-	err = database.QueryRow("SELECT id FROM achievements WHERE id=$1", s.CharID).Scan(&exists)
+	err := db.QueryRow("SELECT id FROM achievements WHERE id=$1", s.CharID).Scan(&exists)
 	if err != nil {
-		database.Exec("INSERT INTO achievements (id) VALUES ($1)", s.CharID)
+		db.Exec("INSERT INTO achievements (id) VALUES ($1)", s.CharID)
 	}
 
-	database.Exec(fmt.Sprintf("UPDATE achievements SET ach%d=ach%d+1 WHERE id=$1", pkt.AchievementID, pkt.AchievementID), s.CharID)
+	db.Exec(fmt.Sprintf("UPDATE achievements SET ach%d=ach%d+1 WHERE id=$1", pkt.AchievementID, pkt.AchievementID), s.CharID)
 }
 
-func handleMsgMhfPaymentAchievement(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfPaymentAchievement(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfDisplayedAchievement(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfDisplayedAchievement(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	// This is how you would figure out if the rank-up notification needs to occur
 }
 
-func handleMsgMhfGetCaAchievementHist(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfGetCaAchievementHist(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfSetCaAchievement(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfSetCaAchievement(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_bbs.go

@@ -6,12 +6,14 @@ import (
 	"erupe-ce/utils/byteframe"
 	"erupe-ce/utils/stringsupport"
 	"erupe-ce/utils/token"
+
+	"github.com/jmoiron/sqlx"
 )
 
 // Handler BBS handles all the interactions with the for the screenshot sending to bulitin board functionality. For it to work it requires the API to be hosted somehwere. This implementation supports discord.
 
 // Checks the status of the user to see if they can use Bulitin Board yet
-func handleMsgMhfGetBbsUserStatus(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetBbsUserStatus(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	//Post Screenshot pauses till this succeedes
 	pkt := p.(*mhfpacket.MsgMhfGetBbsUserStatus)
 	bf := byteframe.NewByteFrame()
@@ -23,7 +25,7 @@ func handleMsgMhfGetBbsUserStatus(s *Session, p mhfpacket.MHFPacket) {
 }
 
 // Checks the status of Bultin Board Server to see if authenticated
-func handleMsgMhfGetBbsSnsStatus(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetBbsSnsStatus(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetBbsSnsStatus)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(200) //200 Success //4XX Authentication has expired Please re-authenticate //5XX
@@ -34,7 +36,7 @@ func handleMsgMhfGetBbsSnsStatus(s *Session, p mhfpacket.MHFPacket) {
 }
 
 // Tells the game client what host port and gives the bultin board article a token
-func handleMsgMhfApplyBbsArticle(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfApplyBbsArticle(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfApplyBbsArticle)
 	bf := byteframe.NewByteFrame()
 	articleToken := token.Generate(40)

server/channelserver/handlers_cafe.go

@@ -13,17 +13,14 @@ import (
 	"io"
 	"time"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
-func handleMsgMhfAcquireCafeItem(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAcquireCafeItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireCafeItem)
 	var netcafePoints uint32
-	database, err := db.GetDB()
+	err := db.QueryRow("UPDATE characters SET netcafe_points = netcafe_points - $1 WHERE id = $2 RETURNING netcafe_points", pkt.PointCost, s.CharID).Scan(&netcafePoints)
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("UPDATE characters SET netcafe_points = netcafe_points - $1 WHERE id = $2 RETURNING netcafe_points", pkt.PointCost, s.CharID).Scan(&netcafePoints)
 	if err != nil {
 		s.Logger.Error("Failed to get netcafe points from db", zap.Error(err))
 	}
@@ -32,14 +29,11 @@ func handleMsgMhfAcquireCafeItem(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfUpdateCafepoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUpdateCafepoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateCafepoint)
 	var netcafePoints uint32
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT COALESCE(netcafe_points, 0) FROM characters WHERE id = $1", s.CharID).Scan(&netcafePoints)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT COALESCE(netcafe_points, 0) FROM characters WHERE id = $1", s.CharID).Scan(&netcafePoints)
 	if err != nil {
 		s.Logger.Error("Failed to get netcate points from db", zap.Error(err))
 	}
@@ -48,7 +42,7 @@ func handleMsgMhfUpdateCafepoint(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfCheckDailyCafepoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfCheckDailyCafepoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfCheckDailyCafepoint)
 
 	midday := gametime.TimeMidnight().Add(12 * time.Hour)
@@ -58,11 +52,8 @@ func handleMsgMhfCheckDailyCafepoint(s *Session, p mhfpacket.MHFPacket) {
 
 	// get time after which daily claiming would be valid from db
 	var dailyTime time.Time
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT COALESCE(daily_time, $2) FROM characters WHERE id = $1", s.CharID, time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)).Scan(&dailyTime)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT COALESCE(daily_time, $2) FROM characters WHERE id = $1", s.CharID, time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)).Scan(&dailyTime)
 	if err != nil {
 		s.Logger.Error("Failed to get daily_time savedata from db", zap.Error(err))
 	}
@@ -74,7 +65,7 @@ func handleMsgMhfCheckDailyCafepoint(s *Session, p mhfpacket.MHFPacket) {
 		bondBonus = 5 // Bond point bonus quests
 		bonusQuests = config.GetConfig().GameplayOptions.BonusQuestAllowance
 		dailyQuests = config.GetConfig().GameplayOptions.DailyQuestAllowance
-		database.Exec("UPDATE characters SET daily_time=$1, bonus_quests = $2, daily_quests = $3 WHERE id=$4", midday, bonusQuests, dailyQuests, s.CharID)
+		db.Exec("UPDATE characters SET daily_time=$1, bonus_quests = $2, daily_quests = $3 WHERE id=$4", midday, bonusQuests, dailyQuests, s.CharID)
 		bf.WriteBool(true) // Success?
 	} else {
 		bf.WriteBool(false)
@@ -85,27 +76,24 @@ func handleMsgMhfCheckDailyCafepoint(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfGetCafeDuration(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetCafeDuration(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetCafeDuration)
 	bf := byteframe.NewByteFrame()
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var cafeReset time.Time
-	err = database.QueryRow(`SELECT cafe_reset FROM characters WHERE id=$1`, s.CharID).Scan(&cafeReset)
+	err := db.QueryRow(`SELECT cafe_reset FROM characters WHERE id=$1`, s.CharID).Scan(&cafeReset)
 	if err != nil {
 		cafeReset = gametime.TimeWeekNext()
-		database.Exec(`UPDATE characters SET cafe_reset=$1 WHERE id=$2`, cafeReset, s.CharID)
+		db.Exec(`UPDATE characters SET cafe_reset=$1 WHERE id=$2`, cafeReset, s.CharID)
 	}
 	if gametime.TimeAdjusted().After(cafeReset) {
 		cafeReset = gametime.TimeWeekNext()
-		database.Exec(`UPDATE characters SET cafe_time=0, cafe_reset=$1 WHERE id=$2`, cafeReset, s.CharID)
+		db.Exec(`UPDATE characters SET cafe_time=0, cafe_reset=$1 WHERE id=$2`, cafeReset, s.CharID)
-		database.Exec(`DELETE FROM cafe_accepted WHERE character_id=$1`, s.CharID)
+		db.Exec(`DELETE FROM cafe_accepted WHERE character_id=$1`, s.CharID)
 	}
 
 	var cafeTime uint32
-	err = database.QueryRow("SELECT cafe_time FROM characters WHERE id = $1", s.CharID).Scan(&cafeTime)
+	err = db.QueryRow("SELECT cafe_time FROM characters WHERE id = $1", s.CharID).Scan(&cafeTime)
 	if err != nil {
 		panic(err)
 	}
@@ -129,15 +117,12 @@ type CafeBonus struct {
 	Claimed  bool   `db:"claimed"`
 }
 
-func handleMsgMhfGetCafeDurationBonusInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetCafeDurationBonusInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetCafeDurationBonusInfo)
 	bf := byteframe.NewByteFrame()
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var count uint32
-	rows, err := database.Queryx(`
+	rows, err := db.Queryx(`
 	SELECT cb.id, time_req, item_type, item_id, quantity,
 	(
 		SELECT count(*)
@@ -171,16 +156,13 @@ func handleMsgMhfGetCafeDurationBonusInfo(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgMhfReceiveCafeDurationBonus(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfReceiveCafeDurationBonus(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReceiveCafeDurationBonus)
 	bf := byteframe.NewByteFrame()
 	var count uint32
 	bf.WriteUint32(0)
-	database, err := db.GetDB()
+
-	if err != nil {
+	rows, err := db.Queryx(`
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	rows, err := database.Queryx(`
 	SELECT c.id, time_req, item_type, item_id, quantity
 	FROM cafebonus c
 	WHERE (
@@ -213,15 +195,12 @@ func handleMsgMhfReceiveCafeDurationBonus(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgMhfPostCafeDurationBonusReceived(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPostCafeDurationBonusReceived(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPostCafeDurationBonusReceived)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var cafeBonus CafeBonus
 	for _, cbID := range pkt.CafeBonusID {
-		err := database.QueryRow(`
+		err := db.QueryRow(`
 		SELECT cb.id, item_type, quantity FROM cafebonus cb WHERE cb.id=$1
 		`, cbID).Scan(&cafeBonus.ID, &cafeBonus.ItemType, &cafeBonus.Quantity)
 		if err == nil {
@@ -229,18 +208,19 @@ func handleMsgMhfPostCafeDurationBonusReceived(s *Session, p mhfpacket.MHFPacket
 				addPointNetcafe(s, int(cafeBonus.Quantity))
 			}
 		}
-		database.Exec("INSERT INTO public.cafe_accepted VALUES ($1, $2)", cbID, s.CharID)
+		db.Exec("INSERT INTO public.cafe_accepted VALUES ($1, $2)", cbID, s.CharID)
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
 func addPointNetcafe(s *Session, p int) error {
-	var points int
+	db, err := db.GetDB()
-	database, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	err = database.QueryRow("SELECT netcafe_points FROM characters WHERE id = $1", s.CharID).Scan(&points)
+	var points int
+
+	err = db.QueryRow("SELECT netcafe_points FROM characters WHERE id = $1", s.CharID).Scan(&points)
 	if err != nil {
 		return err
 	}
@@ -249,42 +229,36 @@ func addPointNetcafe(s *Session, p int) error {
 	} else {
 		points += p
 	}
-	database.Exec("UPDATE characters SET netcafe_points=$1 WHERE id=$2", points, s.CharID)
+	db.Exec("UPDATE characters SET netcafe_points=$1 WHERE id=$2", points, s.CharID)
 	return nil
 }
 
-func handleMsgMhfStartBoostTime(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfStartBoostTime(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfStartBoostTime)
 	bf := byteframe.NewByteFrame()
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	boostLimit := gametime.TimeAdjusted().Add(time.Duration(config.GetConfig().GameplayOptions.BoostTimeDuration) * time.Second)
 	if config.GetConfig().GameplayOptions.DisableBoostTime {
 		bf.WriteUint32(0)
 		s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 		return
 	}
-	database.Exec("UPDATE characters SET boost_time=$1 WHERE id=$2", boostLimit, s.CharID)
+	db.Exec("UPDATE characters SET boost_time=$1 WHERE id=$2", boostLimit, s.CharID)
 	bf.WriteUint32(uint32(boostLimit.Unix()))
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfGetBoostTime(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetBoostTime(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetBoostTime)
 	s.DoAckBufSucceed(pkt.AckHandle, []byte{})
 }
 
-func handleMsgMhfGetBoostTimeLimit(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetBoostTimeLimit(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetBoostTimeLimit)
 	bf := byteframe.NewByteFrame()
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var boostLimit time.Time
-	err = database.QueryRow("SELECT boost_time FROM characters WHERE id=$1", s.CharID).Scan(&boostLimit)
+	err := db.QueryRow("SELECT boost_time FROM characters WHERE id=$1", s.CharID).Scan(&boostLimit)
 	if err != nil {
 		bf.WriteUint32(0)
 	} else {
@@ -294,14 +268,11 @@ func handleMsgMhfGetBoostTimeLimit(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfGetBoostRight(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetBoostRight(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetBoostRight)
 	var boostLimit time.Time
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT boost_time FROM characters WHERE id=$1", s.CharID).Scan(&boostLimit)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT boost_time FROM characters WHERE id=$1", s.CharID).Scan(&boostLimit)
 	if err != nil {
 		s.DoAckBufSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 		return
@@ -313,17 +284,17 @@ func handleMsgMhfGetBoostRight(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgMhfPostBoostTimeQuestReturn(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPostBoostTimeQuestReturn(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPostBoostTimeQuestReturn)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfPostBoostTime(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPostBoostTime(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPostBoostTime)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfPostBoostTimeLimit(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPostBoostTimeLimit(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPostBoostTimeLimit)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }

server/channelserver/handlers_campaign.go

@@ -7,6 +7,8 @@ import (
 	ps "erupe-ce/utils/pascalstring"
 	"erupe-ce/utils/stringsupport"
 	"time"
+
+	"github.com/jmoiron/sqlx"
 )
 
 type CampaignEvent struct {
@@ -47,7 +49,7 @@ type CampaignLink struct {
 	CampaignID uint32
 }
 
-func handleMsgMhfEnumerateCampaign(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateCampaign(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateCampaign)
 	bf := byteframe.NewByteFrame()
 
@@ -132,7 +134,7 @@ func handleMsgMhfEnumerateCampaign(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfStateCampaign(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfStateCampaign(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfStateCampaign)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint16(1)
@@ -140,14 +142,14 @@ func handleMsgMhfStateCampaign(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfApplyCampaign(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfApplyCampaign(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfApplyCampaign)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(1)
 	s.DoAckSimpleSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfEnumerateItem(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateItem)
 	items := []struct {
 		Unk0 uint32
@@ -170,7 +172,7 @@ func handleMsgMhfEnumerateItem(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfAcquireItem(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAcquireItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireItem)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }

server/channelserver/handlers_caravan.go

@@ -5,6 +5,8 @@ import (
 	"erupe-ce/utils/byteframe"
 	"erupe-ce/utils/stringsupport"
 	"time"
+
+	"github.com/jmoiron/sqlx"
 )
 
 type RyoudamaReward struct {
@@ -40,7 +42,7 @@ type Ryoudama struct {
 	Score     []int32
 }
 
-func handleMsgMhfGetRyoudama(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetRyoudama(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetRyoudama)
 	var data []*byteframe.ByteFrame
 	ryoudama := Ryoudama{Score: []int32{0}}
@@ -70,20 +72,20 @@ func handleMsgMhfGetRyoudama(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckEarthSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfPostRyoudama(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfPostRyoudama(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfGetTinyBin(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetTinyBin(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetTinyBin)
 	// requested after conquest quests
 	s.DoAckBufSucceed(pkt.AckHandle, []byte{})
 }
 
-func handleMsgMhfPostTinyBin(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPostTinyBin(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPostTinyBin)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfCaravanMyScore(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfCaravanMyScore(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfCaravanMyScore)
 	var data []*byteframe.ByteFrame
 	/*
@@ -95,7 +97,7 @@ func handleMsgMhfCaravanMyScore(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckEarthSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfCaravanRanking(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfCaravanRanking(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfCaravanRanking)
 	var data []*byteframe.ByteFrame
 	/* RYOUDAN
@@ -111,7 +113,7 @@ func handleMsgMhfCaravanRanking(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckEarthSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfCaravanMyRank(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfCaravanMyRank(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfCaravanMyRank)
 	var data []*byteframe.ByteFrame
 	/*

server/channelserver/handlers_cast_binary.go

@@ -5,7 +5,6 @@ import (
 	"erupe-ce/network/binpacket"
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
-	"erupe-ce/utils/db"
 	"erupe-ce/utils/logger"
 	"erupe-ce/utils/token"
 	"sync"
@@ -14,6 +13,7 @@ import (
 	"math"
 	"strings"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
@@ -79,17 +79,14 @@ func sendServerChatMessage(s *Session, message string) {
 	s.QueueSendMHF(castedBin)
 }
 
-func handleMsgSysCastBinary(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysCastBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysCastBinary)
 	tmp := byteframe.NewByteFrameFromBytes(pkt.RawDataPayload)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if pkt.BroadcastType == 0x03 && pkt.MessageType == 0x03 && len(pkt.RawDataPayload) == 0x10 {
 		if tmp.ReadUint16() == 0x0002 && tmp.ReadUint8() == 0x18 {
 			var timer bool
-			database.QueryRow(`SELECT COALESCE(timer, false) FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&timer)
+			db.QueryRow(`SELECT COALESCE(timer, false) FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&timer)
 			if timer {
 				_ = tmp.ReadBytes(9)
 				tmp.SetLE()
@@ -159,7 +156,7 @@ func handleMsgSysCastBinary(s *Session, p mhfpacket.MHFPacket) {
 			chatMessage := &binpacket.MsgBinChat{}
 			chatMessage.Parse(bf)
 			if strings.HasPrefix(chatMessage.Message, config.GetConfig().CommandPrefix) {
-				err = executeCommand(s, chatMessage.Message)
+				err := executeCommand(s, chatMessage.Message)
 				if err != nil {
 					s.Logger.Error(fmt.Sprintf("Failed to execute command: %s", err))
 				}
@@ -216,4 +213,4 @@ func handleMsgSysCastBinary(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgSysCastedBinary(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysCastedBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_character.go

@@ -12,6 +12,7 @@ import (
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/server/channelserver/compression/nullcomp"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
@@ -121,11 +122,11 @@ func getPointers() map[SavePointer]int {
 }
 
 func GetCharacterSaveData(s *Session, charID uint32) (*CharacterSaveData, error) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	result, err := database.Query("SELECT id, savedata, is_new_character, name FROM characters WHERE id = $1", charID)
+	result, err := db.Query("SELECT id, savedata, is_new_character, name FROM characters WHERE id = $1", charID)
 	if err != nil {
 		s.Logger.Error("Failed to get savedata", zap.Error(err), zap.Uint32("charID", charID))
 		return nil, err
@@ -162,7 +163,7 @@ func GetCharacterSaveData(s *Session, charID uint32) (*CharacterSaveData, error)
 }
 
 func (save *CharacterSaveData) Save(s *Session) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
@@ -185,13 +186,13 @@ func (save *CharacterSaveData) Save(s *Session) {
 		save.compSave = save.decompSave
 	}
 
-	_, err = database.Exec(`UPDATE characters SET savedata=$1, is_new_character=false, hr=$2, gr=$3, is_female=$4, weapon_type=$5, weapon_id=$6 WHERE id=$7
+	_, err = db.Exec(`UPDATE characters SET savedata=$1, is_new_character=false, hr=$2, gr=$3, is_female=$4, weapon_type=$5, weapon_id=$6 WHERE id=$7
 	`, save.compSave, save.HR, save.GR, save.Gender, save.WeaponType, save.WeaponID, save.CharID)
 	if err != nil {
 		s.Logger.Error("Failed to update savedata", zap.Error(err), zap.Uint32("charID", save.CharID))
 	}
 
-	database.Exec(`UPDATE user_binary SET house_tier=$1, house_data=$2, bookshelf=$3, gallery=$4, tore=$5, garden=$6 WHERE id=$7
+	db.Exec(`UPDATE user_binary SET house_tier=$1, house_data=$2, bookshelf=$3, gallery=$4, tore=$5, garden=$6 WHERE id=$7
 	`, save.HouseTier, save.HouseData, save.BookshelfData, save.GalleryData, save.ToreData, save.GardenData, s.CharID)
 }
 
@@ -258,7 +259,7 @@ func (save *CharacterSaveData) updateStructWithSaveData() {
 	return
 }
 
-func handleMsgMhfSexChanger(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSexChanger(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSexChanger)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }

server/channelserver/handlers_clients.go

@@ -3,14 +3,13 @@ package channelserver
 import (
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
-	"erupe-ce/utils/db"
 	"erupe-ce/utils/stringsupport"
-	"fmt"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
-func handleMsgSysEnumerateClient(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysEnumerateClient(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysEnumerateClient)
 
 	s.Server.stagesLock.RLock()
@@ -58,22 +57,19 @@ func handleMsgSysEnumerateClient(s *Session, p mhfpacket.MHFPacket) {
 	s.Logger.Debug("MsgSysEnumerateClient Done!")
 }
 
-func handleMsgMhfListMember(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfListMember(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfListMember)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var csv string
 	var count uint32
 	resp := byteframe.NewByteFrame()
 	resp.WriteUint32(0) // Blacklist count
-	err = database.QueryRow("SELECT blocked FROM characters WHERE id=$1", s.CharID).Scan(&csv)
+	err := db.QueryRow("SELECT blocked FROM characters WHERE id=$1", s.CharID).Scan(&csv)
 	if err == nil {
 		cids := stringsupport.CSVElems(csv)
 		for _, cid := range cids {
 			var name string
-			err = database.QueryRow("SELECT name FROM characters WHERE id=$1", cid).Scan(&name)
+			err = db.QueryRow("SELECT name FROM characters WHERE id=$1", cid).Scan(&name)
 			if err != nil {
 				continue
 			}
@@ -88,39 +84,36 @@ func handleMsgMhfListMember(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfOprMember(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfOprMember(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfOprMember)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var csv string
 	for _, cid := range pkt.CharIDs {
 		if pkt.Blacklist {
-			err := database.QueryRow("SELECT blocked FROM characters WHERE id=$1", s.CharID).Scan(&csv)
+			err := db.QueryRow("SELECT blocked FROM characters WHERE id=$1", s.CharID).Scan(&csv)
 			if err == nil {
 				if pkt.Operation {
 					csv = stringsupport.CSVRemove(csv, int(cid))
 				} else {
 					csv = stringsupport.CSVAdd(csv, int(cid))
 				}
-				database.Exec("UPDATE characters SET blocked=$1 WHERE id=$2", csv, s.CharID)
+				db.Exec("UPDATE characters SET blocked=$1 WHERE id=$2", csv, s.CharID)
 			}
 		} else { // Friendlist
-			err := database.QueryRow("SELECT friends FROM characters WHERE id=$1", s.CharID).Scan(&csv)
+			err := db.QueryRow("SELECT friends FROM characters WHERE id=$1", s.CharID).Scan(&csv)
 			if err == nil {
 				if pkt.Operation {
 					csv = stringsupport.CSVRemove(csv, int(cid))
 				} else {
 					csv = stringsupport.CSVAdd(csv, int(cid))
 				}
-				database.Exec("UPDATE characters SET friends=$1 WHERE id=$2", csv, s.CharID)
+				db.Exec("UPDATE characters SET friends=$1 WHERE id=$2", csv, s.CharID)
 			}
 		}
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfShutClient(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfShutClient(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysHideClient(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysHideClient(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_data.go

@@ -2,7 +2,6 @@ package channelserver
 
 import (
 	"erupe-ce/config"
-	"erupe-ce/utils/db"
 	"erupe-ce/utils/gametime"
 	"erupe-ce/utils/mhfmon"
 	"erupe-ce/utils/stringsupport"
@@ -17,15 +16,13 @@ import (
 	"erupe-ce/server/channelserver/compression/nullcomp"
 	"erupe-ce/utils/byteframe"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
-func handleMsgMhfSavedata(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSavedata(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSavedata)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	characterSaveData, err := GetCharacterSaveData(s, s.CharID)
 	if err != nil {
 		s.Logger.Error("failed to retrieve character save data from db", zap.Error(err), zap.Uint32("charID", s.CharID))
@@ -73,11 +70,11 @@ func handleMsgMhfSavedata(s *Session, p mhfpacket.MHFPacket) {
 		s.rawConn.Close()
 		s.Logger.Warn("Save cancelled due to corruption.")
 		if config.GetConfig().DeleteOnSaveCorruption {
-			database.Exec("UPDATE characters SET deleted=true WHERE id=$1", s.CharID)
+			db.Exec("UPDATE characters SET deleted=true WHERE id=$1", s.CharID)
 		}
 		return
 	}
-	_, err = database.Exec("UPDATE characters SET name=$1 WHERE id=$2", characterSaveData.Name, s.CharID)
+	_, err = db.Exec("UPDATE characters SET name=$1 WHERE id=$2", characterSaveData.Name, s.CharID)
 	if err != nil {
 		s.Logger.Error("Failed to update character name in db", zap.Error(err))
 	}
@@ -145,12 +142,9 @@ func dumpSaveData(s *Session, data []byte, suffix string) {
 	}
 }
 
-func handleMsgMhfLoaddata(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoaddata(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoaddata)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if _, err := os.Stat(filepath.Join(config.GetConfig().BinPath, "save_override.bin")); err == nil {
 		data, _ := os.ReadFile(filepath.Join(config.GetConfig().BinPath, "save_override.bin"))
 		s.DoAckBufSucceed(pkt.AckHandle, data)
@@ -158,7 +152,7 @@ func handleMsgMhfLoaddata(s *Session, p mhfpacket.MHFPacket) {
 	}
 
 	var data []byte
-	err = database.QueryRow("SELECT savedata FROM characters WHERE id = $1", s.CharID).Scan(&data)
+	err := db.QueryRow("SELECT savedata FROM characters WHERE id = $1", s.CharID).Scan(&data)
 	if err != nil || len(data) == 0 {
 		s.Logger.Warn(fmt.Sprintf("Failed to load savedata (CID: %d)", s.CharID), zap.Error(err))
 		s.rawConn.Close() // Terminate the connection
@@ -179,29 +173,23 @@ func handleMsgMhfLoaddata(s *Session, p mhfpacket.MHFPacket) {
 	s.Name = stringsupport.SJISToUTF8(name)
 }
 
-func handleMsgMhfSaveScenarioData(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSaveScenarioData(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSaveScenarioData)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	dumpSaveData(s, pkt.RawDataPayload, "scenario")
-	_, err = database.Exec("UPDATE characters SET scenariodata = $1 WHERE id = $2", pkt.RawDataPayload, s.CharID)
+	_, err := db.Exec("UPDATE characters SET scenariodata = $1 WHERE id = $2", pkt.RawDataPayload, s.CharID)
 	if err != nil {
 		s.Logger.Error("Failed to update scenario data in db", zap.Error(err))
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfLoadScenarioData(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadScenarioData(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadScenarioData)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var scenarioData []byte
 	bf := byteframe.NewByteFrame()
-	err = database.QueryRow("SELECT scenariodata FROM characters WHERE id = $1", s.CharID).Scan(&scenarioData)
+	err := db.QueryRow("SELECT scenariodata FROM characters WHERE id = $1", s.CharID).Scan(&scenarioData)
 	if err != nil || len(scenarioData) < 10 {
 		s.Logger.Error("Failed to load scenariodata", zap.Error(err))
 		bf.WriteBytes(make([]byte, 10))
@@ -1012,7 +1000,7 @@ type PaperGift struct {
 	Unk3 uint16
 }
 
-func handleMsgMhfGetPaperData(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetPaperData(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetPaperData)
 	var data []*byteframe.ByteFrame
 
@@ -1580,4 +1568,4 @@ func handleMsgMhfGetPaperData(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgSysAuthData(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysAuthData(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_distitem.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
@@ -29,16 +30,13 @@ type Distribution struct {
 	Selection       bool      `db:"selection"`
 }
 
-func handleMsgMhfEnumerateDistItem(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateDistItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateDistItem)
 
 	var itemDists []Distribution
 	bf := byteframe.NewByteFrame()
-	database, err := db.GetDB()
+
-	if err != nil {
+	rows, err := db.Queryx(`
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	rows, err := database.Queryx(`
 		SELECT d.id, event_name, description, COALESCE(rights, 0) AS rights, COALESCE(selection, false) AS selection, times_acceptable,
 		COALESCE(min_hr, -1) AS min_hr, COALESCE(max_hr, -1) AS max_hr,
 		COALESCE(min_sr, -1) AS min_sr, COALESCE(max_sr, -1) AS max_sr,
@@ -133,12 +131,12 @@ type DistributionItem struct {
 }
 
 func getDistributionItems(s *Session, i uint32) []DistributionItem {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
 	var distItems []DistributionItem
-	rows, err := database.Queryx(`SELECT id, item_type, COALESCE(item_id, 0) AS item_id, COALESCE(quantity, 0) AS quantity FROM distribution_items WHERE distribution_id=$1`, i)
+	rows, err := db.Queryx(`SELECT id, item_type, COALESCE(item_id, 0) AS item_id, COALESCE(quantity, 0) AS quantity FROM distribution_items WHERE distribution_id=$1`, i)
 	if err == nil {
 		var distItem DistributionItem
 		for rows.Next() {
@@ -152,7 +150,7 @@ func getDistributionItems(s *Session, i uint32) []DistributionItem {
 	return distItems
 }
 
-func handleMsgMhfApplyDistItem(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfApplyDistItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfApplyDistItem)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(pkt.DistributionID)
@@ -169,14 +167,11 @@ func handleMsgMhfApplyDistItem(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfAcquireDistItem(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAcquireDistItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireDistItem)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if pkt.DistributionID > 0 {
-		_, err := database.Exec(`INSERT INTO public.distributions_accepted VALUES ($1, $2)`, pkt.DistributionID, s.CharID)
+		_, err := db.Exec(`INSERT INTO public.distributions_accepted VALUES ($1, $2)`, pkt.DistributionID, s.CharID)
 		if err == nil {
 			distItems := getDistributionItems(s, pkt.DistributionID)
 			for _, item := range distItems {
@@ -184,11 +179,11 @@ func handleMsgMhfAcquireDistItem(s *Session, p mhfpacket.MHFPacket) {
 				case 17:
 					_ = addPointNetcafe(s, int(item.Quantity))
 				case 19:
-					database.Exec("UPDATE users u SET gacha_premium=gacha_premium+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", item.Quantity, s.CharID)
+					db.Exec("UPDATE users u SET gacha_premium=gacha_premium+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", item.Quantity, s.CharID)
 				case 20:
-					database.Exec("UPDATE users u SET gacha_trial=gacha_trial+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", item.Quantity, s.CharID)
+					db.Exec("UPDATE users u SET gacha_trial=gacha_trial+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", item.Quantity, s.CharID)
 				case 21:
-					database.Exec("UPDATE users u SET frontier_points=frontier_points+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", item.Quantity, s.CharID)
+					db.Exec("UPDATE users u SET frontier_points=frontier_points+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", item.Quantity, s.CharID)
 				case 23:
 					saveData, err := GetCharacterSaveData(s, s.CharID)
 					if err == nil {
@@ -202,14 +197,11 @@ func handleMsgMhfAcquireDistItem(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfGetDistDescription(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetDistDescription(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetDistDescription)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var desc string
-	err = database.QueryRow("SELECT description FROM distribution WHERE id = $1", pkt.DistributionID).Scan(&desc)
+	err := db.QueryRow("SELECT description FROM distribution WHERE id = $1", pkt.DistributionID).Scan(&desc)
 	if err != nil {
 		s.Logger.Error("Error parsing item distribution description", zap.Error(err))
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 4))

server/channelserver/handlers_diva.go

@@ -11,18 +11,20 @@ import (
 
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
+
+	"github.com/jmoiron/sqlx"
 )
 
 func cleanupDiva(s *Session) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	database.Exec("DELETE FROM events WHERE event_type='diva'")
+	db.Exec("DELETE FROM events WHERE event_type='diva'")
 }
 
 func generateDivaTimestamps(s *Session, start uint32, debug bool) []uint32 {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
@@ -59,7 +61,7 @@ func generateDivaTimestamps(s *Session, start uint32, debug bool) []uint32 {
 		cleanupDiva(s)
 		// Generate a new diva defense, starting midnight tomorrow
 		start = uint32(midnight.Add(24 * time.Hour).Unix())
-		database.Exec("INSERT INTO events (event_type, start_time) VALUES ('diva', to_timestamp($1)::timestamp without time zone)", start)
+		db.Exec("INSERT INTO events (event_type, start_time) VALUES ('diva', to_timestamp($1)::timestamp without time zone)", start)
 	}
 	timestamps[0] = start
 	timestamps[1] = timestamps[0] + 601200
@@ -70,15 +72,11 @@ func generateDivaTimestamps(s *Session, start uint32, debug bool) []uint32 {
 	return timestamps
 }
 
-func handleMsgMhfGetUdSchedule(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdSchedule(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdSchedule)
 	bf := byteframe.NewByteFrame()
-	database, err := db.GetDB()
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	id, start := uint32(0xCAFEBEEF), uint32(0)
-	rows, _ := database.Queryx("SELECT id, (EXTRACT(epoch FROM start_time)::int) as start_time FROM events WHERE event_type='diva'")
+	rows, _ := db.Queryx("SELECT id, (EXTRACT(epoch FROM start_time)::int) as start_time FROM events WHERE event_type='diva'")
 	for rows.Next() {
 		rows.Scan(&id, &start)
 	}
@@ -113,7 +111,7 @@ func handleMsgMhfGetUdSchedule(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfGetUdInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdInfo)
 	// Message that appears on the Diva Defense NPC and triggers the green exclamation mark
 	udInfos := []struct {
@@ -133,45 +131,45 @@ func handleMsgMhfGetUdInfo(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfGetKijuInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetKijuInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetKijuInfo)
 	// Temporary canned response
 	data, _ := hex.DecodeString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
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfSetKiju(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSetKiju(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSetKiju)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfAddUdPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAddUdPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAddUdPoint)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfGetUdMyPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdMyPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdMyPoint)
 	// Temporary canned response
 	data, _ := hex.DecodeString("00040000013C000000FA000000000000000000040000007E0000003C02000000000000000000000000000000000000000000000000000002000004CC00000438000000000000000000000000000000000000000000000000000000020000026E00000230000000000000000000020000007D0000007D000000000000000000000000000000000000000000000000000000")
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfGetUdTotalPointInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdTotalPointInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdTotalPointInfo)
 	// Temporary canned response
 	data, _ := hex.DecodeString("00000000000007A12000000000000F424000000000001E848000000000002DC6C000000000003D090000000000004C4B4000000000005B8D8000000000006ACFC000000000007A1200000000000089544000000000009896800000000000E4E1C00000000001312D0000000000017D78400000000001C9C3800000000002160EC00000000002625A000000000002AEA5400000000002FAF0800000000003473BC0000000000393870000000000042C1D800000000004C4B40000000000055D4A800000000005F5E10000000000008954400000000001C9C3800000000003473BC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001020300000000000000000000000000000000000000000000000000000000000000000000000000000000101F1420")
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfGetUdSelectedColorInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdSelectedColorInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdSelectedColorInfo)
 
 	// Unk
 	s.DoAckBufSucceed(pkt.AckHandle, []byte{0x00, 0x01, 0x01, 0x01, 0x02, 0x03, 0x02, 0x00, 0x00})
 }
 
-func handleMsgMhfGetUdMonsterPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdMonsterPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdMonsterPoint)
 
 	monsterPoints := []struct {
@@ -303,31 +301,31 @@ func handleMsgMhfGetUdMonsterPoint(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfGetUdDailyPresentList(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdDailyPresentList(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdDailyPresentList)
 	// Temporary canned response
 	data, _ := hex.DecodeString("0100001600000A5397DF00000000000000000000000000000000")
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfGetUdNormaPresentList(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdNormaPresentList(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdNormaPresentList)
 	// Temporary canned response
 	data, _ := hex.DecodeString("0100001600000A5397DF00000000000000000000000000000000")
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfAcquireUdItem(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAcquireUdItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireUdItem)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfGetUdRanking(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdRanking(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdRanking)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfGetUdMyRanking(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdMyRanking(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdMyRanking)
 	// Temporary canned response
 	data, _ := hex.DecodeString("00000515000005150000CEB4000003CE000003CE0000CEB44D49444E494748542D414E47454C0000000000000000000000")

server/channelserver/handlers_event.go

@@ -2,15 +2,15 @@ package channelserver
 
 import (
 	"erupe-ce/config"
-	"erupe-ce/utils/db"
 	"erupe-ce/utils/gametime"
 	"erupe-ce/utils/token"
-	"fmt"
 	"math"
 	"time"
 
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
+
+	"github.com/jmoiron/sqlx"
 )
 
 type Event struct {
@@ -24,7 +24,7 @@ type Event struct {
 	QuestFileIDs []uint16
 }
 
-func handleMsgMhfEnumerateEvent(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateEvent(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateEvent)
 	bf := byteframe.NewByteFrame()
 
@@ -55,12 +55,9 @@ type activeFeature struct {
 	ActiveFeatures uint32    `db:"featured"`
 }
 
-func handleMsgMhfGetWeeklySchedule(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetWeeklySchedule(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetWeeklySchedule)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var features []activeFeature
 	times := []time.Time{
 		gametime.TimeMidnight().Add(-24 * time.Hour),
@@ -70,12 +67,12 @@ func handleMsgMhfGetWeeklySchedule(s *Session, p mhfpacket.MHFPacket) {
 
 	for _, t := range times {
 		var temp activeFeature
-		err := database.QueryRowx(`SELECT start_time, featured FROM feature_weapon WHERE start_time=$1`, t).StructScan(&temp)
+		err := db.QueryRowx(`SELECT start_time, featured FROM feature_weapon WHERE start_time=$1`, t).StructScan(&temp)
 		if err != nil || temp.StartTime.IsZero() {
 			weapons := token.RNG.Intn(config.GetConfig().GameplayOptions.MaxFeatureWeapons-config.GetConfig().GameplayOptions.MinFeatureWeapons+1) + config.GetConfig().GameplayOptions.MinFeatureWeapons
 			temp = generateFeatureWeapons(weapons)
 			temp.StartTime = t
-			database.Exec(`INSERT INTO feature_weapon VALUES ($1, $2)`, temp.StartTime, temp.ActiveFeatures)
+			db.Exec(`INSERT INTO feature_weapon VALUES ($1, $2)`, temp.StartTime, temp.ActiveFeatures)
 		}
 		features = append(features, temp)
 	}
@@ -134,16 +131,13 @@ type loginBoost struct {
 	Reset      time.Time `db:"reset"`
 }
 
-func handleMsgMhfGetKeepLoginBoostStatus(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetKeepLoginBoostStatus(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetKeepLoginBoostStatus)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	bf := byteframe.NewByteFrame()
 
 	var loginBoosts []loginBoost
-	rows, err := database.Queryx("SELECT week_req, expiration, reset FROM login_boost WHERE char_id=$1 ORDER BY week_req", s.CharID)
+	rows, err := db.Queryx("SELECT week_req, expiration, reset FROM login_boost WHERE char_id=$1 ORDER BY week_req", s.CharID)
 	if err != nil || config.GetConfig().GameplayOptions.DisableLoginBoost {
 		rows.Close()
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 35))
@@ -164,7 +158,7 @@ func handleMsgMhfGetKeepLoginBoostStatus(s *Session, p mhfpacket.MHFPacket) {
 			{WeekReq: 5, Expiration: temp},
 		}
 		for _, boost := range loginBoosts {
-			database.Exec(`INSERT INTO login_boost VALUES ($1, $2, $3, $4)`, s.CharID, boost.WeekReq, boost.Expiration, time.Time{})
+			db.Exec(`INSERT INTO login_boost VALUES ($1, $2, $3, $4)`, s.CharID, boost.WeekReq, boost.Expiration, time.Time{})
 		}
 	}
 
@@ -173,7 +167,7 @@ func handleMsgMhfGetKeepLoginBoostStatus(s *Session, p mhfpacket.MHFPacket) {
 		if !boost.Reset.IsZero() && boost.Reset.Before(gametime.TimeAdjusted()) {
 			boost.Expiration = gametime.TimeWeekStart()
 			boost.Reset = time.Time{}
-			database.Exec(`UPDATE login_boost SET expiration=$1, reset=$2 WHERE char_id=$3 AND week_req=$4`, boost.Expiration, boost.Reset, s.CharID, boost.WeekReq)
+			db.Exec(`UPDATE login_boost SET expiration=$1, reset=$2 WHERE char_id=$3 AND week_req=$4`, boost.Expiration, boost.Reset, s.CharID, boost.WeekReq)
 		}
 
 		boost.WeekCount = uint8((gametime.TimeAdjusted().Unix()-boost.Expiration.Unix())/604800 + 1)
@@ -202,7 +196,7 @@ func handleMsgMhfGetKeepLoginBoostStatus(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfUseKeepLoginBoost(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUseKeepLoginBoost(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUseKeepLoginBoost)
 	var expiration time.Time
 	bf := byteframe.NewByteFrame()
@@ -216,17 +210,14 @@ func handleMsgMhfUseKeepLoginBoost(s *Session, p mhfpacket.MHFPacket) {
 		expiration = gametime.TimeAdjusted().Add(240 * time.Minute)
 	}
 	bf.WriteUint32(uint32(expiration.Unix()))
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec(`UPDATE login_boost SET expiration=$1, reset=$2 WHERE char_id=$3 AND week_req=$4`, expiration, gametime.TimeWeekNext(), s.CharID, pkt.BoostWeekUsed)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec(`UPDATE login_boost SET expiration=$1, reset=$2 WHERE char_id=$3 AND week_req=$4`, expiration, gametime.TimeWeekNext(), s.CharID, pkt.BoostWeekUsed)
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfGetRestrictionEvent(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfGetRestrictionEvent(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfSetRestrictionEvent(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSetRestrictionEvent(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSetRestrictionEvent)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }

server/channelserver/handlers_festa.go

@@ -11,26 +11,22 @@ import (
 	"fmt"
 	"sort"
 	"time"
+
+	"github.com/jmoiron/sqlx"
 )
 
-func handleMsgMhfSaveMezfesData(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSaveMezfesData(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSaveMezfesData)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec(`UPDATE characters SET mezfes=$1 WHERE id=$2`, pkt.RawDataPayload, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec(`UPDATE characters SET mezfes=$1 WHERE id=$2`, pkt.RawDataPayload, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfLoadMezfesData(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadMezfesData(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadMezfesData)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var data []byte
-	database.QueryRow(`SELECT mezfes FROM characters WHERE id=$1`, s.CharID).Scan(&data)
+	db.QueryRow(`SELECT mezfes FROM characters WHERE id=$1`, s.CharID).Scan(&data)
 	bf := byteframe.NewByteFrame()
 	if len(data) > 0 {
 		bf.WriteBytes(data)
@@ -44,7 +40,7 @@ func handleMsgMhfLoadMezfesData(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfEnumerateRanking(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateRanking(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateRanking)
 	bf := byteframe.NewByteFrame()
 	state := config.GetConfig().DebugOptions.TournamentOverride
@@ -104,19 +100,19 @@ func handleMsgMhfEnumerateRanking(s *Session, p mhfpacket.MHFPacket) {
 }
 
 func cleanupFesta(s *Session) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	database.Exec("DELETE FROM events WHERE event_type='festa'")
+	db.Exec("DELETE FROM events WHERE event_type='festa'")
-	database.Exec("DELETE FROM festa_registrations")
+	db.Exec("DELETE FROM festa_registrations")
-	database.Exec("DELETE FROM festa_submissions")
+	db.Exec("DELETE FROM festa_submissions")
-	database.Exec("DELETE FROM festa_prizes_accepted")
+	db.Exec("DELETE FROM festa_prizes_accepted")
-	database.Exec("UPDATE guild_characters SET trial_vote=NULL")
+	db.Exec("UPDATE guild_characters SET trial_vote=NULL")
 }
 
 func generateFestaTimestamps(s *Session, start uint32, debug bool) []uint32 {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
@@ -150,7 +146,7 @@ func generateFestaTimestamps(s *Session, start uint32, debug bool) []uint32 {
 		cleanupFesta(s)
 		// Generate a new festa, starting midnight tomorrow
 		start = uint32(midnight.Add(24 * time.Hour).Unix())
-		database.Exec("INSERT INTO events (event_type, start_time) VALUES ('festa', to_timestamp($1)::timestamp without time zone)", start)
+		db.Exec("INSERT INTO events (event_type, start_time) VALUES ('festa', to_timestamp($1)::timestamp without time zone)", start)
 	}
 	timestamps[0] = start
 	timestamps[1] = timestamps[0] + 604800
@@ -182,15 +178,12 @@ type FestaReward struct {
 	Unk7     uint8
 }
 
-func handleMsgMhfInfoFesta(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfInfoFesta(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfInfoFesta)
 	bf := byteframe.NewByteFrame()
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	id, start := uint32(0xDEADBEEF), uint32(0)
-	rows, _ := database.Queryx("SELECT id, (EXTRACT(epoch FROM start_time)::int) as start_time FROM events WHERE event_type='festa'")
+	rows, _ := db.Queryx("SELECT id, (EXTRACT(epoch FROM start_time)::int) as start_time FROM events WHERE event_type='festa'")
 	for rows.Next() {
 		rows.Scan(&id, &start)
 	}
@@ -212,8 +205,8 @@ func handleMsgMhfInfoFesta(s *Session, p mhfpacket.MHFPacket) {
 	}
 
 	var blueSouls, redSouls uint32
-	database.QueryRow(`SELECT COALESCE(SUM(fs.souls), 0) AS souls FROM festa_registrations fr LEFT JOIN festa_submissions fs ON fr.guild_id = fs.guild_id AND fr.team = 'blue'`).Scan(&blueSouls)
+	db.QueryRow(`SELECT COALESCE(SUM(fs.souls), 0) AS souls FROM festa_registrations fr LEFT JOIN festa_submissions fs ON fr.guild_id = fs.guild_id AND fr.team = 'blue'`).Scan(&blueSouls)
-	database.QueryRow(`SELECT COALESCE(SUM(fs.souls), 0) AS souls FROM festa_registrations fr LEFT JOIN festa_submissions fs ON fr.guild_id = fs.guild_id AND fr.team = 'red'`).Scan(&redSouls)
+	db.QueryRow(`SELECT COALESCE(SUM(fs.souls), 0) AS souls FROM festa_registrations fr LEFT JOIN festa_submissions fs ON fr.guild_id = fs.guild_id AND fr.team = 'red'`).Scan(&redSouls)
 
 	bf.WriteUint32(id)
 	for _, timestamp := range timestamps {
@@ -228,7 +221,7 @@ func handleMsgMhfInfoFesta(s *Session, p mhfpacket.MHFPacket) {
 
 	var trials []FestaTrial
 	var trial FestaTrial
-	rows, _ = database.Queryx(`SELECT ft.*,
+	rows, _ = db.Queryx(`SELECT ft.*,
 		COALESCE(CASE
 			WHEN COUNT(gc.id) FILTER (WHERE fr.team = 'blue' AND gc.trial_vote = ft.id) >
 				 COUNT(gc.id) FILTER (WHERE fr.team = 'red' AND gc.trial_vote = ft.id)
@@ -322,7 +315,7 @@ func handleMsgMhfInfoFesta(s *Session, p mhfpacket.MHFPacket) {
 		var guildID uint32
 		var guildName string
 		var guildTeam = FestivalColorNone
-		database.QueryRow(`
+		db.QueryRow(`
 				SELECT fs.guild_id, g.name, fr.team, SUM(fs.souls) as _
 				FROM festa_submissions fs
 				LEFT JOIN festa_registrations fr ON fs.guild_id = fr.guild_id
@@ -342,7 +335,7 @@ func handleMsgMhfInfoFesta(s *Session, p mhfpacket.MHFPacket) {
 		var guildName string
 		var guildTeam = FestivalColorNone
 		offset := 86400 * uint32(i)
-		database.QueryRow(`
+		db.QueryRow(`
 				SELECT fs.guild_id, g.name, fr.team, SUM(fs.souls) as _
 				FROM festa_submissions fs
 				LEFT JOIN festa_registrations fr ON fs.guild_id = fr.guild_id
@@ -376,12 +369,9 @@ func handleMsgMhfInfoFesta(s *Session, p mhfpacket.MHFPacket) {
 }
 
 // state festa (U)ser
-func handleMsgMhfStateFestaU(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfStateFestaU(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfStateFestaU)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	guild, err := GetGuildInfoByCharacterId(s, s.CharID)
 	applicant := false
 	if guild != nil {
@@ -392,8 +382,8 @@ func handleMsgMhfStateFestaU(s *Session, p mhfpacket.MHFPacket) {
 		return
 	}
 	var souls, exists uint32
-	database.QueryRow(`SELECT COALESCE((SELECT SUM(souls) FROM festa_submissions WHERE character_id=$1), 0)`, s.CharID).Scan(&souls)
+	db.QueryRow(`SELECT COALESCE((SELECT SUM(souls) FROM festa_submissions WHERE character_id=$1), 0)`, s.CharID).Scan(&souls)
-	err = database.QueryRow("SELECT prize_id FROM festa_prizes_accepted WHERE prize_id=0 AND character_id=$1", s.CharID).Scan(&exists)
+	err = db.QueryRow("SELECT prize_id FROM festa_prizes_accepted WHERE prize_id=0 AND character_id=$1", s.CharID).Scan(&exists)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(souls)
 	if err != nil {
@@ -407,7 +397,7 @@ func handleMsgMhfStateFestaU(s *Session, p mhfpacket.MHFPacket) {
 }
 
 // state festa (G)uild
-func handleMsgMhfStateFestaG(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfStateFestaG(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfStateFestaG)
 	guild, err := GetGuildInfoByCharacterId(s, s.CharID)
 	applicant := false
@@ -432,7 +422,7 @@ func handleMsgMhfStateFestaG(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfEnumerateFestaMember(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateFestaMember(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateFestaMember)
 	guild, err := GetGuildInfoByCharacterId(s, s.CharID)
 	if err != nil || guild == nil {
@@ -468,22 +458,16 @@ func handleMsgMhfEnumerateFestaMember(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfVoteFesta(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfVoteFesta(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfVoteFesta)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec(`UPDATE guild_characters SET trial_vote=$1 WHERE character_id=$2`, pkt.TrialID, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec(`UPDATE guild_characters SET trial_vote=$1 WHERE character_id=$2`, pkt.TrialID, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfEntryFesta(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEntryFesta(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEntryFesta)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	guild, err := GetGuildInfoByCharacterId(s, s.CharID)
 	if err != nil || guild == nil {
 		s.DoAckSimpleFail(pkt.AckHandle, make([]byte, 4))
@@ -492,22 +476,19 @@ func handleMsgMhfEntryFesta(s *Session, p mhfpacket.MHFPacket) {
 	team := uint32(token.RNG.Intn(2))
 	switch team {
 	case 0:
-		database.Exec("INSERT INTO festa_registrations VALUES ($1, 'blue')", guild.ID)
+		db.Exec("INSERT INTO festa_registrations VALUES ($1, 'blue')", guild.ID)
 	case 1:
-		database.Exec("INSERT INTO festa_registrations VALUES ($1, 'red')", guild.ID)
+		db.Exec("INSERT INTO festa_registrations VALUES ($1, 'red')", guild.ID)
 	}
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(team)
 	s.DoAckSimpleSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfChargeFesta(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfChargeFesta(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfChargeFesta)
-	database, err := db.GetDB()
+
-	if err != nil {
+	tx, _ := db.Begin()
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	tx, _ := database.Begin()
 	for i := range pkt.Souls {
 		if pkt.Souls[i] == 0 {
 			continue
@@ -518,33 +499,24 @@ func handleMsgMhfChargeFesta(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfAcquireFesta(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAcquireFesta(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireFesta)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec("INSERT INTO public.festa_prizes_accepted VALUES (0, $1)", s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec("INSERT INTO public.festa_prizes_accepted VALUES (0, $1)", s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfAcquireFestaPersonalPrize(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAcquireFestaPersonalPrize(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireFestaPersonalPrize)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec("INSERT INTO public.festa_prizes_accepted VALUES ($1, $2)", pkt.PrizeID, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec("INSERT INTO public.festa_prizes_accepted VALUES ($1, $2)", pkt.PrizeID, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfAcquireFestaIntermediatePrize(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAcquireFestaIntermediatePrize(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireFestaIntermediatePrize)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec("INSERT INTO public.festa_prizes_accepted VALUES ($1, $2)", pkt.PrizeID, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec("INSERT INTO public.festa_prizes_accepted VALUES ($1, $2)", pkt.PrizeID, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
@@ -557,13 +529,10 @@ type Prize struct {
 	Claimed  int    `db:"claimed"`
 }
 
-func handleMsgMhfEnumerateFestaPersonalPrize(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateFestaPersonalPrize(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateFestaPersonalPrize)
-	database, err := db.GetDB()
+
-	if err != nil {
+	rows, _ := db.Queryx(`SELECT id, tier, souls_req, item_id, num_item, (SELECT count(*) FROM festa_prizes_accepted fpa WHERE fp.id = fpa.prize_id AND fpa.character_id = $1) AS claimed FROM festa_prizes fp WHERE type='personal'`, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	rows, _ := database.Queryx(`SELECT id, tier, souls_req, item_id, num_item, (SELECT count(*) FROM festa_prizes_accepted fpa WHERE fp.id = fpa.prize_id AND fpa.character_id = $1) AS claimed FROM festa_prizes fp WHERE type='personal'`, s.CharID)
 	var count uint32
 	prizeData := byteframe.NewByteFrame()
 	for rows.Next() {
@@ -587,13 +556,10 @@ func handleMsgMhfEnumerateFestaPersonalPrize(s *Session, p mhfpacket.MHFPacket)
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfEnumerateFestaIntermediatePrize(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateFestaIntermediatePrize(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateFestaIntermediatePrize)
-	database, err := db.GetDB()
+
-	if err != nil {
+	rows, _ := db.Queryx(`SELECT id, tier, souls_req, item_id, num_item, (SELECT count(*) FROM festa_prizes_accepted fpa WHERE fp.id = fpa.prize_id AND fpa.character_id = $1) AS claimed FROM festa_prizes fp WHERE type='guild'`, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	rows, _ := database.Queryx(`SELECT id, tier, souls_req, item_id, num_item, (SELECT count(*) FROM festa_prizes_accepted fpa WHERE fp.id = fpa.prize_id AND fpa.character_id = $1) AS claimed FROM festa_prizes fp WHERE type='guild'`, s.CharID)
 	var count uint32
 	prizeData := byteframe.NewByteFrame()
 	for rows.Next() {

server/channelserver/handlers_guild.go

@@ -191,11 +191,11 @@ SELECT
 `
 
 func (guild *Guild) Save(s *Session) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	_, err = database.Exec(`
+	_, err = db.Exec(`
 		UPDATE guilds SET main_motto=$2, sub_motto=$3, comment=$4, pugi_name_1=$5, pugi_name_2=$6, pugi_name_3=$7,
 		pugi_outfit_1=$8, pugi_outfit_2=$9, pugi_outfit_3=$10, pugi_outfits=$11, icon=$12, leader_id=$13 WHERE id=$1
 	`, guild.ID, guild.MainMotto, guild.SubMotto, guild.Comment, guild.PugiName1, guild.PugiName2, guild.PugiName3,
@@ -210,19 +210,17 @@ func (guild *Guild) Save(s *Session) error {
 }
 
 func (guild *Guild) CreateApplication(s *Session, charID uint32, applicationType GuildApplicationType, transaction *sql.Tx) error {
-
+	db, err := db.GetDB()
+	if err != nil {
+		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
+	}
 	query := `
 		INSERT INTO guild_applications (guild_id, character_id, actor_id, application_type)
 		VALUES ($1, $2, $3, $4)
 	`
 
-	database, err := db.GetDB()
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-
 	if transaction == nil {
-		_, err = database.Exec(query, guild.ID, charID, s.CharID, applicationType)
+		_, err = db.Exec(query, guild.ID, charID, s.CharID, applicationType)
 	} else {
 		_, err = transaction.Exec(query, guild.ID, charID, s.CharID, applicationType)
 	}
@@ -241,11 +239,11 @@ func (guild *Guild) CreateApplication(s *Session, charID uint32, applicationType
 }
 
 func (guild *Guild) Disband(s *Session) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	transaction, err := database.Begin()
+	transaction, err := db.Begin()
 
 	if err != nil {
 		s.Logger.Error("failed to begin transaction", zap.Error(err))
@@ -305,11 +303,11 @@ func (guild *Guild) Disband(s *Session) error {
 }
 
 func (guild *Guild) RemoveCharacter(s *Session, charID uint32) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	_, err = database.Exec("DELETE FROM guild_characters WHERE character_id=$1", charID)
+	_, err = db.Exec("DELETE FROM guild_characters WHERE character_id=$1", charID)
 
 	if err != nil {
 		s.Logger.Error(
@@ -326,11 +324,11 @@ func (guild *Guild) RemoveCharacter(s *Session, charID uint32) error {
 }
 
 func (guild *Guild) AcceptApplication(s *Session, charID uint32) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	transaction, err := database.Begin()
+	transaction, err := db.Begin()
 
 	if err != nil {
 		s.Logger.Error("failed to start db transaction", zap.Error(err))
@@ -375,11 +373,11 @@ func (guild *Guild) AcceptApplication(s *Session, charID uint32) error {
 // This is relying on the fact that invitation ID is also character ID right now
 // if invitation ID changes, this will break.
 func (guild *Guild) CancelInvitation(s *Session, charID uint32) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	_, err = database.Exec(
+	_, err = db.Exec(
 		`DELETE FROM guild_applications WHERE character_id = $1 AND guild_id = $2 AND application_type = 'invited'`,
 		charID, guild.ID,
 	)
@@ -398,11 +396,11 @@ func (guild *Guild) CancelInvitation(s *Session, charID uint32) error {
 }
 
 func (guild *Guild) RejectApplication(s *Session, charID uint32) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	_, err = database.Exec(
+	_, err = db.Exec(
 		`DELETE FROM guild_applications WHERE character_id = $1 AND guild_id = $2 AND application_type = 'applied'`,
 		charID, guild.ID,
 	)
@@ -421,11 +419,11 @@ func (guild *Guild) RejectApplication(s *Session, charID uint32) error {
 }
 
 func (guild *Guild) ArrangeCharacters(s *Session, charIDs []uint32) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	transaction, err := database.Begin()
+	transaction, err := db.Begin()
 
 	if err != nil {
 		s.Logger.Error("failed to start db transaction", zap.Error(err))
@@ -457,11 +455,11 @@ func (guild *Guild) ArrangeCharacters(s *Session, charIDs []uint32) error {
 }
 
 func (guild *Guild) GetApplicationForCharID(s *Session, charID uint32, applicationType GuildApplicationType) (*GuildApplication, error) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	row := database.QueryRowx(`
+	row := db.QueryRowx(`
 		SELECT * from guild_applications WHERE character_id = $1 AND guild_id = $2 AND application_type = $3
 	`, charID, guild.ID, applicationType)
 
@@ -487,11 +485,11 @@ func (guild *Guild) GetApplicationForCharID(s *Session, charID uint32, applicati
 }
 
 func (guild *Guild) HasApplicationForCharID(s *Session, charID uint32) (bool, error) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	row := database.QueryRowx(`
+	row := db.QueryRowx(`
 		SELECT 1 from guild_applications WHERE character_id = $1 AND guild_id = $2
 	`, charID, guild.ID)
 
@@ -517,11 +515,11 @@ func (guild *Guild) HasApplicationForCharID(s *Session, charID uint32) (bool, er
 }
 
 func CreateGuild(s *Session, guildName string) (int32, error) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	transaction, err := database.Begin()
+	transaction, err := db.Begin()
 
 	if err != nil {
 		s.Logger.Error("failed to start db transaction", zap.Error(err))
@@ -593,11 +591,11 @@ func rollbackTransaction(s *Session, transaction *sql.Tx) {
 }
 
 func GetGuildInfoByID(s *Session, guildID uint32) (*Guild, error) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	rows, err := database.Queryx(fmt.Sprintf(`
+	rows, err := db.Queryx(fmt.Sprintf(`
 		%s
 		WHERE g.id = $1
 		LIMIT 1
@@ -620,11 +618,11 @@ func GetGuildInfoByID(s *Session, guildID uint32) (*Guild, error) {
 }
 
 func GetGuildInfoByCharacterId(s *Session, charID uint32) (*Guild, error) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	rows, err := database.Queryx(fmt.Sprintf(`
+	rows, err := db.Queryx(fmt.Sprintf(`
 		%s
 		WHERE EXISTS(
 				SELECT 1
@@ -671,7 +669,7 @@ func buildGuildObjectFromDbResult(result *sqlx.Rows, err error, s *Session) (*Gu
 	return guild, nil
 }
 
-func HandleMsgMhfCreateGuild(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfCreateGuild(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfCreateGuild)
 
 	guildId, err := CreateGuild(s, pkt.Name)
@@ -694,7 +692,7 @@ func HandleMsgMhfCreateGuild(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfOperateGuild(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfOperateGuild(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfOperateGuild)
 
 	guild, err := GetGuildInfoByID(s, pkt.GuildID)
@@ -703,10 +701,7 @@ func HandleMsgMhfOperateGuild(s *Session, p mhfpacket.MHFPacket) {
 		s.DoAckSimpleFail(pkt.AckHandle, make([]byte, 4))
 		return
 	}
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	bf := byteframe.NewByteFrame()
 
 	switch pkt.Action {
@@ -770,9 +765,9 @@ func HandleMsgMhfOperateGuild(s *Session, p mhfpacket.MHFPacket) {
 	case mhfpacket.OperateGuildDonateRank:
 		bf.WriteBytes(handleDonateRP(s, uint16(pkt.Data1.ReadUint32()), guild, 0))
 	case mhfpacket.OperateGuildSetApplicationDeny:
-		database.Exec("UPDATE guilds SET recruiting=false WHERE id=$1", guild.ID)
+		db.Exec("UPDATE guilds SET recruiting=false WHERE id=$1", guild.ID)
 	case mhfpacket.OperateGuildSetApplicationAllow:
-		database.Exec("UPDATE guilds SET recruiting=true WHERE id=$1", guild.ID)
+		db.Exec("UPDATE guilds SET recruiting=true WHERE id=$1", guild.ID)
 	case mhfpacket.OperateGuildSetAvoidLeadershipTrue:
 		handleAvoidLeadershipUpdate(s, pkt, true)
 	case mhfpacket.OperateGuildSetAvoidLeadershipFalse:
@@ -807,7 +802,7 @@ func HandleMsgMhfOperateGuild(s *Session, p mhfpacket.MHFPacket) {
 		handleChangePugi(s, uint8(pkt.Data1.ReadUint32()), guild, 3)
 	case mhfpacket.OperateGuildUnlockOutfit:
 		// TODO: This doesn't implement blocking, if someone unlocked the same outfit at the same time
-		database.Exec(`UPDATE guilds SET pugi_outfits=pugi_outfits+$1 WHERE id=$2`, int(math.Pow(float64(pkt.Data1.ReadUint32()), 2)), guild.ID)
+		db.Exec(`UPDATE guilds SET pugi_outfits=pugi_outfits+$1 WHERE id=$2`, int(math.Pow(float64(pkt.Data1.ReadUint32()), 2)), guild.ID)
 	case mhfpacket.OperateGuildDonateRoom:
 		quantity := uint16(pkt.Data1.ReadUint32())
 		bf.WriteBytes(handleDonateRP(s, quantity, guild, 2))
@@ -815,11 +810,11 @@ func HandleMsgMhfOperateGuild(s *Session, p mhfpacket.MHFPacket) {
 		quantity := uint16(pkt.Data1.ReadUint32())
 		bf.WriteBytes(handleDonateRP(s, quantity, guild, 1))
 		// TODO: Move this value onto rp_yesterday and reset to 0... daily?
-		database.Exec(`UPDATE guild_characters SET rp_today=rp_today+$1 WHERE character_id=$2`, quantity, s.CharID)
+		db.Exec(`UPDATE guild_characters SET rp_today=rp_today+$1 WHERE character_id=$2`, quantity, s.CharID)
 	case mhfpacket.OperateGuildEventExchange:
 		rp := uint16(pkt.Data1.ReadUint32())
 		var balance uint32
-		database.QueryRow(`UPDATE guilds SET event_rp=event_rp-$1 WHERE id=$2 RETURNING event_rp`, rp, guild.ID).Scan(&balance)
+		db.QueryRow(`UPDATE guilds SET event_rp=event_rp-$1 WHERE id=$2 RETURNING event_rp`, rp, guild.ID).Scan(&balance)
 		bf.WriteUint32(balance)
 	default:
 		panic(fmt.Sprintf("unhandled operate guild action '%d'", pkt.Action))
@@ -858,7 +853,7 @@ func handleChangePugi(s *Session, outfit uint8, guild *Guild, num int) {
 }
 
 func handleDonateRP(s *Session, amount uint16, guild *Guild, _type int) []byte {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
@@ -871,7 +866,7 @@ func handleDonateRP(s *Session, amount uint16, guild *Guild, _type int) []byte {
 	var resetRoom bool
 	if _type == 2 {
 		var currentRP uint16
-		database.QueryRow(`SELECT room_rp FROM guilds WHERE id = $1`, guild.ID).Scan(&currentRP)
+		db.QueryRow(`SELECT room_rp FROM guilds WHERE id = $1`, guild.ID).Scan(&currentRP)
 		if currentRP+amount >= 30 {
 			amount = 30 - currentRP
 			resetRoom = true
@@ -882,15 +877,15 @@ func handleDonateRP(s *Session, amount uint16, guild *Guild, _type int) []byte {
 
 	switch _type {
 	case 0:
-		database.Exec(`UPDATE guilds SET rank_rp = rank_rp + $1 WHERE id = $2`, amount, guild.ID)
+		db.Exec(`UPDATE guilds SET rank_rp = rank_rp + $1 WHERE id = $2`, amount, guild.ID)
 	case 1:
-		database.Exec(`UPDATE guilds SET event_rp = event_rp + $1 WHERE id = $2`, amount, guild.ID)
+		db.Exec(`UPDATE guilds SET event_rp = event_rp + $1 WHERE id = $2`, amount, guild.ID)
 	case 2:
 		if resetRoom {
-			database.Exec(`UPDATE guilds SET room_rp = 0 WHERE id = $1`, guild.ID)
+			db.Exec(`UPDATE guilds SET room_rp = 0 WHERE id = $1`, guild.ID)
-			database.Exec(`UPDATE guilds SET room_expiry = $1 WHERE id = $2`, gametime.TimeAdjusted().Add(time.Hour*24*7), guild.ID)
+			db.Exec(`UPDATE guilds SET room_expiry = $1 WHERE id = $2`, gametime.TimeAdjusted().Add(time.Hour*24*7), guild.ID)
 		} else {
-			database.Exec(`UPDATE guilds SET room_rp = room_rp + $1 WHERE id = $2`, amount, guild.ID)
+			db.Exec(`UPDATE guilds SET room_rp = room_rp + $1 WHERE id = $2`, amount, guild.ID)
 		}
 	}
 	bf.Seek(0, 0)
@@ -918,7 +913,7 @@ func handleAvoidLeadershipUpdate(s *Session, pkt *mhfpacket.MsgMhfOperateGuild,
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfOperateGuildMember(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfOperateGuildMember(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfOperateGuildMember)
 
 	guild, err := GetGuildInfoByCharacterId(s, pkt.CharID)
@@ -981,7 +976,7 @@ func HandleMsgMhfOperateGuildMember(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func HandleMsgMhfInfoGuild(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfInfoGuild(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfInfoGuild)
 
 	var guild *Guild
@@ -1226,20 +1221,17 @@ func HandleMsgMhfInfoGuild(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func HandleMsgMhfEnumerateGuild(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfEnumerateGuild(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateGuild)
 
 	var guilds []*Guild
 	var alliances []*GuildAlliance
 	var rows *sqlx.Rows
 	var err error
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if pkt.Type <= 8 {
 		var tempGuilds []*Guild
-		rows, err = database.Queryx(guildInfoSelectQuery)
+		rows, err = db.Queryx(guildInfoSelectQuery)
 		if err == nil {
 			for rows.Next() {
 				guild, err := buildGuildObjectFromDbResult(rows, err, s)
@@ -1322,7 +1314,7 @@ func HandleMsgMhfEnumerateGuild(s *Session, p mhfpacket.MHFPacket) {
 
 	if pkt.Type > 8 {
 		var tempAlliances []*GuildAlliance
-		rows, err = database.Queryx(allianceInfoSelectQuery)
+		rows, err = db.Queryx(allianceInfoSelectQuery)
 		if err == nil {
 			for rows.Next() {
 				alliance, _ := buildAllianceObjectFromDbResult(rows, err, s)
@@ -1432,7 +1424,7 @@ func HandleMsgMhfEnumerateGuild(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfArrangeGuildMember(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfArrangeGuildMember(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfArrangeGuildMember)
 
 	guild, err := GetGuildInfoByID(s, pkt.GuildID)
@@ -1467,7 +1459,7 @@ func HandleMsgMhfArrangeGuildMember(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfEnumerateGuildMember(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfEnumerateGuildMember(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateGuildMember)
 
 	var guild *Guild
@@ -1588,7 +1580,7 @@ func HandleMsgMhfEnumerateGuildMember(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfGetGuildManageRight(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGetGuildManageRight(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildManageRight)
 
 	guild, err := GetGuildInfoByCharacterId(s, s.CharID)
@@ -1612,12 +1604,12 @@ func HandleMsgMhfGetGuildManageRight(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfGetUdGuildMapInfo(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGetUdGuildMapInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdGuildMapInfo)
 	s.DoAckSimpleFail(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfGetGuildTargetMemberNum(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGetGuildTargetMemberNum(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildTargetMemberNum)
 
 	var guild *Guild
@@ -1643,13 +1635,14 @@ func HandleMsgMhfGetGuildTargetMemberNum(s *Session, p mhfpacket.MHFPacket) {
 }
 
 func guildGetItems(s *Session, guildID uint32) []mhfitem.MHFItemStack {
-	var data []byte
+	db, err := db.GetDB()
-	var items []mhfitem.MHFItemStack
-	database, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	database.QueryRow(`SELECT item_box FROM guilds WHERE id=$1`, guildID).Scan(&data)
+	var data []byte
+	var items []mhfitem.MHFItemStack
+
+	db.QueryRow(`SELECT item_box FROM guilds WHERE id=$1`, guildID).Scan(&data)
 	if len(data) > 0 {
 		box := byteframe.NewByteFrameFromBytes(data)
 		numStacks := box.ReadUint16()
@@ -1661,7 +1654,7 @@ func guildGetItems(s *Session, guildID uint32) []mhfitem.MHFItemStack {
 	return items
 }
 
-func HandleMsgMhfEnumerateGuildItem(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfEnumerateGuildItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateGuildItem)
 	items := guildGetItems(s, pkt.GuildID)
 	bf := byteframe.NewByteFrame()
@@ -1669,18 +1662,15 @@ func HandleMsgMhfEnumerateGuildItem(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfUpdateGuildItem(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfUpdateGuildItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateGuildItem)
 	newStacks := mhfitem.DiffItemStacks(guildGetItems(s, pkt.GuildID), pkt.UpdatedItems)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec(`UPDATE guilds SET item_box=$1 WHERE id=$2`, mhfitem.SerializeWarehouseItems(newStacks), pkt.GuildID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec(`UPDATE guilds SET item_box=$1 WHERE id=$2`, mhfitem.SerializeWarehouseItems(newStacks), pkt.GuildID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfUpdateGuildIcon(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfUpdateGuildIcon(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateGuildIcon)
 
 	guild, err := GetGuildInfoByID(s, pkt.GuildID)
@@ -1736,7 +1726,7 @@ func HandleMsgMhfUpdateGuildIcon(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfReadGuildcard(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfReadGuildcard(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReadGuildcard)
 
 	resp := byteframe.NewByteFrame()
@@ -1764,7 +1754,7 @@ type GuildMission struct {
 	RewardLevel uint16
 }
 
-func HandleMsgMhfGetGuildMissionList(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGetGuildMissionList(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildMissionList)
 	bf := byteframe.NewByteFrame()
 	missions := []GuildMission{
@@ -1799,24 +1789,24 @@ func HandleMsgMhfGetGuildMissionList(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfGetGuildMissionRecord(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGetGuildMissionRecord(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildMissionRecord)
 
 	// No guild mission records = 0x190 empty bytes
 	s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 0x190))
 }
 
-func HandleMsgMhfAddGuildMissionCount(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfAddGuildMissionCount(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAddGuildMissionCount)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfSetGuildMissionTarget(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfSetGuildMissionTarget(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSetGuildMissionTarget)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfCancelGuildMissionTarget(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfCancelGuildMissionTarget(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfCancelGuildMissionTarget)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
@@ -1828,14 +1818,11 @@ type GuildMeal struct {
 	CreatedAt time.Time `db:"created_at"`
 }
 
-func HandleMsgMhfLoadGuildCooking(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfLoadGuildCooking(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadGuildCooking)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	guild, _ := GetGuildInfoByCharacterId(s, s.CharID)
-	data, err := database.Queryx("SELECT id, meal_id, level, created_at FROM guild_meals WHERE guild_id = $1", guild.ID)
+	data, err := db.Queryx("SELECT id, meal_id, level, created_at FROM guild_meals WHERE guild_id = $1", guild.ID)
 	if err != nil {
 		s.Logger.Error("Failed to get guild meals from db", zap.Error(err))
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 2))
@@ -1863,18 +1850,15 @@ func HandleMsgMhfLoadGuildCooking(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfRegistGuildCooking(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfRegistGuildCooking(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfRegistGuildCooking)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	guild, _ := GetGuildInfoByCharacterId(s, s.CharID)
 	startTime := gametime.TimeAdjusted().Add(time.Duration(config.GetConfig().GameplayOptions.ClanMealDuration-3600) * time.Second)
 	if pkt.OverwriteID != 0 {
-		database.Exec("UPDATE guild_meals SET meal_id = $1, level = $2, created_at = $3 WHERE id = $4", pkt.MealID, pkt.Success, startTime, pkt.OverwriteID)
+		db.Exec("UPDATE guild_meals SET meal_id = $1, level = $2, created_at = $3 WHERE id = $4", pkt.MealID, pkt.Success, startTime, pkt.OverwriteID)
 	} else {
-		database.QueryRow("INSERT INTO guild_meals (guild_id, meal_id, level, created_at) VALUES ($1, $2, $3, $4) RETURNING id", guild.ID, pkt.MealID, pkt.Success, startTime).Scan(&pkt.OverwriteID)
+		db.QueryRow("INSERT INTO guild_meals (guild_id, meal_id, level, created_at) VALUES ($1, $2, $3, $4) RETURNING id", guild.ID, pkt.MealID, pkt.Success, startTime).Scan(&pkt.OverwriteID)
 	}
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint16(1)
@@ -1885,13 +1869,13 @@ func HandleMsgMhfRegistGuildCooking(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfGetGuildWeeklyBonusMaster(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGetGuildWeeklyBonusMaster(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildWeeklyBonusMaster)
 
 	// Values taken from brand new guild capture
 	s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 40))
 }
-func HandleMsgMhfGetGuildWeeklyBonusActiveCount(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGetGuildWeeklyBonusActiveCount(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildWeeklyBonusActiveCount)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint8(60) // Active count
@@ -1900,19 +1884,16 @@ func HandleMsgMhfGetGuildWeeklyBonusActiveCount(s *Session, p mhfpacket.MHFPacke
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfGuildHuntdata(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGuildHuntdata(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGuildHuntdata)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	bf := byteframe.NewByteFrame()
 	switch pkt.Operation {
 	case 0: // Acquire
-		database.Exec(`UPDATE guild_characters SET box_claimed=$1 WHERE character_id=$2`, gametime.TimeAdjusted(), s.CharID)
+		db.Exec(`UPDATE guild_characters SET box_claimed=$1 WHERE character_id=$2`, gametime.TimeAdjusted(), s.CharID)
 	case 1: // Enumerate
 		bf.WriteUint8(0) // Entries
-		rows, err := database.Query(`SELECT kl.id, kl.monster FROM kill_logs kl
+		rows, err := db.Query(`SELECT kl.id, kl.monster FROM kill_logs kl
 			INNER JOIN guild_characters gc ON kl.character_id = gc.character_id
 			WHERE gc.guild_id=$1
 			AND kl.timestamp >= (SELECT box_claimed FROM guild_characters WHERE character_id=$2)
@@ -1941,7 +1922,7 @@ func HandleMsgMhfGuildHuntdata(s *Session, p mhfpacket.MHFPacket) {
 		guild, err := GetGuildInfoByCharacterId(s, s.CharID)
 		if err == nil {
 			var count uint8
-			err = database.QueryRow(`SELECT COUNT(*) FROM kill_logs kl
+			err = db.QueryRow(`SELECT COUNT(*) FROM kill_logs kl
 				INNER JOIN guild_characters gc ON kl.character_id = gc.character_id
 				WHERE gc.guild_id=$1
 				AND kl.timestamp >= (SELECT box_claimed FROM guild_characters WHERE character_id=$2)
@@ -1968,23 +1949,20 @@ type MessageBoardPost struct {
 	LikedBy   string    `db:"liked_by"`
 }
 
-func HandleMsgMhfEnumerateGuildMessageBoard(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfEnumerateGuildMessageBoard(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateGuildMessageBoard)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	guild, _ := GetGuildInfoByCharacterId(s, s.CharID)
 	if pkt.BoardType == 1 {
 		pkt.MaxPosts = 4
 	}
-	msgs, err := database.Queryx("SELECT id, stamp_id, title, body, author_id, created_at, liked_by FROM guild_posts WHERE guild_id = $1 AND post_type = $2 ORDER BY created_at DESC", guild.ID, int(pkt.BoardType))
+	msgs, err := db.Queryx("SELECT id, stamp_id, title, body, author_id, created_at, liked_by FROM guild_posts WHERE guild_id = $1 AND post_type = $2 ORDER BY created_at DESC", guild.ID, int(pkt.BoardType))
 	if err != nil {
 		s.Logger.Error("Failed to get guild messages from db", zap.Error(err))
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 4))
 		return
 	}
-	database.Exec("UPDATE characters SET guild_post_checked = now() WHERE id = $1", s.CharID)
+	db.Exec("UPDATE characters SET guild_post_checked = now() WHERE id = $1", s.CharID)
 	bf := byteframe.NewByteFrame()
 	var postCount uint32
 	for msgs.Next() {
@@ -2010,12 +1988,9 @@ func HandleMsgMhfEnumerateGuildMessageBoard(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, data.Data())
 }
 
-func HandleMsgMhfUpdateGuildMessageBoard(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfUpdateGuildMessageBoard(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateGuildMessageBoard)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	guild, err := GetGuildInfoByCharacterId(s, s.CharID)
 	applicant := false
 	if guild != nil {
@@ -2027,34 +2002,34 @@ func HandleMsgMhfUpdateGuildMessageBoard(s *Session, p mhfpacket.MHFPacket) {
 	}
 	switch pkt.MessageOp {
 	case 0: // Create message
-		database.Exec("INSERT INTO guild_posts (guild_id, author_id, stamp_id, post_type, title, body) VALUES ($1, $2, $3, $4, $5, $6)", guild.ID, s.CharID, pkt.StampID, pkt.PostType, pkt.Title, pkt.Body)
+		db.Exec("INSERT INTO guild_posts (guild_id, author_id, stamp_id, post_type, title, body) VALUES ($1, $2, $3, $4, $5, $6)", guild.ID, s.CharID, pkt.StampID, pkt.PostType, pkt.Title, pkt.Body)
 		// TODO: if there are too many messages, purge excess
 	case 1: // Delete message
-		database.Exec("DELETE FROM guild_posts WHERE id = $1", pkt.PostID)
+		db.Exec("DELETE FROM guild_posts WHERE id = $1", pkt.PostID)
 	case 2: // Update message
-		database.Exec("UPDATE guild_posts SET title = $1, body = $2 WHERE id = $3", pkt.Title, pkt.Body, pkt.PostID)
+		db.Exec("UPDATE guild_posts SET title = $1, body = $2 WHERE id = $3", pkt.Title, pkt.Body, pkt.PostID)
 	case 3: // Update stamp
-		database.Exec("UPDATE guild_posts SET stamp_id = $1 WHERE id = $2", pkt.StampID, pkt.PostID)
+		db.Exec("UPDATE guild_posts SET stamp_id = $1 WHERE id = $2", pkt.StampID, pkt.PostID)
 	case 4: // Like message
 		var likedBy string
-		err := database.QueryRow("SELECT liked_by FROM guild_posts WHERE id = $1", pkt.PostID).Scan(&likedBy)
+		err := db.QueryRow("SELECT liked_by FROM guild_posts WHERE id = $1", pkt.PostID).Scan(&likedBy)
 		if err != nil {
 			s.Logger.Error("Failed to get guild message like data from db", zap.Error(err))
 		} else {
 			if pkt.LikeState {
 				likedBy = stringsupport.CSVAdd(likedBy, int(s.CharID))
-				database.Exec("UPDATE guild_posts SET liked_by = $1 WHERE id = $2", likedBy, pkt.PostID)
+				db.Exec("UPDATE guild_posts SET liked_by = $1 WHERE id = $2", likedBy, pkt.PostID)
 			} else {
 				likedBy = stringsupport.CSVRemove(likedBy, int(s.CharID))
-				database.Exec("UPDATE guild_posts SET liked_by = $1 WHERE id = $2", likedBy, pkt.PostID)
+				db.Exec("UPDATE guild_posts SET liked_by = $1 WHERE id = $2", likedBy, pkt.PostID)
 			}
 		}
 	case 5: // Check for new messages
 		var timeChecked time.Time
 		var newPosts int
-		err := database.QueryRow("SELECT guild_post_checked FROM characters WHERE id = $1", s.CharID).Scan(&timeChecked)
+		err := db.QueryRow("SELECT guild_post_checked FROM characters WHERE id = $1", s.CharID).Scan(&timeChecked)
 		if err == nil {
-			database.QueryRow("SELECT COUNT(*) FROM guild_posts WHERE guild_id = $1 AND (EXTRACT(epoch FROM created_at)::int) > $2", guild.ID, timeChecked.Unix()).Scan(&newPosts)
+			db.QueryRow("SELECT COUNT(*) FROM guild_posts WHERE guild_id = $1 AND (EXTRACT(epoch FROM created_at)::int) > $2", guild.ID, timeChecked.Unix()).Scan(&newPosts)
 			if newPosts > 0 {
 				s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x01})
 				return
@@ -2064,57 +2039,54 @@ func HandleMsgMhfUpdateGuildMessageBoard(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfEntryRookieGuild(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfEntryRookieGuild(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEntryRookieGuild)
 	s.DoAckSimpleFail(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfUpdateForceGuildRank(s *Session, p mhfpacket.MHFPacket) {}
+func HandleMsgMhfUpdateForceGuildRank(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func HandleMsgMhfAddGuildWeeklyBonusExceptionalUser(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfAddGuildWeeklyBonusExceptionalUser(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAddGuildWeeklyBonusExceptionalUser)
 	// TODO: record pkt.NumUsers to DB
 	// must use addition
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func HandleMsgMhfGenerateUdGuildMap(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGenerateUdGuildMap(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGenerateUdGuildMap)
 	s.DoAckSimpleFail(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfUpdateGuild(s *Session, p mhfpacket.MHFPacket) {}
+func HandleMsgMhfUpdateGuild(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func HandleMsgMhfSetGuildManageRight(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfSetGuildManageRight(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSetGuildManageRight)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec("UPDATE guild_characters SET recruiter=$1 WHERE character_id=$2", pkt.Allowed, pkt.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec("UPDATE guild_characters SET recruiter=$1 WHERE character_id=$2", pkt.Allowed, pkt.CharID)
 	s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfCheckMonthlyItem(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfCheckMonthlyItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfCheckMonthlyItem)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x01})
 	// TODO: Implement month-by-month tracker, 0 = Not claimed, 1 = Claimed
 	// Also handles HLC and EXC items, IDs = 064D, 076B
 }
 
-func HandleMsgMhfAcquireMonthlyItem(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfAcquireMonthlyItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireMonthlyItem)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfEnumerateInvGuild(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfEnumerateInvGuild(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateInvGuild)
 	stubEnumerateNoResults(s, pkt.AckHandle)
 }
 
-func HandleMsgMhfOperationInvGuild(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfOperationInvGuild(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfOperationInvGuild)
 	s.DoAckSimpleFail(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfUpdateGuildcard(s *Session, p mhfpacket.MHFPacket) {}
+func HandleMsgMhfUpdateGuildcard(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_guild_adventure.go

@@ -1,15 +1,14 @@
 package channelserver
 
 import (
-	"fmt"
 	"time"
 
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
-	"erupe-ce/utils/db"
 	"erupe-ce/utils/gametime"
 	"erupe-ce/utils/stringsupport"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
@@ -22,14 +21,11 @@ type GuildAdventure struct {
 	CollectedBy string `db:"collected_by"`
 }
 
-func HandleMsgMhfLoadGuildAdventure(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfLoadGuildAdventure(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadGuildAdventure)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	guild, _ := GetGuildInfoByCharacterId(s, s.CharID)
-	data, err := database.Queryx("SELECT id, destination, charge, depart, return, collected_by FROM guild_adventures WHERE guild_id = $1", guild.ID)
+	data, err := db.Queryx("SELECT id, destination, charge, depart, return, collected_by FROM guild_adventures WHERE guild_id = $1", guild.ID)
 	if err != nil {
 		s.Logger.Error("Failed to get guild adventures from db", zap.Error(err))
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 1))
@@ -57,33 +53,27 @@ func HandleMsgMhfLoadGuildAdventure(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfRegistGuildAdventure(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfRegistGuildAdventure(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfRegistGuildAdventure)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	guild, _ := GetGuildInfoByCharacterId(s, s.CharID)
-	_, err = database.Exec("INSERT INTO guild_adventures (guild_id, destination, depart, return) VALUES ($1, $2, $3, $4)", guild.ID, pkt.Destination, gametime.TimeAdjusted().Unix(), gametime.TimeAdjusted().Add(6*time.Hour).Unix())
+	_, err := db.Exec("INSERT INTO guild_adventures (guild_id, destination, depart, return) VALUES ($1, $2, $3, $4)", guild.ID, pkt.Destination, gametime.TimeAdjusted().Unix(), gametime.TimeAdjusted().Add(6*time.Hour).Unix())
 	if err != nil {
 		s.Logger.Error("Failed to register guild adventure", zap.Error(err))
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfAcquireGuildAdventure(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfAcquireGuildAdventure(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireGuildAdventure)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var collectedBy string
-	err = database.QueryRow("SELECT collected_by FROM guild_adventures WHERE id = $1", pkt.ID).Scan(&collectedBy)
+	err := db.QueryRow("SELECT collected_by FROM guild_adventures WHERE id = $1", pkt.ID).Scan(&collectedBy)
 	if err != nil {
 		s.Logger.Error("Error parsing adventure collected by", zap.Error(err))
 	} else {
 		collectedBy = stringsupport.CSVAdd(collectedBy, int(s.CharID))
-		_, err := database.Exec("UPDATE guild_adventures SET collected_by = $1 WHERE id = $2", collectedBy, pkt.ID)
+		_, err := db.Exec("UPDATE guild_adventures SET collected_by = $1 WHERE id = $2", collectedBy, pkt.ID)
 		if err != nil {
 			s.Logger.Error("Failed to collect adventure in db", zap.Error(err))
 		}
@@ -91,27 +81,21 @@ func HandleMsgMhfAcquireGuildAdventure(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfChargeGuildAdventure(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfChargeGuildAdventure(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfChargeGuildAdventure)
-	database, err := db.GetDB()
+
-	if err != nil {
+	_, err := db.Exec("UPDATE guild_adventures SET charge = charge + $1 WHERE id = $2", pkt.Amount, pkt.ID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	_, err = database.Exec("UPDATE guild_adventures SET charge = charge + $1 WHERE id = $2", pkt.Amount, pkt.ID)
 	if err != nil {
 		s.Logger.Error("Failed to charge guild adventure", zap.Error(err))
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfRegistGuildAdventureDiva(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfRegistGuildAdventureDiva(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfRegistGuildAdventureDiva)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	guild, _ := GetGuildInfoByCharacterId(s, s.CharID)
-	_, err = database.Exec("INSERT INTO guild_adventures (guild_id, destination, charge, depart, return) VALUES ($1, $2, $3, $4, $5)", guild.ID, pkt.Destination, pkt.Charge, gametime.TimeAdjusted().Unix(), gametime.TimeAdjusted().Add(1*time.Hour).Unix())
+	_, err := db.Exec("INSERT INTO guild_adventures (guild_id, destination, charge, depart, return) VALUES ($1, $2, $3, $4, $5)", guild.ID, pkt.Destination, pkt.Charge, gametime.TimeAdjusted().Unix(), gametime.TimeAdjusted().Add(1*time.Hour).Unix())
 	if err != nil {
 		s.Logger.Error("Failed to register guild adventure", zap.Error(err))
 	}

server/channelserver/handlers_guild_alliance.go

@@ -46,11 +46,11 @@ type GuildAlliance struct {
 }
 
 func GetAllianceData(s *Session, AllianceID uint32) (*GuildAlliance, error) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	rows, err := database.Queryx(fmt.Sprintf(`
+	rows, err := db.Queryx(fmt.Sprintf(`
 		%s
 		WHERE ga.id = $1
 	`, allianceInfoSelectQuery), AllianceID)
@@ -111,25 +111,19 @@ func buildAllianceObjectFromDbResult(result *sqlx.Rows, err error, s *Session) (
 	return alliance, nil
 }
 
-func HandleMsgMhfCreateJoint(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfCreateJoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfCreateJoint)
-	database, err := db.GetDB()
+
-	if err != nil {
+	_, err := db.Exec("INSERT INTO guild_alliances (name, parent_id) VALUES ($1, $2)", pkt.Name, pkt.GuildID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	_, err = database.Exec("INSERT INTO guild_alliances (name, parent_id) VALUES ($1, $2)", pkt.Name, pkt.GuildID)
 	if err != nil {
 		s.Logger.Error("Failed to create guild alliance in db", zap.Error(err))
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x01, 0x01, 0x01, 0x01})
 }
 
-func HandleMsgMhfOperateJoint(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfOperateJoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfOperateJoint)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	guild, err := GetGuildInfoByID(s, pkt.GuildID)
 	if err != nil {
 		s.Logger.Error("Failed to get guild info", zap.Error(err))
@@ -142,7 +136,7 @@ func HandleMsgMhfOperateJoint(s *Session, p mhfpacket.MHFPacket) {
 	switch pkt.Action {
 	case mhfpacket.OPERATE_JOINT_DISBAND:
 		if guild.LeaderCharID == s.CharID && alliance.ParentGuildID == guild.ID {
-			_, err = database.Exec("DELETE FROM guild_alliances WHERE id=$1", alliance.ID)
+			_, err = db.Exec("DELETE FROM guild_alliances WHERE id=$1", alliance.ID)
 			if err != nil {
 				s.Logger.Error("Failed to disband alliance", zap.Error(err))
 			}
@@ -158,11 +152,11 @@ func HandleMsgMhfOperateJoint(s *Session, p mhfpacket.MHFPacket) {
 	case mhfpacket.OPERATE_JOINT_LEAVE:
 		if guild.LeaderCharID == s.CharID {
 			if guild.ID == alliance.SubGuild1ID && alliance.SubGuild2ID > 0 {
-				database.Exec(`UPDATE guild_alliances SET sub1_id = sub2_id, sub2_id = NULL WHERE id = $1`, alliance.ID)
+				db.Exec(`UPDATE guild_alliances SET sub1_id = sub2_id, sub2_id = NULL WHERE id = $1`, alliance.ID)
 			} else if guild.ID == alliance.SubGuild1ID && alliance.SubGuild2ID == 0 {
-				database.Exec(`UPDATE guild_alliances SET sub1_id = NULL WHERE id = $1`, alliance.ID)
+				db.Exec(`UPDATE guild_alliances SET sub1_id = NULL WHERE id = $1`, alliance.ID)
 			} else {
-				database.Exec(`UPDATE guild_alliances SET sub2_id = NULL WHERE id = $1`, alliance.ID)
+				db.Exec(`UPDATE guild_alliances SET sub2_id = NULL WHERE id = $1`, alliance.ID)
 			}
 			// TODO: Handle deleting Alliance applications
 			s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
@@ -177,11 +171,11 @@ func HandleMsgMhfOperateJoint(s *Session, p mhfpacket.MHFPacket) {
 		if alliance.ParentGuild.LeaderCharID == s.CharID {
 			kickedGuildID := pkt.Data1.ReadUint32()
 			if kickedGuildID == alliance.SubGuild1ID && alliance.SubGuild2ID > 0 {
-				database.Exec(`UPDATE guild_alliances SET sub1_id = sub2_id, sub2_id = NULL WHERE id = $1`, alliance.ID)
+				db.Exec(`UPDATE guild_alliances SET sub1_id = sub2_id, sub2_id = NULL WHERE id = $1`, alliance.ID)
 			} else if kickedGuildID == alliance.SubGuild1ID && alliance.SubGuild2ID == 0 {
-				database.Exec(`UPDATE guild_alliances SET sub1_id = NULL WHERE id = $1`, alliance.ID)
+				db.Exec(`UPDATE guild_alliances SET sub1_id = NULL WHERE id = $1`, alliance.ID)
 			} else {
-				database.Exec(`UPDATE guild_alliances SET sub2_id = NULL WHERE id = $1`, alliance.ID)
+				db.Exec(`UPDATE guild_alliances SET sub2_id = NULL WHERE id = $1`, alliance.ID)
 			}
 			s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 		} else {
@@ -198,7 +192,7 @@ func HandleMsgMhfOperateJoint(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func HandleMsgMhfInfoJoint(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfInfoJoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfInfoJoint)
 	bf := byteframe.NewByteFrame()
 	alliance, err := GetAllianceData(s, pkt.AllianceID)

server/channelserver/handlers_guild_member.go

@@ -47,11 +47,11 @@ func (gm *GuildMember) IsSubLeader() bool {
 }
 
 func (gm *GuildMember) Save(s *Session) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	_, err = database.Exec("UPDATE guild_characters SET avoid_leadership=$1, order_index=$2 WHERE character_id=$3", gm.AvoidLeadership, gm.OrderIndex, gm.CharID)
+	_, err = db.Exec("UPDATE guild_characters SET avoid_leadership=$1, order_index=$2 WHERE character_id=$3", gm.AvoidLeadership, gm.OrderIndex, gm.CharID)
 
 	if err != nil {
 		s.Logger.Error(
@@ -92,11 +92,11 @@ SELECT * FROM (
 `
 
 func GetGuildMembers(s *Session, guildID uint32, applicants bool) ([]*GuildMember, error) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	rows, err := database.Queryx(fmt.Sprintf(`
+	rows, err := db.Queryx(fmt.Sprintf(`
 			%s
 			WHERE guild_id = $1 AND is_applicant = $2
 	`, guildMembersSelectSQL), guildID, applicants)
@@ -124,12 +124,11 @@ func GetGuildMembers(s *Session, guildID uint32, applicants bool) ([]*GuildMembe
 }
 
 func GetCharacterGuildData(s *Session, charID uint32) (*GuildMember, error) {
-
+	db, err := db.GetDB()
-	database, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	rows, err := database.Queryx(fmt.Sprintf("%s	WHERE character_id=$1", guildMembersSelectSQL), charID)
+	rows, err := db.Queryx(fmt.Sprintf("%s	WHERE character_id=$1", guildMembersSelectSQL), charID)
 
 	if err != nil {
 		s.Logger.Error(fmt.Sprintf("failed to retrieve membership data for character '%d'", charID))

server/channelserver/handlers_guild_scout.go

@@ -3,16 +3,16 @@ package channelserver
 import (
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
-	"erupe-ce/utils/db"
 	"erupe-ce/utils/gametime"
 	"erupe-ce/utils/stringsupport"
 	"fmt"
 	"io"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
-func HandleMsgMhfPostGuildScout(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfPostGuildScout(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPostGuildScout)
 
 	actorCharGuildData, err := GetCharacterGuildData(s, s.CharID)
@@ -45,11 +45,8 @@ func HandleMsgMhfPostGuildScout(s *Session, p mhfpacket.MHFPacket) {
 		s.DoAckBufSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x04})
 		return
 	}
-	database, err := db.GetDB()
+
-	if err != nil {
+	transaction, err := db.Begin()
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	transaction, err := database.Begin()
 
 	if err != nil {
 		panic(err)
@@ -92,7 +89,7 @@ func HandleMsgMhfPostGuildScout(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func HandleMsgMhfCancelGuildScout(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfCancelGuildScout(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfCancelGuildScout)
 
 	guildCharData, err := GetCharacterGuildData(s, s.CharID)
@@ -123,7 +120,7 @@ func HandleMsgMhfCancelGuildScout(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfAnswerGuildScout(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfAnswerGuildScout(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAnswerGuildScout)
 	bf := byteframe.NewByteFrame()
 	guild, err := GetGuildInfoByCharacterId(s, pkt.LeaderID)
@@ -193,7 +190,7 @@ func HandleMsgMhfAnswerGuildScout(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func HandleMsgMhfGetGuildScoutList(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGetGuildScoutList(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildScoutList)
 
 	guildInfo, err := GetGuildInfoByCharacterId(s, s.CharID)
@@ -208,11 +205,8 @@ func HandleMsgMhfGetGuildScoutList(s *Session, p mhfpacket.MHFPacket) {
 			return
 		}
 	}
-	database, err := db.GetDB()
+
-	if err != nil {
+	rows, err := db.Queryx(`
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	rows, err := database.Queryx(`
 		SELECT c.id, c.name, c.hr, c.gr, ga.actor_id
 			FROM guild_applications ga 
 			JOIN characters c ON c.id = ga.character_id
@@ -272,17 +266,14 @@ func HandleMsgMhfGetGuildScoutList(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfGetRejectGuildScout(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGetRejectGuildScout(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetRejectGuildScout)
-	database, err := db.GetDB()
+
-	if err != nil {
+	row := db.QueryRow("SELECT restrict_guild_scout FROM characters WHERE id=$1", s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	row := database.QueryRow("SELECT restrict_guild_scout FROM characters WHERE id=$1", s.CharID)
 
 	var currentStatus bool
 
-	err = row.Scan(&currentStatus)
+	err := row.Scan(&currentStatus)
 
 	if err != nil {
 		s.Logger.Error(
@@ -303,13 +294,10 @@ func HandleMsgMhfGetRejectGuildScout(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, response})
 }
 
-func HandleMsgMhfSetRejectGuildScout(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfSetRejectGuildScout(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSetRejectGuildScout)
-	database, err := db.GetDB()
+
-	if err != nil {
+	_, err := db.Exec("UPDATE characters SET restrict_guild_scout=$1 WHERE id=$2", pkt.Reject, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	_, err = database.Exec("UPDATE characters SET restrict_guild_scout=$1 WHERE id=$2", pkt.Reject, s.CharID)
 
 	if err != nil {
 		s.Logger.Error(

server/channelserver/handlers_guild_tresure.go

@@ -4,11 +4,11 @@ import (
 	"erupe-ce/config"
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
-	"erupe-ce/utils/db"
 	"erupe-ce/utils/gametime"
 	"erupe-ce/utils/stringsupport"
-	"fmt"
 	"time"
+
+	"github.com/jmoiron/sqlx"
 )
 
 type TreasureHunt struct {
@@ -24,7 +24,7 @@ type TreasureHunt struct {
 	Claimed     bool      `db:"claimed"`
 }
 
-func HandleMsgMhfEnumerateGuildTresure(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfEnumerateGuildTresure(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateGuildTresure)
 	guild, err := GetGuildInfoByCharacterId(s, s.CharID)
 	if err != nil || guild == nil {
@@ -33,18 +33,15 @@ func HandleMsgMhfEnumerateGuildTresure(s *Session, p mhfpacket.MHFPacket) {
 	}
 	var hunts []TreasureHunt
 	var hunt TreasureHunt
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	switch pkt.MaxHunts {
 	case 1:
-		err = database.QueryRowx(`SELECT id, host_id, destination, level, start, hunt_data FROM guild_hunts WHERE host_id=$1 AND acquired=FALSE`, s.CharID).StructScan(&hunt)
+		err = db.QueryRowx(`SELECT id, host_id, destination, level, start, hunt_data FROM guild_hunts WHERE host_id=$1 AND acquired=FALSE`, s.CharID).StructScan(&hunt)
 		if err == nil {
 			hunts = append(hunts, hunt)
 		}
 	case 30:
-		rows, err := database.Queryx(`SELECT gh.id, gh.host_id, gh.destination, gh.level, gh.start, gh.collected, gh.hunt_data,
+		rows, err := db.Queryx(`SELECT gh.id, gh.host_id, gh.destination, gh.level, gh.start, gh.collected, gh.hunt_data,
 			(SELECT COUNT(*) FROM guild_characters gc WHERE gc.treasure_hunt = gh.id AND gc.character_id <> $1) AS hunters,
 			CASE
 				WHEN ghc.character_id IS NOT NULL THEN true
@@ -86,7 +83,7 @@ func HandleMsgMhfEnumerateGuildTresure(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfRegistGuildTresure(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfRegistGuildTresure(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfRegistGuildTresure)
 	bf := byteframe.NewByteFrameFromBytes(pkt.Data)
 	huntData := byteframe.NewByteFrame()
@@ -115,39 +112,30 @@ func HandleMsgMhfRegistGuildTresure(s *Session, p mhfpacket.MHFPacket) {
 			huntData.WriteBytes(bf.ReadBytes(9))
 		}
 	}
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec(`INSERT INTO guild_hunts (guild_id, host_id, destination, level, hunt_data, cats_used) VALUES ($1, $2, $3, $4, $5, $6)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec(`INSERT INTO guild_hunts (guild_id, host_id, destination, level, hunt_data, cats_used) VALUES ($1, $2, $3, $4, $5, $6)
 		`, guild.ID, s.CharID, destination, level, huntData.Data(), catsUsed)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfAcquireGuildTresure(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfAcquireGuildTresure(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireGuildTresure)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec(`UPDATE guild_hunts SET acquired=true WHERE id=$1`, pkt.HuntID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec(`UPDATE guild_hunts SET acquired=true WHERE id=$1`, pkt.HuntID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func HandleMsgMhfOperateGuildTresureReport(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfOperateGuildTresureReport(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfOperateGuildTresureReport)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	switch pkt.State {
 	case 0: // Report registration
-		database.Exec(`UPDATE guild_characters SET treasure_hunt=$1 WHERE character_id=$2`, pkt.HuntID, s.CharID)
+		db.Exec(`UPDATE guild_characters SET treasure_hunt=$1 WHERE character_id=$2`, pkt.HuntID, s.CharID)
 	case 1: // Collected by hunter
-		database.Exec(`UPDATE guild_hunts SET collected=true WHERE id=$1`, pkt.HuntID)
+		db.Exec(`UPDATE guild_hunts SET collected=true WHERE id=$1`, pkt.HuntID)
-		database.Exec(`UPDATE guild_characters SET treasure_hunt=NULL WHERE treasure_hunt=$1`, pkt.HuntID)
+		db.Exec(`UPDATE guild_characters SET treasure_hunt=NULL WHERE treasure_hunt=$1`, pkt.HuntID)
 	case 2: // Claim treasure
-		database.Exec(`INSERT INTO guild_hunts_claimed VALUES ($1, $2)`, pkt.HuntID, s.CharID)
+		db.Exec(`INSERT INTO guild_hunts_claimed VALUES ($1, $2)`, pkt.HuntID, s.CharID)
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
@@ -157,7 +145,7 @@ type TreasureSouvenir struct {
 	Quantity    uint32
 }
 
-func HandleMsgMhfGetGuildTresureSouvenir(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfGetGuildTresureSouvenir(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildTresureSouvenir)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(0)
@@ -170,7 +158,7 @@ func HandleMsgMhfGetGuildTresureSouvenir(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func HandleMsgMhfAcquireGuildTresureSouvenir(s *Session, p mhfpacket.MHFPacket) {
+func HandleMsgMhfAcquireGuildTresureSouvenir(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireGuildTresureSouvenir)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }

server/channelserver/handlers_house.go

@@ -13,6 +13,7 @@ import (
 	"io"
 	"time"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
@@ -41,13 +42,10 @@ COALESCE(equip9name, '')
 FROM warehouse
 `
 
-func handleMsgMhfUpdateInterior(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUpdateInterior(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateInterior)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec(`UPDATE user_binary SET house_furniture=$1 WHERE id=$2`, pkt.InteriorData, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec(`UPDATE user_binary SET house_furniture=$1 WHERE id=$2`, pkt.InteriorData, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
@@ -60,12 +58,9 @@ type HouseData struct {
 	HousePassword string `db:"house_password"`
 }
 
-func handleMsgMhfEnumerateHouse(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateHouse(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateHouse)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint16(0)
 	var houses []HouseData
@@ -74,11 +69,11 @@ func handleMsgMhfEnumerateHouse(s *Session, p mhfpacket.MHFPacket) {
 	switch pkt.Method {
 	case 1:
 		var friendsList string
-		database.QueryRow("SELECT friends FROM characters WHERE id=$1", s.CharID).Scan(&friendsList)
+		db.QueryRow("SELECT friends FROM characters WHERE id=$1", s.CharID).Scan(&friendsList)
 		cids := stringsupport.CSVElems(friendsList)
 		for _, cid := range cids {
 			house := HouseData{}
-			row := database.QueryRowx(houseQuery, cid)
+			row := db.QueryRowx(houseQuery, cid)
 			err := row.StructScan(&house)
 			if err == nil {
 				houses = append(houses, house)
@@ -95,7 +90,7 @@ func handleMsgMhfEnumerateHouse(s *Session, p mhfpacket.MHFPacket) {
 		}
 		for _, member := range guildMembers {
 			house := HouseData{}
-			row := database.QueryRowx(houseQuery, member.CharID)
+			row := db.QueryRowx(houseQuery, member.CharID)
 			err = row.StructScan(&house)
 			if err == nil {
 				houses = append(houses, house)
@@ -105,7 +100,7 @@ func handleMsgMhfEnumerateHouse(s *Session, p mhfpacket.MHFPacket) {
 		houseQuery = `SELECT c.id, hr, gr, name, COALESCE(ub.house_state, 2) as house_state, COALESCE(ub.house_password, '') as house_password
 			FROM characters c LEFT JOIN user_binary ub ON ub.id = c.id WHERE name ILIKE $1`
 		house := HouseData{}
-		rows, _ := database.Queryx(houseQuery, fmt.Sprintf(`%%%s%%`, pkt.Name))
+		rows, _ := db.Queryx(houseQuery, fmt.Sprintf(`%%%s%%`, pkt.Name))
 		for rows.Next() {
 			err := rows.StructScan(&house)
 			if err == nil {
@@ -114,7 +109,7 @@ func handleMsgMhfEnumerateHouse(s *Session, p mhfpacket.MHFPacket) {
 		}
 	case 4:
 		house := HouseData{}
-		row := database.QueryRowx(houseQuery, pkt.CharID)
+		row := db.QueryRowx(houseQuery, pkt.CharID)
 		err := row.StructScan(&house)
 		if err == nil {
 			houses = append(houses, house)
@@ -141,32 +136,26 @@ func handleMsgMhfEnumerateHouse(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfUpdateHouse(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUpdateHouse(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateHouse)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	// 01 = closed
 	// 02 = open anyone
 	// 03 = open friends
 	// 04 = open guild
 	// 05 = open friends+guild
-	database.Exec(`UPDATE user_binary SET house_state=$1, house_password=$2 WHERE id=$3`, pkt.State, pkt.Password, s.CharID)
+	db.Exec(`UPDATE user_binary SET house_state=$1, house_password=$2 WHERE id=$3`, pkt.State, pkt.Password, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfLoadHouse(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadHouse(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadHouse)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	bf := byteframe.NewByteFrame()
 
 	var state uint8
 	var password string
-	database.QueryRow(`SELECT COALESCE(house_state, 2) as house_state, COALESCE(house_password, '') as house_password FROM user_binary WHERE id=$1
+	db.QueryRow(`SELECT COALESCE(house_state, 2) as house_state, COALESCE(house_password, '') as house_password FROM user_binary WHERE id=$1
 	`, pkt.CharID).Scan(&state, &password)
 
 	if pkt.Destination != 9 && len(pkt.Password) > 0 && pkt.CheckPass {
@@ -182,7 +171,7 @@ func handleMsgMhfLoadHouse(s *Session, p mhfpacket.MHFPacket) {
 		// Friends list verification
 		if state == 3 || state == 5 {
 			var friendsList string
-			database.QueryRow(`SELECT friends FROM characters WHERE id=$1`, pkt.CharID).Scan(&friendsList)
+			db.QueryRow(`SELECT friends FROM characters WHERE id=$1`, pkt.CharID).Scan(&friendsList)
 			cids := stringsupport.CSVElems(friendsList)
 			for _, cid := range cids {
 				if uint32(cid) == s.CharID {
@@ -213,7 +202,7 @@ func handleMsgMhfLoadHouse(s *Session, p mhfpacket.MHFPacket) {
 	}
 
 	var houseTier, houseData, houseFurniture, bookshelf, gallery, tore, garden []byte
-	database.QueryRow(`SELECT house_tier, house_data, house_furniture, bookshelf, gallery, tore, garden FROM user_binary WHERE id=$1
+	db.QueryRow(`SELECT house_tier, house_data, house_furniture, bookshelf, gallery, tore, garden FROM user_binary WHERE id=$1
 	`, pkt.CharID).Scan(&houseTier, &houseData, &houseFurniture, &bookshelf, &gallery, &tore, &garden)
 	if houseFurniture == nil {
 		houseFurniture = make([]byte, 20)
@@ -249,14 +238,11 @@ func handleMsgMhfLoadHouse(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgMhfGetMyhouseInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetMyhouseInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetMyhouseInfo)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var data []byte
-	database.QueryRow(`SELECT mission FROM user_binary WHERE id=$1`, s.CharID).Scan(&data)
+	db.QueryRow(`SELECT mission FROM user_binary WHERE id=$1`, s.CharID).Scan(&data)
 	if len(data) > 0 {
 		s.DoAckBufSucceed(pkt.AckHandle, data)
 	} else {
@@ -264,25 +250,18 @@ func handleMsgMhfGetMyhouseInfo(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgMhfUpdateMyhouseInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUpdateMyhouseInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateMyhouseInfo)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec("UPDATE user_binary SET mission=$1 WHERE id=$2", pkt.Data, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec("UPDATE user_binary SET mission=$1 WHERE id=$2", pkt.Data, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfLoadDecoMyset(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadDecoMyset(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadDecoMyset)
 
-	database, err := db.GetDB()
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var data []byte
-	err = database.QueryRow("SELECT decomyset FROM characters WHERE id = $1", s.CharID).Scan(&data)
+	err := db.QueryRow("SELECT decomyset FROM characters WHERE id = $1", s.CharID).Scan(&data)
 	if err != nil {
 		s.Logger.Error("Failed to load decomyset", zap.Error(err))
 	}
@@ -295,14 +274,11 @@ func handleMsgMhfLoadDecoMyset(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfSaveDecoMyset(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSaveDecoMyset(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSaveDecoMyset)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var temp []byte
-	err = database.QueryRow("SELECT decomyset FROM characters WHERE id = $1", s.CharID).Scan(&temp)
+	err := db.QueryRow("SELECT decomyset FROM characters WHERE id = $1", s.CharID).Scan(&temp)
 	if err != nil {
 		s.Logger.Error("Failed to load decomyset", zap.Error(err))
 		s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
@@ -348,7 +324,7 @@ func handleMsgMhfSaveDecoMyset(s *Session, p mhfpacket.MHFPacket) {
 	}
 
 	dumpSaveData(s, bf.Data(), "decomyset")
-	database.Exec("UPDATE characters SET decomyset=$1 WHERE id=$2", bf.Data(), s.CharID)
+	db.Exec("UPDATE characters SET decomyset=$1 WHERE id=$2", bf.Data(), s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
@@ -358,17 +334,14 @@ type Title struct {
 	Updated  time.Time `db:"updated_at"`
 }
 
-func handleMsgMhfEnumerateTitle(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateTitle(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateTitle)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var count uint16
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint16(0)
 	bf.WriteUint16(0) // Unk
-	rows, err := database.Queryx("SELECT id, unlocked_at, updated_at FROM titles WHERE char_id=$1", s.CharID)
+	rows, err := db.Queryx("SELECT id, unlocked_at, updated_at FROM titles WHERE char_id=$1", s.CharID)
 	if err != nil {
 		s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 		return
@@ -390,44 +363,38 @@ func handleMsgMhfEnumerateTitle(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfAcquireTitle(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAcquireTitle(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireTitle)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	for _, title := range pkt.TitleIDs {
 		var exists int
-		err := database.QueryRow(`SELECT count(*) FROM titles WHERE id=$1 AND char_id=$2`, title, s.CharID).Scan(&exists)
+		err := db.QueryRow(`SELECT count(*) FROM titles WHERE id=$1 AND char_id=$2`, title, s.CharID).Scan(&exists)
 		if err != nil || exists == 0 {
-			database.Exec(`INSERT INTO titles VALUES ($1, $2, now(), now())`, title, s.CharID)
+			db.Exec(`INSERT INTO titles VALUES ($1, $2, now(), now())`, title, s.CharID)
 		} else {
-			database.Exec(`UPDATE titles SET updated_at=now() WHERE id=$1 AND char_id=$2`, title, s.CharID)
+			db.Exec(`UPDATE titles SET updated_at=now() WHERE id=$1 AND char_id=$2`, title, s.CharID)
 		}
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfResetTitle(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfResetTitle(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
 func initializeWarehouse(s *Session) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
 	var t int
-	err = database.QueryRow("SELECT character_id FROM warehouse WHERE character_id=$1", s.CharID).Scan(&t)
+	err = db.QueryRow("SELECT character_id FROM warehouse WHERE character_id=$1", s.CharID).Scan(&t)
 	if err != nil {
-		database.Exec("INSERT INTO warehouse (character_id) VALUES ($1)", s.CharID)
+		db.Exec("INSERT INTO warehouse (character_id) VALUES ($1)", s.CharID)
 	}
 }
 
-func handleMsgMhfOperateWarehouse(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfOperateWarehouse(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfOperateWarehouse)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	initializeWarehouse(s)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint8(pkt.Operation)
@@ -436,7 +403,7 @@ func handleMsgMhfOperateWarehouse(s *Session, p mhfpacket.MHFPacket) {
 		var count uint8
 		itemNames := make([]string, 10)
 		equipNames := make([]string, 10)
-		database.QueryRow(fmt.Sprintf("%s WHERE character_id=$1", warehouseNamesQuery), s.CharID).Scan(&itemNames[0],
+		db.QueryRow(fmt.Sprintf("%s WHERE character_id=$1", warehouseNamesQuery), s.CharID).Scan(&itemNames[0],
 			&itemNames[1], &itemNames[2], &itemNames[3], &itemNames[4], &itemNames[5], &itemNames[6], &itemNames[7], &itemNames[8], &itemNames[9], &equipNames[0],
 			&equipNames[1], &equipNames[2], &equipNames[3], &equipNames[4], &equipNames[5], &equipNames[6], &equipNames[7], &equipNames[8], &equipNames[9])
 		bf.WriteUint32(0)
@@ -465,9 +432,9 @@ func handleMsgMhfOperateWarehouse(s *Session, p mhfpacket.MHFPacket) {
 	case 2:
 		switch pkt.BoxType {
 		case 0:
-			database.Exec(fmt.Sprintf("UPDATE warehouse SET item%dname=$1 WHERE character_id=$2", pkt.BoxIndex), pkt.Name, s.CharID)
+			db.Exec(fmt.Sprintf("UPDATE warehouse SET item%dname=$1 WHERE character_id=$2", pkt.BoxIndex), pkt.Name, s.CharID)
 		case 1:
-			database.Exec(fmt.Sprintf("UPDATE warehouse SET equip%dname=$1 WHERE character_id=$2", pkt.BoxIndex), pkt.Name, s.CharID)
+			db.Exec(fmt.Sprintf("UPDATE warehouse SET equip%dname=$1 WHERE character_id=$2", pkt.BoxIndex), pkt.Name, s.CharID)
 		}
 	case 3:
 		bf.WriteUint32(0)     // Usage renewal time, >1 = disabled
@@ -487,36 +454,36 @@ func handleMsgMhfOperateWarehouse(s *Session, p mhfpacket.MHFPacket) {
 }
 
 func addWarehouseItem(s *Session, item mhfitem.MHFItemStack) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
 	giftBox := warehouseGetItems(s, 10)
 	item.WarehouseID = token.RNG.Uint32()
 	giftBox = append(giftBox, item)
-	database.Exec("UPDATE warehouse SET item10=$1 WHERE character_id=$2", mhfitem.SerializeWarehouseItems(giftBox), s.CharID)
+	db.Exec("UPDATE warehouse SET item10=$1 WHERE character_id=$2", mhfitem.SerializeWarehouseItems(giftBox), s.CharID)
 }
 
 func addWarehouseEquipment(s *Session, equipment mhfitem.MHFEquipment) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
 	giftBox := warehouseGetEquipment(s, 10)
 	equipment.WarehouseID = token.RNG.Uint32()
 	giftBox = append(giftBox, equipment)
-	database.Exec("UPDATE warehouse SET equip10=$1 WHERE character_id=$2", mhfitem.SerializeWarehouseEquipment(giftBox), s.CharID)
+	db.Exec("UPDATE warehouse SET equip10=$1 WHERE character_id=$2", mhfitem.SerializeWarehouseEquipment(giftBox), s.CharID)
 }
 
 func warehouseGetItems(s *Session, index uint8) []mhfitem.MHFItemStack {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
 	initializeWarehouse(s)
 	var data []byte
 	var items []mhfitem.MHFItemStack
-	database.QueryRow(fmt.Sprintf(`SELECT item%d FROM warehouse WHERE character_id=$1`, index), s.CharID).Scan(&data)
+	db.QueryRow(fmt.Sprintf(`SELECT item%d FROM warehouse WHERE character_id=$1`, index), s.CharID).Scan(&data)
 	if len(data) > 0 {
 		box := byteframe.NewByteFrameFromBytes(data)
 		numStacks := box.ReadUint16()
@@ -529,13 +496,13 @@ func warehouseGetItems(s *Session, index uint8) []mhfitem.MHFItemStack {
 }
 
 func warehouseGetEquipment(s *Session, index uint8) []mhfitem.MHFEquipment {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
 	var data []byte
 	var equipment []mhfitem.MHFEquipment
-	database.QueryRow(fmt.Sprintf(`SELECT equip%d FROM warehouse WHERE character_id=$1`, index), s.CharID).Scan(&data)
+	db.QueryRow(fmt.Sprintf(`SELECT equip%d FROM warehouse WHERE character_id=$1`, index), s.CharID).Scan(&data)
 	if len(data) > 0 {
 		box := byteframe.NewByteFrameFromBytes(data)
 		numStacks := box.ReadUint16()
@@ -547,7 +514,7 @@ func warehouseGetEquipment(s *Session, index uint8) []mhfitem.MHFEquipment {
 	return equipment
 }
 
-func handleMsgMhfEnumerateWarehouse(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateWarehouse(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateWarehouse)
 	bf := byteframe.NewByteFrame()
 	switch pkt.BoxType {
@@ -565,16 +532,13 @@ func handleMsgMhfEnumerateWarehouse(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgMhfUpdateWarehouse(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUpdateWarehouse(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateWarehouse)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	switch pkt.BoxType {
 	case 0:
 		newStacks := mhfitem.DiffItemStacks(warehouseGetItems(s, pkt.BoxIndex), pkt.UpdatedItems)
-		database.Exec(fmt.Sprintf(`UPDATE warehouse SET item%d=$1 WHERE character_id=$2`, pkt.BoxIndex), mhfitem.SerializeWarehouseItems(newStacks), s.CharID)
+		db.Exec(fmt.Sprintf(`UPDATE warehouse SET item%d=$1 WHERE character_id=$2`, pkt.BoxIndex), mhfitem.SerializeWarehouseItems(newStacks), s.CharID)
 	case 1:
 		var fEquip []mhfitem.MHFEquipment
 		oEquips := warehouseGetEquipment(s, pkt.BoxIndex)
@@ -598,7 +562,7 @@ func handleMsgMhfUpdateWarehouse(s *Session, p mhfpacket.MHFPacket) {
 				fEquip = append(fEquip, oEquip)
 			}
 		}
-		database.Exec(fmt.Sprintf(`UPDATE warehouse SET equip%d=$1 WHERE character_id=$2`, pkt.BoxIndex), mhfitem.SerializeWarehouseEquipment(fEquip), s.CharID)
+		db.Exec(fmt.Sprintf(`UPDATE warehouse SET equip%d=$1 WHERE character_id=$2`, pkt.BoxIndex), mhfitem.SerializeWarehouseEquipment(fEquip), s.CharID)
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }

server/channelserver/handlers_kouryou.go

@@ -3,21 +3,17 @@ package channelserver
 import (
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
-	"erupe-ce/utils/db"
-	"fmt"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
-func handleMsgMhfAddKouryouPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAddKouryouPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	// hunting with both ranks maxed gets you these
 	pkt := p.(*mhfpacket.MsgMhfAddKouryouPoint)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var points int
-	err = database.QueryRow("UPDATE characters SET kouryou_point=COALESCE(kouryou_point + $1, $1) WHERE id=$2 RETURNING kouryou_point", pkt.KouryouPoints, s.CharID).Scan(&points)
+	err := db.QueryRow("UPDATE characters SET kouryou_point=COALESCE(kouryou_point + $1, $1) WHERE id=$2 RETURNING kouryou_point", pkt.KouryouPoints, s.CharID).Scan(&points)
 	if err != nil {
 		s.Logger.Error("Failed to update KouryouPoint in db", zap.Error(err))
 	}
@@ -26,14 +22,11 @@ func handleMsgMhfAddKouryouPoint(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfGetKouryouPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetKouryouPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetKouryouPoint)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var points int
-	err = database.QueryRow("SELECT COALESCE(kouryou_point, 0) FROM characters WHERE id = $1", s.CharID).Scan(&points)
+	err := db.QueryRow("SELECT COALESCE(kouryou_point, 0) FROM characters WHERE id = $1", s.CharID).Scan(&points)
 	if err != nil {
 		s.Logger.Error("Failed to get kouryou_point savedata from db", zap.Error(err))
 	}
@@ -42,15 +35,12 @@ func handleMsgMhfGetKouryouPoint(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfExchangeKouryouPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfExchangeKouryouPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	// spent at the guildmaster, 10000 a roll
 	var points int
 	pkt := p.(*mhfpacket.MsgMhfExchangeKouryouPoint)
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("UPDATE characters SET kouryou_point=kouryou_point - $1 WHERE id=$2 RETURNING kouryou_point", pkt.KouryouPoints, s.CharID).Scan(&points)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("UPDATE characters SET kouryou_point=kouryou_point - $1 WHERE id=$2 RETURNING kouryou_point", pkt.KouryouPoints, s.CharID).Scan(&points)
 	if err != nil {
 		s.Logger.Error("Failed to update platemyset savedata in db", zap.Error(err))
 	}

server/channelserver/handlers_mail.go

@@ -11,6 +11,7 @@ import (
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
@@ -33,7 +34,7 @@ type Mail struct {
 }
 
 func (m *Mail) Send(s *Session, transaction *sql.Tx) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
@@ -43,7 +44,7 @@ func (m *Mail) Send(s *Session, transaction *sql.Tx) error {
 	`
 
 	if transaction == nil {
-		_, err = database.Exec(query, m.SenderID, m.RecipientID, m.Subject, m.Body, m.AttachedItemID, m.AttachedItemAmount, m.IsGuildInvite, m.IsSystemMessage)
+		_, err = db.Exec(query, m.SenderID, m.RecipientID, m.Subject, m.Body, m.AttachedItemID, m.AttachedItemAmount, m.IsGuildInvite, m.IsSystemMessage)
 	} else {
 		_, err = transaction.Exec(query, m.SenderID, m.RecipientID, m.Subject, m.Body, m.AttachedItemID, m.AttachedItemAmount, m.IsGuildInvite, m.IsSystemMessage)
 	}
@@ -68,11 +69,11 @@ func (m *Mail) Send(s *Session, transaction *sql.Tx) error {
 }
 
 func (m *Mail) MarkRead(s *Session) error {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	_, err = database.Exec(`
+	_, err = db.Exec(`
 		UPDATE mail SET read = true WHERE id = $1
 	`, m.ID)
 
@@ -89,11 +90,11 @@ func (m *Mail) MarkRead(s *Session) error {
 }
 
 func GetMailListForCharacter(s *Session, charID uint32) ([]Mail, error) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	rows, err := database.Queryx(`
+	rows, err := db.Queryx(`
 		SELECT
 			m.id,
 			m.sender_id,
@@ -141,11 +142,11 @@ func GetMailListForCharacter(s *Session, charID uint32) ([]Mail, error) {
 }
 
 func GetMailByID(s *Session, ID int) (*Mail, error) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	row := database.QueryRowx(`
+	row := db.QueryRowx(`
 		SELECT
 			m.id,
 			m.sender_id,
@@ -206,11 +207,11 @@ func SendMailNotification(s *Session, m *Mail, recipient *Session) {
 }
 
 func getCharacterName(s *Session, charID uint32) string {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	row := database.QueryRow("SELECT name FROM characters WHERE id = $1", charID)
+	row := db.QueryRow("SELECT name FROM characters WHERE id = $1", charID)
 
 	charName := ""
 
@@ -222,12 +223,9 @@ func getCharacterName(s *Session, charID uint32) string {
 	return charName
 }
 
-func handleMsgMhfReadMail(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfReadMail(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReadMail)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	mailId := s.mailList[pkt.AccIndex]
 	if mailId == 0 {
 		s.DoAckBufSucceed(pkt.AckHandle, []byte{0})
@@ -240,14 +238,14 @@ func handleMsgMhfReadMail(s *Session, p mhfpacket.MHFPacket) {
 		return
 	}
 
-	database.Exec(`UPDATE mail SET read = true WHERE id = $1`, mail.ID)
+	db.Exec(`UPDATE mail SET read = true WHERE id = $1`, mail.ID)
 	bf := byteframe.NewByteFrame()
 	body := stringsupport.UTF8ToSJIS(mail.Body)
 	bf.WriteNullTerminatedBytes(body)
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfListMail(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfListMail(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfListMail)
 
 	mail, err := GetMailListForCharacter(s, s.CharID)
@@ -316,12 +314,9 @@ func handleMsgMhfListMail(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, msg.Data())
 }
 
-func handleMsgMhfOprtMail(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfOprtMail(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfOprtMail)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	mail, err := GetMailByID(s, s.mailList[pkt.AccIndex])
 	if err != nil {
 		s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
@@ -330,23 +325,20 @@ func handleMsgMhfOprtMail(s *Session, p mhfpacket.MHFPacket) {
 
 	switch pkt.Operation {
 	case mhfpacket.OperateMailDelete:
-		database.Exec(`UPDATE mail SET deleted = true WHERE id = $1`, mail.ID)
+		db.Exec(`UPDATE mail SET deleted = true WHERE id = $1`, mail.ID)
 	case mhfpacket.OperateMailLock:
-		database.Exec(`UPDATE mail SET locked = TRUE WHERE id = $1`, mail.ID)
+		db.Exec(`UPDATE mail SET locked = TRUE WHERE id = $1`, mail.ID)
 	case mhfpacket.OperateMailUnlock:
-		database.Exec(`UPDATE mail SET locked = FALSE WHERE id = $1`, mail.ID)
+		db.Exec(`UPDATE mail SET locked = FALSE WHERE id = $1`, mail.ID)
 	case mhfpacket.OperateMailAcquireItem:
-		database.Exec(`UPDATE mail SET attached_item_received = TRUE WHERE id = $1`, mail.ID)
+		db.Exec(`UPDATE mail SET attached_item_received = TRUE WHERE id = $1`, mail.ID)
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfSendMail(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSendMail(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSendMail)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	query := `
 		INSERT INTO mail (sender_id, recipient_id, subject, body, attached_item, attached_item_amount, is_guild_invite)
 		VALUES ($1, $2, $3, $4, $5, $6, $7)
@@ -366,7 +358,7 @@ func handleMsgMhfSendMail(s *Session, p mhfpacket.MHFPacket) {
 			return
 		}
 		for i := 0; i < len(gm); i++ {
-			_, err := database.Exec(query, s.CharID, gm[i].CharID, pkt.Subject, pkt.Body, 0, 0, false)
+			_, err := db.Exec(query, s.CharID, gm[i].CharID, pkt.Subject, pkt.Body, 0, 0, false)
 			if err != nil {
 				s.Logger.Error("Failed to send mail")
 				s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
@@ -374,7 +366,7 @@ func handleMsgMhfSendMail(s *Session, p mhfpacket.MHFPacket) {
 			}
 		}
 	} else {
-		_, err := database.Exec(query, s.CharID, pkt.RecipientID, pkt.Subject, pkt.Body, pkt.ItemID, pkt.Quantity, false)
+		_, err := db.Exec(query, s.CharID, pkt.RecipientID, pkt.Subject, pkt.Body, pkt.ItemID, pkt.Quantity, false)
 		if err != nil {
 			s.Logger.Error("Failed to send mail")
 		}

server/channelserver/handlers_mercenary.go

@@ -5,26 +5,24 @@ import (
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/server/channelserver/compression/deltacomp"
 	"erupe-ce/server/channelserver/compression/nullcomp"
+	"fmt"
 
 	"erupe-ce/utils/byteframe"
 	"erupe-ce/utils/db"
 	"erupe-ce/utils/gametime"
 	"erupe-ce/utils/stringsupport"
-	"fmt"
 	"io"
 	"time"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
-func handleMsgMhfLoadPartner(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadPartner(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadPartner)
 	var data []byte
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT partner FROM characters WHERE id = $1", s.CharID).Scan(&data)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT partner FROM characters WHERE id = $1", s.CharID).Scan(&data)
 	if len(data) == 0 {
 		s.Logger.Error("Failed to load partner", zap.Error(err))
 		data = make([]byte, 9)
@@ -32,21 +30,18 @@ func handleMsgMhfLoadPartner(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfSavePartner(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSavePartner(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSavePartner)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	dumpSaveData(s, pkt.RawDataPayload, "partner")
-	_, err = database.Exec("UPDATE characters SET partner=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
+	_, err := db.Exec("UPDATE characters SET partner=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
 	if err != nil {
 		s.Logger.Error("Failed to save partner", zap.Error(err))
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfLoadLegendDispatch(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadLegendDispatch(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadLegendDispatch)
 	bf := byteframe.NewByteFrame()
 	legendDispatch := []struct {
@@ -65,18 +60,15 @@ func handleMsgMhfLoadLegendDispatch(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfLoadHunterNavi(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadHunterNavi(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadHunterNavi)
 	naviLength := 552
 	if config.GetConfig().ClientID <= config.G7 {
 		naviLength = 280
 	}
 	var data []byte
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT hunternavi FROM characters WHERE id = $1", s.CharID).Scan(&data)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT hunternavi FROM characters WHERE id = $1", s.CharID).Scan(&data)
 	if len(data) == 0 {
 		s.Logger.Error("Failed to load hunternavi", zap.Error(err))
 		data = make([]byte, naviLength)
@@ -84,12 +76,9 @@ func handleMsgMhfLoadHunterNavi(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfSaveHunterNavi(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSaveHunterNavi(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSaveHunterNavi)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if pkt.IsDataDiff {
 		naviLength := 552
 		if config.GetConfig().ClientID <= config.G7 {
@@ -97,7 +86,7 @@ func handleMsgMhfSaveHunterNavi(s *Session, p mhfpacket.MHFPacket) {
 		}
 		var data []byte
 		// Load existing save
-		err := database.QueryRow("SELECT hunternavi FROM characters WHERE id = $1", s.CharID).Scan(&data)
+		err := db.QueryRow("SELECT hunternavi FROM characters WHERE id = $1", s.CharID).Scan(&data)
 		if err != nil {
 			s.Logger.Error("Failed to load hunternavi", zap.Error(err))
 		}
@@ -111,7 +100,7 @@ func handleMsgMhfSaveHunterNavi(s *Session, p mhfpacket.MHFPacket) {
 		// Perform diff and compress it to write back to db
 		s.Logger.Info("Diffing...")
 		saveOutput := deltacomp.ApplyDataDiff(pkt.RawDataPayload, data)
-		_, err = database.Exec("UPDATE characters SET hunternavi=$1 WHERE id=$2", saveOutput, s.CharID)
+		_, err = db.Exec("UPDATE characters SET hunternavi=$1 WHERE id=$2", saveOutput, s.CharID)
 		if err != nil {
 			s.Logger.Error("Failed to save hunternavi", zap.Error(err))
 		}
@@ -119,7 +108,7 @@ func handleMsgMhfSaveHunterNavi(s *Session, p mhfpacket.MHFPacket) {
 	} else {
 		dumpSaveData(s, pkt.RawDataPayload, "hunternavi")
 		// simply update database, no extra processing
-		_, err := database.Exec("UPDATE characters SET hunternavi=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
+		_, err := db.Exec("UPDATE characters SET hunternavi=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
 		if err != nil {
 			s.Logger.Error("Failed to save hunternavi", zap.Error(err))
 		}
@@ -127,7 +116,7 @@ func handleMsgMhfSaveHunterNavi(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfMercenaryHuntdata(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfMercenaryHuntdata(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfMercenaryHuntdata)
 	if pkt.Unk0 == 1 {
 		// Format:
@@ -141,7 +130,7 @@ func handleMsgMhfMercenaryHuntdata(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgMhfEnumerateMercenaryLog(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateMercenaryLog(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateMercenaryLog)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(0)
@@ -154,48 +143,39 @@ func handleMsgMhfEnumerateMercenaryLog(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfCreateMercenary(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfCreateMercenary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfCreateMercenary)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	bf := byteframe.NewByteFrame()
 	var nextID uint32
-	_ = database.QueryRow("SELECT nextval('rasta_id_seq')").Scan(&nextID)
+	_ = db.QueryRow("SELECT nextval('rasta_id_seq')").Scan(&nextID)
-	database.Exec("UPDATE characters SET rasta_id=$1 WHERE id=$2", nextID, s.CharID)
+	db.Exec("UPDATE characters SET rasta_id=$1 WHERE id=$2", nextID, s.CharID)
 	bf.WriteUint32(nextID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfSaveMercenary(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSaveMercenary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSaveMercenary)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	dumpSaveData(s, pkt.MercData, "mercenary")
 	if len(pkt.MercData) > 0 {
 		temp := byteframe.NewByteFrameFromBytes(pkt.MercData)
-		database.Exec("UPDATE characters SET savemercenary=$1, rasta_id=$2 WHERE id=$3", pkt.MercData, temp.ReadUint32(), s.CharID)
+		db.Exec("UPDATE characters SET savemercenary=$1, rasta_id=$2 WHERE id=$3", pkt.MercData, temp.ReadUint32(), s.CharID)
 	}
-	database.Exec("UPDATE characters SET gcp=$1, pact_id=$2 WHERE id=$3", pkt.GCP, pkt.PactMercID, s.CharID)
+	db.Exec("UPDATE characters SET gcp=$1, pact_id=$2 WHERE id=$3", pkt.GCP, pkt.PactMercID, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfReadMercenaryW(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfReadMercenaryW(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReadMercenaryW)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	bf := byteframe.NewByteFrame()
 
 	var pactID, cid uint32
 	var name string
-	database.QueryRow("SELECT pact_id FROM characters WHERE id=$1", s.CharID).Scan(&pactID)
+	db.QueryRow("SELECT pact_id FROM characters WHERE id=$1", s.CharID).Scan(&pactID)
 	if pactID > 0 {
-		database.QueryRow("SELECT name, id FROM characters WHERE rasta_id = $1", pactID).Scan(&name, &cid)
+		db.QueryRow("SELECT name, id FROM characters WHERE rasta_id = $1", pactID).Scan(&name, &cid)
 		bf.WriteUint8(1) // numLends
 		bf.WriteUint32(pactID)
 		bf.WriteUint32(cid)
@@ -210,7 +190,7 @@ func handleMsgMhfReadMercenaryW(s *Session, p mhfpacket.MHFPacket) {
 	var loans uint8
 	temp := byteframe.NewByteFrame()
 	if pkt.Op < 2 {
-		rows, _ := database.Query("SELECT name, id, pact_id FROM characters WHERE pact_id=(SELECT rasta_id FROM characters WHERE id=$1)", s.CharID)
+		rows, _ := db.Query("SELECT name, id, pact_id FROM characters WHERE pact_id=(SELECT rasta_id FROM characters WHERE id=$1)", s.CharID)
 		for rows.Next() {
 			err := rows.Scan(&name, &cid, &pactID)
 			if err != nil {
@@ -230,8 +210,8 @@ func handleMsgMhfReadMercenaryW(s *Session, p mhfpacket.MHFPacket) {
 	if pkt.Op < 1 {
 		var data []byte
 		var gcp uint32
-		database.QueryRow("SELECT savemercenary FROM characters WHERE id=$1", s.CharID).Scan(&data)
+		db.QueryRow("SELECT savemercenary FROM characters WHERE id=$1", s.CharID).Scan(&data)
-		database.QueryRow("SELECT COALESCE(gcp, 0) FROM characters WHERE id=$1", s.CharID).Scan(&gcp)
+		db.QueryRow("SELECT COALESCE(gcp, 0) FROM characters WHERE id=$1", s.CharID).Scan(&gcp)
 
 		if len(data) == 0 {
 			bf.WriteBool(false)
@@ -245,14 +225,11 @@ func handleMsgMhfReadMercenaryW(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfReadMercenaryM(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfReadMercenaryM(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReadMercenaryM)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var data []byte
-	database.QueryRow("SELECT savemercenary FROM characters WHERE id = $1", pkt.CharID).Scan(&data)
+	db.QueryRow("SELECT savemercenary FROM characters WHERE id = $1", pkt.CharID).Scan(&data)
 	resp := byteframe.NewByteFrame()
 	if len(data) == 0 {
 		resp.WriteBool(false)
@@ -262,31 +239,25 @@ func handleMsgMhfReadMercenaryM(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfContractMercenary(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfContractMercenary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfContractMercenary)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	switch pkt.Op {
 	case 0: // Form loan
-		database.Exec("UPDATE characters SET pact_id=$1 WHERE id=$2", pkt.PactMercID, pkt.CID)
+		db.Exec("UPDATE characters SET pact_id=$1 WHERE id=$2", pkt.PactMercID, pkt.CID)
 	case 1: // Cancel lend
-		database.Exec("UPDATE characters SET pact_id=0 WHERE id=$1", s.CharID)
+		db.Exec("UPDATE characters SET pact_id=0 WHERE id=$1", s.CharID)
 	case 2: // Cancel loan
-		database.Exec("UPDATE characters SET pact_id=0 WHERE id=$1", pkt.CID)
+		db.Exec("UPDATE characters SET pact_id=0 WHERE id=$1", pkt.CID)
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfLoadOtomoAirou(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadOtomoAirou(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadOtomoAirou)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var data []byte
-	err = database.QueryRow("SELECT otomoairou FROM characters WHERE id = $1", s.CharID).Scan(&data)
+	err := db.QueryRow("SELECT otomoairou FROM characters WHERE id = $1", s.CharID).Scan(&data)
 	if len(data) == 0 {
 		s.Logger.Error("Failed to load otomoairou", zap.Error(err))
 		data = make([]byte, 10)
@@ -294,12 +265,9 @@ func handleMsgMhfLoadOtomoAirou(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfSaveOtomoAirou(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSaveOtomoAirou(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSaveOtomoAirou)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	dumpSaveData(s, pkt.RawDataPayload, "otomoairou")
 	decomp, err := nullcomp.Decompress(pkt.RawDataPayload[1:])
 	if err != nil {
@@ -317,7 +285,7 @@ func handleMsgMhfSaveOtomoAirou(s *Session, p mhfpacket.MHFPacket) {
 		dataLen := bf.ReadUint32()
 		catID := bf.ReadUint32()
 		if catID == 0 {
-			_ = database.QueryRow("SELECT nextval('airou_id_seq')").Scan(&catID)
+			_ = db.QueryRow("SELECT nextval('airou_id_seq')").Scan(&catID)
 		}
 		exists := bf.ReadBool()
 		data := bf.ReadBytes(uint(dataLen) - 5)
@@ -337,12 +305,12 @@ func handleMsgMhfSaveOtomoAirou(s *Session, p mhfpacket.MHFPacket) {
 		s.Logger.Error("Failed to compress airou", zap.Error(err))
 	} else {
 		comp = append([]byte{0x01}, comp...)
-		database.Exec("UPDATE characters SET otomoairou=$1 WHERE id=$2", comp, s.CharID)
+		db.Exec("UPDATE characters SET otomoairou=$1 WHERE id=$2", comp, s.CharID)
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfEnumerateAiroulist(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateAiroulist(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateAiroulist)
 	resp := byteframe.NewByteFrame()
 	airouList := getGuildAirouList(s)
@@ -373,7 +341,7 @@ type Airou struct {
 }
 
 func getGuildAirouList(s *Session) []Airou {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
@@ -383,7 +351,7 @@ func getGuildAirouList(s *Session) []Airou {
 	if err != nil {
 		return guildCats
 	}
-	rows, err := database.Query(`SELECT cats_used FROM guild_hunts gh
+	rows, err := db.Query(`SELECT cats_used FROM guild_hunts gh
 		INNER JOIN characters c ON gh.host_id = c.id WHERE c.id=$1
 	`, s.CharID)
 	if err != nil {
@@ -405,7 +373,7 @@ func getGuildAirouList(s *Session) []Airou {
 		}
 	}
 
-	rows, err = database.Query(`SELECT c.otomoairou FROM characters c
+	rows, err = db.Query(`SELECT c.otomoairou FROM characters c
 	INNER JOIN guild_characters gc ON gc.character_id = c.id
 	WHERE gc.guild_id = $1 AND c.otomoairou IS NOT NULL
 	ORDER BY c.id LIMIT 60`, guild.ID)

server/channelserver/handlers_mutex.go

@@ -1,13 +1,17 @@
 package channelserver
 
-import "erupe-ce/network/mhfpacket"
+import (
+	"erupe-ce/network/mhfpacket"
 
-func handleMsgSysCreateMutex(s *Session, p mhfpacket.MHFPacket) {}
+	"github.com/jmoiron/sqlx"
+)
 
-func handleMsgSysCreateOpenMutex(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysCreateMutex(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysDeleteMutex(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysCreateOpenMutex(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysOpenMutex(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysDeleteMutex(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysCloseMutex(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysOpenMutex(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
+
+func handleMsgSysCloseMutex(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_object.go

@@ -6,9 +6,11 @@ import (
 	"erupe-ce/config"
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
+
+	"github.com/jmoiron/sqlx"
 )
 
-func handleMsgSysCreateObject(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysCreateObject(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysCreateObject)
 
 	s.stage.Lock()
@@ -39,9 +41,9 @@ func handleMsgSysCreateObject(s *Session, p mhfpacket.MHFPacket) {
 	s.stage.BroadcastMHF(dupObjUpdate, s)
 }
 
-func handleMsgSysDeleteObject(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysDeleteObject(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysPositionObject(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysPositionObject(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysPositionObject)
 	if config.GetConfig().DebugOptions.LogInboundMessages {
 		fmt.Printf("[%s] with objectID [%d] move to (%f,%f,%f)\n\n", s.Name, pkt.ObjID, pkt.X, pkt.Y, pkt.Z)
@@ -58,11 +60,11 @@ func handleMsgSysPositionObject(s *Session, p mhfpacket.MHFPacket) {
 	s.stage.BroadcastMHF(pkt, s)
 }
 
-func handleMsgSysRotateObject(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysRotateObject(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysDuplicateObject(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysDuplicateObject(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysSetObjectBinary(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysSetObjectBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	_ = p.(*mhfpacket.MsgSysSetObjectBinary)
 	/* This causes issues with PS3 as this actually sends with endiness!
 	for _, session := range s.Server.sessions {
@@ -80,18 +82,18 @@ func handleMsgSysSetObjectBinary(s *Session, p mhfpacket.MHFPacket) {
 	*/
 }
 
-func handleMsgSysGetObjectBinary(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysGetObjectBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysGetObjectOwner(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysGetObjectOwner(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysUpdateObjectBinary(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysUpdateObjectBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysCleanupObject(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysCleanupObject(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysAddObject(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysAddObject(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysDelObject(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysDelObject(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysDispObject(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysDispObject(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysHideObject(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysHideObject(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_plate.go

@@ -4,37 +4,30 @@ import (
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/server/channelserver/compression/deltacomp"
 	"erupe-ce/server/channelserver/compression/nullcomp"
-	"erupe-ce/utils/db"
-	"fmt"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
-func handleMsgMhfLoadPlateData(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadPlateData(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadPlateData)
 	var data []byte
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT platedata FROM characters WHERE id = $1", s.CharID).Scan(&data)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT platedata FROM characters WHERE id = $1", s.CharID).Scan(&data)
 	if err != nil {
 		s.Logger.Error("Failed to load platedata", zap.Error(err))
 	}
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfSavePlateData(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSavePlateData(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSavePlateData)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if pkt.IsDataDiff {
 		var data []byte
 
 		// Load existing save
-		err := database.QueryRow("SELECT platedata FROM characters WHERE id = $1", s.CharID).Scan(&data)
+		err := db.QueryRow("SELECT platedata FROM characters WHERE id = $1", s.CharID).Scan(&data)
 		if err != nil {
 			s.Logger.Error("Failed to load platedata", zap.Error(err))
 			s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
@@ -64,7 +57,7 @@ func handleMsgMhfSavePlateData(s *Session, p mhfpacket.MHFPacket) {
 			return
 		}
 
-		_, err = database.Exec("UPDATE characters SET platedata=$1 WHERE id=$2", saveOutput, s.CharID)
+		_, err = db.Exec("UPDATE characters SET platedata=$1 WHERE id=$2", saveOutput, s.CharID)
 		if err != nil {
 			s.Logger.Error("Failed to save platedata", zap.Error(err))
 			s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
@@ -75,7 +68,7 @@ func handleMsgMhfSavePlateData(s *Session, p mhfpacket.MHFPacket) {
 	} else {
 		dumpSaveData(s, pkt.RawDataPayload, "platedata")
 		// simply update database, no extra processing
-		_, err := database.Exec("UPDATE characters SET platedata=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
+		_, err := db.Exec("UPDATE characters SET platedata=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
 		if err != nil {
 			s.Logger.Error("Failed to save platedata", zap.Error(err))
 		}
@@ -84,31 +77,25 @@ func handleMsgMhfSavePlateData(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfLoadPlateBox(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadPlateBox(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadPlateBox)
 	var data []byte
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT platebox FROM characters WHERE id = $1", s.CharID).Scan(&data)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT platebox FROM characters WHERE id = $1", s.CharID).Scan(&data)
 	if err != nil {
 		s.Logger.Error("Failed to load platebox", zap.Error(err))
 	}
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfSavePlateBox(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSavePlateBox(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSavePlateBox)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if pkt.IsDataDiff {
 		var data []byte
 
 		// Load existing save
-		err := database.QueryRow("SELECT platebox FROM characters WHERE id = $1", s.CharID).Scan(&data)
+		err := db.QueryRow("SELECT platebox FROM characters WHERE id = $1", s.CharID).Scan(&data)
 		if err != nil {
 			s.Logger.Error("Failed to load platebox", zap.Error(err))
 			s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
@@ -139,7 +126,7 @@ func handleMsgMhfSavePlateBox(s *Session, p mhfpacket.MHFPacket) {
 			return
 		}
 
-		_, err = database.Exec("UPDATE characters SET platebox=$1 WHERE id=$2", saveOutput, s.CharID)
+		_, err = db.Exec("UPDATE characters SET platebox=$1 WHERE id=$2", saveOutput, s.CharID)
 		if err != nil {
 			s.Logger.Error("Failed to save platebox", zap.Error(err))
 			s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
@@ -150,7 +137,7 @@ func handleMsgMhfSavePlateBox(s *Session, p mhfpacket.MHFPacket) {
 	} else {
 		dumpSaveData(s, pkt.RawDataPayload, "platebox")
 		// simply update database, no extra processing
-		_, err := database.Exec("UPDATE characters SET platebox=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
+		_, err := db.Exec("UPDATE characters SET platebox=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
 		if err != nil {
 			s.Logger.Error("Failed to save platebox", zap.Error(err))
 		}
@@ -158,14 +145,11 @@ func handleMsgMhfSavePlateBox(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfLoadPlateMyset(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadPlateMyset(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadPlateMyset)
 	var data []byte
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT platemyset FROM characters WHERE id = $1", s.CharID).Scan(&data)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT platemyset FROM characters WHERE id = $1", s.CharID).Scan(&data)
 	if len(data) == 0 {
 		s.Logger.Error("Failed to load platemyset", zap.Error(err))
 		data = make([]byte, 1920)
@@ -173,15 +157,12 @@ func handleMsgMhfLoadPlateMyset(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfSavePlateMyset(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSavePlateMyset(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSavePlateMyset)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	// looks to always return the full thing, simply update database, no extra processing
 	dumpSaveData(s, pkt.RawDataPayload, "platemyset")
-	_, err = database.Exec("UPDATE characters SET platemyset=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
+	_, err := db.Exec("UPDATE characters SET platemyset=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
 	if err != nil {
 		s.Logger.Error("Failed to save platemyset", zap.Error(err))
 	}

server/channelserver/handlers_quest.go

@@ -4,7 +4,6 @@ import (
 	"database/sql"
 	"encoding/binary"
 	"erupe-ce/utils/byteframe"
-	"erupe-ce/utils/db"
 	"erupe-ce/utils/decryption"
 	"erupe-ce/utils/gametime"
 
@@ -17,6 +16,7 @@ import (
 	"path/filepath"
 	"time"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
@@ -91,7 +91,7 @@ func BackportQuest(data []byte) []byte {
 	return data
 }
 
-func handleMsgSysGetFile(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysGetFile(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysGetFile)
 
 	if pkt.IsScenario {
@@ -167,14 +167,11 @@ func seasonConversion(s *Session, questFile string) string {
 	}
 }
 
-func handleMsgMhfLoadFavoriteQuest(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadFavoriteQuest(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadFavoriteQuest)
 	var data []byte
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT savefavoritequest FROM characters WHERE id = $1", s.CharID).Scan(&data)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT savefavoritequest FROM characters WHERE id = $1", s.CharID).Scan(&data)
 	if err == nil && len(data) > 0 {
 		s.DoAckBufSucceed(pkt.AckHandle, data)
 	} else {
@@ -182,14 +179,11 @@ func handleMsgMhfLoadFavoriteQuest(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgMhfSaveFavoriteQuest(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSaveFavoriteQuest(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSaveFavoriteQuest)
 	dumpSaveData(s, pkt.Data, "favquest")
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec("UPDATE characters SET savefavoritequest=$1 WHERE id=$2", pkt.Data, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec("UPDATE characters SET savefavoritequest=$1 WHERE id=$2", pkt.Data, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
@@ -330,19 +324,16 @@ func makeEventQuest(s *Session, rows *sql.Rows) ([]byte, error) {
 	return bf.Data(), nil
 }
 
-func handleMsgMhfEnumerateQuest(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateQuest(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateQuest)
 	var totalCount, returnedCount uint16
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint16(0)
-	database, err := db.GetDB()
+
-	if err != nil {
+	rows, err := db.Query("SELECT id, COALESCE(max_players, 4) AS max_players, quest_type, quest_id, COALESCE(mark, 0) AS mark, COALESCE(flags, -1), start_time, COALESCE(active_days, 0) AS active_days, COALESCE(inactive_days, 0) AS inactive_days FROM event_quests ORDER BY quest_id")
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	rows, err := database.Query("SELECT id, COALESCE(max_players, 4) AS max_players, quest_type, quest_id, COALESCE(mark, 0) AS mark, COALESCE(flags, -1), start_time, COALESCE(active_days, 0) AS active_days, COALESCE(inactive_days, 0) AS inactive_days FROM event_quests ORDER BY quest_id")
 	if err == nil {
 		currentTime := time.Now()
-		tx, _ := database.Begin()
+		tx, _ := db.Begin()
 
 		for rows.Next() {
 			var id, mark uint32
@@ -667,9 +658,9 @@ func getTuneValueRange(start uint16, value uint16) []tuneValue {
 	return tv
 }
 
-func handleMsgMhfEnterTournamentQuest(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfEnterTournamentQuest(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfGetUdBonusQuestInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdBonusQuestInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdBonusQuestInfo)
 
 	udBonusQuestInfos := []struct {

server/channelserver/handlers_register.go

@@ -5,9 +5,11 @@ import (
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
 	"strings"
+
+	"github.com/jmoiron/sqlx"
 )
 
-func handleMsgMhfRegisterEvent(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfRegisterEvent(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfRegisterEvent)
 	bf := byteframe.NewByteFrame()
 	// Some kind of check if there's already a session
@@ -21,7 +23,7 @@ func handleMsgMhfRegisterEvent(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfReleaseEvent(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfReleaseEvent(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReleaseEvent)
 
 	// Do this ack manually because it uses a non-(0|1) error code
@@ -56,7 +58,7 @@ type RaviUpdate struct {
 	Data uint32
 }
 
-func handleMsgSysOperateRegister(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysOperateRegister(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysOperateRegister)
 
 	var raviUpdates []RaviUpdate
@@ -93,7 +95,7 @@ func handleMsgSysOperateRegister(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgSysLoadRegister(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysLoadRegister(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysLoadRegister)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint8(0)
@@ -142,4 +144,4 @@ func (server *ChannelServer) getRaviSemaphore() *Semaphore {
 	return nil
 }
 
-func handleMsgSysNotifyRegister(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysNotifyRegister(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_rengoku.go

@@ -2,7 +2,6 @@ package channelserver
 
 import (
 	"erupe-ce/config"
-	"erupe-ce/utils/db"
 	ps "erupe-ce/utils/pascalstring"
 	"fmt"
 	"os"
@@ -16,16 +15,13 @@ import (
 	"go.uber.org/zap"
 )
 
-func handleMsgMhfSaveRengokuData(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfSaveRengokuData(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	// saved every floor on road, holds values such as floors progressed, points etc.
 	// can be safely handled by the client
 	pkt := p.(*mhfpacket.MsgMhfSaveRengokuData)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	dumpSaveData(s, pkt.RawDataPayload, "rengoku")
-	_, err = database.Exec("UPDATE characters SET rengokudata=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
+	_, err := db.Exec("UPDATE characters SET rengokudata=$1 WHERE id=$2", pkt.RawDataPayload, s.CharID)
 	if err != nil {
 		s.Logger.Error("Failed to save rengokudata", zap.Error(err))
 		s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
@@ -39,22 +35,19 @@ func handleMsgMhfSaveRengokuData(s *Session, p mhfpacket.MHFPacket) {
 	maxStageSp := bf.ReadUint32()
 	maxScoreSp := bf.ReadUint32()
 	var t int
-	err = database.QueryRow("SELECT character_id FROM rengoku_score WHERE character_id=$1", s.CharID).Scan(&t)
+	err = db.QueryRow("SELECT character_id FROM rengoku_score WHERE character_id=$1", s.CharID).Scan(&t)
 	if err != nil {
-		database.Exec("INSERT INTO rengoku_score (character_id) VALUES ($1)", s.CharID)
+		db.Exec("INSERT INTO rengoku_score (character_id) VALUES ($1)", s.CharID)
 	}
-	database.Exec("UPDATE rengoku_score SET max_stages_mp=$1, max_points_mp=$2, max_stages_sp=$3, max_points_sp=$4 WHERE character_id=$5", maxStageMp, maxScoreMp, maxStageSp, maxScoreSp, s.CharID)
+	db.Exec("UPDATE rengoku_score SET max_stages_mp=$1, max_points_mp=$2, max_stages_sp=$3, max_points_sp=$4 WHERE character_id=$5", maxStageMp, maxScoreMp, maxStageSp, maxScoreSp, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfLoadRengokuData(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfLoadRengokuData(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadRengokuData)
 	var data []byte
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT rengokudata FROM characters WHERE id = $1", s.CharID).Scan(&data)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT rengokudata FROM characters WHERE id = $1", s.CharID).Scan(&data)
 	if err != nil {
 		s.Logger.Error("Failed to load rengokudata", zap.Error(err))
 	}
@@ -101,7 +94,7 @@ func handleMsgMhfLoadRengokuData(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgMhfGetRengokuBinary(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetRengokuBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetRengokuBinary)
 	// a (massively out of date) version resides in the game's /dat/ folder or up to date can be pulled from packets
 	data, err := os.ReadFile(filepath.Join(config.GetConfig().BinPath, "rengoku_data.bin"))
@@ -120,7 +113,7 @@ type RengokuScore struct {
 	Score uint32 `db:"score"`
 }
 
-func handleMsgMhfEnumerateRengokuRanking(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateRengokuRanking(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateRengokuRanking)
 
 	guild, _ := GetGuildInfoByCharacterId(s, s.CharID)
@@ -141,28 +134,25 @@ func handleMsgMhfEnumerateRengokuRanking(s *Session, p mhfpacket.MHFPacket) {
 	i := uint32(1)
 	bf := byteframe.NewByteFrame()
 	scoreData := byteframe.NewByteFrame()
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var rows *sqlx.Rows
 	switch pkt.Leaderboard {
 	case 0:
-		rows, _ = database.Queryx(fmt.Sprintf("SELECT max_stages_mp AS score %s ORDER BY max_stages_mp DESC", rengokuScoreQuery))
+		rows, _ = db.Queryx(fmt.Sprintf("SELECT max_stages_mp AS score %s ORDER BY max_stages_mp DESC", rengokuScoreQuery))
 	case 1:
-		rows, _ = database.Queryx(fmt.Sprintf("SELECT max_points_mp AS score %s ORDER BY max_points_mp DESC", rengokuScoreQuery))
+		rows, _ = db.Queryx(fmt.Sprintf("SELECT max_points_mp AS score %s ORDER BY max_points_mp DESC", rengokuScoreQuery))
 	case 2:
-		rows, _ = database.Queryx(fmt.Sprintf("SELECT max_stages_mp AS score %s WHERE guild_id=$1 ORDER BY max_stages_mp DESC", rengokuScoreQuery), guild.ID)
+		rows, _ = db.Queryx(fmt.Sprintf("SELECT max_stages_mp AS score %s WHERE guild_id=$1 ORDER BY max_stages_mp DESC", rengokuScoreQuery), guild.ID)
 	case 3:
-		rows, _ = database.Queryx(fmt.Sprintf("SELECT max_points_mp AS score %s WHERE guild_id=$1 ORDER BY max_points_mp DESC", rengokuScoreQuery), guild.ID)
+		rows, _ = db.Queryx(fmt.Sprintf("SELECT max_points_mp AS score %s WHERE guild_id=$1 ORDER BY max_points_mp DESC", rengokuScoreQuery), guild.ID)
 	case 4:
-		rows, _ = database.Queryx(fmt.Sprintf("SELECT max_stages_sp AS score %s ORDER BY max_stages_sp DESC", rengokuScoreQuery))
+		rows, _ = db.Queryx(fmt.Sprintf("SELECT max_stages_sp AS score %s ORDER BY max_stages_sp DESC", rengokuScoreQuery))
 	case 5:
-		rows, _ = database.Queryx(fmt.Sprintf("SELECT max_points_sp AS score %s ORDER BY max_points_sp DESC", rengokuScoreQuery))
+		rows, _ = db.Queryx(fmt.Sprintf("SELECT max_points_sp AS score %s ORDER BY max_points_sp DESC", rengokuScoreQuery))
 	case 6:
-		rows, _ = database.Queryx(fmt.Sprintf("SELECT max_stages_sp AS score %s WHERE guild_id=$1 ORDER BY max_stages_sp DESC", rengokuScoreQuery), guild.ID)
+		rows, _ = db.Queryx(fmt.Sprintf("SELECT max_stages_sp AS score %s WHERE guild_id=$1 ORDER BY max_stages_sp DESC", rengokuScoreQuery), guild.ID)
 	case 7:
-		rows, _ = database.Queryx(fmt.Sprintf("SELECT max_points_sp AS score %s WHERE guild_id=$1 ORDER BY max_points_sp DESC", rengokuScoreQuery), guild.ID)
+		rows, _ = db.Queryx(fmt.Sprintf("SELECT max_points_sp AS score %s WHERE guild_id=$1 ORDER BY max_points_sp DESC", rengokuScoreQuery), guild.ID)
 	}
 
 	for rows.Next() {
@@ -193,7 +183,7 @@ func handleMsgMhfEnumerateRengokuRanking(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfGetRengokuRankingRank(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetRengokuRankingRank(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetRengokuRankingRank)
 	// What is this for?
 	bf := byteframe.NewByteFrame()

server/channelserver/handlers_reserve.go

@@ -2,130 +2,132 @@ package channelserver
 
 import (
 	"erupe-ce/network/mhfpacket"
+
+	"github.com/jmoiron/sqlx"
 )
 
-func handleMsgSysReserve188(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysReserve188(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysReserve188)
 
 	// Left as raw bytes because I couldn't easily find the request or resp parser function in the binary.
 	s.DoAckBufSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgSysReserve18B(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysReserve18B(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysReserve18B)
 
 	// Left as raw bytes because I couldn't easily find the request or resp parser function in the binary.
 	s.DoAckBufSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x3C})
 }
 
-func handleMsgSysReserve55(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve55(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve56(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve56(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve57(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve57(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve01(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve01(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve02(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve02(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve03(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve03(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve04(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve04(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve05(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve05(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve06(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve06(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve07(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve07(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve0C(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve0C(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve0D(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve0D(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve0E(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve0E(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve4A(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve4A(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve4B(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve4B(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve4C(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve4C(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve4D(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve4D(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve4E(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve4E(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve4F(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve4F(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve5C(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve5C(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve5E(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve5E(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve5F(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve5F(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve71(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve71(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve72(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve72(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve73(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve73(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve74(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve74(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve75(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve75(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve76(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve76(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve77(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve77(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve78(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve78(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve79(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve79(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve7A(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve7A(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve7B(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve7B(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve7C(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve7C(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve7E(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve7E(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfReserve10F(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfReserve10F(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve180(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve180(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve18E(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve18E(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve18F(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve18F(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve19E(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve19E(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve19F(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve19F(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve1A4(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve1A4(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve1A6(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve1A6(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve1A7(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve1A7(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve1A8(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve1A8(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve1A9(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve1A9(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve1AA(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve1AA(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve1AB(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve1AB(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve1AC(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve1AC(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve1AD(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve1AD(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve1AE(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve1AE(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve1AF(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve1AF(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve19B(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve19B(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve192(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve192(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve193(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve193(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysReserve194(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysReserve194(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_reward.go

@@ -5,9 +5,11 @@ import (
 
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
+
+	"github.com/jmoiron/sqlx"
 )
 
-func handleMsgMhfGetAdditionalBeatReward(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetAdditionalBeatReward(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetAdditionalBeatReward)
 	// Actual response in packet captures are all just giant batches of null bytes
 	// I'm assuming this is because it used to be tied to an actual event and
@@ -15,25 +17,25 @@ func handleMsgMhfGetAdditionalBeatReward(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 0x104))
 }
 
-func handleMsgMhfGetUdRankingRewardList(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdRankingRewardList(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdRankingRewardList)
 	// Temporary canned response
 	data, _ := hex.DecodeString("0100001600000A5397DF00000000000000000000000000000000")
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfGetRewardSong(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetRewardSong(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetRewardSong)
 	// Temporary canned response
 	data, _ := hex.DecodeString("0100001600000A5397DF00000000000000000000000000000000")
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfUseRewardSong(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfUseRewardSong(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfAddRewardSongCount(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfAddRewardSongCount(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfAcquireMonthlyReward(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAcquireMonthlyReward(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireMonthlyReward)
 
 	resp := byteframe.NewByteFrame()
@@ -42,4 +44,4 @@ func handleMsgMhfAcquireMonthlyReward(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfAcceptReadReward(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfAcceptReadReward(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_seibattle.go

@@ -3,9 +3,11 @@ package channelserver
 import (
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
+
+	"github.com/jmoiron/sqlx"
 )
 
-func handleMsgMhfGetBreakSeibatuLevelReward(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetBreakSeibatuLevelReward(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetBreakSeibatuLevelReward)
 	bf := byteframe.NewByteFrame()
 	bf.WriteInt32(0)
@@ -24,7 +26,7 @@ type WeeklySeibatuRankingReward struct {
 	Unk5 int32
 }
 
-func handleMsgMhfGetWeeklySeibatuRankingReward(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetWeeklySeibatuRankingReward(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetWeeklySeibatuRankingReward)
 	var data []*byteframe.ByteFrame
 	weeklySeibatuRankingRewards := []WeeklySeibatuRankingReward{
@@ -43,7 +45,7 @@ func handleMsgMhfGetWeeklySeibatuRankingReward(s *Session, p mhfpacket.MHFPacket
 	s.DoAckEarthSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfGetFixedSeibatuRankingTable(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetFixedSeibatuRankingTable(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetFixedSeibatuRankingTable)
 	bf := byteframe.NewByteFrame()
 	bf.WriteInt32(0)
@@ -52,7 +54,7 @@ func handleMsgMhfGetFixedSeibatuRankingTable(s *Session, p mhfpacket.MHFPacket)
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfReadBeatLevel(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfReadBeatLevel(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReadBeatLevel)
 
 	// This response is fixed and will never change on JP,
@@ -68,7 +70,7 @@ func handleMsgMhfReadBeatLevel(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfReadLastWeekBeatRanking(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfReadLastWeekBeatRanking(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReadLastWeekBeatRanking)
 	bf := byteframe.NewByteFrame()
 	bf.WriteInt32(0)
@@ -78,13 +80,13 @@ func handleMsgMhfReadLastWeekBeatRanking(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfUpdateBeatLevel(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUpdateBeatLevel(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateBeatLevel)
 
 	s.DoAckBufSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfReadBeatLevelAllRanking(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfReadBeatLevelAllRanking(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReadBeatLevelAllRanking)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(0)
@@ -99,7 +101,7 @@ func handleMsgMhfReadBeatLevelAllRanking(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfReadBeatLevelMyRanking(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfReadBeatLevelMyRanking(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReadBeatLevelMyRanking)
 	bf := byteframe.NewByteFrame()
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())

server/channelserver/handlers_semaphore.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 
 	"erupe-ce/network/mhfpacket"
@@ -20,7 +21,7 @@ func removeSessionFromSemaphore(s *Session) {
 	s.Server.semaphoreLock.Unlock()
 }
 
-func handleMsgSysCreateSemaphore(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysCreateSemaphore(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysCreateSemaphore)
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x03, 0x00, 0x0d})
 }
@@ -39,7 +40,7 @@ func destructEmptySemaphores(s *Session) {
 	s.Server.semaphoreLock.Unlock()
 }
 
-func handleMsgSysDeleteSemaphore(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysDeleteSemaphore(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysDeleteSemaphore)
 	destructEmptySemaphores(s)
 	s.Server.semaphoreLock.Lock()
@@ -62,7 +63,7 @@ func handleMsgSysDeleteSemaphore(s *Session, p mhfpacket.MHFPacket) {
 	s.Server.semaphoreLock.Unlock()
 }
 
-func handleMsgSysCreateAcquireSemaphore(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysCreateAcquireSemaphore(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysCreateAcquireSemaphore)
 	SemaphoreID := pkt.SemaphoreID
 
@@ -110,7 +111,7 @@ func handleMsgSysCreateAcquireSemaphore(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgSysAcquireSemaphore(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysAcquireSemaphore(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysAcquireSemaphore)
 	if sema, exists := s.Server.semaphore[pkt.SemaphoreID]; exists {
 		sema.host = s
@@ -122,11 +123,11 @@ func handleMsgSysAcquireSemaphore(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgSysReleaseSemaphore(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysReleaseSemaphore(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	//pkt := p.(*mhfpacket.MsgSysReleaseSemaphore)
 }
 
-func handleMsgSysCheckSemaphore(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysCheckSemaphore(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysCheckSemaphore)
 	resp := []byte{0x00, 0x00, 0x00, 0x00}
 	s.Server.semaphoreLock.Lock()

server/channelserver/handlers_shop_gacha.go

@@ -9,6 +9,8 @@ import (
 	ps "erupe-ce/utils/pascalstring"
 	"fmt"
 	"math/rand"
+
+	"github.com/jmoiron/sqlx"
 )
 
 type ShopItem struct {
@@ -92,13 +94,14 @@ func writeShopItems(bf *byteframe.ByteFrame, items []ShopItem) {
 }
 
 func getShopItems(s *Session, shopType uint8, shopID uint32) []ShopItem {
-	var items []ShopItem
+	db, err := db.GetDB()
-	var temp ShopItem
-	database, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	rows, err := database.Queryx(`SELECT id, item_id, cost, quantity, min_hr, min_sr, min_gr, store_level, max_quantity,
+	var items []ShopItem
+	var temp ShopItem
+
+	rows, err := db.Queryx(`SELECT id, item_id, cost, quantity, min_hr, min_sr, min_gr, store_level, max_quantity,
        		COALESCE((SELECT bought FROM shop_items_bought WHERE shop_item_id=si.id AND character_id=$3), 0) as used_quantity,
        		road_floors, road_fatalis FROM shop_items si WHERE shop_type=$1 AND shop_id=$2
        		`, shopType, shopID, s.CharID)
@@ -114,12 +117,9 @@ func getShopItems(s *Session, shopType uint8, shopID uint32) []ShopItem {
 	return items
 }
 
-func handleMsgMhfEnumerateShop(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEnumerateShop(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateShop)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	// Generic Shop IDs
 	// 0: basic item
 	// 1: gatherables
@@ -138,7 +138,7 @@ func handleMsgMhfEnumerateShop(s *Session, p mhfpacket.MHFPacket) {
 			return
 		}
 
-		rows, err := database.Queryx("SELECT id, min_gr, min_hr, name, url_banner, url_feature, url_thumbnail, wide, recommended, gacha_type, hidden FROM gacha_shop")
+		rows, err := db.Queryx("SELECT id, min_gr, min_hr, name, url_banner, url_feature, url_thumbnail, wide, recommended, gacha_type, hidden FROM gacha_shop")
 		if err != nil {
 			s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 4))
 			return
@@ -185,14 +185,14 @@ func handleMsgMhfEnumerateShop(s *Session, p mhfpacket.MHFPacket) {
 		bf := byteframe.NewByteFrame()
 		bf.WriteUint32(pkt.ShopID)
 		var gachaType int
-		database.QueryRow(`SELECT gacha_type FROM gacha_shop WHERE id = $1`, pkt.ShopID).Scan(&gachaType)
+		db.QueryRow(`SELECT gacha_type FROM gacha_shop WHERE id = $1`, pkt.ShopID).Scan(&gachaType)
-		rows, err := database.Queryx(`SELECT entry_type, id, item_type, item_number, item_quantity, weight, rarity, rolls, daily_limit, frontier_points, COALESCE(name, '') AS name FROM gacha_entries WHERE gacha_id = $1 ORDER BY weight DESC`, pkt.ShopID)
+		rows, err := db.Queryx(`SELECT entry_type, id, item_type, item_number, item_quantity, weight, rarity, rolls, daily_limit, frontier_points, COALESCE(name, '') AS name FROM gacha_entries WHERE gacha_id = $1 ORDER BY weight DESC`, pkt.ShopID)
 		if err != nil {
 			s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 4))
 			return
 		}
 		var divisor float64
-		database.QueryRow(`SELECT COALESCE(SUM(weight) / 100000.0, 0) AS chance FROM gacha_entries WHERE gacha_id = $1`, pkt.ShopID).Scan(&divisor)
+		db.QueryRow(`SELECT COALESCE(SUM(weight) / 100000.0, 0) AS chance FROM gacha_entries WHERE gacha_id = $1`, pkt.ShopID).Scan(&divisor)
 
 		var entry GachaEntry
 		var entries []GachaEntry
@@ -219,7 +219,7 @@ func handleMsgMhfEnumerateShop(s *Session, p mhfpacket.MHFPacket) {
 			bf.WriteUint8(ge.Rarity)
 			bf.WriteUint8(ge.Rolls)
 
-			rows, err = database.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id=$1`, ge.ID)
+			rows, err = db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id=$1`, ge.ID)
 			if err != nil {
 				bf.WriteUint8(0)
 			} else {
@@ -271,21 +271,18 @@ func handleMsgMhfEnumerateShop(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgMhfAcquireExchangeShop(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAcquireExchangeShop(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireExchangeShop)
 	bf := byteframe.NewByteFrameFromBytes(pkt.RawDataPayload)
 	exchanges := int(bf.ReadUint16())
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	for i := 0; i < exchanges; i++ {
 		itemHash := bf.ReadUint32()
 		if itemHash == 0 {
 			continue
 		}
 		buyCount := bf.ReadUint32()
-		database.Exec(`INSERT INTO shop_items_bought (character_id, shop_item_id, bought)
+		db.Exec(`INSERT INTO shop_items_bought (character_id, shop_item_id, bought)
 			VALUES ($1,$2,$3) ON CONFLICT (character_id, shop_item_id)
 			DO UPDATE SET bought = bought + $3
 			WHERE EXCLUDED.character_id=$1 AND EXCLUDED.shop_item_id=$2
@@ -294,21 +291,18 @@ func handleMsgMhfAcquireExchangeShop(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfGetGachaPlayHistory(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetGachaPlayHistory(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGachaPlayHistory)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint8(1)
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfGetGachaPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetGachaPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGachaPoint)
 	var fp, gp, gt uint32
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.QueryRow("SELECT COALESCE(frontier_points, 0), COALESCE(gacha_premium, 0), COALESCE(gacha_trial, 0) FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)", s.CharID).Scan(&fp, &gp, &gt)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.QueryRow("SELECT COALESCE(frontier_points, 0), COALESCE(gacha_premium, 0), COALESCE(gacha_trial, 0) FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)", s.CharID).Scan(&fp, &gp, &gt)
 	resp := byteframe.NewByteFrame()
 	resp.WriteUint32(gp)
 	resp.WriteUint32(gt)
@@ -316,44 +310,44 @@ func handleMsgMhfGetGachaPoint(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, resp.Data())
 }
 
-func handleMsgMhfUseGachaPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfUseGachaPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUseGachaPoint)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if pkt.TrialCoins > 0 {
-		database.Exec(`UPDATE users u SET gacha_trial=gacha_trial-$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, pkt.TrialCoins, s.CharID)
+		db.Exec(`UPDATE users u SET gacha_trial=gacha_trial-$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, pkt.TrialCoins, s.CharID)
 	}
 	if pkt.PremiumCoins > 0 {
-		database.Exec(`UPDATE users u SET gacha_premium=gacha_premium-$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, pkt.PremiumCoins, s.CharID)
+		db.Exec(`UPDATE users u SET gacha_premium=gacha_premium-$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, pkt.PremiumCoins, s.CharID)
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
 func spendGachaCoin(s *Session, quantity uint16) {
-	var gt uint16
+
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	database.QueryRow(`SELECT COALESCE(gacha_trial, 0) FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&gt)
+	var gt uint16
+
+	db.QueryRow(`SELECT COALESCE(gacha_trial, 0) FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&gt)
 	if quantity <= gt {
-		database.Exec(`UPDATE users u SET gacha_trial=gacha_trial-$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, quantity, s.CharID)
+		db.Exec(`UPDATE users u SET gacha_trial=gacha_trial-$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, quantity, s.CharID)
 	} else {
-		database.Exec(`UPDATE users u SET gacha_premium=gacha_premium-$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, quantity, s.CharID)
+		db.Exec(`UPDATE users u SET gacha_premium=gacha_premium-$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, quantity, s.CharID)
 	}
 }
 
 func transactGacha(s *Session, gachaID uint32, rollID uint8) (error, int) {
-	var itemType uint8
+	db, err := db.GetDB()
-	var itemNumber uint16
-	var rolls int
-	database, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	err = database.QueryRowx(`SELECT item_type, item_number, rolls FROM gacha_entries WHERE gacha_id = $1 AND entry_type = $2`, gachaID, rollID).Scan(&itemType, &itemNumber, &rolls)
+	var itemType uint8
+	var itemNumber uint16
+	var rolls int
+
+	err = db.QueryRowx(`SELECT item_type, item_number, rolls FROM gacha_entries WHERE gacha_id = $1 AND entry_type = $2`, gachaID, rollID).Scan(&itemType, &itemNumber, &rolls)
 	if err != nil {
 		return err, 0
 	}
@@ -374,19 +368,20 @@ func transactGacha(s *Session, gachaID uint32, rollID uint8) (error, int) {
 	case 20:
 		spendGachaCoin(s, itemNumber)
 	case 21:
-		database.Exec("UPDATE users u SET frontier_points=frontier_points-$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", itemNumber, s.CharID)
+		db.Exec("UPDATE users u SET frontier_points=frontier_points-$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", itemNumber, s.CharID)
 	}
 	return nil, rolls
 }
 
 func getGuaranteedItems(s *Session, gachaID uint32, rollID uint8) []GachaItem {
-	var rewards []GachaItem
+	db, err := db.GetDB()
-	var reward GachaItem
-	database, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	items, err := database.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = (SELECT id FROM gacha_entries WHERE entry_type = $1 AND gacha_id = $2)`, rollID, gachaID)
+	var rewards []GachaItem
+	var reward GachaItem
+
+	items, err := db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = (SELECT id FROM gacha_entries WHERE entry_type = $1 AND gacha_id = $2)`, rollID, gachaID)
 	if err == nil {
 		for items.Next() {
 			items.StructScan(&reward)
@@ -397,12 +392,13 @@ func getGuaranteedItems(s *Session, gachaID uint32, rollID uint8) []GachaItem {
 }
 
 func addGachaItem(s *Session, items []GachaItem) {
-	var data []byte
+	db, err := db.GetDB()
-	database, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	database.QueryRow(`SELECT gacha_items FROM characters WHERE id = $1`, s.CharID).Scan(&data)
+	var data []byte
+
+	db.QueryRow(`SELECT gacha_items FROM characters WHERE id = $1`, s.CharID).Scan(&data)
 	if len(data) > 0 {
 		numItems := int(data[0])
 		data = data[1:]
@@ -422,7 +418,7 @@ func addGachaItem(s *Session, items []GachaItem) {
 		newItem.WriteUint16(items[i].ItemID)
 		newItem.WriteUint16(items[i].Quantity)
 	}
-	database.Exec(`UPDATE characters SET gacha_items = $1 WHERE id = $2`, newItem.Data(), s.CharID)
+	db.Exec(`UPDATE characters SET gacha_items = $1 WHERE id = $2`, newItem.Data(), s.CharID)
 }
 
 func getRandomEntries(entries []GachaEntry, rolls int, isBox bool) ([]GachaEntry, error) {
@@ -454,14 +450,11 @@ func getRandomEntries(entries []GachaEntry, rolls int, isBox bool) ([]GachaEntry
 	return chosen, nil
 }
 
-func handleMsgMhfReceiveGachaItem(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfReceiveGachaItem(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReceiveGachaItem)
 	var data []byte
-	database, err := db.GetDB()
+
-	if err != nil {
+	err := db.QueryRow("SELECT COALESCE(gacha_items, $2) FROM characters WHERE id = $1", s.CharID, []byte{0x00}).Scan(&data)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	err = database.QueryRow("SELECT COALESCE(gacha_items, $2) FROM characters WHERE id = $1", s.CharID, []byte{0x00}).Scan(&data)
 	if err != nil {
 		data = []byte{0x00}
 	}
@@ -481,31 +474,28 @@ func handleMsgMhfReceiveGachaItem(s *Session, p mhfpacket.MHFPacket) {
 			update := byteframe.NewByteFrame()
 			update.WriteUint8(uint8(len(data[181:]) / 5))
 			update.WriteBytes(data[181:])
-			database.Exec("UPDATE characters SET gacha_items = $1 WHERE id = $2", update.Data(), s.CharID)
+			db.Exec("UPDATE characters SET gacha_items = $1 WHERE id = $2", update.Data(), s.CharID)
 		} else {
-			database.Exec("UPDATE characters SET gacha_items = null WHERE id = $1", s.CharID)
+			db.Exec("UPDATE characters SET gacha_items = null WHERE id = $1", s.CharID)
 		}
 	}
 }
 
-func handleMsgMhfPlayNormalGacha(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPlayNormalGacha(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPlayNormalGacha)
 	bf := byteframe.NewByteFrame()
 	var entries []GachaEntry
 	var entry GachaEntry
 	var rewards []GachaItem
 	var reward GachaItem
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	err, rolls := transactGacha(s, pkt.GachaID, pkt.RollType)
 	if err != nil {
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 1))
 		return
 	}
 
-	rows, err := database.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
+	rows, err := db.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
 	if err != nil {
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 1))
 		return
@@ -521,7 +511,7 @@ func handleMsgMhfPlayNormalGacha(s *Session, p mhfpacket.MHFPacket) {
 	rewardEntries, err := getRandomEntries(entries, rolls, false)
 	temp := byteframe.NewByteFrame()
 	for i := range rewardEntries {
-		rows, err = database.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = $1`, rewardEntries[i].ID)
+		rows, err = db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = $1`, rewardEntries[i].ID)
 		if err != nil {
 			continue
 		}
@@ -544,7 +534,7 @@ func handleMsgMhfPlayNormalGacha(s *Session, p mhfpacket.MHFPacket) {
 	addGachaItem(s, rewards)
 }
 
-func handleMsgMhfPlayStepupGacha(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPlayStepupGacha(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPlayStepupGacha)
 	bf := byteframe.NewByteFrame()
 	var entries []GachaEntry
@@ -556,15 +546,12 @@ func handleMsgMhfPlayStepupGacha(s *Session, p mhfpacket.MHFPacket) {
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 1))
 		return
 	}
-	database, err := db.GetDB()
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec("UPDATE users u SET frontier_points=frontier_points+(SELECT frontier_points FROM gacha_entries WHERE gacha_id = $1 AND entry_type = $2) WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$3)", pkt.GachaID, pkt.RollType, s.CharID)
-	database.Exec(`DELETE FROM gacha_stepup WHERE gacha_id = $1 AND character_id = $2`, pkt.GachaID, s.CharID)
-	database.Exec(`INSERT INTO gacha_stepup (gacha_id, step, character_id) VALUES ($1, $2, $3)`, pkt.GachaID, pkt.RollType+1, s.CharID)
 
-	rows, err := database.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
+	db.Exec("UPDATE users u SET frontier_points=frontier_points+(SELECT frontier_points FROM gacha_entries WHERE gacha_id = $1 AND entry_type = $2) WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$3)", pkt.GachaID, pkt.RollType, s.CharID)
+	db.Exec(`DELETE FROM gacha_stepup WHERE gacha_id = $1 AND character_id = $2`, pkt.GachaID, s.CharID)
+	db.Exec(`INSERT INTO gacha_stepup (gacha_id, step, character_id) VALUES ($1, $2, $3)`, pkt.GachaID, pkt.RollType+1, s.CharID)
+
+	rows, err := db.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
 	if err != nil {
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 1))
 		return
@@ -581,7 +568,7 @@ func handleMsgMhfPlayStepupGacha(s *Session, p mhfpacket.MHFPacket) {
 	rewardEntries, err := getRandomEntries(entries, rolls, false)
 	temp := byteframe.NewByteFrame()
 	for i := range rewardEntries {
-		rows, err = database.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = $1`, rewardEntries[i].ID)
+		rows, err = db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = $1`, rewardEntries[i].ID)
 		if err != nil {
 			continue
 		}
@@ -612,19 +599,16 @@ func handleMsgMhfPlayStepupGacha(s *Session, p mhfpacket.MHFPacket) {
 	addGachaItem(s, guaranteedItems)
 }
 
-func handleMsgMhfGetStepupStatus(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetStepupStatus(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetStepupStatus)
 	// TODO: Reset daily (noon)
 	var step uint8
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.QueryRow(`SELECT step FROM gacha_stepup WHERE gacha_id = $1 AND character_id = $2`, pkt.GachaID, s.CharID).Scan(&step)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.QueryRow(`SELECT step FROM gacha_stepup WHERE gacha_id = $1 AND character_id = $2`, pkt.GachaID, s.CharID).Scan(&step)
 	var stepCheck int
-	database.QueryRow(`SELECT COUNT(1) FROM gacha_entries WHERE gacha_id = $1 AND entry_type = $2`, pkt.GachaID, step).Scan(&stepCheck)
+	db.QueryRow(`SELECT COUNT(1) FROM gacha_entries WHERE gacha_id = $1 AND entry_type = $2`, pkt.GachaID, step).Scan(&stepCheck)
 	if stepCheck == 0 {
-		database.Exec(`DELETE FROM gacha_stepup WHERE gacha_id = $1 AND character_id = $2`, pkt.GachaID, s.CharID)
+		db.Exec(`DELETE FROM gacha_stepup WHERE gacha_id = $1 AND character_id = $2`, pkt.GachaID, s.CharID)
 		step = 0
 	}
 	bf := byteframe.NewByteFrame()
@@ -633,13 +617,10 @@ func handleMsgMhfGetStepupStatus(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfGetBoxGachaInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetBoxGachaInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetBoxGachaInfo)
-	database, err := db.GetDB()
+
-	if err != nil {
+	entries, err := db.Queryx(`SELECT entry_id FROM gacha_box WHERE gacha_id = $1 AND character_id = $2`, pkt.GachaID, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	entries, err := database.Queryx(`SELECT entry_id FROM gacha_box WHERE gacha_id = $1 AND character_id = $2`, pkt.GachaID, s.CharID)
 	if err != nil {
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 1))
 		return
@@ -659,7 +640,7 @@ func handleMsgMhfGetBoxGachaInfo(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfPlayBoxGacha(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPlayBoxGacha(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPlayBoxGacha)
 	bf := byteframe.NewByteFrame()
 	var entries []GachaEntry
@@ -671,11 +652,8 @@ func handleMsgMhfPlayBoxGacha(s *Session, p mhfpacket.MHFPacket) {
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 1))
 		return
 	}
-	database, err := db.GetDB()
+
-	if err != nil {
+	rows, err := db.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	rows, err := database.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
 	if err != nil {
 		s.DoAckBufSucceed(pkt.AckHandle, make([]byte, 1))
 		return
@@ -688,11 +666,11 @@ func handleMsgMhfPlayBoxGacha(s *Session, p mhfpacket.MHFPacket) {
 	}
 	rewardEntries, err := getRandomEntries(entries, rolls, true)
 	for i := range rewardEntries {
-		items, err := database.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = $1`, rewardEntries[i].ID)
+		items, err := db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = $1`, rewardEntries[i].ID)
 		if err != nil {
 			continue
 		}
-		database.Exec(`INSERT INTO gacha_box (gacha_id, entry_id, character_id) VALUES ($1, $2, $3)`, pkt.GachaID, rewardEntries[i].ID, s.CharID)
+		db.Exec(`INSERT INTO gacha_box (gacha_id, entry_id, character_id) VALUES ($1, $2, $3)`, pkt.GachaID, rewardEntries[i].ID, s.CharID)
 		for items.Next() {
 			err = items.StructScan(&reward)
 			if err == nil {
@@ -711,43 +689,34 @@ func handleMsgMhfPlayBoxGacha(s *Session, p mhfpacket.MHFPacket) {
 	addGachaItem(s, rewards)
 }
 
-func handleMsgMhfResetBoxGachaInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfResetBoxGachaInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfResetBoxGachaInfo)
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.Exec("DELETE FROM gacha_box WHERE gacha_id = $1 AND character_id = $2", pkt.GachaID, s.CharID)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.Exec("DELETE FROM gacha_box WHERE gacha_id = $1 AND character_id = $2", pkt.GachaID, s.CharID)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfExchangeFpoint2Item(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfExchangeFpoint2Item(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfExchangeFpoint2Item)
 	var balance uint32
 	var itemValue, quantity int
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.QueryRow("SELECT quantity, fpoints FROM fpoint_items WHERE id=$1", pkt.TradeID).Scan(&quantity, &itemValue)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.QueryRow("SELECT quantity, fpoints FROM fpoint_items WHERE id=$1", pkt.TradeID).Scan(&quantity, &itemValue)
 	cost := (int(pkt.Quantity) * quantity) * itemValue
-	database.QueryRow("UPDATE users u SET frontier_points=frontier_points::int - $1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2) RETURNING frontier_points", cost, s.CharID).Scan(&balance)
+	db.QueryRow("UPDATE users u SET frontier_points=frontier_points::int - $1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2) RETURNING frontier_points", cost, s.CharID).Scan(&balance)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(balance)
 	s.DoAckSimpleSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfExchangeItem2Fpoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfExchangeItem2Fpoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfExchangeItem2Fpoint)
 	var balance uint32
 	var itemValue, quantity int
-	database, err := db.GetDB()
+
-	if err != nil {
+	db.QueryRow("SELECT quantity, fpoints FROM fpoint_items WHERE id=$1", pkt.TradeID).Scan(&quantity, &itemValue)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	database.QueryRow("SELECT quantity, fpoints FROM fpoint_items WHERE id=$1", pkt.TradeID).Scan(&quantity, &itemValue)
 	cost := (int(pkt.Quantity) / quantity) * itemValue
-	database.QueryRow("UPDATE users u SET frontier_points=COALESCE(frontier_points::int + $1, $1) WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2) RETURNING frontier_points", cost, s.CharID).Scan(&balance)
+	db.QueryRow("UPDATE users u SET frontier_points=COALESCE(frontier_points::int + $1, $1) WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2) RETURNING frontier_points", cost, s.CharID).Scan(&balance)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(balance)
 	s.DoAckSimpleSucceed(pkt.AckHandle, bf.Data())
@@ -762,18 +731,15 @@ type FPointExchange struct {
 	Buyable  bool   `db:"buyable"`
 }
 
-func handleMsgMhfGetFpointExchangeList(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetFpointExchangeList(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetFpointExchangeList)
 
 	bf := byteframe.NewByteFrame()
 	var exchange FPointExchange
 	var exchanges []FPointExchange
 	var buyables uint16
-	database, err := db.GetDB()
+
-	if err != nil {
+	rows, err := db.Queryx(`SELECT id, item_type, item_id, quantity, fpoints, buyable FROM fpoint_items ORDER BY buyable DESC`)
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
-	rows, err := database.Queryx(`SELECT id, item_type, item_id, quantity, fpoints, buyable FROM fpoint_items ORDER BY buyable DESC`)
 	if err == nil {
 		for rows.Next() {
 			err = rows.StructScan(&exchange)
@@ -807,7 +773,7 @@ func handleMsgMhfGetFpointExchangeList(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfPlayFreeGacha(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPlayFreeGacha(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPlayFreeGacha)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(1)

server/channelserver/handlers_stage.go

@@ -9,10 +9,11 @@ import (
 	"erupe-ce/utils/byteframe"
 	ps "erupe-ce/utils/pascalstring"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
 
-func handleMsgSysCreateStage(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysCreateStage(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysCreateStage)
 	s.Server.Lock()
 	defer s.Server.Unlock()
@@ -27,7 +28,7 @@ func handleMsgSysCreateStage(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgSysStageDestruct(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysStageDestruct(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
 func doStageTransfer(s *Session, ackHandle uint32, stageID string) {
 	s.Server.Lock()
@@ -149,7 +150,7 @@ func isStageFull(s *Session, StageID string) bool {
 	return false
 }
 
-func handleMsgSysEnterStage(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysEnterStage(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysEnterStage)
 
 	if isStageFull(s, pkt.StageID) {
@@ -172,7 +173,7 @@ func handleMsgSysEnterStage(s *Session, p mhfpacket.MHFPacket) {
 	doStageTransfer(s, pkt.AckHandle, pkt.StageID)
 }
 
-func handleMsgSysBackStage(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysBackStage(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysBackStage)
 
 	// Transfer back to the saved stage ID before the previous move or enter.
@@ -198,7 +199,7 @@ func handleMsgSysBackStage(s *Session, p mhfpacket.MHFPacket) {
 	doStageTransfer(s, pkt.AckHandle, backStage)
 }
 
-func handleMsgSysMoveStage(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysMoveStage(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysMoveStage)
 
 	if isStageFull(s, pkt.StageID) {
@@ -209,9 +210,9 @@ func handleMsgSysMoveStage(s *Session, p mhfpacket.MHFPacket) {
 	doStageTransfer(s, pkt.AckHandle, pkt.StageID)
 }
 
-func handleMsgSysLeaveStage(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysLeaveStage(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysLockStage(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysLockStage(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysLockStage)
 	if stage, exists := s.Server.stages[pkt.StageID]; exists {
 		stage.Lock()
@@ -221,7 +222,7 @@ func handleMsgSysLockStage(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgSysUnlockStage(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysUnlockStage(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	if s.reservationStage != nil {
 		s.reservationStage.RLock()
 		defer s.reservationStage.RUnlock()
@@ -239,7 +240,7 @@ func handleMsgSysUnlockStage(s *Session, p mhfpacket.MHFPacket) {
 	destructEmptyStages(s)
 }
 
-func handleMsgSysReserveStage(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysReserveStage(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysReserveStage)
 	if stage, exists := s.Server.stages[pkt.StageID]; exists {
 		stage.Lock()
@@ -278,7 +279,7 @@ func handleMsgSysReserveStage(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgSysUnreserveStage(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysUnreserveStage(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	s.Lock()
 	stage := s.reservationStage
 	s.reservationStage = nil
@@ -292,7 +293,7 @@ func handleMsgSysUnreserveStage(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgSysSetStagePass(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysSetStagePass(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysSetStagePass)
 	s.Lock()
 	stage := s.reservationStage
@@ -312,7 +313,7 @@ func handleMsgSysSetStagePass(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgSysSetStageBinary(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysSetStageBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysSetStageBinary)
 	if stage, exists := s.Server.stages[pkt.StageID]; exists {
 		stage.Lock()
@@ -323,7 +324,7 @@ func handleMsgSysSetStageBinary(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgSysGetStageBinary(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysGetStageBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysGetStageBinary)
 	if stage, exists := s.Server.stages[pkt.StageID]; exists {
 		stage.Lock()
@@ -345,7 +346,7 @@ func handleMsgSysGetStageBinary(s *Session, p mhfpacket.MHFPacket) {
 	s.Logger.Debug("MsgSysGetStageBinary Done!")
 }
 
-func handleMsgSysWaitStageBinary(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysWaitStageBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysWaitStageBinary)
 	if stage, exists := s.Server.stages[pkt.StageID]; exists {
 		if pkt.BinaryType0 == 1 && pkt.BinaryType1 == 12 {
@@ -374,7 +375,7 @@ func handleMsgSysWaitStageBinary(s *Session, p mhfpacket.MHFPacket) {
 	s.Logger.Debug("MsgSysWaitStageBinary Done!")
 }
 
-func handleMsgSysEnumerateStage(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysEnumerateStage(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysEnumerateStage)
 
 	// Read-lock the server stage map.

server/channelserver/handlers_tactics.go

@@ -4,9 +4,11 @@ import (
 	"encoding/hex"
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
+
+	"github.com/jmoiron/sqlx"
 )
 
-func handleMsgMhfGetUdTacticsPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdTacticsPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	// Diva defense interception points
 	pkt := p.(*mhfpacket.MsgMhfGetUdTacticsPoint)
 	// Temporary canned response
@@ -14,12 +16,12 @@ func handleMsgMhfGetUdTacticsPoint(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfAddUdTacticsPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAddUdTacticsPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAddUdTacticsPoint)
 	stubEnumerateNoResults(s, pkt.AckHandle)
 }
 
-func handleMsgMhfGetUdTacticsRewardList(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdTacticsRewardList(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	// Diva defense interception
 	pkt := p.(*mhfpacket.MsgMhfGetUdTacticsRewardList)
 	// Temporary canned response
@@ -27,39 +29,39 @@ func handleMsgMhfGetUdTacticsRewardList(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfGetUdTacticsFollower(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdTacticsFollower(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdTacticsFollower)
 	s.DoAckBufSucceed(pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
 }
 
-func handleMsgMhfGetUdTacticsBonusQuest(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdTacticsBonusQuest(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdTacticsBonusQuest)
 	// Temporary canned response
 	data, _ := hex.DecodeString("14E2F55DCBFE505DCC1A7003E8E2C55DCC6ED05DCC8AF00258E2CE5DCCDF505DCCFB700279E3075DCD4FD05DCD6BF0041AE2F15DCDC0505DCDDC700258E2C45DCE30D05DCE4CF00258E2F55DCEA1505DCEBD7003E8E2C25DCF11D05DCF2DF00258E2CE5DCF82505DCF9E700279E3075DCFF2D05DD00EF0041AE2CE5DD063505DD07F700279E2F35DD0D3D05DD0EFF0028AE2C35DD144505DD160700258E2F05DD1B4D05DD1D0F00258E2CE5DD225505DD241700279E2F55DD295D05DD2B1F003E8E2F25DD306505DD3227002EEE2CA5DD376D05DD392F00258E3075DD3E7505DD40370041AE2F55DD457D05DD473F003E82027313220686F757273273A3A696E74657276616C29202B2027313220686F757273273A3A696E74657276616C2047524F5550204259206D6170204F52444552204259206D61703B2000C7312B000032")
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfGetUdTacticsFirstQuestBonus(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdTacticsFirstQuestBonus(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdTacticsFirstQuestBonus)
 	// Temporary canned response
 	data, _ := hex.DecodeString("0500000005DC01000007D002000009C40300000BB80400001194")
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfGetUdTacticsRemainingPoint(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdTacticsRemainingPoint(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdTacticsRemainingPoint)
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(0) // Points until Special Guild Hall earned
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfGetUdTacticsRanking(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetUdTacticsRanking(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetUdTacticsRanking)
 	// Temporary canned response
 	data, _ := hex.DecodeString("00000515000005150000CEB4000003CE000003CE0000CEB44D49444E494748542D414E47454C0000000000000000000000")
 	s.DoAckBufSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfSetUdTacticsFollower(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfSetUdTacticsFollower(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgMhfGetUdTacticsLog(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgMhfGetUdTacticsLog(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_tournament.go

@@ -6,6 +6,8 @@ import (
 	"erupe-ce/utils/gametime"
 	ps "erupe-ce/utils/pascalstring"
 	"time"
+
+	"github.com/jmoiron/sqlx"
 )
 
 type TournamentInfo0 struct {
@@ -44,7 +46,7 @@ type TournamentInfo22 struct {
 	Unk4 string
 }
 
-func handleMsgMhfInfoTournament(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfInfoTournament(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfInfoTournament)
 	bf := byteframe.NewByteFrame()
 
@@ -106,7 +108,7 @@ func handleMsgMhfInfoTournament(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckBufSucceed(pkt.AckHandle, bf.Data())
 }
 
-func handleMsgMhfEntryTournament(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfEntryTournament(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEntryTournament)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
@@ -117,7 +119,7 @@ type TournamentReward struct {
 	Unk2 uint16
 }
 
-func handleMsgMhfAcquireTournament(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfAcquireTournament(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireTournament)
 	rewards := []TournamentReward{}
 	bf := byteframe.NewByteFrame()

server/channelserver/handlers_tower.go

@@ -6,11 +6,11 @@ import (
 	"strings"
 	"time"
 
+	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/utils/byteframe"
-	"erupe-ce/utils/db"
 	"erupe-ce/utils/stringsupport"
 )
 
@@ -44,7 +44,7 @@ func EmptyTowerCSV(len int) string {
 	return strings.Join(temp, ",")
 }
 
-func handleMsgMhfGetTowerInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetTowerInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetTowerInfo)
 	var data []*byteframe.ByteFrame
 	type TowerInfo struct {
@@ -60,15 +60,12 @@ func handleMsgMhfGetTowerInfo(s *Session, p mhfpacket.MHFPacket) {
 		History: []TowerInfoHistory{{make([]int16, 5), make([]int16, 5)}},
 		Level:   []TowerInfoLevel{{0, 0, 0, 0}, {0, 0, 0, 0}},
 	}
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var tempSkills string
-	err = database.QueryRow(`SELECT COALESCE(tr, 0),  COALESCE(trp, 0),  COALESCE(tsp, 0), COALESCE(block1, 0), COALESCE(block2, 0), COALESCE(skills, $1) FROM tower WHERE char_id=$2
+	err := db.QueryRow(`SELECT COALESCE(tr, 0),  COALESCE(trp, 0),  COALESCE(tsp, 0), COALESCE(block1, 0), COALESCE(block2, 0), COALESCE(skills, $1) FROM tower WHERE char_id=$2
 		`, EmptyTowerCSV(64), s.CharID).Scan(&towerInfo.TRP[0].TR, &towerInfo.TRP[0].TRP, &towerInfo.Skill[0].TSP, &towerInfo.Level[0].Floors, &towerInfo.Level[1].Floors, &tempSkills)
 	if err != nil {
-		database.Exec(`INSERT INTO tower (char_id) VALUES ($1)`, s.CharID)
+		db.Exec(`INSERT INTO tower (char_id) VALUES ($1)`, s.CharID)
 	}
 
 	if config.GetConfig().ClientID <= config.G7 {
@@ -120,7 +117,7 @@ func handleMsgMhfGetTowerInfo(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckEarthSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfPostTowerInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPostTowerInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPostTowerInfo)
 
 	if config.GetConfig().DebugOptions.QuestTools {
@@ -138,18 +135,15 @@ func handleMsgMhfPostTowerInfo(s *Session, p mhfpacket.MHFPacket) {
 			zap.Int64("Unk9", pkt.Unk9),
 		)
 	}
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	switch pkt.InfoType {
 	case 2:
 		var skills string
-		database.QueryRow(`SELECT COALESCE(skills, $1) FROM tower WHERE char_id=$2`, EmptyTowerCSV(64), s.CharID).Scan(&skills)
+		db.QueryRow(`SELECT COALESCE(skills, $1) FROM tower WHERE char_id=$2`, EmptyTowerCSV(64), s.CharID).Scan(&skills)
-		database.Exec(`UPDATE tower SET skills=$1, tsp=tsp-$2 WHERE char_id=$3`, stringsupport.CSVSetIndex(skills, int(pkt.Skill), stringsupport.CSVGetIndex(skills, int(pkt.Skill))+1), pkt.Cost, s.CharID)
+		db.Exec(`UPDATE tower SET skills=$1, tsp=tsp-$2 WHERE char_id=$3`, stringsupport.CSVSetIndex(skills, int(pkt.Skill), stringsupport.CSVGetIndex(skills, int(pkt.Skill))+1), pkt.Cost, s.CharID)
 	case 1, 7:
 		// This might give too much TSP? No idea what the rate is supposed to be
-		database.Exec(`UPDATE tower SET tr=$1, trp=COALESCE(trp, 0)+$2, tsp=COALESCE(tsp, 0)+$3, block1=COALESCE(block1, 0)+$4 WHERE char_id=$5`, pkt.TR, pkt.TRP, pkt.Cost, pkt.Block1, s.CharID)
+		db.Exec(`UPDATE tower SET tr=$1, trp=COALESCE(trp, 0)+$2, tsp=COALESCE(tsp, 0)+$3, block1=COALESCE(block1, 0)+$4 WHERE char_id=$5`, pkt.TR, pkt.TRP, pkt.Cost, pkt.Block1, s.CharID)
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
@@ -248,7 +242,7 @@ type Tenrouirai struct {
 	Ticket    []TenrouiraiTicket
 }
 
-func handleMsgMhfGetTenrouirai(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetTenrouirai(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetTenrouirai)
 	var data []*byteframe.ByteFrame
 
@@ -257,10 +251,7 @@ func handleMsgMhfGetTenrouirai(s *Session, p mhfpacket.MHFPacket) {
 		Data:     tenrouiraiData,
 		Ticket:   []TenrouiraiTicket{{0, 0, 0}},
 	}
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	switch pkt.Unk1 {
 	case 1:
 		for _, tdata := range tenrouirai.Data {
@@ -294,8 +285,8 @@ func handleMsgMhfGetTenrouirai(s *Session, p mhfpacket.MHFPacket) {
 			data = append(data, bf)
 		}
 	case 4:
-		database.QueryRow(`SELECT tower_mission_page FROM guilds WHERE id=$1`, pkt.GuildID).Scan(&tenrouirai.Progress[0].Page)
+		db.QueryRow(`SELECT tower_mission_page FROM guilds WHERE id=$1`, pkt.GuildID).Scan(&tenrouirai.Progress[0].Page)
-		database.QueryRow(`SELECT SUM(tower_mission_1) AS _, SUM(tower_mission_2) AS _, SUM(tower_mission_3) AS _ FROM guild_characters WHERE guild_id=$1
+		db.QueryRow(`SELECT SUM(tower_mission_1) AS _, SUM(tower_mission_2) AS _, SUM(tower_mission_3) AS _ FROM guild_characters WHERE guild_id=$1
 				`, pkt.GuildID).Scan(&tenrouirai.Progress[0].Mission1, &tenrouirai.Progress[0].Mission2, &tenrouirai.Progress[0].Mission3)
 
 		if tenrouirai.Progress[0].Mission1 > tenrouiraiData[(tenrouirai.Progress[0].Page*3)-3].Goal {
@@ -323,7 +314,7 @@ func handleMsgMhfGetTenrouirai(s *Session, p mhfpacket.MHFPacket) {
 				pkt.Unk3 = 3
 			}
 		}
-		rows, _ := database.Query(fmt.Sprintf(`SELECT name, tower_mission_%d FROM guild_characters gc INNER JOIN characters c ON gc.character_id = c.id WHERE guild_id=$1 AND tower_mission_%d IS NOT NULL ORDER BY tower_mission_%d DESC`, pkt.Unk3, pkt.Unk3, pkt.Unk3), pkt.GuildID)
+		rows, _ := db.Query(fmt.Sprintf(`SELECT name, tower_mission_%d FROM guild_characters gc INNER JOIN characters c ON gc.character_id = c.id WHERE guild_id=$1 AND tower_mission_%d IS NOT NULL ORDER BY tower_mission_%d DESC`, pkt.Unk3, pkt.Unk3, pkt.Unk3), pkt.GuildID)
 		for rows.Next() {
 			temp := TenrouiraiCharScore{}
 			rows.Scan(&temp.Name, &temp.Score)
@@ -336,7 +327,7 @@ func handleMsgMhfGetTenrouirai(s *Session, p mhfpacket.MHFPacket) {
 			data = append(data, bf)
 		}
 	case 6:
-		database.QueryRow(`SELECT tower_rp FROM guilds WHERE id=$1`, pkt.GuildID).Scan(&tenrouirai.Ticket[0].RP)
+		db.QueryRow(`SELECT tower_rp FROM guilds WHERE id=$1`, pkt.GuildID).Scan(&tenrouirai.Ticket[0].RP)
 		for _, ticket := range tenrouirai.Ticket {
 			bf := byteframe.NewByteFrame()
 			bf.WriteUint8(ticket.Unk0)
@@ -349,12 +340,9 @@ func handleMsgMhfGetTenrouirai(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckEarthSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfPostTenrouirai(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPostTenrouirai(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPostTenrouirai)
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	if config.GetConfig().DebugOptions.QuestTools {
 		s.Logger.Debug(
 			p.Opcode().String(),
@@ -373,7 +361,7 @@ func handleMsgMhfPostTenrouirai(s *Session, p mhfpacket.MHFPacket) {
 
 	if pkt.Op == 2 {
 		var page, requirement, donated int
-		database.QueryRow(`SELECT tower_mission_page, tower_rp FROM guilds WHERE id=$1`, pkt.GuildID).Scan(&page, &donated)
+		db.QueryRow(`SELECT tower_mission_page, tower_rp FROM guilds WHERE id=$1`, pkt.GuildID).Scan(&page, &donated)
 
 		for i := 0; i < (page*3)+1; i++ {
 			requirement += int(tenrouiraiData[i].Cost)
@@ -386,12 +374,12 @@ func handleMsgMhfPostTenrouirai(s *Session, p mhfpacket.MHFPacket) {
 			sd.RP -= pkt.DonatedRP
 			sd.Save(s)
 			if donated+int(pkt.DonatedRP) >= requirement {
-				database.Exec(`UPDATE guilds SET tower_mission_page=tower_mission_page+1 WHERE id=$1`, pkt.GuildID)
+				db.Exec(`UPDATE guilds SET tower_mission_page=tower_mission_page+1 WHERE id=$1`, pkt.GuildID)
-				database.Exec(`UPDATE guild_characters SET tower_mission_1=NULL, tower_mission_2=NULL, tower_mission_3=NULL WHERE guild_id=$1`, pkt.GuildID)
+				db.Exec(`UPDATE guild_characters SET tower_mission_1=NULL, tower_mission_2=NULL, tower_mission_3=NULL WHERE guild_id=$1`, pkt.GuildID)
 				pkt.DonatedRP = uint16(requirement - donated)
 			}
 			bf.WriteUint32(uint32(pkt.DonatedRP))
-			database.Exec(`UPDATE guilds SET tower_rp=tower_rp+$1 WHERE id=$2`, pkt.DonatedRP, pkt.GuildID)
+			db.Exec(`UPDATE guilds SET tower_rp=tower_rp+$1 WHERE id=$2`, pkt.DonatedRP, pkt.GuildID)
 		} else {
 			bf.WriteUint32(0)
 		}
@@ -402,7 +390,7 @@ func handleMsgMhfPostTenrouirai(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgMhfPresentBox(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPresentBox(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPresentBox)
 	var data []*byteframe.ByteFrame
 	/*
@@ -433,17 +421,14 @@ type GemHistory struct {
 	Sender    string
 }
 
-func handleMsgMhfGetGemInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetGemInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGemInfo)
 	var data []*byteframe.ByteFrame
 	gemInfo := []GemInfo{}
 	gemHistory := []GemHistory{}
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var tempGems string
-	database.QueryRow(`SELECT COALESCE(gems, $1) FROM tower WHERE char_id=$2`, EmptyTowerCSV(30), s.CharID).Scan(&tempGems)
+	db.QueryRow(`SELECT COALESCE(gems, $1) FROM tower WHERE char_id=$2`, EmptyTowerCSV(30), s.CharID).Scan(&tempGems)
 	for i, v := range stringsupport.CSVElems(tempGems) {
 		gemInfo = append(gemInfo, GemInfo{uint16((i / 5 << 8) + (i%5 + 1)), uint16(v)})
 	}
@@ -469,7 +454,7 @@ func handleMsgMhfGetGemInfo(s *Session, p mhfpacket.MHFPacket) {
 	s.DoAckEarthSucceed(pkt.AckHandle, data)
 }
 
-func handleMsgMhfPostGemInfo(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPostGemInfo(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPostGemInfo)
 
 	if config.GetConfig().DebugOptions.QuestTools {
@@ -484,28 +469,25 @@ func handleMsgMhfPostGemInfo(s *Session, p mhfpacket.MHFPacket) {
 			zap.Int32("Unk6", pkt.Unk6),
 		)
 	}
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var gems string
-	database.QueryRow(`SELECT COALESCE(gems, $1) FROM tower WHERE char_id=$2`, EmptyTowerCSV(30), s.CharID).Scan(&gems)
+	db.QueryRow(`SELECT COALESCE(gems, $1) FROM tower WHERE char_id=$2`, EmptyTowerCSV(30), s.CharID).Scan(&gems)
 	switch pkt.Op {
 	case 1: // Add gem
 		i := int((pkt.Gem >> 8 * 5) + (pkt.Gem - pkt.Gem&0xFF00 - 1%5))
-		database.Exec(`UPDATE tower SET gems=$1 WHERE char_id=$2`, stringsupport.CSVSetIndex(gems, i, stringsupport.CSVGetIndex(gems, i)+int(pkt.Quantity)), s.CharID)
+		db.Exec(`UPDATE tower SET gems=$1 WHERE char_id=$2`, stringsupport.CSVSetIndex(gems, i, stringsupport.CSVGetIndex(gems, i)+int(pkt.Quantity)), s.CharID)
 	case 2: // Transfer gem
 		// no way im doing this for now
 	}
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfGetNotice(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfGetNotice(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetNotice)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }
 
-func handleMsgMhfPostNotice(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgMhfPostNotice(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPostNotice)
 	s.DoAckSimpleSucceed(pkt.AckHandle, make([]byte, 4))
 }

server/channelserver/handlers_users.go

@@ -4,29 +4,27 @@ import (
 	"fmt"
 
 	"erupe-ce/network/mhfpacket"
-	"erupe-ce/utils/db"
+
+	"github.com/jmoiron/sqlx"
 )
 
-func handleMsgSysInsertUser(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysInsertUser(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysDeleteUser(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysDeleteUser(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}
 
-func handleMsgSysSetUserBinary(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysSetUserBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysSetUserBinary)
 	s.Server.userBinaryPartsLock.Lock()
 	s.Server.userBinaryParts[userBinaryPartID{charID: s.CharID, index: pkt.BinaryType}] = pkt.RawDataPayload
 	s.Server.userBinaryPartsLock.Unlock()
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	var exists []byte
-	err = database.QueryRow("SELECT type2 FROM user_binary WHERE id=$1", s.CharID).Scan(&exists)
+	err := db.QueryRow("SELECT type2 FROM user_binary WHERE id=$1", s.CharID).Scan(&exists)
 	if err != nil {
-		database.Exec("INSERT INTO user_binary (id) VALUES ($1)", s.CharID)
+		db.Exec("INSERT INTO user_binary (id) VALUES ($1)", s.CharID)
 	}
 
-	database.Exec(fmt.Sprintf("UPDATE user_binary SET type%d=$1 WHERE id=$2", pkt.BinaryType), pkt.RawDataPayload, s.CharID)
+	db.Exec(fmt.Sprintf("UPDATE user_binary SET type%d=$1 WHERE id=$2", pkt.BinaryType), pkt.RawDataPayload, s.CharID)
 
 	msg := &mhfpacket.MsgSysNotifyUserBinary{
 		CharID:     s.CharID,
@@ -36,20 +34,17 @@ func handleMsgSysSetUserBinary(s *Session, p mhfpacket.MHFPacket) {
 	s.Server.BroadcastMHF(msg, s)
 }
 
-func handleMsgSysGetUserBinary(s *Session, p mhfpacket.MHFPacket) {
+func handleMsgSysGetUserBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysGetUserBinary)
 
 	// Try to get the data.
 	s.Server.userBinaryPartsLock.RLock()
 	defer s.Server.userBinaryPartsLock.RUnlock()
 	data, ok := s.Server.userBinaryParts[userBinaryPartID{charID: pkt.CharID, index: pkt.BinaryType}]
-	database, err := db.GetDB()
+
-	if err != nil {
-		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
-	}
 	// If we can't get the real data, try to get it from the database.
 	if !ok {
-		err = database.QueryRow(fmt.Sprintf("SELECT type%d FROM user_binary WHERE id=$1", pkt.BinaryType), pkt.CharID).Scan(&data)
+		err := db.QueryRow(fmt.Sprintf("SELECT type%d FROM user_binary WHERE id=$1", pkt.BinaryType), pkt.CharID).Scan(&data)
 		if err != nil {
 			s.DoAckBufFail(pkt.AckHandle, make([]byte, 4))
 		} else {
@@ -60,4 +55,4 @@ func handleMsgSysGetUserBinary(s *Session, p mhfpacket.MHFPacket) {
 	}
 }
 
-func handleMsgSysNotifyUserBinary(s *Session, p mhfpacket.MHFPacket) {}
+func handleMsgSysNotifyUserBinary(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket) {}

server/channelserver/sys_channel_server.go

@@ -207,11 +207,11 @@ func (server *ChannelServer) FindSessionByCharID(charID uint32) *Session {
 func (server *ChannelServer) DisconnectUser(uid uint32) {
 	var cid uint32
 	var cids []uint32
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		server.logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	rows, _ := database.Query(`SELECT id FROM characters WHERE user_id=$1`, uid)
+	rows, _ := db.Query(`SELECT id FROM characters WHERE user_id=$1`, uid)
 	for rows.Next() {
 		rows.Scan(&cid)
 		cids = append(cids, cid)

server/channelserver/sys_discord.go

@@ -71,14 +71,14 @@ func getCharacterList(server *ChannelServer) string {
 
 // onInteraction handles slash commands
 func (server *ChannelServer) onInteraction(ds *discordgo.Session, i *discordgo.InteractionCreate) {
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		server.logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
 	switch i.Interaction.ApplicationCommandData().Name {
 	case "link":
 		var temp string
-		err := database.QueryRow(`UPDATE users SET discord_id = $1 WHERE discord_token = $2 RETURNING discord_id`, i.Member.User.ID, i.ApplicationCommandData().Options[0].StringValue()).Scan(&temp)
+		err := db.QueryRow(`UPDATE users SET discord_id = $1 WHERE discord_token = $2 RETURNING discord_id`, i.Member.User.ID, i.ApplicationCommandData().Options[0].StringValue()).Scan(&temp)
 		if err == nil {
 			ds.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
 				Type: discordgo.InteractionResponseChannelMessageWithSource,
@@ -98,7 +98,7 @@ func (server *ChannelServer) onInteraction(ds *discordgo.Session, i *discordgo.I
 		}
 	case "password":
 		password, _ := bcrypt.GenerateFromPassword([]byte(i.ApplicationCommandData().Options[0].StringValue()), 10)
-		_, err := database.Exec(`UPDATE users SET password = $1 WHERE discord_id = $2`, password, i.Member.User.ID)
+		_, err := db.Exec(`UPDATE users SET password = $1 WHERE discord_id = $2`, password, i.Member.User.ID)
 		if err == nil {
 			ds.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
 				Type: discordgo.InteractionResponseChannelMessageWithSource,

server/channelserver/sys_handlers_table.go

@@ -3,9 +3,11 @@ package channelserver
 import (
 	"erupe-ce/network"
 	"erupe-ce/network/mhfpacket"
+
+	"github.com/jmoiron/sqlx"
 )
 
-type handlerFunc func(s *Session, p mhfpacket.MHFPacket)
+type handlerFunc func(s *Session, db *sqlx.DB, p mhfpacket.MHFPacket)
 
 var handlerTable map[network.PacketID]handlerFunc
 

server/channelserver/sys_session.go

@@ -193,8 +193,12 @@ func (s *Session) handlePacketGroup(pktGroup []byte) {
 		fmt.Printf("\n!!! [%s] %s NOT IMPLEMENTED !!! \n\n\n", s.Name, opcode)
 		return
 	}
+	database, err := db.GetDB()
+	if err != nil {
+		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
+	}
 	// Handle the packet.
-	handlerTable[opcode](s, mhfPkt)
+	handlerTable[opcode](s, database, mhfPkt)
 	// If there is more data on the stream that the .Parse method didn't read, then read another packet off it.
 	remainingData := bf.DataFromCurrent()
 	if len(remainingData) >= 2 {
@@ -307,11 +311,11 @@ func (s *Session) GetSemaphoreID() uint32 {
 
 func (s *Session) isOp() bool {
 	var op bool
-	database, err := db.GetDB()
+	db, err := db.GetDB()
 	if err != nil {
 		s.Logger.Fatal(fmt.Sprintf("Failed to get database instance: %s", err))
 	}
-	err = database.QueryRow(`SELECT op FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&op)
+	err = db.QueryRow(`SELECT op FROM users u WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$1)`, s.CharID).Scan(&op)
 	if err == nil && op {
 		return true
 	}