refactor: replace panic calls with structured error handling

Replace ~25 panic() calls in non-fatal code paths with proper
s.logger.Error + return patterns. Panics in handler code crashed
goroutines (caught by defer/recover but still disruptive) instead
of failing gracefully.

Key changes:
- SJISToUTF8 now returns (string, error); all 30+ callers updated
- Handler DB/IO panics replaced with log + return/ack fail
- Unhandled switch-case panics replaced with logger.Error
- Sign server Accept() panic replaced with log + continue
- Dead unreachable panic in guild_model.go removed
- deltacomp patch error logs and returns partial data

Panics intentionally kept: ByteFrame sentinel, unimplemented
packet stubs, os.Exit in main.go.

server/channelserver/compression/deltacomp/deltacomp.go

@@ -92,7 +92,8 @@ func ApplyDataDiff(diff []byte, baseData []byte) []byte {
 		for i := 0; i < differentCount; i++ {
 			b, err := checkReadUint8(patch)
 			if err != nil {
-				panic("Invalid or misunderstood patch format!")
+				zap.L().Error("Invalid or misunderstood patch format", zap.Int("dataOffset", dataOffset))
+				return baseCopy
 			}
 
 			baseCopy[dataOffset+i] = b

server/channelserver/guild_model.go

@@ -484,10 +484,6 @@ func CreateGuild(s *Session, guildName string) (int32, error) {
 		return 0, err
 	}
 
-	if err != nil {
-		panic(err)
-	}
-
 	guildResult, err := transaction.Query(
 		"INSERT INTO guilds (name, leader_id) VALUES ($1, $2) RETURNING id",
 		guildName, s.charID,

server/channelserver/handlers_cafe.go

@@ -96,7 +96,8 @@ func handleMsgMhfGetCafeDuration(s *Session, p mhfpacket.MHFPacket) {
 	var cafeTime uint32
 	err = s.server.db.QueryRow("SELECT cafe_time FROM characters WHERE id = $1", s.charID).Scan(&cafeTime)
 	if err != nil {
-		panic(err)
+		s.logger.Error("Failed to get cafe time", zap.Error(err))
+		return
 	}
 	if mhfcourse.CourseExists(30, s.courses) {
 		cafeTime = uint32(TimeAdjusted().Unix()) - uint32(s.sessionStart) + cafeTime

server/channelserver/handlers_data.go

@@ -178,7 +178,7 @@ func handleMsgMhfLoaddata(s *Session, p mhfpacket.MHFPacket) {
 	s.server.userBinaryPartsLock.Lock()
 	s.server.userBinaryParts[userBinaryPartID{charID: s.charID, index: 1}] = append(name, []byte{0x00}...)
 	s.server.userBinaryPartsLock.Unlock()
-	s.Name = stringsupport.SJISToUTF8(name)
+	s.Name, _ = stringsupport.SJISToUTF8(name)
 }
 
 func handleMsgMhfSaveScenarioData(s *Session, p mhfpacket.MHFPacket) {
@@ -200,16 +200,7 @@ func handleMsgMhfSaveScenarioData(s *Session, p mhfpacket.MHFPacket) {
 
 func handleMsgMhfLoadScenarioData(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadScenarioData)
-	var scenarioData []byte
-	bf := byteframe.NewByteFrame()
-	err := s.server.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))
-	} else {
-		bf.WriteBytes(scenarioData)
-	}
-	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
+	loadCharacterData(s, pkt.AckHandle, "scenariodata", make([]byte, 10))
 }
 
 func handleMsgSysAuthData(s *Session, p mhfpacket.MHFPacket) {}

server/channelserver/handlers_festa.go

@@ -17,15 +17,7 @@ import (
 
 func handleMsgMhfSaveMezfesData(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSaveMezfesData)
-	if len(pkt.RawDataPayload) > 4096 {
-		s.logger.Warn("MezFes payload too large", zap.Int("len", len(pkt.RawDataPayload)))
-		doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
-		return
-	}
-	if _, err := s.server.db.Exec(`UPDATE characters SET mezfes=$1 WHERE id=$2`, pkt.RawDataPayload, s.charID); err != nil {
-		s.logger.Error("Failed to save mezfes data", zap.Error(err))
-	}
-	doAckSimpleSucceed(s, pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
+	saveCharacterData(s, pkt.AckHandle, "mezfes", pkt.RawDataPayload, 4096)
 }
 
 func handleMsgMhfLoadMezfesData(s *Session, p mhfpacket.MHFPacket) {

server/channelserver/handlers_guild.go

@@ -154,7 +154,8 @@ func handleMsgMhfEnumerateGuildMember(s *Session, p mhfpacket.MHFPacket) {
 		if guild.ID != alliance.ParentGuildID {
 			mems, err := GetGuildMembers(s, alliance.ParentGuildID, false)
 			if err != nil {
-				panic(err)
+				s.logger.Error("Failed to get parent guild members for alliance", zap.Error(err))
+				return
 			}
 			for _, m := range mems {
 				bf.WriteUint32(m.CharID)
@@ -163,7 +164,8 @@ func handleMsgMhfEnumerateGuildMember(s *Session, p mhfpacket.MHFPacket) {
 		if guild.ID != alliance.SubGuild1ID {
 			mems, err := GetGuildMembers(s, alliance.SubGuild1ID, false)
 			if err != nil {
-				panic(err)
+				s.logger.Error("Failed to get sub guild 1 members for alliance", zap.Error(err))
+				return
 			}
 			for _, m := range mems {
 				bf.WriteUint32(m.CharID)
@@ -172,7 +174,8 @@ func handleMsgMhfEnumerateGuildMember(s *Session, p mhfpacket.MHFPacket) {
 		if guild.ID != alliance.SubGuild2ID {
 			mems, err := GetGuildMembers(s, alliance.SubGuild2ID, false)
 			if err != nil {
-				panic(err)
+				s.logger.Error("Failed to get sub guild 2 members for alliance", zap.Error(err))
+				return
 			}
 			for _, m := range mems {
 				bf.WriteUint32(m.CharID)
@@ -267,13 +270,17 @@ func handleMsgMhfUpdateGuildIcon(s *Session, p mhfpacket.MHFPacket) {
 	guild, err := GetGuildInfoByID(s, pkt.GuildID)
 
 	if err != nil {
-		panic(err)
+		s.logger.Error("Failed to get guild info for icon update", zap.Error(err))
+		doAckSimpleFail(s, pkt.AckHandle, make([]byte, 4))
+		return
 	}
 
 	characterInfo, err := GetCharacterGuildData(s, s.charID)
 
 	if err != nil {
-		panic(err)
+		s.logger.Error("Failed to get character guild data for icon update", zap.Error(err))
+		doAckSimpleFail(s, pkt.AckHandle, make([]byte, 4))
+		return
 	}
 
 	if !characterInfo.IsSubLeader() && !characterInfo.IsLeader {

server/channelserver/handlers_guild_alliance.go

@@ -195,8 +195,8 @@ func handleMsgMhfOperateJoint(s *Session, p mhfpacket.MHFPacket) {
 			doAckSimpleFail(s, pkt.AckHandle, make([]byte, 4))
 		}
 	default:
+		s.logger.Error("unhandled operate joint action", zap.Uint8("action", uint8(pkt.Action)))
 		doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
-		panic(fmt.Sprintf("Unhandled operate joint action '%d'", pkt.Action))
 	}
 }
 

server/channelserver/handlers_guild_info.go

@@ -291,14 +291,16 @@ func handleMsgMhfEnumerateGuild(s *Session, p mhfpacket.MHFPacket) {
 		}
 		switch pkt.Type {
 		case mhfpacket.ENUMERATE_GUILD_TYPE_GUILD_NAME:
+			searchName, _ := stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())
 			for _, guild := range tempGuilds {
-				if strings.Contains(guild.Name, stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())) {
+				if strings.Contains(guild.Name, searchName) {
 					guilds = append(guilds, guild)
 				}
 			}
 		case mhfpacket.ENUMERATE_GUILD_TYPE_LEADER_NAME:
+			searchName, _ := stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())
 			for _, guild := range tempGuilds {
-				if strings.Contains(guild.LeaderName, stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())) {
+				if strings.Contains(guild.LeaderName, searchName) {
 					guilds = append(guilds, guild)
 				}
 			}
@@ -371,14 +373,16 @@ func handleMsgMhfEnumerateGuild(s *Session, p mhfpacket.MHFPacket) {
 		}
 		switch pkt.Type {
 		case mhfpacket.ENUMERATE_ALLIANCE_TYPE_ALLIANCE_NAME:
+			searchName, _ := stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())
 			for _, alliance := range tempAlliances {
-				if strings.Contains(alliance.Name, stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())) {
+				if strings.Contains(alliance.Name, searchName) {
 					alliances = append(alliances, alliance)
 				}
 			}
 		case mhfpacket.ENUMERATE_ALLIANCE_TYPE_LEADER_NAME:
+			searchName, _ := stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())
 			for _, alliance := range tempAlliances {
-				if strings.Contains(alliance.ParentGuild.LeaderName, stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())) {
+				if strings.Contains(alliance.ParentGuild.LeaderName, searchName) {
 					alliances = append(alliances, alliance)
 				}
 			}

server/channelserver/handlers_guild_ops.go

@@ -104,7 +104,7 @@ func handleMsgMhfOperateGuild(s *Session, p mhfpacket.MHFPacket) {
 			doAckSimpleFail(s, pkt.AckHandle, make([]byte, 4))
 			return
 		}
-		guild.Comment = stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())
+		guild.Comment, _ = stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())
 		_ = guild.Save(s)
 	case mhfpacket.OperateGuildUpdateMotto:
 		if !characterGuildInfo.IsLeader && !characterGuildInfo.IsSubLeader() {
@@ -149,7 +149,7 @@ func handleMsgMhfOperateGuild(s *Session, p mhfpacket.MHFPacket) {
 		}
 		bf.WriteUint32(balance)
 	default:
-		panic(fmt.Sprintf("unhandled operate guild action '%d'", pkt.Action))
+		s.logger.Error("unhandled operate guild action", zap.Uint8("action", uint8(pkt.Action)))
 	}
 
 	if len(bf.Data()) > 0 {
@@ -160,7 +160,7 @@ func handleMsgMhfOperateGuild(s *Session, p mhfpacket.MHFPacket) {
 }
 
 func handleRenamePugi(s *Session, bf *byteframe.ByteFrame, guild *Guild, num int) {
-	name := stringsupport.SJISToUTF8(bf.ReadNullTerminatedBytes())
+	name, _ := stringsupport.SJISToUTF8(bf.ReadNullTerminatedBytes())
 	switch num {
 	case 1:
 		guild.PugiName1 = name

server/channelserver/handlers_guild_scout.go

@@ -15,8 +15,9 @@ func handleMsgMhfPostGuildScout(s *Session, p mhfpacket.MHFPacket) {
 	actorCharGuildData, err := GetCharacterGuildData(s, s.charID)
 
 	if err != nil {
+		s.logger.Error("Failed to get character guild data for scout", zap.Error(err))
 		doAckBufFail(s, pkt.AckHandle, make([]byte, 4))
-		panic(err)
+		return
 	}
 
 	if actorCharGuildData == nil || !actorCharGuildData.CanRecruit() {
@@ -27,15 +28,17 @@ func handleMsgMhfPostGuildScout(s *Session, p mhfpacket.MHFPacket) {
 	guildInfo, err := GetGuildInfoByID(s, actorCharGuildData.GuildID)
 
 	if err != nil {
+		s.logger.Error("Failed to get guild info for scout", zap.Error(err))
 		doAckBufFail(s, pkt.AckHandle, make([]byte, 4))
-		panic(err)
+		return
 	}
 
 	hasApplication, err := guildInfo.HasApplicationForCharID(s, pkt.CharID)
 
 	if err != nil {
+		s.logger.Error("Failed to check application for scout", zap.Error(err))
 		doAckBufFail(s, pkt.AckHandle, make([]byte, 4))
-		panic(err)
+		return
 	}
 
 	if hasApplication {
@@ -46,15 +49,18 @@ func handleMsgMhfPostGuildScout(s *Session, p mhfpacket.MHFPacket) {
 	transaction, err := s.server.db.Begin()
 
 	if err != nil {
-		panic(err)
+		s.logger.Error("Failed to begin transaction for guild scout", zap.Error(err))
+		doAckBufFail(s, pkt.AckHandle, nil)
+		return
 	}
 
 	err = guildInfo.CreateApplication(s, pkt.CharID, GuildApplicationTypeInvited, transaction)
 
 	if err != nil {
 		rollbackTransaction(s, transaction)
+		s.logger.Error("Failed to create guild scout application", zap.Error(err))
 		doAckBufFail(s, pkt.AckHandle, nil)
-		panic(err)
+		return
 	}
 
 	mail := &Mail{
@@ -79,8 +85,9 @@ func handleMsgMhfPostGuildScout(s *Session, p mhfpacket.MHFPacket) {
 	err = transaction.Commit()
 
 	if err != nil {
+		s.logger.Error("Failed to commit guild scout transaction", zap.Error(err))
 		doAckBufFail(s, pkt.AckHandle, nil)
-		panic(err)
+		return
 	}
 
 	doAckBufSucceed(s, pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
@@ -92,7 +99,9 @@ func handleMsgMhfCancelGuildScout(s *Session, p mhfpacket.MHFPacket) {
 	guildCharData, err := GetCharacterGuildData(s, s.charID)
 
 	if err != nil {
-		panic(err)
+		s.logger.Error("Failed to get character guild data for cancel scout", zap.Error(err))
+		doAckBufFail(s, pkt.AckHandle, make([]byte, 4))
+		return
 	}
 
 	if guildCharData == nil || !guildCharData.CanRecruit() {
@@ -123,7 +132,9 @@ func handleMsgMhfAnswerGuildScout(s *Session, p mhfpacket.MHFPacket) {
 	guild, err := GetGuildInfoByCharacterId(s, pkt.LeaderID)
 
 	if err != nil {
-		panic(err)
+		s.logger.Error("Failed to get guild info for answer scout", zap.Error(err))
+		doAckBufFail(s, pkt.AckHandle, nil)
+		return
 	}
 
 	app, err := guild.GetApplicationForCharID(s, s.charID, GuildApplicationTypeInvited)
@@ -255,7 +266,9 @@ func handleMsgMhfGetGuildScoutList(s *Session, p mhfpacket.MHFPacket) {
 	_, err = bf.Seek(0, io.SeekStart)
 
 	if err != nil {
-		panic(err)
+		s.logger.Error("Failed to seek in guild scout list buffer", zap.Error(err))
+		doAckBufFail(s, pkt.AckHandle, nil)
+		return
 	}
 
 	bf.WriteUint32(count)

server/channelserver/handlers_helpers.go

@@ -4,6 +4,8 @@ import (
 	"erupe-ce/common/byteframe"
 	"erupe-ce/common/mhfcourse"
 	"erupe-ce/network/mhfpacket"
+
+	"go.uber.org/zap"
 )
 
 // Temporary function to just return no results for a MSG_MHF_ENUMERATE* packet
@@ -62,6 +64,36 @@ func doAckSimpleFail(s *Session, ackHandle uint32, data []byte) {
 	})
 }
 
+// loadCharacterData loads a column from the characters table and sends it as
+// a buffered ack response. If the data is empty/nil, defaultData is sent instead.
+func loadCharacterData(s *Session, ackHandle uint32, column string, defaultData []byte) {
+	var data []byte
+	err := s.server.db.QueryRow("SELECT "+column+" FROM characters WHERE id = $1", s.charID).Scan(&data)
+	if err != nil {
+		s.logger.Error("Failed to load "+column, zap.Error(err))
+	}
+	if len(data) == 0 && defaultData != nil {
+		data = defaultData
+	}
+	doAckBufSucceed(s, ackHandle, data)
+}
+
+// saveCharacterData saves data to a column in the characters table with size
+// validation, optional save dump, and a simple ack response.
+func saveCharacterData(s *Session, ackHandle uint32, column string, data []byte, maxSize int) {
+	if maxSize > 0 && len(data) > maxSize {
+		s.logger.Warn("Payload too large for "+column, zap.Int("len", len(data)), zap.Int("max", maxSize))
+		doAckSimpleSucceed(s, ackHandle, make([]byte, 4))
+		return
+	}
+	dumpSaveData(s, data, column)
+	_, err := s.server.db.Exec("UPDATE characters SET "+column+"=$1 WHERE id=$2", data, s.charID)
+	if err != nil {
+		s.logger.Error("Failed to save "+column, zap.Error(err))
+	}
+	doAckSimpleSucceed(s, ackHandle, make([]byte, 4))
+}
+
 func updateRights(s *Session) {
 	rightsInt := uint32(2)
 	_ = s.server.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)

server/channelserver/handlers_mercenary.go

@@ -14,28 +14,12 @@ import (
 
 func handleMsgMhfLoadPartner(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadPartner)
-	var data []byte
-	err := s.server.db.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)
-	}
-	doAckBufSucceed(s, pkt.AckHandle, data)
+	loadCharacterData(s, pkt.AckHandle, "partner", make([]byte, 9))
 }
 
 func handleMsgMhfSavePartner(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSavePartner)
-	if len(pkt.RawDataPayload) > 65536 {
-		s.logger.Warn("Partner payload too large", zap.Int("len", len(pkt.RawDataPayload)))
-		doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
-		return
-	}
-	dumpSaveData(s, pkt.RawDataPayload, "partner")
-	_, err := s.server.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))
-	}
-	doAckSimpleSucceed(s, pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
+	saveCharacterData(s, pkt.AckHandle, "partner", pkt.RawDataPayload, 65536)
 }
 
 func handleMsgMhfLoadLegendDispatch(s *Session, p mhfpacket.MHFPacket) {
@@ -311,13 +295,7 @@ func handleMsgMhfContractMercenary(s *Session, p mhfpacket.MHFPacket) {
 
 func handleMsgMhfLoadOtomoAirou(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadOtomoAirou)
-	var data []byte
-	err := s.server.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)
-	}
-	doAckBufSucceed(s, pkt.AckHandle, data)
+	loadCharacterData(s, pkt.AckHandle, "otomoairou", make([]byte, 10))
 }
 
 func handleMsgMhfSaveOtomoAirou(s *Session, p mhfpacket.MHFPacket) {

server/channelserver/handlers_plate.go

@@ -31,12 +31,7 @@ import (
 
 func handleMsgMhfLoadPlateData(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadPlateData)
-	var data []byte
-	err := s.server.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))
-	}
-	doAckBufSucceed(s, pkt.AckHandle, data)
+	loadCharacterData(s, pkt.AckHandle, "platedata", nil)
 }
 
 func handleMsgMhfSavePlateData(s *Session, p mhfpacket.MHFPacket) {
@@ -144,12 +139,7 @@ func handleMsgMhfSavePlateData(s *Session, p mhfpacket.MHFPacket) {
 
 func handleMsgMhfLoadPlateBox(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadPlateBox)
-	var data []byte
-	err := s.server.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))
-	}
-	doAckBufSucceed(s, pkt.AckHandle, data)
+	loadCharacterData(s, pkt.AckHandle, "platebox", nil)
 }
 
 func handleMsgMhfSavePlateBox(s *Session, p mhfpacket.MHFPacket) {
@@ -223,13 +213,7 @@ func handleMsgMhfSavePlateBox(s *Session, p mhfpacket.MHFPacket) {
 
 func handleMsgMhfLoadPlateMyset(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfLoadPlateMyset)
-	var data []byte
-	err := s.server.db.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)
-	}
-	doAckBufSucceed(s, pkt.AckHandle, data)
+	loadCharacterData(s, pkt.AckHandle, "platemyset", make([]byte, 1920))
 }
 
 func handleMsgMhfSavePlateMyset(s *Session, p mhfpacket.MHFPacket) {

server/channelserver/handlers_rengoku.go

@@ -103,7 +103,9 @@ func handleMsgMhfGetRengokuBinary(s *Session, p mhfpacket.MHFPacket) {
 	// 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(s.server.erupeConfig.BinPath, "rengoku_data.bin"))
 	if err != nil {
-		panic(err)
+		s.logger.Error("Failed to read rengoku_data.bin", zap.Error(err))
+		doAckBufFail(s, pkt.AckHandle, nil)
+		return
 	}
 	doAckBufSucceed(s, pkt.AckHandle, data)
 }

server/channelserver/handlers_session.go

@@ -76,22 +76,26 @@ func handleMsgSysLogin(s *Session, p mhfpacket.MHFPacket) {
 
 	_, err := s.server.db.Exec("UPDATE servers SET current_players=$1 WHERE server_id=$2", len(s.server.sessions), s.server.ID)
 	if err != nil {
-		panic(err)
+		s.logger.Error("Failed to update current players", zap.Error(err))
+		return
 	}
 
 	_, err = s.server.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)
+		s.logger.Error("Failed to update sign session", zap.Error(err))
+		return
 	}
 
 	_, err = s.server.db.Exec("UPDATE characters SET last_login=$1 WHERE id=$2", TimeAdjusted().Unix(), s.charID)
 	if err != nil {
-		panic(err)
+		s.logger.Error("Failed to update last login", zap.Error(err))
+		return
 	}
 
 	_, err = s.server.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)
+		s.logger.Error("Failed to update last character", zap.Error(err))
+		return
 	}
 
 	doAckSimpleSucceed(s, pkt.AckHandle, bf.Data())
@@ -361,7 +365,8 @@ func handleMsgSysIssueLogkey(s *Session, p mhfpacket.MHFPacket) {
 	logKey := make([]byte, 16)
 	_, err := rand.Read(logKey)
 	if err != nil {
-		panic(err)
+		s.logger.Error("Failed to generate log key", zap.Error(err))
+		return
 	}
 
 	// TODO(Andoryuuta): In the offical client, the log key index is off by one,
@@ -461,7 +466,7 @@ func handleMsgMhfTransitMessage(s *Session, p mhfpacket.MHFPacket) {
 		bf.ReadUint16() // term length
 		maxResults = bf.ReadUint16()
 		bf.ReadUint8() // Unk
-		term = stringsupport.SJISToUTF8(bf.ReadNullTerminatedBytes())
+		term, _ = stringsupport.SJISToUTF8(bf.ReadNullTerminatedBytes())
 	case 3:
 		_ip := bf.ReadBytes(4)
 		ip = fmt.Sprintf("%d.%d.%d.%d", _ip[3], _ip[2], _ip[1], _ip[0])

server/channelserver/model_character.go

@@ -155,7 +155,7 @@ func (save *CharacterSaveData) updateSaveDataWithStruct() {
 
 // This will update the save struct with the values stored in the character save
 func (save *CharacterSaveData) updateStructWithSaveData() {
-	save.Name = stringsupport.SJISToUTF8(bfutil.UpToNull(save.decompSave[88:100]))
+	save.Name, _ = stringsupport.SJISToUTF8(bfutil.UpToNull(save.decompSave[88:100]))
 	if save.decompSave[save.Pointers[pGender]] == 1 {
 		save.Gender = true
 	} else {