Mirror/Erupe
1
0
Fork 0
mirror of https://github.com/Mezeporta/Erupe.git synced 2026-03-22 07:32:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor: replace panic calls with structured error handling

Browse Source 
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.
This commit is contained in:
Houmgaor
2026-02-20 19:11:41 +01:00
parent 06cb3afa57
commit d32e77efba
31 changed files with 141 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
server/channelserver/compression/deltacomp/deltacomp.go
View File

@@ -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

4
server/channelserver/guild_model.go
View File

@@ -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,

3
server/channelserver/handlers_cafe.go
View File

@@ -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

13
server/channelserver/handlers_data.go
View File

@@ -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) {}

10
server/channelserver/handlers_festa.go
View File

@@ -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) {

17
server/channelserver/handlers_guild.go
View File

@@ -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 {

2
server/channelserver/handlers_guild_alliance.go
View File

@@ -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))
}
}

12
server/channelserver/handlers_guild_info.go
View File

@@ -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)
}
}

6
server/channelserver/handlers_guild_ops.go
View File

@@ -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

31
server/channelserver/handlers_guild_scout.go
View File

@@ -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)

32
server/channelserver/handlers_helpers.go
View File

@@ -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)

28
server/channelserver/handlers_mercenary.go
View File

@@ -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) {

22
server/channelserver/handlers_plate.go
View File

@@ -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) {

4
server/channelserver/handlers_rengoku.go
View File

@@ -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)
}

17
server/channelserver/handlers_session.go
View File

@@ -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])

2
server/channelserver/model_character.go
View File

@@ -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 {

7
server/signserver/session.go
View File

@@ -157,7 +157,8 @@ func (s *Session) handlePSSGN(bf *byteframe.ByteFrame) {
func (s *Session) handlePSNLink(bf *byteframe.ByteFrame) {
_ = bf.ReadNullTerminatedBytes() // Client ID
credentials := strings.Split(stringsupport.SJISToUTF8(bf.ReadNullTerminatedBytes()), "\n")
credStr, _ := stringsupport.SJISToUTF8(bf.ReadNullTerminatedBytes())
credentials := strings.Split(credStr, "\n")
token := string(bf.ReadNullTerminatedBytes())
uid, resp := s.server.validateLogin(credentials[0], credentials[1])
if resp == SIGN_SUCCESS && uid > 0 {
@@ -199,8 +200,8 @@ func (s *Session) handlePSNLink(bf *byteframe.ByteFrame) {
}
func (s *Session) handleDSGN(bf *byteframe.ByteFrame) {
user := stringsupport.SJISToUTF8(bf.ReadNullTerminatedBytes())
pass := stringsupport.SJISToUTF8(bf.ReadNullTerminatedBytes())
user, _ := stringsupport.SJISToUTF8(bf.ReadNullTerminatedBytes())
pass, _ := stringsupport.SJISToUTF8(bf.ReadNullTerminatedBytes())
_ = string(bf.ReadNullTerminatedBytes()) // Unk
s.authenticate(user, pass)
}

3
server/signserver/sign_server.go
View File

@@ -76,7 +76,8 @@ func (s *Server) acceptClients() {
if shutdown {
break
} else {
panic(err)
s.logger.Warn("Error accepting client", zap.Error(err))
continue
}
}