1275 lines
51 KiB
Go
1275 lines
51 KiB
Go
// service.go 负责 DNF bridge 生命周期、目录加载和监听器管理。
|
||
// 这里不写玩法状态，只装配频道服与 game 端口的 transport 边界。
|
||
package dnfbridge
|
||
|
||
import (
|
||
"context"
|
||
"encoding/hex"
|
||
"errors"
|
||
"fmt"
|
||
"log/slog"
|
||
"net"
|
||
"net/http"
|
||
"net/netip"
|
||
runtimedebug "runtime/debug"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"sync/atomic"
|
||
"time"
|
||
|
||
"longheng.io/server/internal/modules/dnf/adventuregroup"
|
||
"longheng.io/server/internal/modules/dnf/channelcatalog"
|
||
"longheng.io/server/internal/modules/dnf/channelinfo"
|
||
dnfcharstat "longheng.io/server/internal/modules/dnf/charstat"
|
||
dnfcombatpower "longheng.io/server/internal/modules/dnf/combatpower"
|
||
"longheng.io/server/internal/modules/dnf/dnfenum"
|
||
"longheng.io/server/internal/modules/dnf/dproto"
|
||
dnfdungeonadmission "longheng.io/server/internal/modules/dnf/dungeonadmission"
|
||
dnfepicbook "longheng.io/server/internal/modules/dnf/epicbook"
|
||
dnfexpertjob "longheng.io/server/internal/modules/dnf/expertjob"
|
||
dnfhellparty "longheng.io/server/internal/modules/dnf/hellparty"
|
||
dnfhonor "longheng.io/server/internal/modules/dnf/honor"
|
||
dnfjoust "longheng.io/server/internal/modules/dnf/joust"
|
||
dnfonlineevent "longheng.io/server/internal/modules/dnf/onlineevent"
|
||
"longheng.io/server/internal/modules/dnf/party"
|
||
dnfpet "longheng.io/server/internal/modules/dnf/pet"
|
||
dnfprofession "longheng.io/server/internal/modules/dnf/profession"
|
||
dnfprogression "longheng.io/server/internal/modules/dnf/progression"
|
||
dnfpvp "longheng.io/server/internal/modules/dnf/pvp"
|
||
dnfquest "longheng.io/server/internal/modules/dnf/quest"
|
||
dnfraid "longheng.io/server/internal/modules/dnf/raid"
|
||
dnfrepo "longheng.io/server/internal/modules/dnf/repository"
|
||
dnfskill "longheng.io/server/internal/modules/dnf/skill"
|
||
dnfstorydigest "longheng.io/server/internal/modules/dnf/storydigest"
|
||
dnftown "longheng.io/server/internal/modules/dnf/town"
|
||
"longheng.io/server/internal/modules/dnf/wedding"
|
||
"longheng.io/server/internal/modules/dnf/worldmap"
|
||
appkit "longheng.io/server/internal/platform/app"
|
||
platformpvf "longheng.io/server/internal/platform/pvf"
|
||
)
|
||
|
||
// Service 是 DNF 最新客户端 bridge 的生命周期组件。
|
||
type Service struct {
|
||
logger *slog.Logger
|
||
options options
|
||
// launcherAuthHTTPClient performs the loopback verify-game-ticket call for
|
||
// external game connections when launcher auth is enabled; nil otherwise.
|
||
launcherAuthHTTPClient *http.Client
|
||
// launcherIdentity pins the deployment's launcher. It is never nil: a
|
||
// disabled verifier keeps every legacy account-binding path reachable.
|
||
launcherIdentity *launcherIdentityVerifier
|
||
// launcherIdentityErr is a launcher identity configuration error. It is
|
||
// surfaced by Start so a misconfigured server refuses to serve rather than
|
||
// quietly running unbound.
|
||
launcherIdentityErr error
|
||
// localDebugMode is supplied only by the local composition root. It is
|
||
// intentionally process-local and never persisted with character data.
|
||
localDebugMode bool
|
||
localDebugStrikeOnSkillUse bool
|
||
|
||
// petEggProbeOnce 装配进程级的"宠物蛋"判据（见 pet_egg_item.go）；petEggCache
|
||
// 缓存模板级判定结果，避免每次对账都重新解析 PVF 文档。
|
||
petEggProbeOnce sync.Once
|
||
petEggCache sync.Map
|
||
|
||
// chatMu 保护下面两张 1:1 会话表（见 town_chat_conversation.go）。它是服务端
|
||
// 自己记的"这个客户端的聊天窗口里是谁"：当前客户端的聊天请求里没有可用的对端
|
||
// 字段，对端只能由服务端维护。会话是纯内存状态，随 session 结束回收，不落盘。
|
||
chatMu sync.Mutex
|
||
chatConversations map[uint64]*currentChatConversation
|
||
chatConversationByMember map[uint16]*currentChatConversation
|
||
chatConversationSeq uint32
|
||
|
||
// companionConfigMu 串行化支援兵配置的读-改-写（见 dungeon_companion_control.go）。
|
||
// 配置按账号落库（repos.Settings），运行态按副本冻结；这把锁只保护那一段
|
||
// "读当前 revision → 校验 → 写回"的临界区，避免并发保存把 revision 撞掉。
|
||
companionConfigMu sync.Mutex
|
||
// companionPresenceMu guards the synthetic sessions that expose a volunteer
|
||
// in the native friend list / party frame. These sessions have no socket and
|
||
// are deliberately NOT stored in gameSessions: only the social and party
|
||
// projection helpers below may resolve them.
|
||
companionPresenceMu sync.Mutex
|
||
companionSessions map[uint16]*gameSession
|
||
|
||
mu sync.Mutex
|
||
catalog *channelcatalog.Catalog
|
||
channelScript []byte
|
||
listeners []net.Listener
|
||
// gameListeners 按游戏端口登记监听，供热重载时对账（gm_channel_reload.go）。
|
||
// 与 listeners 同步维护：listeners 仍是 Stop 的唯一清理来源，gameListeners 只提供
|
||
// "哪个端口对应哪个 listener"的反查能力。
|
||
gameListeners map[int]net.Listener
|
||
// runCtx 是 Start 建立的运行期上下文，供热重载时为新启用的频道开监听。
|
||
// 由 s.mu 保护，Stop 时置 nil。
|
||
runCtx context.Context
|
||
conns map[net.Conn]struct{}
|
||
gameSessions map[uint16]*gameSession
|
||
// onlineSeats tracks every authenticated game connection that currently
|
||
// occupies an online seat, whether or not it has bound a character yet
|
||
// (role-select / loading connections included). Guarded by s.mu. It is
|
||
// the authoritative source for online-capacity accounting: a server at
|
||
// its limit must reject a new launcher verify immediately instead of
|
||
// overselling a seat to a connection that is still connecting.
|
||
onlineSeats map[*gameSession]struct{}
|
||
onlineReportTrigger chan struct{}
|
||
|
||
pvpMu sync.Mutex
|
||
pvpRooms map[uint16]*currentPVPRoom
|
||
pvpMatching []*currentPVPMatchingRequest // protected by pvpMu
|
||
nextPVPMatchingToken uint32
|
||
pvpSubscribers map[*gameSession]int
|
||
pvpMapOrder []int64 // protected by pvpMu
|
||
pvpDailyCatalog *dnfpvp.Catalog // protected by initialEquipmentMu
|
||
pvpTotalCatalog *dnfpvp.Catalog // protected by initialEquipmentMu
|
||
pvpFatigueRules *currentPVPFatigueRules // protected by initialEquipmentMu
|
||
nextGameSessionGeneration uint64
|
||
nextDungeonLifecycleToken atomic.Uint64
|
||
nextPartyRoutingKey atomic.Uint32
|
||
// abisAdventureGroupMu 保护 abisAdventureGroupLevel：周常五图的账号额度上限
|
||
// 要按 [adventure group add enterable count chn] 加上冒险团分档加成，而
|
||
// currentDungeonAdmissionPolicies 是同步且只带 dungeonID 的入口，拿不到账号。
|
||
// 因此由带 session 的路径刷新这个缓存，策略生成时读它。只影响"多给几次"，
|
||
// 读不到时按 0 处理（纯基础 5 次），属于安全方向。
|
||
abisAdventureGroupMu sync.Mutex
|
||
abisAdventureGroupLevel uint32
|
||
guildMu sync.Mutex
|
||
guildDungeonCatalog currentGuildDungeonCatalogCache
|
||
guildCompoundCatalog currentGuildCompoundCatalogCache
|
||
guildCompoundCandidates currentGuildCompoundCandidates
|
||
guildCreateMu sync.Mutex
|
||
friendMu sync.Mutex
|
||
// weddingMu 串行化婚姻手势（求婚/应答/戒指/心意点/婚房），并保护
|
||
// weddingInvitations。获取顺序必须是 weddingMu 先于 mu（见 game_sessions.go），
|
||
// 与上游一致，避免会话绑定/解绑路径与婚姻事务互相等待。
|
||
weddingMu sync.Mutex
|
||
weddingInvitations map[uint16]*currentWeddingInvitation
|
||
weddingCatalogMu sync.Mutex
|
||
weddingCatalog *wedding.Catalog
|
||
weddingCatalogLoadErr error
|
||
weddingCapsuleCatalog *wedding.CapsuleCatalog
|
||
weddingCapsuleCatalogErr error
|
||
tradeMu sync.Mutex
|
||
itemTrades map[uint16]*onlineItemTrade
|
||
privateStoreOpMu sync.Mutex
|
||
privateStoreMu sync.Mutex
|
||
privateStores map[uint16]*currentPrivateStore
|
||
privateStoreVisitors map[*gameSession]uint16
|
||
nextPrivateStoreGeneration atomic.Uint64
|
||
privateStoreItemEligibility func(uint32) bool
|
||
auctionMu sync.Mutex
|
||
nextAuctionListingID atomic.Uint64
|
||
auctionItemEligibility func(uint32) bool
|
||
auctionCategoryItem func(uint16, uint32) bool
|
||
expertJobStoreMu sync.Mutex
|
||
expertJobStoreOpMu sync.Mutex
|
||
skillSwitchInventoryMu sync.Mutex
|
||
expertJobStores map[uint16]*currentExpertJobStore
|
||
expertJobVisitors map[*gameSession]uint16
|
||
raidMu sync.Mutex
|
||
raidStartMu sync.Mutex
|
||
raids map[uint32]*runtimeRaidState
|
||
// raidPhaseCompletionRetries 是"阶段收尾重试"的预算，按 RaidKey 计：
|
||
// 门还没关完时 finishRuntimeRaidPhase 会把自己再排一次，直到所有人都回城
|
||
// 或预算用尽（见 scheduleRuntimeRaidPhaseCompletionRetry）。
|
||
raidPhaseCompletionMu sync.Mutex
|
||
raidPhaseCompletionRetries map[uint32]int
|
||
raidSituationValues map[runtimeRaidMonsterRuntimeKey][]uint32
|
||
raidBuffActivations map[runtimeRaidBuffActivationKey]runtimeRaidBuffActivation
|
||
raidReviveUses map[runtimeRaidReviveCoinKey]uint32
|
||
raidReviveGrants map[runtimeRaidReviveCoinKey]uint32
|
||
raidPeerAdmissions map[runtimeRaidPeerAdmissionKey]runtimeRaidPeerAdmission
|
||
raidDisconnects map[uint16]runtimeRaidDisconnectReservation
|
||
// raidPhaseDeaths 是本阶段整团的死亡次数（0x0259 的 deaths 字段），按
|
||
// (RaidKey, Phase) 计；与 raidReviveUses 共用 raidMu。见 raid_phase_death_count.go。
|
||
raidPhaseDeaths map[runtimeRaidPhaseDeathKey]uint32
|
||
nextRaidSeq uint32
|
||
raidAntonMu sync.Mutex
|
||
raidAnton *dnfraid.AntonConfig
|
||
raidAntonErr error
|
||
raidLukeMu sync.Mutex
|
||
raidLuke *dnfraid.LukeConfig
|
||
raidLukeErr error
|
||
// raidFiendWar 是 etc/raid/fiendwar/fiendwar.etc：招募标量 + 30 区域地图 +
|
||
// trigger/behavior 规则对 + 奖励。与 raidAnton/raidLuke 同形：一次读档、缓存，
|
||
// 失败也缓存（缺档只报一次）。见 raid_fiendwar_runtime.go。
|
||
raidFiendWarMu sync.Mutex
|
||
raidFiendWar *dnfraid.FiendWarConfig
|
||
raidFiendWarErr error
|
||
// raidLukeCardSet 是 etc/raid/luke/LukeCardSet.etc（塔罗牌面的图案表 + 22 张
|
||
// 大阿卡纳），只被 1181 的下发路径读，见 raid_luke_card_display.go。
|
||
raidLukeCardSetMu sync.Mutex
|
||
raidLukeCardSet *dnfraid.LukeCardSetConfig
|
||
raidLukeCardSetErr error
|
||
// raidLukeMonsterList 是 etc/raid/luke/luke.etc.buff 的 [RAID MONSTER LIST]
|
||
// （每个迷宫真会刷的 named/boss），1181 的牌面按它推，见 raid_luke_card_display.go。
|
||
raidLukeMonsterListMu sync.Mutex
|
||
raidLukeMonsterList *dnfraid.LukeRaidMonsterListConfig
|
||
raidLukeMonsterListErr error
|
||
raidAntonRewardMu sync.Mutex
|
||
raidAntonReward *antonRewardPVFCatalog
|
||
raidAntonRewardErr error
|
||
raidLukeRewardMu sync.Mutex
|
||
raidLukeReward *antonRewardPVFCatalog
|
||
raidLukeRewardErr error
|
||
raidRewardCommitMu sync.Mutex
|
||
raidRewardFlowMu sync.Mutex
|
||
raidRewardCompleted map[runtimeRaidRewardCompletionKey]runtimeRaidSettlementRewardCompletion
|
||
raidRewardPublished map[runtimeRaidRewardCompletionKey]*runtimeRaidRewardPublication
|
||
// 上面两张表的插入顺序。键含单调递增的 Token、RaidKey 永不复用，所以每条都是
|
||
// 新键；没有这个顺序就无法在超限时淘汰最旧的一条。见 raid_reward_bounds.go。
|
||
raidRewardCompletedOrder []runtimeRaidRewardCompletionKey
|
||
raidRewardPublishedOrder []runtimeRaidRewardCompletionKey
|
||
// finishedRaidLeavers 记录"攻坚已被释放后"已经点过退出的成员，按 raid key 分组：
|
||
// 这时 s.raids 里已经没有状态，剩下的名册只能由 completion 记录减去这些人生成
|
||
// （见 markFinishedRuntimeRaidLeaver）。
|
||
finishedRaidLeaverMu sync.Mutex
|
||
finishedRaidLeavers map[uint32]map[uint16]bool
|
||
raidRewardRandom func() uint64
|
||
packetLog atomic.Pointer[packetLogger]
|
||
// records 是三类审计记录（点券消费/对话/副本）的追加写入器，见 activity_record.go。
|
||
// 与 packetLog 同样用 atomic：玩法主路径会在任意协程调 recordActivity，
|
||
// 而 Start/Stop 会在生命周期线程创建/关闭它。
|
||
records atomic.Pointer[activityRecorder]
|
||
partyUDPRelay *currentPartyUDPRelay
|
||
partyUDPProbe *currentPartyUDPProbe
|
||
partyEndpointMu sync.Mutex
|
||
partyEndpoints currentPartyUDPEndpointRegistry
|
||
partyUDPOwnerPID func(netip.AddrPort) (uint32, bool)
|
||
runtimePartyManager *party.RuntimePartyManager
|
||
// partyPublishFormation maps a party to the token of its live formation-retry
|
||
// epoch; see party_publish_retry.go. It has its own mutex (never s.mu) because
|
||
// a retry callback runs from the gameplay timer queue and must not contend
|
||
// with, or invert against, the session/party locks taken by a publish.
|
||
partyPublishMu sync.Mutex
|
||
partyPublishSerial uint64
|
||
partyPublishFormation map[int]uint64
|
||
// raidCost 是每场攻坚的服务端成本计数（见 raid_cost_summary.go）：慢事件、
|
||
// 安装分片、写阻塞、中继端口占用等聚合成一行团本记录，供"收不到玩家日志"
|
||
// 时判定这场到底卡没卡、掉没掉。它有自己的锁，绝不在 gameplay 锁内取用。
|
||
raidCost runtimeRaidCostRegistry
|
||
partyTeleportMu sync.Mutex
|
||
partyTeleportPending map[int]*currentPartyTeleportSession
|
||
partyTeleportLastRequest map[int]currentPartyTeleportRequest
|
||
partyTeleportToken uint64
|
||
cancel context.CancelFunc
|
||
wg sync.WaitGroup
|
||
packetID uint64
|
||
clientAccounts clientAccountRegistry
|
||
robotSessionSecret []byte
|
||
robotSessionReplayMu sync.Mutex
|
||
robotSessionReplays map[[32]byte]time.Time
|
||
// characterCreateMu serializes the name/slot/numeric-ID reservation shared
|
||
// by native character creation and loopback GM robot provisioning. The
|
||
// repository creation transaction makes one aggregate atomic, but the
|
||
// three reservations are account/global reads that must not race each
|
||
// other before that transaction begins.
|
||
characterCreateMu sync.Mutex
|
||
|
||
initialEquipmentMu sync.Mutex
|
||
initialEquipmentArchive *platformpvf.Archive
|
||
initialEquipmentByJob map[byte][]initialEquipmentEntry
|
||
initialEquipmentLoadErr error
|
||
pvfItemCatalogMu sync.Mutex
|
||
pvfItemCatalog *pvfDungeonDropCatalog
|
||
pvfItemCatalogLoadErr error
|
||
gmGameplaySettingsMu sync.Mutex
|
||
gmGameplaySettingsReady bool
|
||
gmHellEpicDropRatePct int
|
||
// gmEpicDropRatePotionTestMultiplierPct 是"城镇增益药剂临时测试倍率"的缓存
|
||
// （0 = 关闭，倍数按 PVF 表走）。见 gm_tool_dungeon.go 里那个常量的说明。
|
||
gmEpicDropRatePotionTestMultiplierPct int
|
||
// gmFatigueMode / gmBurningEnabled 是疲劳与燃烧疲劳的 GM 配置缓存。
|
||
// 见 gm_tool_dungeon.go 常量区与 gmFatigueModeLocked 的说明。
|
||
gmFatigueMode string
|
||
gmBurningEnabled bool
|
||
gmGameplaySettingsAt time.Time
|
||
automaticRobotAppearanceMu sync.Mutex
|
||
automaticRobotAvatarConfig *currentAvatarFittingRoomConfig
|
||
automaticRobotAvatarLoadErr error
|
||
chatEmoticonCatalogMu sync.Mutex
|
||
chatEmoticonCatalog []currentChatEmoticonEntry
|
||
chatEmoticonCatalogLoadErr error
|
||
vendingMachineCatalogMu sync.Mutex
|
||
vendingMachineCatalog *currentVendingMachineCatalog
|
||
vendingMachineCatalogLoadErr error
|
||
vendingMachineRoll func(uint64) (uint64, error)
|
||
vendingMachineCompletionKey func() (string, error)
|
||
joustCatalogMu sync.Mutex
|
||
joustCatalog *dnfjoust.Catalog
|
||
joustCatalogLoadErr error
|
||
joustHistoryMu sync.Mutex
|
||
joustOperationMu sync.Mutex
|
||
spendTimeCatalogMu sync.Mutex
|
||
spendTimeCatalogState *currentSpendTimeRuntimeCatalog
|
||
spendTimeCatalogLoadErr error
|
||
attendanceMarbleMu sync.Mutex
|
||
attendanceMarbleCatalog *attendanceMarbleCatalog
|
||
attendanceMarbleLoadErr error
|
||
laborDayMu sync.Mutex
|
||
laborDayCatalog *dnfonlineevent.LaborDayCatalog
|
||
monthlyAttendanceMu sync.Mutex
|
||
monthlyAttendanceCatalog *dnfonlineevent.MonthlyCatalog
|
||
weeklyAttendanceMu sync.Mutex
|
||
weeklyAttendanceCatalog *dnfonlineevent.WeeklyCatalog
|
||
returneeLuckyMu sync.Mutex
|
||
returneeCatalog *dnfonlineevent.ReturneeCatalog
|
||
luckyCharacterCatalog *currentLuckyCatalog
|
||
legacyLevelMu sync.Mutex
|
||
legacyLevelCatalog *dnfonlineevent.LegacyLevelCatalog
|
||
levelAimingMu sync.Mutex
|
||
levelAimingCatalog *dnfonlineevent.LevelAimingCatalog
|
||
expertJobMu sync.Mutex
|
||
expertJobCatalog *dnfexpertjob.Catalog
|
||
expertJobCatalogLoadErr error
|
||
petCatalogMu sync.Mutex
|
||
petCatalog *dnfpet.PVFCatalog
|
||
petCatalogLoadErr error
|
||
collectboxMu sync.Mutex
|
||
collectboxCatalog *currentCollectboxCatalog
|
||
collectboxCatalogLoadErr error
|
||
epicBookMu sync.Mutex
|
||
epicBookCatalog *dnfepicbook.Catalog
|
||
epicBookCatalogLoadErr error
|
||
hellPartyMu sync.Mutex
|
||
hellPartyCatalog *dnfhellparty.Catalog
|
||
hellPartyCatalogLoadErr error
|
||
hellPartyDropMu sync.Mutex
|
||
hellPartyDropCatalog *dnfhellparty.DropCatalog
|
||
hellPartyFragmentPools map[int][]currentDungeonHellPartyFragmentCandidate
|
||
hellPartyDropCatalogLoadErr error
|
||
premiumCatalogMu sync.Mutex
|
||
premiumCatalog *currentPremiumCatalog
|
||
premiumCatalogLoadErr error
|
||
weaknessCostMu sync.Mutex
|
||
weaknessCostTable *currentWeaknessCostTable
|
||
weaknessCostErr error
|
||
disjointConfigMu sync.Mutex
|
||
disjointPVFConfig *currentDisjointPVFConfig
|
||
disjointPVFConfigErr error
|
||
repairCostMu sync.Mutex
|
||
repairCostCatalog *currentRepairCostCatalog
|
||
repairCostLoadErr error
|
||
equipmentRegenerationMu sync.Mutex
|
||
equipmentRegenerationCatalog *currentEquipmentRegenerationCatalog
|
||
equipmentRegenerationLoadErr error
|
||
npcShopCatalogMu sync.Mutex
|
||
npcShopCatalog *currentNPCShopCatalog
|
||
npcShopCatalogLoadErr error
|
||
adventureGroupMu sync.Mutex
|
||
adventureGroupLoginMu sync.Mutex
|
||
adventureGroupRuntimeMu sync.Mutex
|
||
adventureRepresentativeMu sync.Mutex
|
||
adventureGroupTable *adventuregroup.Tables
|
||
adventureGroupLoadErr error
|
||
honorMu sync.Mutex
|
||
honorTable *dnfhonor.Tables
|
||
honorLoadErr error
|
||
initialSkillsMu sync.Mutex
|
||
initialSkillsByJob map[byte][]initialSkillEntry
|
||
skillCatalog *dnfskill.Table
|
||
initialSPTable map[int]int
|
||
initialTPTable map[int]int
|
||
experienceMu sync.Mutex
|
||
experienceTable *dnfprogression.ExperienceTable
|
||
experienceTableLoadErr error
|
||
professionMu sync.Mutex
|
||
professionProfiles *dnfprofession.Profiles
|
||
professionProfilesErr error
|
||
questCatalogMu sync.Mutex
|
||
questCatalog *dnfquest.Catalog
|
||
questCatalogLoadErr error
|
||
ceraShopMu sync.Mutex
|
||
ceraShopCatalog *pvfCeraShopCatalog
|
||
ceraShopCatalogLoadErr error
|
||
ceraShopPurchaseMu sync.Mutex
|
||
premiumWeb *currentPremiumWebPortal
|
||
deathTowerMu sync.Mutex
|
||
deathTowerStageMapIDs []int
|
||
deathTowerBasisLevel int
|
||
titleBookMappingMu sync.Mutex
|
||
titleBookMappingCache map[int32]titleBookMappingEntry
|
||
onlinePlayers *OnlinePlayerManager
|
||
characterStatsMu sync.Mutex
|
||
characterStats *dnfcharstat.Table
|
||
characterStatsLoadErr error
|
||
equipmentStatsMu sync.Mutex
|
||
equipmentStatPaths map[int64]string
|
||
equipmentStats map[int64]dnfcharstat.Vector
|
||
equipmentExpAdvantages map[int64]int64
|
||
equipmentStatsLoadErr error
|
||
combatPowerMu sync.Mutex
|
||
combatPowerCatalog *dnfcombatpower.Catalog
|
||
combatPowerCatalogErr error
|
||
townCatalogMu sync.RWMutex
|
||
townCatalog *dnftown.Table
|
||
// townMovieCatalog 是 etc/townmovielist.etc：城镇区域开启后要自动播放的过场。
|
||
townMovieCatalog *dnftown.TownMovieTable
|
||
// storyDigestCatalog 是 etc/storydigest/digest.etc：章节过场的播放边界。
|
||
// 城镇区域的过场影片属于哪一段，就把 last_level 下发到那段的等级下界，
|
||
// 客户端才会在该段结束处播放影片。
|
||
storyDigestCatalog *dnfstorydigest.Digest
|
||
worldMapMu sync.RWMutex
|
||
worldMapTable *worldmap.Table
|
||
worldMapResolver *worldmap.Resolver
|
||
dungeonAdmissionCatalog *dnfdungeonadmission.Catalog
|
||
dungeonAdmissionReceiptOnce sync.Once
|
||
dungeonAdmissionReceiptNonce string
|
||
dungeonAdmissionReceiptErr error
|
||
sequentialDungeonMu sync.Mutex
|
||
sequentialDungeonCatalog *currentSequentialDungeonCatalog
|
||
sequentialDungeonCatalogErr error
|
||
dungeonMonsterTable *pvfDungeonMonsterCatalog
|
||
dungeonAICharacterTable *pvfDungeonAICharacterCatalog
|
||
dungeonTutorialScripts *pvfDungeonTutorialScriptCatalog
|
||
dungeonChoice func(int) (int, error)
|
||
dungeonSeed func() (uint32, error)
|
||
gameplayTimers gameplayTimeQueue
|
||
repositoryProvider func() (dnfrepo.Group, bool)
|
||
initialTownEntryWait func(time.Duration)
|
||
initialSceneMemoryTrimOnce sync.Once
|
||
dprotoProvider dproto.Provider
|
||
|
||
// Personal-teleport (C2S op470) lock, kept in its own block so it does not
|
||
// re-align the field groups above. Keyed by CHARACTER id: the client keeps
|
||
// its countdown on the logged-in user object, so two characters of one
|
||
// account each own an entry. The server mirrors it so a request cannot
|
||
// bypass the client-side gate.
|
||
soloTeleportCooldownMu sync.Mutex
|
||
soloTeleportCooldownUntil map[uint16]time.Time
|
||
// soloTeleportClock is a test hook for the expiry above; nil means time.Now.
|
||
soloTeleportClock func() time.Time
|
||
// purchaseLimitClock 是 PVF 限购窗口取值用的时钟；nil 表示 time.Now。
|
||
purchaseLimitClock func() time.Time
|
||
}
|
||
|
||
const initialSceneMemoryTrimDelay = 5 * time.Second
|
||
|
||
func (s *Service) scheduleInitialSceneMemoryTrim() {
|
||
if s == nil {
|
||
return
|
||
}
|
||
s.initialEquipmentMu.Lock()
|
||
archiveLoaded := s.initialEquipmentArchive != nil
|
||
s.initialEquipmentMu.Unlock()
|
||
if !archiveLoaded {
|
||
return
|
||
}
|
||
s.scheduleProcessMemoryTrim(initialSceneMemoryTrimDelay, runtimedebug.FreeOSMemory)
|
||
}
|
||
|
||
func (s *Service) scheduleProcessMemoryTrim(delay time.Duration, trim func()) {
|
||
if s == nil || trim == nil {
|
||
return
|
||
}
|
||
s.initialSceneMemoryTrimOnce.Do(func() {
|
||
time.AfterFunc(delay, trim)
|
||
})
|
||
}
|
||
|
||
// ServiceOptions 描述 dnfbridge 对外注入的项目侧依赖。
|
||
// 这里只保存依赖入口，不直接创建 MySQL/Redis，也不把玩法状态塞进 bridge。
|
||
type ServiceOptions struct {
|
||
RepositoryProvider func() (dnfrepo.Group, bool)
|
||
DprotoProvider dproto.Provider
|
||
LocalDebugMode bool
|
||
LocalDebugStrikeOnSkillUse bool
|
||
// RobotSessionSecret authenticates the private-LAN dofrobot adapter. The
|
||
// value is process-only: it must never be logged or persisted by bridge.
|
||
RobotSessionSecret string
|
||
}
|
||
|
||
// New 使用框架环境创建 DNF bridge 服务。
|
||
func New(env *appkit.Env) *Service {
|
||
return NewWithOptions(env, ServiceOptions{})
|
||
}
|
||
|
||
// NewWithOptions 使用框架环境和项目侧依赖创建 DNF bridge 服务。
|
||
func NewWithOptions(env *appkit.Env, serviceOptions ServiceOptions) *Service {
|
||
if env == nil {
|
||
env = &appkit.Env{}
|
||
}
|
||
core := env.Core()
|
||
service := &Service{
|
||
logger: core.Logger,
|
||
options: optionsFromConfig(core.Config),
|
||
localDebugMode: serviceOptions.LocalDebugMode && strings.EqualFold(core.Config.Service.Environment, "local"),
|
||
conns: make(map[net.Conn]struct{}),
|
||
gameSessions: make(map[uint16]*gameSession),
|
||
onlineSeats: make(map[*gameSession]struct{}),
|
||
onlineReportTrigger: make(chan struct{}, 1),
|
||
itemTrades: make(map[uint16]*onlineItemTrade),
|
||
weddingInvitations: make(map[uint16]*currentWeddingInvitation),
|
||
privateStores: make(map[uint16]*currentPrivateStore),
|
||
privateStoreVisitors: make(map[*gameSession]uint16),
|
||
expertJobStores: make(map[uint16]*currentExpertJobStore),
|
||
expertJobVisitors: make(map[*gameSession]uint16),
|
||
raids: make(map[uint32]*runtimeRaidState),
|
||
initialEquipmentArchive: env.PVF,
|
||
repositoryProvider: serviceOptions.RepositoryProvider,
|
||
dprotoProvider: serviceOptions.DprotoProvider,
|
||
clientAccounts: newClientAccountRegistry(),
|
||
partyEndpoints: newCurrentPartyUDPEndpointRegistry(),
|
||
partyUDPOwnerPID: localUDPEndpointOwnerPID,
|
||
runtimePartyManager: party.NewRuntimePartyManager(),
|
||
robotSessionSecret: []byte(strings.TrimSpace(serviceOptions.RobotSessionSecret)),
|
||
robotSessionReplays: make(map[[32]byte]time.Time),
|
||
}
|
||
service.localDebugStrikeOnSkillUse = service.localDebugMode && serviceOptions.LocalDebugStrikeOnSkillUse
|
||
service.launcherAuthHTTPClient = newLauncherAuthVerifyClient(service.options)
|
||
identity, identityErr := newLauncherIdentityVerifier(
|
||
service.options.launcherIdentityMode,
|
||
service.options.launcherIdentityPublicKeys,
|
||
)
|
||
if identityErr != nil {
|
||
// Fail closed on a broken configuration: a server that looks bound but
|
||
// silently accepts anyone is worse than one that refuses to start, so
|
||
// the error is held and returned by Start.
|
||
service.launcherIdentityErr = identityErr
|
||
identity = &launcherIdentityVerifier{mode: LauncherIdentityModeOff}
|
||
}
|
||
service.launcherIdentity = identity
|
||
if service.launcherIdentity.enabled() {
|
||
service.logInfo("dnfbridge launcher identity configured",
|
||
"mode", service.launcherIdentity.modeName(),
|
||
"server_id", service.launcherIdentity.serverID,
|
||
"public_keys", len(service.launcherIdentity.keys))
|
||
}
|
||
service.nextAuctionListingID.Store(uint64(time.Now().Unix()))
|
||
service.gameplayTimers = newProcessGameplayTimeQueue(func(name string, recovered any) {
|
||
service.logWarn("dnfbridge gameplay timer callback panic", "timer_name", name, "recovered", recovered)
|
||
})
|
||
service.onlinePlayers = newOnlinePlayerManager()
|
||
_, _ = service.currentDungeonAdmissionReceiptNonce()
|
||
service.registerDungeonRuntimeDebugRoute(env)
|
||
return service
|
||
}
|
||
|
||
// Name 返回生命周期组件名。
|
||
func (s *Service) Name() string {
|
||
return "dnfbridge-service"
|
||
}
|
||
|
||
// Start 加载外部 channel_info.etc，并启动频道服和 game 端口监听。
|
||
func (s *Service) Start(ctx context.Context) error {
|
||
// 客户端影片指纹校验：文件被改动或删除则拒绝启动。
|
||
if err := verifyClientArtifacts(); err != nil {
|
||
return fmt.Errorf("client movie integrity check failed: %w", err)
|
||
}
|
||
|
||
if ctx == nil {
|
||
ctx = context.Background()
|
||
}
|
||
if err := s.validateDprotoConfiguration(); err != nil {
|
||
return err
|
||
}
|
||
if s.launcherIdentityErr != nil {
|
||
return fmt.Errorf("dnfbridge launcher identity: %w", s.launcherIdentityErr)
|
||
}
|
||
catalog, channelScript, err := s.loadChannelAssets()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
// 表能起来但玩家侧会受影响的状态（缺默认城镇频道 / 没有特殊区域频道）在启动时也要可见，
|
||
// 手改过 channel_info.etc 的人不该只在热重载里才看到。
|
||
for _, warning := range currentChannelTableWarnings(catalog, true) {
|
||
s.logWarn("dnfbridge channel table warning",
|
||
"warning", warning,
|
||
"channel_info", s.options.channelInfoFile)
|
||
}
|
||
packetLog, err := s.openPacketLog()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
// 审计记录器：目录不可写时 newActivityRecorder 返回 nil，后续 recordActivity 自动空转，
|
||
// 不影响服务启动——记录是旁路，不能因为磁盘/权限问题把服务端拦在门外。
|
||
records := newActivityRecorder(s.options.recordDir, s.logger)
|
||
runCtx, cancel := context.WithCancel(ctx)
|
||
s.mu.Lock()
|
||
s.catalog = catalog
|
||
s.channelScript = append([]byte(nil), channelScript...)
|
||
s.runCtx = runCtx
|
||
s.cancel = cancel
|
||
s.packetLog.Store(packetLog)
|
||
s.records.Store(records)
|
||
if s.initialTownEntryWait == nil {
|
||
// Initial-town visual delay is disabled. Production never blocks the
|
||
// server packet stream at the retained test boundary.
|
||
s.initialTownEntryWait = func(time.Duration) {}
|
||
}
|
||
if s.conns == nil {
|
||
s.conns = make(map[net.Conn]struct{})
|
||
}
|
||
s.mu.Unlock()
|
||
|
||
// 2026-09-12: both live sessions stopped answering right after login while the
|
||
// accept loop stayed healthy -- the signature of a handler blocked on a shared
|
||
// mutex (the read loop shares the session goroutine, so a blocked handler stops
|
||
// every later RECV from being logged at all). Keep a rolling goroutine dump on
|
||
// disk so the next occurrence names the exact frame instead of being inferred.
|
||
s.startGoroutineWatchdog(runCtx)
|
||
|
||
// 2026-09-25: the same class of question again, one level finer. The
|
||
// watchdog above dumps every 20s, which is far too coarse to land inside a
|
||
// 4-10s stall. This sampler is default-off (DNF90_STALL_SAMPLER) and
|
||
// appends an all-goroutine stack snapshot only when the snapshot changed,
|
||
// so it names the exact frame a slow path is sitting in -- including a
|
||
// frame nobody thought to instrument, which is what the five existing
|
||
// step probes in completeRuntimePartyDungeonLoading failed to do.
|
||
s.startStallStackSampler(runCtx)
|
||
|
||
// PVF preload stages run in a fixed order before any listener opens. Keep
|
||
// one row per stage: the order, each loader's own wrapped error text, and
|
||
// the shared cleanup path are observable startup behavior. The loop must
|
||
// not re-wrap loader errors or change what is reset on failure; name only
|
||
// labels the stage for audit, it is never merged into the returned error.
|
||
pvfPreloads := []struct {
|
||
name string
|
||
load func(context.Context) error
|
||
}{
|
||
{"initial equipment index", s.preloadInitialEquipmentIndex},
|
||
{"item catalog", s.preloadPVFItemCatalog},
|
||
{"pet catalog", s.preloadPetPVFCatalog},
|
||
{"expert job catalog", s.preloadExpertJobCatalog},
|
||
{"adventure group table", s.preloadAdventureGroupTable},
|
||
{"honor table", s.preloadHonorTable},
|
||
{"town catalog", s.preloadTownCatalog},
|
||
{"skill catalog", s.preloadSkillCatalog},
|
||
{"profession profiles", s.preloadProfessionProfiles},
|
||
{"quest catalog", s.preloadQuestCatalog},
|
||
{"dungeon world map", s.preloadDungeonWorldMap},
|
||
{"character stat table", s.preloadCharacterStatTable},
|
||
{"equipment stat index", s.preloadEquipmentStatIndex},
|
||
{"combat power affix catalog", s.preloadCombatPowerAffixCatalog},
|
||
{"epic book catalog", s.preloadEpicBookCatalog},
|
||
{"hell party catalog", s.preloadHellPartyCatalog},
|
||
{"hell party drop catalog", s.preloadHellPartyDropCatalog},
|
||
{"dungeon drop catalog", s.preloadDungeonDropCatalog},
|
||
// 把 itemRefs 索引里的全部道具定义解析好，消掉玩家进城时的逐道具冷解析。
|
||
// 依赖上一行的 catalog，必须排在它后面；代价与失败语义见
|
||
// dungeon_drop_item_preload.go。
|
||
{"dungeon drop item definitions", s.preloadDungeonDropItemDefinitions},
|
||
{"gold carry limit table", s.preloadCarryGoldLevelLimits},
|
||
}
|
||
for _, preload := range pvfPreloads {
|
||
if err := preload.load(runCtx); err != nil {
|
||
cancel()
|
||
closeErr := packetLog.Close()
|
||
s.mu.Lock()
|
||
s.catalog = nil
|
||
s.cancel = nil
|
||
s.packetLog.Store(nil)
|
||
s.mu.Unlock()
|
||
return errors.Join(err, closeErr)
|
||
}
|
||
}
|
||
// Build the PVF catalogs that would otherwise be created lazily inside the
|
||
// first player request that needs one. Measured 2026-09-26 on a cold server:
|
||
// the first town entry built three of them inside that player's own session
|
||
// event loop and blocked the session for 1589ms (op143
|
||
// ENUM_CMDPACKET_CHANGE_TUTORIAL_FLAG); the same entry 30 seconds later, with
|
||
// the catalogs warm, took 491ms. Deliberately best effort, and deliberately
|
||
// not rows in pvfPreloads -- see warmOptionalPVFCatalogs for both reasons.
|
||
s.warmOptionalPVFCatalogs(runCtx)
|
||
if err := s.restoreRuntimeCreatedRaidSeed(); err != nil {
|
||
cancel()
|
||
closeErr := packetLog.Close()
|
||
s.mu.Lock()
|
||
s.catalog = nil
|
||
s.cancel = nil
|
||
s.packetLog.Store(nil)
|
||
s.mu.Unlock()
|
||
return errors.Join(err, closeErr)
|
||
}
|
||
// Startup builds several short-lived PVF document indexes before retaining
|
||
// their compact domain catalogs. Force one collection/scavenge at this fixed
|
||
// boundary so those temporary token graphs and spans do not remain resident
|
||
// until normal gameplay eventually reaches the next GC target. This runs
|
||
// before listeners open, so it cannot add a pause to an active session.
|
||
runtimedebug.FreeOSMemory()
|
||
gamePorts := s.gameListenPorts(catalog)
|
||
if len(gamePorts) == 0 {
|
||
cancel()
|
||
closeErr := packetLog.Close()
|
||
s.mu.Lock()
|
||
s.catalog = nil
|
||
s.cancel = nil
|
||
s.packetLog.Store(nil)
|
||
s.mu.Unlock()
|
||
return errors.Join(fmt.Errorf("dnfbridge has no game listen ports"), closeErr)
|
||
}
|
||
partyRelay, err := newCurrentPartyUDPRelay(
|
||
s.options.partyUDPRelayEnabled,
|
||
s.options.serverIP,
|
||
s.options.partyUDPRelayPortStart,
|
||
s.options.partyUDPRelayPortCount,
|
||
func(message string, args ...any) { s.logWarn(message, args...) },
|
||
)
|
||
if err != nil {
|
||
cancel()
|
||
closeErr := packetLog.Close()
|
||
s.mu.Lock()
|
||
s.catalog = nil
|
||
s.cancel = nil
|
||
s.packetLog.Store(nil)
|
||
s.mu.Unlock()
|
||
return errors.Join(err, closeErr)
|
||
}
|
||
// The relay's own diagnostics: prose warnings for its lifecycle, and named
|
||
// packet-log events for the forwarding budget, so a throttled leg is
|
||
// greppable as game-party-udp-relay-throttled.
|
||
partyRelay.logEvent = func(kind string, args ...any) { s.logPacketEvent(kind, args...) }
|
||
if s.options.packetLogEnabled {
|
||
// The dump is a diagnostic, not a transcript. Party traffic between two
|
||
// clients in one town runs at thousands of datagrams per second, and
|
||
// writing every payload as hex put 228 MB into the packet log in five
|
||
// minutes, which starved the server's own packet path and made the client
|
||
// look unresponsive. Sample it the way the relay already samples its own
|
||
// trace: the head of the stream in full, then every thousandth datagram.
|
||
relayDumps := make(map[currentPartyUDPRelayLegKey]int)
|
||
var relayDumpsMu sync.Mutex
|
||
partyRelay.payloadDump = func(leg currentPartyUDPRelayLegKey, source *net.UDPAddr, payload []byte) {
|
||
relayDumpsMu.Lock()
|
||
relayDumps[leg]++
|
||
seen := relayDumps[leg]
|
||
relayDumpsMu.Unlock()
|
||
if !currentPartyUDPRelayDumpDatagram(seen) {
|
||
return
|
||
}
|
||
s.logPacketEvent("party-udp-relay-payload",
|
||
"party_id", leg.partyID,
|
||
"owner_id", leg.ownerID,
|
||
"peer_id", leg.peerID,
|
||
"source", source.String(),
|
||
"bytes", len(payload),
|
||
"packet_count", seen,
|
||
"sampled", seen > currentPartyUDPRelayDumpHeadPackets,
|
||
"payload_hex", hex.EncodeToString(payload))
|
||
}
|
||
}
|
||
partyProbeBindIP := s.options.partyUDPBindIP
|
||
if partyProbeBindIP == "" {
|
||
partyProbeBindIP = s.options.serverIP
|
||
}
|
||
partyProbe, err := newCurrentPartyUDPProbe(
|
||
runCtx,
|
||
partyProbeBindIP,
|
||
[]int{s.options.initialUDPPort1, s.options.initialUDPPort2},
|
||
s.observeCurrentPartyUDPEndpoint,
|
||
func(message string, args ...any) { s.logInfo(message, args...) },
|
||
)
|
||
if err != nil {
|
||
cancel()
|
||
_ = partyRelay.Close()
|
||
closeErr := packetLog.Close()
|
||
s.mu.Lock()
|
||
s.catalog = nil
|
||
s.cancel = nil
|
||
s.packetLog.Store(nil)
|
||
s.mu.Unlock()
|
||
return errors.Join(err, closeErr)
|
||
}
|
||
s.mu.Lock()
|
||
s.partyUDPRelay = partyRelay
|
||
s.partyUDPProbe = partyProbe
|
||
s.mu.Unlock()
|
||
|
||
if err := s.listen(runCtx, s.options.channelListen, s.handleChannelConn); err != nil {
|
||
cancel()
|
||
_ = partyRelay.Close()
|
||
_ = partyProbe.Close()
|
||
closeErr := packetLog.Close()
|
||
s.mu.Lock()
|
||
s.catalog = nil
|
||
s.cancel = nil
|
||
s.packetLog.Store(nil)
|
||
s.partyUDPRelay = nil
|
||
s.partyUDPProbe = nil
|
||
s.mu.Unlock()
|
||
return errors.Join(err, closeErr)
|
||
}
|
||
s.startGameplayTimeQueue(runCtx)
|
||
s.registerDailyQuestResetTimer()
|
||
// 骑士马战（joust）活动已取消：不再启动该活动的边界调度器，
|
||
// 服务端不会主动推送 op1240/op1241/op1242/op1243。
|
||
// 实现（joust_scheduler.go）保留为死代码，便于日后按需恢复。
|
||
s.startLauncherOnlineReport(runCtx)
|
||
|
||
for _, port := range gamePorts {
|
||
if err := s.listenGamePort(runCtx, port); err != nil {
|
||
cancel()
|
||
_ = s.Stop(context.Background())
|
||
return err
|
||
}
|
||
}
|
||
s.logInfo("dnfbridge started",
|
||
"channel_listen", s.options.channelListen,
|
||
"channel_info", s.options.channelInfoFile,
|
||
"channel_server_index", s.channelServerID(),
|
||
"advertise_server_index", s.channelAdvertiseID(),
|
||
"channel_info_body_mode", s.channelInfoBodyMode(),
|
||
"game_initial_mode", s.gameInitialMode(),
|
||
"game_pre_bootstrap", s.gamePreBootstrapMode(),
|
||
"game_post_bootstrap", s.gamePostBootstrapMode(),
|
||
"game_upper_header", s.gameUpperHeaderMode(),
|
||
"game_upper_client_body_codec", s.gameUpperClientBodyCodecMode(),
|
||
"game_dproto_mode", s.gameDprotoMode(),
|
||
"game_listen_host", s.options.gameListenHost,
|
||
"game_ports", len(gamePorts),
|
||
"server_ip", s.options.serverIP,
|
||
"party_udp_probe_ports", fmt.Sprintf("%d,%d", s.options.initialUDPPort1, s.options.initialUDPPort2),
|
||
"party_udp_relay", partyRelay.Enabled(),
|
||
"party_udp_relay_port_start", s.options.partyUDPRelayPortStart,
|
||
"party_udp_relay_port_count", s.options.partyUDPRelayPortCount,
|
||
// 支援兵自建 APC 的开关状态。
|
||
//
|
||
// 为什么要在启动日志里打这一行：这条通道由环境变量控制，而环境变量
|
||
// 是否真的传到了服务端进程，从外面看不出来（父进程可能是登录器、
|
||
// 也可能是 START.bat，链路不同）。把它写进启动日志，就能一眼确认
|
||
// "开关到没到位"，不必靠行为反推。
|
||
"companion_server_start_map_apc", currentDungeonCompanionP0StartMapEnabled())
|
||
return nil
|
||
}
|
||
|
||
func gameListenAddress(host string, port int) string {
|
||
host = strings.TrimSpace(host)
|
||
if host == "" {
|
||
return ":" + strconv.Itoa(port)
|
||
}
|
||
return net.JoinHostPort(strings.Trim(host, "[]"), strconv.Itoa(port))
|
||
}
|
||
|
||
// Stop 关闭监听并等待连接处理退出。
|
||
func (s *Service) Stop(ctx context.Context) error {
|
||
if ctx == nil {
|
||
ctx = context.Background()
|
||
}
|
||
s.mu.Lock()
|
||
cancel := s.cancel
|
||
listeners := append([]net.Listener(nil), s.listeners...)
|
||
packetLog := s.packetLog.Load()
|
||
records := s.records.Load()
|
||
partyRelay := s.partyUDPRelay
|
||
partyProbe := s.partyUDPProbe
|
||
conns := make([]net.Conn, 0, len(s.conns))
|
||
for conn := range s.conns {
|
||
conns = append(conns, conn)
|
||
}
|
||
s.listeners = nil
|
||
s.gameListeners = nil
|
||
s.runCtx = nil
|
||
s.cancel = nil
|
||
s.packetLog.Store(nil)
|
||
s.records.Store(nil)
|
||
s.partyUDPRelay = nil
|
||
s.partyUDPProbe = nil
|
||
s.channelScript = nil
|
||
s.mu.Unlock()
|
||
|
||
if cancel != nil {
|
||
cancel()
|
||
}
|
||
var stopErr error
|
||
for _, listener := range listeners {
|
||
stopErr = errors.Join(stopErr, listener.Close())
|
||
}
|
||
for _, conn := range conns {
|
||
stopErr = errors.Join(stopErr, conn.Close())
|
||
}
|
||
if partyRelay != nil {
|
||
stopErr = errors.Join(stopErr, partyRelay.Close())
|
||
}
|
||
if partyProbe != nil {
|
||
stopErr = errors.Join(stopErr, partyProbe.Close())
|
||
}
|
||
stopErr = errors.Join(stopErr, packetLog.Close())
|
||
// 记录器先关：关闭后再来的 recordActivity 会因为 s.records 为空而空转，
|
||
// 不会往一个已经关掉的文件句柄里写。
|
||
records.Close()
|
||
done := make(chan struct{})
|
||
go func() {
|
||
s.wg.Wait()
|
||
close(done)
|
||
}()
|
||
select {
|
||
case <-ctx.Done():
|
||
return errors.Join(stopErr, ctx.Err())
|
||
case <-done:
|
||
return stopErr
|
||
}
|
||
}
|
||
|
||
func (s *Service) listen(ctx context.Context, addr string, handler func(context.Context, net.Conn)) error {
|
||
listener, err := net.Listen("tcp", addr)
|
||
if err != nil {
|
||
return fmt.Errorf("listen %s: %w", addr, err)
|
||
}
|
||
s.mu.Lock()
|
||
s.listeners = append(s.listeners, listener)
|
||
s.mu.Unlock()
|
||
s.wg.Add(1)
|
||
go s.acceptLoop(ctx, listener, handler)
|
||
return nil
|
||
}
|
||
|
||
// listenGamePort 打开一个游戏端口监听，并按端口登记，供热重载时按频道开关对账。
|
||
// 只用于游戏端口；频道口（channelListen）仍走 listen()。
|
||
func (s *Service) listenGamePort(ctx context.Context, port int) error {
|
||
addr := gameListenAddress(s.options.gameListenHost, port)
|
||
listener, err := net.Listen("tcp", addr)
|
||
if err != nil {
|
||
return fmt.Errorf("listen %s: %w", addr, err)
|
||
}
|
||
s.mu.Lock()
|
||
if s.gameListeners == nil {
|
||
s.gameListeners = make(map[int]net.Listener)
|
||
}
|
||
// 同一端口若已有监听（重复对账），保留先到的那个，并把这个多余的关掉。
|
||
// 注意要在登记进 s.listeners **之前**判断，否则会给 Stop 留一个已关闭的孤儿 listener。
|
||
if existing := s.gameListeners[port]; existing != nil {
|
||
s.mu.Unlock()
|
||
_ = listener.Close()
|
||
return nil
|
||
}
|
||
s.gameListeners[port] = listener
|
||
s.listeners = append(s.listeners, listener)
|
||
s.mu.Unlock()
|
||
s.wg.Add(1)
|
||
go s.acceptLoop(ctx, listener, s.handleGameConn)
|
||
return nil
|
||
}
|
||
|
||
// closeGamePort 关闭某个游戏端口的监听并解除登记。
|
||
//
|
||
// 注意语义：只停止接受**新**连接。net.Listener.Close 不会断开已经 Accept 的连接，
|
||
// 所以关闭频道不会把站在该频道里的玩家踢下线——这正是热重载想要的行为。
|
||
func (s *Service) closeGamePort(port int) error {
|
||
s.mu.Lock()
|
||
listener := s.gameListeners[port]
|
||
delete(s.gameListeners, port)
|
||
if listener != nil {
|
||
kept := make([]net.Listener, 0, len(s.listeners))
|
||
for _, item := range s.listeners {
|
||
if item != listener {
|
||
kept = append(kept, item)
|
||
}
|
||
}
|
||
s.listeners = kept
|
||
}
|
||
s.mu.Unlock()
|
||
if listener == nil {
|
||
return nil
|
||
}
|
||
return listener.Close()
|
||
}
|
||
|
||
// currentAcceptLoopFailureLimit 是 accept 连续失败多少次后放弃该监听。
|
||
//
|
||
// 存在的理由：Accept 的错误有两类——一类是监听被关闭（必须退出，见下），另一类
|
||
// 是资源类临时错误（EMFILE 之类，值得重试）。如果某天出现"永久性且非 ErrClosed"
|
||
// 的错误，无上限重试同样会变成空转 + 日志刷屏，所以给一个上限兜底。
|
||
const currentAcceptLoopFailureLimit = 32
|
||
|
||
func (s *Service) acceptLoop(ctx context.Context, listener net.Listener, handler func(context.Context, net.Conn)) {
|
||
defer s.wg.Done()
|
||
consecutiveFailures := 0
|
||
for {
|
||
conn, err := listener.Accept()
|
||
if err != nil {
|
||
// 监听被关闭时必须直接退出。
|
||
//
|
||
// 频道热重载会关掉"已停用频道"的游戏端口（gm_channel_reload.go → closeGamePort），
|
||
// 那条路径**不会**取消运行期 ctx（取消会把整个服务停掉）。此时 Accept 会立刻
|
||
// 返回 closed 错误，只判 ctx.Err() 就会 continue → 死循环：一个核 100% 空转，
|
||
// 而且每圈写一条 warn，日志会被刷爆。Stop 是先 cancel 再 Close listener，所以
|
||
// 老路径掩盖了这个坑，热重载才把它暴露出来。
|
||
if ctx.Err() != nil || errors.Is(err, net.ErrClosed) {
|
||
return
|
||
}
|
||
consecutiveFailures++
|
||
if consecutiveFailures >= currentAcceptLoopFailureLimit {
|
||
s.logWarn("dnfbridge accept loop stopped after repeated failures",
|
||
"addr", listener.Addr().String(), "failures", consecutiveFailures, "error", err)
|
||
return
|
||
}
|
||
s.logWarn("dnfbridge accept failed", "addr", listener.Addr().String(), "error", err)
|
||
continue
|
||
}
|
||
consecutiveFailures = 0
|
||
s.wg.Add(1)
|
||
go func() {
|
||
defer s.wg.Done()
|
||
s.trackConn(conn)
|
||
defer s.untrackConn(conn)
|
||
handler(ctx, conn)
|
||
}()
|
||
}
|
||
}
|
||
|
||
func (s *Service) loadChannelAssets() (*channelcatalog.Catalog, []byte, error) {
|
||
raw, err := osReadFile(s.options.channelInfoFile)
|
||
if err != nil {
|
||
return nil, nil, fmt.Errorf("load dnf channel info: %w", err)
|
||
}
|
||
index, err := channelinfo.Parse(raw)
|
||
if err != nil {
|
||
return nil, nil, fmt.Errorf("parse dnf channel info: %w", err)
|
||
}
|
||
catalog, err := channelcatalog.New(index, channelcatalog.Options{ServerID: s.channelServerID()})
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
script, err := s.buildChannelScript(raw)
|
||
if err != nil {
|
||
return nil, nil, fmt.Errorf("build 90CN online channel script: %w", err)
|
||
}
|
||
return catalog, script, nil
|
||
}
|
||
|
||
func (s *Service) buildChannelScript(raw []byte) ([]byte, error) {
|
||
if s.channelTableStrict() {
|
||
return channelinfo.Build90CNOnlineScript(
|
||
raw,
|
||
s.channelServerID(),
|
||
s.channelAdvertiseID(),
|
||
dnfenum.BootstrapChannelID,
|
||
)
|
||
}
|
||
// 宽松模式：源表没有引导频道 19 时不再让 loadChannelAssets 失败（服务端起不来）。
|
||
// 只告警，让运维在"只开少数频道"的配置下仍能启动；要恢复旧硬校验把
|
||
// DNFBRIDGE_CHANNEL_TABLE_STRICT 设成 1。
|
||
script, bootstrapPresent, err := channelinfo.Build90CNOnlineScriptAllowingMissingBootstrap(
|
||
raw,
|
||
s.channelServerID(),
|
||
s.channelAdvertiseID(),
|
||
dnfenum.BootstrapChannelID,
|
||
)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if !bootstrapPresent {
|
||
s.logWarn("dnfbridge channel table has no bootstrap channel; starting anyway",
|
||
"bootstrap_channel", dnfenum.BootstrapChannelID,
|
||
"channel_info", s.options.channelInfoFile,
|
||
"reason", "bootstrap_channel_check_is_legacy_for_the_official_pvf_flow",
|
||
"restore_strict", "DNFBRIDGE_CHANNEL_TABLE_STRICT=1")
|
||
}
|
||
return script, nil
|
||
}
|
||
|
||
// channelTableStrict 返回是否恢复"频道表必须含 11/19"的旧硬校验。
|
||
func (s *Service) channelTableStrict() bool {
|
||
if s == nil {
|
||
return false
|
||
}
|
||
return s.options.channelTableStrict
|
||
}
|
||
|
||
func (s *Service) channelServerID() int {
|
||
if s != nil {
|
||
if s.options.channelServerID > 0 {
|
||
return s.options.channelServerID
|
||
}
|
||
}
|
||
return 1
|
||
}
|
||
|
||
func (s *Service) channelAdvertiseID() int {
|
||
if s != nil {
|
||
if s.options.channelAdvertiseID >= 0 {
|
||
return s.options.channelAdvertiseID
|
||
}
|
||
}
|
||
return s.channelServerID()
|
||
}
|
||
|
||
func (s *Service) channelInfoBodyMode() string {
|
||
if s == nil {
|
||
return channelInfoBodyLatest
|
||
}
|
||
return normalizeChannelInfoBodyMode(s.options.channelInfoBodyMode)
|
||
}
|
||
|
||
func (s *Service) currentCatalog() *channelcatalog.Catalog {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
return s.catalog
|
||
}
|
||
|
||
func (s *Service) currentChannelScript() []byte {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
return append([]byte(nil), s.channelScript...)
|
||
}
|
||
|
||
func (s *Service) openPacketLog() (*packetLogger, error) {
|
||
if !s.options.packetLogEnabled {
|
||
return nil, nil
|
||
}
|
||
logger, err := openPacketLogger(s.options.packetLogPath)
|
||
if err != nil {
|
||
// 与 records 同一条策略（见下方 newActivityRecorder 的注释）：包日志是旁路，
|
||
// 磁盘/密钥问题不能把服务端拦在门外。但这里**绝不退化成明文**——打不开就整条
|
||
// 通道关闭，并留下一条显式告警，让运维能立刻发现"日志没了"而不是"日志变明文了"。
|
||
if s.logger != nil {
|
||
s.logger.Warn(
|
||
"dnfbridge packet log disabled: encrypted log channel could not be opened",
|
||
"path", s.options.packetLogPath,
|
||
"error", err,
|
||
)
|
||
}
|
||
return nil, nil
|
||
}
|
||
return logger, nil
|
||
}
|
||
|
||
func (s *Service) logPacket(direction string, kind string, data []byte, fields ...any) {
|
||
if suppressPacketLogLine(direction, kind, fields...) {
|
||
return
|
||
}
|
||
logger := s.packetLog.Load()
|
||
logger.Log(direction, kind, data, fields...)
|
||
}
|
||
|
||
func (s *Service) logPacketEvent(kind string, args ...any) {
|
||
if suppressPacketLogEvent(kind, args...) {
|
||
return
|
||
}
|
||
logger := s.packetLog.Load()
|
||
logger.Event(kind, args...)
|
||
}
|
||
|
||
func suppressPacketLogLine(direction string, kind string, fields ...any) bool {
|
||
if kind == "game-raw" {
|
||
return true
|
||
}
|
||
msgID, hasMsgID := packetLogUintField(fields, "msg_id")
|
||
typ, hasType := packetLogUintField(fields, "type")
|
||
if hasMsgID {
|
||
switch msgID {
|
||
case 1276, 1516, 1518: // heartbeat / antibot / DPROTO callback noise.
|
||
return true
|
||
case 13:
|
||
// op13 full container refreshes already have concise EVENT evidence.
|
||
return direction == "SEND"
|
||
}
|
||
}
|
||
if hasType {
|
||
switch typ {
|
||
case 35: // SET_USER_POSITION, emitted continuously while walking.
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func suppressPacketLogEvent(kind string, fields ...any) bool {
|
||
switch kind {
|
||
case "game-town-set-user-position-captured":
|
||
return true
|
||
case "game-upper-check-user-connection-selected-success":
|
||
return true
|
||
// 攻坚高频噪声：这两种 2.5 小时内接近一千条（实测 708 + 264），而它们的全部
|
||
// 信息量就是"同类型的门边界通知又跳过一次"——原因已经写在 kind 名里，且真正
|
||
// 要看的那次边界现在写在 records/raid-*.jsonl（带 wall_ms / 名单 / 就绪位图）。
|
||
// 掐掉它们不损失任何证据，只把 packet_log 里翻日志的时间还回来。
|
||
case "game-raid-dungeon-lifecycle-skipped-already-notified":
|
||
return true
|
||
case "game-raid-dungeon-lifecycle-skipped-joined":
|
||
return true
|
||
}
|
||
msgID, hasMsgID := packetLogUintField(fields, "msg_id")
|
||
typ, hasType := packetLogUintField(fields, "type")
|
||
if hasMsgID {
|
||
switch msgID {
|
||
case 1276, 1516, 1518:
|
||
return true
|
||
case 13:
|
||
return kind == "game-upper-send-meta"
|
||
}
|
||
}
|
||
if hasType && typ == 35 {
|
||
return kind == "game-legacy-meta"
|
||
}
|
||
return false
|
||
}
|
||
|
||
func packetLogUintField(fields []any, name string) (uint64, bool) {
|
||
for i := 0; i+1 < len(fields); i += 2 {
|
||
if fmt.Sprint(fields[i]) != name {
|
||
continue
|
||
}
|
||
switch v := fields[i+1].(type) {
|
||
case uint8:
|
||
return uint64(v), true
|
||
case uint16:
|
||
return uint64(v), true
|
||
case uint32:
|
||
return uint64(v), true
|
||
case uint64:
|
||
return v, true
|
||
case uint:
|
||
return uint64(v), true
|
||
case int8:
|
||
if v >= 0 {
|
||
return uint64(v), true
|
||
}
|
||
case int16:
|
||
if v >= 0 {
|
||
return uint64(v), true
|
||
}
|
||
case int32:
|
||
if v >= 0 {
|
||
return uint64(v), true
|
||
}
|
||
case int64:
|
||
if v >= 0 {
|
||
return uint64(v), true
|
||
}
|
||
case int:
|
||
if v >= 0 {
|
||
return uint64(v), true
|
||
}
|
||
}
|
||
}
|
||
return 0, false
|
||
}
|
||
|
||
func (s *Service) trackConn(conn net.Conn) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
if s.conns == nil {
|
||
s.conns = make(map[net.Conn]struct{})
|
||
}
|
||
s.conns[conn] = struct{}{}
|
||
}
|
||
|
||
func (s *Service) untrackConn(conn net.Conn) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
delete(s.conns, conn)
|
||
}
|
||
|
||
func (s *Service) nextPacketConnID(prefix string) string {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
s.packetID++
|
||
return fmt.Sprintf("%s-%06d", prefix, s.packetID)
|
||
}
|
||
|
||
func (s *Service) aesKey() string {
|
||
return time.Now().Format("20060102") + "000006"
|
||
}
|
||
|
||
func (s *Service) logInfo(msg string, args ...any) {
|
||
if s.logger != nil {
|
||
s.logger.Info(msg, args...)
|
||
}
|
||
}
|
||
|
||
func (s *Service) logWarn(msg string, args ...any) {
|
||
if s.logger != nil {
|
||
s.logger.Warn(msg, args...)
|
||
}
|
||
}
|