diff --git a/main.go b/main.go index 7a5a26b6f..3a009d49a 100644 --- a/main.go +++ b/main.go @@ -199,7 +199,7 @@ func main() { logger.Info("API: Disabled") } - var channels []*channelserver.Server + var channelServers []*channelserver.Server if config.Channel.Enabled { channelQuery := "" @@ -228,7 +228,7 @@ func main() { preventClose(fmt.Sprintf("Channel: Failed to start, %s", err.Error())) } else { channelQuery += fmt.Sprintf(`INSERT INTO servers (server_id, current_players, world_name, world_description, land) VALUES (%d, 0, '%s', '%s', %d);`, sid, ee.Name, ee.Description, i+1) - channels = append(channels, &c) + channelServers = append(channelServers, &c) logger.Info(fmt.Sprintf("Channel %d (%d): Started successfully", count, ce.Port)) ci++ count++ @@ -241,8 +241,8 @@ func main() { // Register all servers in DB _ = db.MustExec(channelQuery) - for _, c := range channels { - c.Channels = channels + for _, c := range channelServers { + c.Channels = channelServers } } @@ -256,8 +256,8 @@ func main() { if !config.DisableSoftCrash { for i := 0; i < 10; i++ { message := fmt.Sprintf("Shutting down in %d...", 10-i) - for _, c := range channels { - c.BroadcastChatMessage(message) + for _, channelServer := range channelServers { + channelServer.BroadcastChatMessage(message) } logger.Info(message) time.Sleep(time.Second) @@ -265,8 +265,8 @@ func main() { } if config.Channel.Enabled { - for _, c := range channels { - c.Shutdown() + for _, channelServer := range channelServers { + channelServer.Shutdown() } } diff --git a/server/channelserver/handlers_register.go b/server/channelserver/handlers_register.go index 9e5d40aab..fd8d0f0b9 100644 --- a/server/channelserver/handlers_register.go +++ b/server/channelserver/handlers_register.go @@ -132,8 +132,8 @@ func (s *Session) notifyRavi() { } } -func (s *Server) getRaviSemaphore() *Semaphore { - for _, semaphore := range s.semaphore { +func (server *Server) getRaviSemaphore() *Semaphore { + for _, semaphore := range server.semaphore { if strings.HasPrefix(semaphore.name, "hs_l0") && strings.HasSuffix(semaphore.name, "3") { return semaphore } diff --git a/server/channelserver/sys_broadcast.go b/server/channelserver/sys_broadcast.go new file mode 100644 index 000000000..52f9181ff --- /dev/null +++ b/server/channelserver/sys_broadcast.go @@ -0,0 +1,83 @@ +package channelserver + +import ( + "erupe-ce/network/binpacket" + "erupe-ce/network/mhfpacket" + "erupe-ce/utils/byteframe" + ps "erupe-ce/utils/pascalstring" + + "go.uber.org/zap" +) + +// BroadcastMHF queues a MHFPacket to be sent to all sessions. +func (server *Server) BroadcastMHF(pkt mhfpacket.MHFPacket, ignoredSession *Session) { + // Broadcast the data. + server.Lock() + defer server.Unlock() + for _, session := range server.sessions { + if session == ignoredSession { + continue + } + session.QueueSendMHF(pkt) + } +} + +func (server *Server) WorldcastMHF(pkt mhfpacket.MHFPacket, ignoredSession *Session, ignoredChannel *Server) { + for _, c := range server.Channels { + if c == ignoredChannel { + continue + } + c.BroadcastMHF(pkt, ignoredSession) + } +} + +// BroadcastChatMessage broadcasts a simple chat message to all the sessions. +func (server *Server) BroadcastChatMessage(message string) { + bf := byteframe.NewByteFrame() + bf.SetLE() + msgBinChat := &binpacket.MsgBinChat{ + Unk0: 0, + Type: 5, + Flags: 0x80, + Message: message, + SenderName: server.name, + } + msgBinChat.Build(bf) + + server.BroadcastMHF(&mhfpacket.MsgSysCastedBinary{ + MessageType: BinaryMessageTypeChat, + RawDataPayload: bf.Data(), + }, nil) +} + +func (server *Server) BroadcastRaviente(ip uint32, port uint16, stage []byte, _type uint8) { + bf := byteframe.NewByteFrame() + bf.SetLE() + bf.WriteUint16(0) // Unk + bf.WriteUint16(0x43) // Data len + bf.WriteUint16(3) // Unk len + var text string + switch _type { + case 2: + text = server.i18n.raviente.berserk + case 3: + text = server.i18n.raviente.extreme + case 4: + text = server.i18n.raviente.extremeLimited + case 5: + text = server.i18n.raviente.berserkSmall + default: + server.logger.Error("Unk raviente type", zap.Uint8("_type", _type)) + } + ps.Uint16(bf, text, true) + bf.WriteBytes([]byte{0x5F, 0x53, 0x00}) + bf.WriteUint32(ip) // IP address + bf.WriteUint16(port) // Port + bf.WriteUint16(0) // Unk + bf.WriteBytes(stage) + server.WorldcastMHF(&mhfpacket.MsgSysCastedBinary{ + BroadcastType: BroadcastTypeServer, + MessageType: BinaryMessageTypeChat, + RawDataPayload: bf.Data(), + }, nil, server) +} diff --git a/server/channelserver/sys_channel_server.go b/server/channelserver/sys_channel_server.go index 456962680..14e2b074f 100644 --- a/server/channelserver/sys_channel_server.go +++ b/server/channelserver/sys_channel_server.go @@ -3,17 +3,12 @@ package channelserver import ( "fmt" "net" - "strings" "sync" "time" _config "erupe-ce/config" - "erupe-ce/network/binpacket" - "erupe-ce/network/mhfpacket" "erupe-ce/server/discordbot" - "erupe-ce/utils/byteframe" "erupe-ce/utils/gametime" - ps "erupe-ce/utils/pascalstring" "github.com/jmoiron/sqlx" "go.uber.org/zap" @@ -80,74 +75,22 @@ type Server struct { questCacheTime map[int]time.Time } -type Raviente struct { - sync.Mutex - id uint16 - register []uint32 - state []uint32 - support []uint32 -} - -func (s *Server) resetRaviente() { - for _, semaphore := range s.semaphore { - if strings.HasPrefix(semaphore.name, "hs_l0") { - return - } - } - s.logger.Debug("All Raviente Semaphores empty, resetting") - s.raviente.id = s.raviente.id + 1 - s.raviente.register = make([]uint32, 30) - s.raviente.state = make([]uint32, 30) - s.raviente.support = make([]uint32, 30) -} - -func (s *Server) GetRaviMultiplier() float64 { - raviSema := s.getRaviSemaphore() - if raviSema != nil { - var minPlayers int - if s.raviente.register[9] > 8 { - minPlayers = 24 - } else { - minPlayers = 4 - } - if len(raviSema.clients) > minPlayers { - return 1 - } - return float64(minPlayers / len(raviSema.clients)) - } - return 0 -} - -func (s *Server) UpdateRavi(semaID uint32, index uint8, value uint32, update bool) (uint32, uint32) { - var prev uint32 - var dest *[]uint32 - switch semaID { - case 0x40000: - switch index { - case 17, 28: // Ignore res and poison - break - default: - value = uint32(float64(value) * s.GetRaviMultiplier()) - } - dest = &s.raviente.state - case 0x50000: - dest = &s.raviente.support - case 0x60000: - dest = &s.raviente.register - default: - return 0, 0 - } - if update { - (*dest)[index] += value - } else { - (*dest)[index] = value - } - return prev, (*dest)[index] -} - // NewServer creates a new Server type. func NewServer(config *Config) *Server { - s := &Server{ + stageNames := []string{ + "sl1Ns200p0a0u0", // Mezeporta + "sl1Ns211p0a0u0", // Rasta bar + "sl1Ns260p0a0u0", // Pallone Carvan + "sl1Ns262p0a0u0", // Pallone Guest House 1st Floor + "sl1Ns263p0a0u0", // Pallone Guest House 2nd Floor + "sl2Ns379p0a0u0", // Diva fountain + "sl1Ns462p0a0u0", // MezFes + } + stages := make(map[string]*Stage) + for _, name := range stageNames { + stages[name] = NewStage(name) + } + server := &Server{ ID: config.ID, logger: config.Logger, db: config.DB, @@ -156,7 +99,7 @@ func NewServer(config *Config) *Server { deleteConns: make(chan net.Conn), sessions: make(map[net.Conn]*Session), objectIDs: make(map[*Session]uint16), - stages: make(map[string]*Stage), + stages: stages, userBinaryParts: make(map[userBinaryPartID][]byte), semaphore: make(map[string]*Semaphore), semaphoreIndex: 7, @@ -172,203 +115,94 @@ func NewServer(config *Config) *Server { questCacheTime: make(map[int]time.Time), } - // Mezeporta - s.stages["sl1Ns200p0a0u0"] = NewStage("sl1Ns200p0a0u0") + server.i18n = getLangStrings(server) - // Rasta bar stage - s.stages["sl1Ns211p0a0u0"] = NewStage("sl1Ns211p0a0u0") - - // Pallone Carvan - s.stages["sl1Ns260p0a0u0"] = NewStage("sl1Ns260p0a0u0") - - // Pallone Guest House 1st Floor - s.stages["sl1Ns262p0a0u0"] = NewStage("sl1Ns262p0a0u0") - - // Pallone Guest House 2nd Floor - s.stages["sl1Ns263p0a0u0"] = NewStage("sl1Ns263p0a0u0") - - // Diva fountain / prayer fountain. - s.stages["sl2Ns379p0a0u0"] = NewStage("sl2Ns379p0a0u0") - - // MezFes - s.stages["sl1Ns462p0a0u0"] = NewStage("sl1Ns462p0a0u0") - - s.i18n = getLangStrings(s) - - return s + return server } // Start starts the server in a new goroutine. -func (s *Server) Start() error { - l, err := net.Listen("tcp", fmt.Sprintf(":%d", s.Port)) +func (server *Server) Start() error { + l, err := net.Listen("tcp", fmt.Sprintf(":%d", server.Port)) if err != nil { return err } - s.listener = l + server.listener = l - go s.acceptClients() - go s.manageSessions() + go server.acceptClients() + go server.manageSessions() // Start the discord bot for chat integration. - if s.erupeConfig.Discord.Enabled && s.discordBot != nil { - s.discordBot.Session.AddHandler(s.onDiscordMessage) - s.discordBot.Session.AddHandler(s.onInteraction) + if server.erupeConfig.Discord.Enabled && server.discordBot != nil { + server.discordBot.Session.AddHandler(server.onDiscordMessage) + server.discordBot.Session.AddHandler(server.onInteraction) } return nil } // Shutdown tries to shut down the server gracefully. -func (s *Server) Shutdown() { - s.Lock() - s.isShuttingDown = true - s.Unlock() +func (server *Server) Shutdown() { + server.Lock() + server.isShuttingDown = true + server.Unlock() - s.listener.Close() + server.listener.Close() - close(s.acceptConns) + close(server.acceptConns) } -func (s *Server) acceptClients() { +func (server *Server) acceptClients() { for { - conn, err := s.listener.Accept() + conn, err := server.listener.Accept() if err != nil { - s.Lock() - shutdown := s.isShuttingDown - s.Unlock() + server.Lock() + shutdown := server.isShuttingDown + server.Unlock() if shutdown { break } else { - s.logger.Warn("Error accepting client", zap.Error(err)) + server.logger.Warn("Error accepting client", zap.Error(err)) continue } } - s.acceptConns <- conn + server.acceptConns <- conn } } -func (s *Server) manageSessions() { +func (server *Server) manageSessions() { for { select { - case newConn := <-s.acceptConns: + case newConn := <-server.acceptConns: // Gracefully handle acceptConns channel closing. if newConn == nil { - s.Lock() - shutdown := s.isShuttingDown - s.Unlock() + server.Lock() + shutdown := server.isShuttingDown + server.Unlock() if shutdown { return } } - session := NewSession(s, newConn) + session := NewSession(server, newConn) - s.Lock() - s.sessions[newConn] = session - s.Unlock() + server.Lock() + server.sessions[newConn] = session + server.Unlock() session.Start() - case delConn := <-s.deleteConns: - s.Lock() - delete(s.sessions, delConn) - s.Unlock() + case delConn := <-server.deleteConns: + server.Lock() + delete(server.sessions, delConn) + server.Unlock() } } } -// BroadcastMHF queues a MHFPacket to be sent to all sessions. -func (s *Server) BroadcastMHF(pkt mhfpacket.MHFPacket, ignoredSession *Session) { - // Broadcast the data. - s.Lock() - defer s.Unlock() - for _, session := range s.sessions { - if session == ignoredSession { - continue - } - session.QueueSendMHF(pkt) - } -} - -func (s *Server) WorldcastMHF(pkt mhfpacket.MHFPacket, ignoredSession *Session, ignoredChannel *Server) { - for _, c := range s.Channels { - if c == ignoredChannel { - continue - } - c.BroadcastMHF(pkt, ignoredSession) - } -} - -// BroadcastChatMessage broadcasts a simple chat message to all the sessions. -func (s *Server) BroadcastChatMessage(message string) { - bf := byteframe.NewByteFrame() - bf.SetLE() - msgBinChat := &binpacket.MsgBinChat{ - Unk0: 0, - Type: 5, - Flags: 0x80, - Message: message, - SenderName: s.name, - } - msgBinChat.Build(bf) - - s.BroadcastMHF(&mhfpacket.MsgSysCastedBinary{ - MessageType: BinaryMessageTypeChat, - RawDataPayload: bf.Data(), - }, nil) -} - -func (s *Server) BroadcastRaviente(ip uint32, port uint16, stage []byte, _type uint8) { - bf := byteframe.NewByteFrame() - bf.SetLE() - bf.WriteUint16(0) // Unk - bf.WriteUint16(0x43) // Data len - bf.WriteUint16(3) // Unk len - var text string - switch _type { - case 2: - text = s.i18n.raviente.berserk - case 3: - text = s.i18n.raviente.extreme - case 4: - text = s.i18n.raviente.extremeLimited - case 5: - text = s.i18n.raviente.berserkSmall - default: - s.logger.Error("Unk raviente type", zap.Uint8("_type", _type)) - } - ps.Uint16(bf, text, true) - bf.WriteBytes([]byte{0x5F, 0x53, 0x00}) - bf.WriteUint32(ip) // IP address - bf.WriteUint16(port) // Port - bf.WriteUint16(0) // Unk - bf.WriteBytes(stage) - s.WorldcastMHF(&mhfpacket.MsgSysCastedBinary{ - BroadcastType: BroadcastTypeServer, - MessageType: BinaryMessageTypeChat, - RawDataPayload: bf.Data(), - }, nil, s) -} - -func (s *Server) DiscordChannelSend(charName string, content string) { - if s.erupeConfig.Discord.Enabled && s.discordBot != nil { - message := fmt.Sprintf("**%s**: %s", charName, content) - s.discordBot.RealtimeChannelSend(message) - } -} - -func (s *Server) DiscordScreenShotSend(charName string, title string, description string, articleToken string) { - if s.erupeConfig.Discord.Enabled && s.discordBot != nil { - imageUrl := fmt.Sprintf("%s:%d/api/ss/bbs/%s", s.erupeConfig.Screenshots.Host, s.erupeConfig.Screenshots.Port, articleToken) - message := fmt.Sprintf("**%s**: %s - %s %s", charName, title, description, imageUrl) - s.discordBot.RealtimeChannelSend(message) - } -} - -func (s *Server) FindSessionByCharID(charID uint32) *Session { - for _, c := range s.Channels { +func (server *Server) FindSessionByCharID(charID uint32) *Session { + for _, c := range server.Channels { for _, session := range c.sessions { if session.charID == charID { return session @@ -378,15 +212,15 @@ func (s *Server) FindSessionByCharID(charID uint32) *Session { return nil } -func (s *Server) DisconnectUser(uid uint32) { +func (server *Server) DisconnectUser(uid uint32) { var cid uint32 var cids []uint32 - rows, _ := s.db.Query(`SELECT id FROM characters WHERE user_id=$1`, uid) + rows, _ := server.db.Query(`SELECT id FROM characters WHERE user_id=$1`, uid) for rows.Next() { rows.Scan(&cid) cids = append(cids, cid) } - for _, c := range s.Channels { + for _, c := range server.Channels { for _, session := range c.sessions { for _, cid := range cids { if session.charID == cid { @@ -398,10 +232,10 @@ func (s *Server) DisconnectUser(uid uint32) { } } -func (s *Server) FindObjectByChar(charID uint32) *Object { - s.stagesLock.RLock() - defer s.stagesLock.RUnlock() - for _, stage := range s.stages { +func (server *Server) FindObjectByChar(charID uint32) *Object { + server.stagesLock.RLock() + defer server.stagesLock.RUnlock() + for _, stage := range server.stages { stage.RLock() for objId := range stage.objects { obj := stage.objects[objId] @@ -416,8 +250,8 @@ func (s *Server) FindObjectByChar(charID uint32) *Object { return nil } -func (s *Server) HasSemaphore(ses *Session) bool { - for _, semaphore := range s.semaphore { +func (server *Server) HasSemaphore(ses *Session) bool { + for _, semaphore := range server.semaphore { if semaphore.host == ses { return true } @@ -425,7 +259,7 @@ func (s *Server) HasSemaphore(ses *Session) bool { return false } -func (s *Server) Season() uint8 { - sid := int64(((s.ID & 0xFF00) - 4096) / 256) +func (server *Server) Season() uint8 { + sid := int64(((server.ID & 0xFF00) - 4096) / 256) return uint8(((gametime.TimeAdjusted().Unix() / 86400) + sid) % 3) } diff --git a/server/channelserver/handlers_discord.go b/server/channelserver/sys_discord.go similarity index 65% rename from server/channelserver/handlers_discord.go rename to server/channelserver/sys_discord.go index 3144b5e7b..c05f292be 100644 --- a/server/channelserver/handlers_discord.go +++ b/server/channelserver/sys_discord.go @@ -2,11 +2,12 @@ package channelserver import ( "fmt" - "github.com/bwmarrin/discordgo" - "golang.org/x/crypto/bcrypt" "sort" "strings" "unicode" + + "github.com/bwmarrin/discordgo" + "golang.org/x/crypto/bcrypt" ) type Player struct { @@ -14,11 +15,11 @@ type Player struct { QuestID int } -func getPlayerSlice(s *Server) []Player { +func getPlayerSlice(server *Server) []Player { var p []Player var questIndex int - for _, channel := range s.Channels { + for _, channel := range server.Channels { for _, stage := range channel.stages { if len(stage.clients) == 0 { continue @@ -39,7 +40,7 @@ func getPlayerSlice(s *Server) []Player { return p } -func getCharacterList(s *Server) string { +func getCharacterList(server *Server) string { questEmojis := []string{ ":person_in_lotus_position:", ":white_circle:", @@ -53,7 +54,7 @@ func getCharacterList(s *Server) string { ":black_circle:", } - playerSlice := getPlayerSlice(s) + playerSlice := getPlayerSlice(server) sort.SliceStable(playerSlice, func(i, j int) bool { return playerSlice[i].QuestID < playerSlice[j].QuestID @@ -68,11 +69,11 @@ func getCharacterList(s *Server) string { } // onInteraction handles slash commands -func (s *Server) onInteraction(ds *discordgo.Session, i *discordgo.InteractionCreate) { +func (server *Server) onInteraction(ds *discordgo.Session, i *discordgo.InteractionCreate) { switch i.Interaction.ApplicationCommandData().Name { case "link": var temp string - err := s.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) + err := server.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, @@ -92,7 +93,7 @@ func (s *Server) onInteraction(ds *discordgo.Session, i *discordgo.InteractionCr } case "password": password, _ := bcrypt.GenerateFromPassword([]byte(i.ApplicationCommandData().Options[0].StringValue()), 10) - _, err := s.db.Exec(`UPDATE users SET password = $1 WHERE discord_id = $2`, password, i.Member.User.ID) + _, err := server.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, @@ -114,9 +115,9 @@ func (s *Server) onInteraction(ds *discordgo.Session, i *discordgo.InteractionCr } // onDiscordMessage handles receiving messages from discord and forwarding them ingame. -func (s *Server) onDiscordMessage(ds *discordgo.Session, m *discordgo.MessageCreate) { +func (server *Server) onDiscordMessage(ds *discordgo.Session, m *discordgo.MessageCreate) { // Ignore messages from bots, or messages that are not in the correct channel. - if m.Author.Bot || m.ChannelID != s.erupeConfig.Discord.RelayChannel.RelayChannelID { + if m.Author.Bot || m.ChannelID != server.erupeConfig.Discord.RelayChannel.RelayChannelID { return } @@ -129,8 +130,8 @@ func (s *Server) onDiscordMessage(ds *discordgo.Session, m *discordgo.MessageCre for i := 0; i < 8-len(m.Author.Username); i++ { paddedName += " " } - message := s.discordBot.NormalizeDiscordMessage(fmt.Sprintf("[D] %s > %s", paddedName, m.Content)) - if len(message) > s.erupeConfig.Discord.RelayChannel.MaxMessageLength { + message := server.discordBot.NormalizeDiscordMessage(fmt.Sprintf("[D] %s > %s", paddedName, m.Content)) + if len(message) > server.erupeConfig.Discord.RelayChannel.MaxMessageLength { return } @@ -144,6 +145,20 @@ func (s *Server) onDiscordMessage(ds *discordgo.Session, m *discordgo.MessageCre messages = append(messages, message[i:end]) } for i := range messages { - s.BroadcastChatMessage(messages[i]) + server.BroadcastChatMessage(messages[i]) + } +} +func (server *Server) DiscordChannelSend(charName string, content string) { + if server.erupeConfig.Discord.Enabled && server.discordBot != nil { + message := fmt.Sprintf("**%s**: %s", charName, content) + server.discordBot.RealtimeChannelSend(message) + } +} + +func (server *Server) DiscordScreenShotSend(charName string, title string, description string, articleToken string) { + if server.erupeConfig.Discord.Enabled && server.discordBot != nil { + imageUrl := fmt.Sprintf("%s:%d/api/ss/bbs/%s", server.erupeConfig.Screenshots.Host, server.erupeConfig.Screenshots.Port, articleToken) + message := fmt.Sprintf("**%s**: %s - %s %s", charName, title, description, imageUrl) + server.discordBot.RealtimeChannelSend(message) } } diff --git a/server/channelserver/sys_language.go b/server/channelserver/sys_language.go index aae8706bb..5fb423d99 100644 --- a/server/channelserver/sys_language.go +++ b/server/channelserver/sys_language.go @@ -101,9 +101,9 @@ type i18n struct { } } -func getLangStrings(s *Server) i18n { +func getLangStrings(server *Server) i18n { var i i18n - switch s.erupeConfig.Language { + switch server.erupeConfig.Language { case "jp": i.language = "日本語" i.cafe.reset = "%d/%dにリセット" diff --git a/server/channelserver/sys_ravi.go b/server/channelserver/sys_ravi.go new file mode 100644 index 000000000..83dcbcbb8 --- /dev/null +++ b/server/channelserver/sys_ravi.go @@ -0,0 +1,71 @@ +package channelserver + +import ( + "strings" + "sync" +) + +type Raviente struct { + sync.Mutex + id uint16 + register []uint32 + state []uint32 + support []uint32 +} + +func (server *Server) resetRaviente() { + for _, semaphore := range server.semaphore { + if strings.HasPrefix(semaphore.name, "hs_l0") { + return + } + } + server.logger.Debug("All Raviente Semaphores empty, resetting") + server.raviente.id = server.raviente.id + 1 + server.raviente.register = make([]uint32, 30) + server.raviente.state = make([]uint32, 30) + server.raviente.support = make([]uint32, 30) +} + +func (server *Server) GetRaviMultiplier() float64 { + raviSema := server.getRaviSemaphore() + if raviSema != nil { + var minPlayers int + if server.raviente.register[9] > 8 { + minPlayers = 24 + } else { + minPlayers = 4 + } + if len(raviSema.clients) > minPlayers { + return 1 + } + return float64(minPlayers / len(raviSema.clients)) + } + return 0 +} + +func (server *Server) UpdateRavi(semaID uint32, index uint8, value uint32, update bool) (uint32, uint32) { + var prev uint32 + var dest *[]uint32 + switch semaID { + case 0x40000: + switch index { + case 17, 28: // Ignore res and poison + break + default: + value = uint32(float64(value) * server.GetRaviMultiplier()) + } + dest = &server.raviente.state + case 0x50000: + dest = &server.raviente.support + case 0x60000: + dest = &server.raviente.register + default: + return 0, 0 + } + if update { + (*dest)[index] += value + } else { + (*dest)[index] = value + } + return prev, (*dest)[index] +} diff --git a/server/entranceserver/entrance_server.go b/server/entranceserver/entrance_server.go index 18869304b..1deb92365 100644 --- a/server/entranceserver/entrance_server.go +++ b/server/entranceserver/entrance_server.go @@ -8,8 +8,9 @@ import ( "strings" "sync" - "erupe-ce/config" + _config "erupe-ce/config" "erupe-ce/network" + "github.com/jmoiron/sqlx" "go.uber.org/zap" ) @@ -33,50 +34,50 @@ type Config struct { // NewServer creates a new Server type. func NewServer(config *Config) *Server { - s := &Server{ + server := &Server{ logger: config.Logger, erupeConfig: config.ErupeConfig, db: config.DB, } - return s + return server } // Start starts the server in a new goroutine. -func (s *Server) Start() error { +func (server *Server) Start() error { - l, err := net.Listen("tcp", fmt.Sprintf(":%d", s.erupeConfig.Entrance.Port)) + l, err := net.Listen("tcp", fmt.Sprintf(":%d", server.erupeConfig.Entrance.Port)) if err != nil { return err } - s.listener = l + server.listener = l - go s.acceptClients() + go server.acceptClients() return nil } // Shutdown exits the server gracefully. -func (s *Server) Shutdown() { - s.logger.Debug("Shutting down...") +func (server *Server) Shutdown() { + server.logger.Debug("Shutting down...") - s.Lock() - s.isShuttingDown = true - s.Unlock() + server.Lock() + server.isShuttingDown = true + server.Unlock() // This will cause the acceptor goroutine to error and exit gracefully. - s.listener.Close() + server.listener.Close() } // acceptClients handles accepting new clients in a loop. -func (s *Server) acceptClients() { +func (server *Server) acceptClients() { for { - conn, err := s.listener.Accept() + conn, err := server.listener.Accept() if err != nil { // Check if we are shutting down and exit gracefully if so. - s.Lock() - shutdown := s.isShuttingDown - s.Unlock() + server.Lock() + shutdown := server.isShuttingDown + server.Unlock() if shutdown { break @@ -86,20 +87,20 @@ func (s *Server) acceptClients() { } // Start a new goroutine for the connection so that we don't block other incoming connections. - go s.handleEntranceServerConnection(conn) + go server.handleEntranceServerConnection(conn) } } -func (s *Server) handleEntranceServerConnection(conn net.Conn) { +func (server *Server) handleEntranceServerConnection(conn net.Conn) { defer conn.Close() // Client initalizes the connection with a one-time buffer of 8 NULL bytes. nullInit := make([]byte, 8) n, err := io.ReadFull(conn, nullInit) if err != nil { - s.logger.Warn("Failed to read 8 NULL init", zap.Error(err)) + server.logger.Warn("Failed to read 8 NULL init", zap.Error(err)) return } else if n != len(nullInit) { - s.logger.Warn("io.ReadFull couldn't read the full 8 byte init.") + server.logger.Warn("io.ReadFull couldn't read the full 8 byte init.") return } @@ -107,11 +108,11 @@ func (s *Server) handleEntranceServerConnection(conn net.Conn) { cc := network.NewCryptConn(conn) pkt, err := cc.ReadPacket() if err != nil { - s.logger.Warn("Error reading packet", zap.Error(err)) + server.logger.Warn("Error reading packet", zap.Error(err)) return } - if s.erupeConfig.DebugOptions.LogInboundMessages { + if server.erupeConfig.DebugOptions.LogInboundMessages { fmt.Printf("[Client] -> [Server]\nData [%d bytes]:\n%s\n", len(pkt), hex.Dump(pkt)) } @@ -119,9 +120,9 @@ func (s *Server) handleEntranceServerConnection(conn net.Conn) { if strings.Split(conn.RemoteAddr().String(), ":")[0] == "127.0.0.1" { local = true } - data := makeSv2Resp(s.erupeConfig, s, local) + data := makeSv2Resp(server.erupeConfig, server, local) if len(pkt) > 5 { - data = append(data, makeUsrResp(pkt, s)...) + data = append(data, makeUsrResp(pkt, server)...) } cc.SendPacket(data) // Close because we only need to send the response once. diff --git a/server/entranceserver/make_resp.go b/server/entranceserver/make_resp.go index 36f37744c..53373701d 100644 --- a/server/entranceserver/make_resp.go +++ b/server/entranceserver/make_resp.go @@ -12,7 +12,7 @@ import ( "net" ) -func encodeServerInfo(config *_config.Config, s *Server, local bool) []byte { +func encodeServerInfo(config *_config.Config, server *Server, local bool) []byte { serverInfos := config.Entrance.Entries bf := byteframe.NewByteFrame() @@ -42,22 +42,22 @@ func encodeServerInfo(config *_config.Config, s *Server, local bool) []byte { bf.WriteUint16(uint16(len(si.Channels))) bf.WriteUint8(si.Type) bf.WriteUint8(uint8(((gametime.TimeAdjusted().Unix() / 86400) + int64(serverIdx)) % 3)) - if s.erupeConfig.ClientID >= _config.G1 { + if server.erupeConfig.ClientID >= _config.G1 { bf.WriteUint8(si.Recommended) } fullName := append(append(stringsupport.UTF8ToSJIS(si.Name), []byte{0x00}...), stringsupport.UTF8ToSJIS(si.Description)...) - if s.erupeConfig.ClientID >= _config.G1 && s.erupeConfig.ClientID <= _config.G5 { + if server.erupeConfig.ClientID >= _config.G1 && server.erupeConfig.ClientID <= _config.G5 { bf.WriteUint8(uint8(len(fullName))) bf.WriteBytes(fullName) } else { - if s.erupeConfig.ClientID >= _config.G51 { + if server.erupeConfig.ClientID >= _config.G51 { bf.WriteUint8(0) // Ignored } bf.WriteBytes(stringsupport.PaddedString(string(fullName), 65, false)) } - if s.erupeConfig.ClientID >= _config.GG { + if server.erupeConfig.ClientID >= _config.GG { bf.WriteUint32(si.AllowedClientFlags) } @@ -71,7 +71,7 @@ func encodeServerInfo(config *_config.Config, s *Server, local bool) []byte { bf.WriteUint16(uint16(channelIdx | 16)) bf.WriteUint16(ci.MaxPlayers) var currentPlayers uint16 - s.db.QueryRow("SELECT current_players FROM servers WHERE server_id=$1", sid).Scan(¤tPlayers) + server.db.QueryRow("SELECT current_players FROM servers WHERE server_id=$1", sid).Scan(¤tPlayers) bf.WriteUint16(currentPlayers) bf.WriteUint16(0) bf.WriteUint16(0) @@ -86,7 +86,7 @@ func encodeServerInfo(config *_config.Config, s *Server, local bool) []byte { } } bf.WriteUint32(uint32(gametime.TimeAdjusted().Unix())) - bf.WriteUint32(uint32(s.erupeConfig.GameplayOptions.ClanMemberLimits[len(s.erupeConfig.GameplayOptions.ClanMemberLimits)-1][1])) + bf.WriteUint32(uint32(server.erupeConfig.GameplayOptions.ClanMemberLimits[len(server.erupeConfig.GameplayOptions.ClanMemberLimits)-1][1])) return bf.Data() } @@ -108,7 +108,7 @@ func makeHeader(data []byte, respType string, entryCount uint16, key byte) []byt return bf.Data() } -func makeSv2Resp(config *_config.Config, s *Server, local bool) []byte { +func makeSv2Resp(config *_config.Config, server *Server, local bool) []byte { serverInfos := config.Entrance.Entries // Decrease by the number of MezFes Worlds var mf int @@ -128,9 +128,9 @@ func makeSv2Resp(config *_config.Config, s *Server, local bool) []byte { } } } - rawServerData := encodeServerInfo(config, s, local) + rawServerData := encodeServerInfo(config, server, local) - if s.erupeConfig.DebugOptions.LogOutboundMessages { + if server.erupeConfig.DebugOptions.LogOutboundMessages { fmt.Printf("[Server] -> [Client]\nData [%d bytes]:\n%s\n", len(rawServerData), hex.Dump(rawServerData)) } @@ -144,7 +144,7 @@ func makeSv2Resp(config *_config.Config, s *Server, local bool) []byte { return bf.Data() } -func makeUsrResp(pkt []byte, s *Server) []byte { +func makeUsrResp(pkt []byte, server *Server) []byte { bf := byteframe.NewByteFrameFromBytes(pkt) _ = bf.ReadUint32() // ALL+ _ = bf.ReadUint8() // 0x00 @@ -153,7 +153,7 @@ func makeUsrResp(pkt []byte, s *Server) []byte { for i := 0; i < int(userEntries); i++ { cid := bf.ReadUint32() var sid uint16 - err := s.db.QueryRow("SELECT(SELECT server_id FROM sign_sessions WHERE char_id=$1) AS _", cid).Scan(&sid) + err := server.db.QueryRow("SELECT(SELECT server_id FROM sign_sessions WHERE char_id=$1) AS _", cid).Scan(&sid) if err != nil { resp.WriteUint16(0) } else { @@ -162,7 +162,7 @@ func makeUsrResp(pkt []byte, s *Server) []byte { resp.WriteUint16(0) } - if s.erupeConfig.DebugOptions.LogOutboundMessages { + if server.erupeConfig.DebugOptions.LogOutboundMessages { fmt.Printf("[Server] -> [Client]\nData [%d bytes]:\n%s\n", len(resp.Data()), hex.Dump(resp.Data())) } diff --git a/server/signserver/dbutils.go b/server/signserver/dbutils.go index bacce3de9..efe49267e 100644 --- a/server/signserver/dbutils.go +++ b/server/signserver/dbutils.go @@ -12,9 +12,9 @@ import ( "golang.org/x/crypto/bcrypt" ) -func (s *Server) newUserChara(uid uint32) error { +func (server *Server) newUserChara(uid uint32) error { var numNewChars int - err := s.db.QueryRow("SELECT COUNT(*) FROM characters WHERE user_id = $1 AND is_new_character = true", uid).Scan(&numNewChars) + err := server.db.QueryRow("SELECT COUNT(*) FROM characters WHERE user_id = $1 AND is_new_character = true", uid).Scan(&numNewChars) if err != nil { return err } @@ -24,7 +24,7 @@ func (s *Server) newUserChara(uid uint32) error { return err } - _, err = s.db.Exec(` + _, err = server.db.Exec(` INSERT INTO characters ( user_id, is_female, is_new_character, name, unk_desc_string, hr, gr, weapon_type, last_login) @@ -39,9 +39,9 @@ func (s *Server) newUserChara(uid uint32) error { return nil } -func (s *Server) registerDBAccount(username string, password string) (uint32, error) { +func (server *Server) registerDBAccount(username string, password string) (uint32, error) { var uid uint32 - s.logger.Info("Creating user", zap.String("User", username)) + server.logger.Info("Creating user", zap.String("User", username)) // Create salted hash of user password passwordHash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost) @@ -49,7 +49,7 @@ func (s *Server) registerDBAccount(username string, password string) (uint32, er return 0, err } - err = s.db.QueryRow("INSERT INTO users (username, password, return_expires) VALUES ($1, $2, $3) RETURNING id", username, string(passwordHash), time.Now().Add(time.Hour*24*30)).Scan(&uid) + err = server.db.QueryRow("INSERT INTO users (username, password, return_expires) VALUES ($1, $2, $3) RETURNING id", username, string(passwordHash), time.Now().Add(time.Hour*24*30)).Scan(&uid) if err != nil { return 0, err } @@ -69,42 +69,42 @@ type character struct { LastLogin uint32 `db:"last_login"` } -func (s *Server) getCharactersForUser(uid uint32) ([]character, error) { +func (server *Server) getCharactersForUser(uid uint32) ([]character, error) { characters := make([]character, 0) - err := s.db.Select(&characters, "SELECT id, is_female, is_new_character, name, unk_desc_string, hr, gr, weapon_type, last_login FROM characters WHERE user_id = $1 AND deleted = false ORDER BY id", uid) + err := server.db.Select(&characters, "SELECT id, is_female, is_new_character, name, unk_desc_string, hr, gr, weapon_type, last_login FROM characters WHERE user_id = $1 AND deleted = false ORDER BY id", uid) if err != nil { return nil, err } return characters, nil } -func (s *Server) getReturnExpiry(uid uint32) time.Time { +func (server *Server) getReturnExpiry(uid uint32) time.Time { var returnExpiry, lastLogin time.Time - s.db.Get(&lastLogin, "SELECT COALESCE(last_login, now()) FROM users WHERE id=$1", uid) + server.db.Get(&lastLogin, "SELECT COALESCE(last_login, now()) FROM users WHERE id=$1", uid) if time.Now().Add((time.Hour * 24) * -90).After(lastLogin) { returnExpiry = time.Now().Add(time.Hour * 24 * 30) - s.db.Exec("UPDATE users SET return_expires=$1 WHERE id=$2", returnExpiry, uid) + server.db.Exec("UPDATE users SET return_expires=$1 WHERE id=$2", returnExpiry, uid) } else { - err := s.db.Get(&returnExpiry, "SELECT return_expires FROM users WHERE id=$1", uid) + err := server.db.Get(&returnExpiry, "SELECT return_expires FROM users WHERE id=$1", uid) if err != nil { returnExpiry = time.Now() - s.db.Exec("UPDATE users SET return_expires=$1 WHERE id=$2", returnExpiry, uid) + server.db.Exec("UPDATE users SET return_expires=$1 WHERE id=$2", returnExpiry, uid) } } - s.db.Exec("UPDATE users SET last_login=$1 WHERE id=$2", time.Now(), uid) + server.db.Exec("UPDATE users SET last_login=$1 WHERE id=$2", time.Now(), uid) return returnExpiry } -func (s *Server) getLastCID(uid uint32) uint32 { +func (server *Server) getLastCID(uid uint32) uint32 { var lastPlayed uint32 - _ = s.db.QueryRow("SELECT last_character FROM users WHERE id=$1", uid).Scan(&lastPlayed) + _ = server.db.QueryRow("SELECT last_character FROM users WHERE id=$1", uid).Scan(&lastPlayed) return lastPlayed } -func (s *Server) getUserRights(uid uint32) uint32 { +func (server *Server) getUserRights(uid uint32) uint32 { var rights uint32 if uid != 0 { - _ = s.db.QueryRow("SELECT rights FROM users WHERE id=$1", uid).Scan(&rights) + _ = server.db.QueryRow("SELECT rights FROM users WHERE id=$1", uid).Scan(&rights) _, rights = mhfcourse.GetCourseStruct(rights) } return rights @@ -116,11 +116,11 @@ type members struct { Name string `db:"name"` } -func (s *Server) getFriendsForCharacters(chars []character) []members { +func (server *Server) getFriendsForCharacters(chars []character) []members { friends := make([]members, 0) for _, char := range chars { friendsCSV := "" - err := s.db.QueryRow("SELECT friends FROM characters WHERE id=$1", char.ID).Scan(&friendsCSV) + err := server.db.QueryRow("SELECT friends FROM characters WHERE id=$1", char.ID).Scan(&friendsCSV) friendsSlice := strings.Split(friendsCSV, ",") friendQuery := "SELECT id, name FROM characters WHERE id=" for i := 0; i < len(friendsSlice); i++ { @@ -130,7 +130,7 @@ func (s *Server) getFriendsForCharacters(chars []character) []members { } } charFriends := make([]members, 0) - err = s.db.Select(&charFriends, friendQuery) + err = server.db.Select(&charFriends, friendQuery) if err != nil { continue } @@ -142,19 +142,19 @@ func (s *Server) getFriendsForCharacters(chars []character) []members { return friends } -func (s *Server) getGuildmatesForCharacters(chars []character) []members { +func (server *Server) getGuildmatesForCharacters(chars []character) []members { guildmates := make([]members, 0) for _, char := range chars { var inGuild int - _ = s.db.QueryRow("SELECT count(*) FROM guild_characters WHERE character_id=$1", char.ID).Scan(&inGuild) + _ = server.db.QueryRow("SELECT count(*) FROM guild_characters WHERE character_id=$1", char.ID).Scan(&inGuild) if inGuild > 0 { var guildID int - err := s.db.QueryRow("SELECT guild_id FROM guild_characters WHERE character_id=$1", char.ID).Scan(&guildID) + err := server.db.QueryRow("SELECT guild_id FROM guild_characters WHERE character_id=$1", char.ID).Scan(&guildID) if err != nil { continue } charGuildmates := make([]members, 0) - err = s.db.Select(&charGuildmates, "SELECT character_id AS id, c.name FROM guild_characters gc JOIN characters c ON c.id = gc.character_id WHERE guild_id=$1 AND character_id!=$2", guildID, char.ID) + err = server.db.Select(&charGuildmates, "SELECT character_id AS id, c.name FROM guild_characters gc JOIN characters c ON c.id = gc.character_id WHERE guild_id=$1 AND character_id!=$2", guildID, char.ID) if err != nil { continue } @@ -167,16 +167,16 @@ func (s *Server) getGuildmatesForCharacters(chars []character) []members { return guildmates } -func (s *Server) deleteCharacter(cid int, token string, tokenID uint32) error { - if !s.validateToken(token, tokenID) { +func (server *Server) deleteCharacter(cid int, token string, tokenID uint32) error { + if !server.validateToken(token, tokenID) { return errors.New("invalid token") } var isNew bool - err := s.db.QueryRow("SELECT is_new_character FROM characters WHERE id = $1", cid).Scan(&isNew) + err := server.db.QueryRow("SELECT is_new_character FROM characters WHERE id = $1", cid).Scan(&isNew) if isNew { - _, err = s.db.Exec("DELETE FROM characters WHERE id = $1", cid) + _, err = server.db.Exec("DELETE FROM characters WHERE id = $1", cid) } else { - _, err = s.db.Exec("UPDATE characters SET deleted = true WHERE id = $1", cid) + _, err = server.db.Exec("UPDATE characters SET deleted = true WHERE id = $1", cid) } if err != nil { return err @@ -185,9 +185,9 @@ func (s *Server) deleteCharacter(cid int, token string, tokenID uint32) error { } // Unused -func (s *Server) checkToken(uid uint32) (bool, error) { +func (server *Server) checkToken(uid uint32) (bool, error) { var exists int - err := s.db.QueryRow("SELECT count(*) FROM sign_sessions WHERE user_id = $1", uid).Scan(&exists) + err := server.db.QueryRow("SELECT count(*) FROM sign_sessions WHERE user_id = $1", uid).Scan(&exists) if err != nil { return false, err } @@ -197,42 +197,42 @@ func (s *Server) checkToken(uid uint32) (bool, error) { return false, nil } -func (s *Server) registerUidToken(uid uint32) (uint32, string, error) { +func (server *Server) registerUidToken(uid uint32) (uint32, string, error) { _token := token.Generate(16) var tid uint32 - err := s.db.QueryRow(`INSERT INTO sign_sessions (user_id, token) VALUES ($1, $2) RETURNING id`, uid, _token).Scan(&tid) + err := server.db.QueryRow(`INSERT INTO sign_sessions (user_id, token) VALUES ($1, $2) RETURNING id`, uid, _token).Scan(&tid) return tid, _token, err } -func (s *Server) registerPsnToken(psn string) (uint32, string, error) { +func (server *Server) registerPsnToken(psn string) (uint32, string, error) { _token := token.Generate(16) var tid uint32 - err := s.db.QueryRow(`INSERT INTO sign_sessions (psn_id, token) VALUES ($1, $2) RETURNING id`, psn, _token).Scan(&tid) + err := server.db.QueryRow(`INSERT INTO sign_sessions (psn_id, token) VALUES ($1, $2) RETURNING id`, psn, _token).Scan(&tid) return tid, _token, err } -func (s *Server) validateToken(token string, tokenID uint32) bool { +func (server *Server) validateToken(token string, tokenID uint32) bool { query := `SELECT count(*) FROM sign_sessions WHERE token = $1` if tokenID > 0 { query += ` AND id = $2` } var exists int - err := s.db.QueryRow(query, token, tokenID).Scan(&exists) + err := server.db.QueryRow(query, token, tokenID).Scan(&exists) if err != nil || exists == 0 { return false } return true } -func (s *Server) validateLogin(user string, pass string) (uint32, RespID) { +func (server *Server) validateLogin(user string, pass string) (uint32, RespID) { var uid uint32 var passDB string - err := s.db.QueryRow(`SELECT id, password FROM users WHERE username = $1`, user).Scan(&uid, &passDB) + err := server.db.QueryRow(`SELECT id, password FROM users WHERE username = $1`, user).Scan(&uid, &passDB) if err != nil { if errors.Is(err, sql.ErrNoRows) { - s.logger.Info("User not found", zap.String("User", user)) - if s.erupeConfig.AutoCreateAccount { - uid, err = s.registerDBAccount(user, pass) + server.logger.Info("User not found", zap.String("User", user)) + if server.erupeConfig.AutoCreateAccount { + uid, err = server.registerDBAccount(user, pass) if err == nil { return uid, SIGN_SUCCESS } else { @@ -245,11 +245,11 @@ func (s *Server) validateLogin(user string, pass string) (uint32, RespID) { } else { if bcrypt.CompareHashAndPassword([]byte(passDB), []byte(pass)) == nil { var bans int - err = s.db.QueryRow(`SELECT count(*) FROM bans WHERE user_id=$1 AND expires IS NULL`, uid).Scan(&bans) + err = server.db.QueryRow(`SELECT count(*) FROM bans WHERE user_id=$1 AND expires IS NULL`, uid).Scan(&bans) if err == nil && bans > 0 { return uid, SIGN_EELIMINATE } - err = s.db.QueryRow(`SELECT count(*) FROM bans WHERE user_id=$1 AND expires > now()`, uid).Scan(&bans) + err = server.db.QueryRow(`SELECT count(*) FROM bans WHERE user_id=$1 AND expires > now()`, uid).Scan(&bans) if err == nil && bans > 0 { return uid, SIGN_ESUSPEND } diff --git a/server/signserver/sign_server.go b/server/signserver/sign_server.go index f93a6459a..975cc1112 100644 --- a/server/signserver/sign_server.go +++ b/server/signserver/sign_server.go @@ -6,8 +6,9 @@ import ( "net" "sync" - "erupe-ce/config" + _config "erupe-ce/config" "erupe-ce/network" + "github.com/jmoiron/sqlx" "go.uber.org/zap" ) @@ -41,38 +42,38 @@ func NewServer(config *Config) *Server { } // Start starts the server in a new goroutine. -func (s *Server) Start() error { - l, err := net.Listen("tcp", fmt.Sprintf(":%d", s.erupeConfig.Sign.Port)) +func (server *Server) Start() error { + l, err := net.Listen("tcp", fmt.Sprintf(":%d", server.erupeConfig.Sign.Port)) if err != nil { return err } - s.listener = l + server.listener = l - go s.acceptClients() + go server.acceptClients() return nil } // Shutdown exits the server gracefully. -func (s *Server) Shutdown() { - s.logger.Debug("Shutting down...") +func (server *Server) Shutdown() { + server.logger.Debug("Shutting down...") - s.Lock() - s.isShuttingDown = true - s.Unlock() + server.Lock() + server.isShuttingDown = true + server.Unlock() // This will cause the acceptor goroutine to error and exit gracefully. - s.listener.Close() + server.listener.Close() } -func (s *Server) acceptClients() { +func (server *Server) acceptClients() { for { - conn, err := s.listener.Accept() + conn, err := server.listener.Accept() if err != nil { // Check if we are shutting down and exit gracefully if so. - s.Lock() - shutdown := s.isShuttingDown - s.Unlock() + server.Lock() + shutdown := server.isShuttingDown + server.Unlock() if shutdown { break @@ -81,26 +82,26 @@ func (s *Server) acceptClients() { } } - go s.handleConnection(conn) + go server.handleConnection(conn) } } -func (s *Server) handleConnection(conn net.Conn) { - s.logger.Debug("New connection", zap.String("RemoteAddr", conn.RemoteAddr().String())) +func (server *Server) handleConnection(conn net.Conn) { + server.logger.Debug("New connection", zap.String("RemoteAddr", conn.RemoteAddr().String())) defer conn.Close() // Client initalizes the connection with a one-time buffer of 8 NULL bytes. nullInit := make([]byte, 8) _, err := io.ReadFull(conn, nullInit) if err != nil { - s.logger.Error("Error initializing connection", zap.Error(err)) + server.logger.Error("Error initializing connection", zap.Error(err)) return } // Create a new session. session := &Session{ - logger: s.logger, - server: s, + logger: server.logger, + server: server, rawConn: conn, cryptConn: network.NewCryptConn(conn), }