Mirror/Erupe
1
0
Fork 0
mirror of https://github.com/Mezeporta/Erupe.git synced 2025-12-14 16:04:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

made it clearer when session object and server object was being used by renaming s to session and server. Split out ravi,broadcast and discord into sys_*

Browse Source
This commit is contained in:
stratic-dev
2024-10-10 21:38:12 +01:00
parent 830834c5b5
commit 32dbfa7514
11 changed files with 367 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
main.go
View File

@@ -199,7 +199,7 @@ func main() {
logger.Info("API: Disabled") logger.Info("API: Disabled")
} }
var channels []*channelserver.Server var channelServers []*channelserver.Server
if config.Channel.Enabled { if config.Channel.Enabled {
channelQuery := "" channelQuery := ""
@@ -228,7 +228,7 @@ func main() {
preventClose(fmt.Sprintf("Channel: Failed to start, %s", err.Error())) preventClose(fmt.Sprintf("Channel: Failed to start, %s", err.Error()))
} else { } 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) 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)) logger.Info(fmt.Sprintf("Channel %d (%d): Started successfully", count, ce.Port))
ci++ ci++
count++ count++
@@ -241,8 +241,8 @@ func main() {
// Register all servers in DB // Register all servers in DB
_ = db.MustExec(channelQuery) _ = db.MustExec(channelQuery)
for _, c := range channels { for _, c := range channelServers {
c.Channels = channels c.Channels = channelServers
} }
} }
@@ -256,8 +256,8 @@ func main() {
if !config.DisableSoftCrash { if !config.DisableSoftCrash {
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
message := fmt.Sprintf("Shutting down in %d...", 10-i) message := fmt.Sprintf("Shutting down in %d...", 10-i)
for _, c := range channels { for _, channelServer := range channelServers {
c.BroadcastChatMessage(message) channelServer.BroadcastChatMessage(message)
} }
logger.Info(message) logger.Info(message)
time.Sleep(time.Second) time.Sleep(time.Second)
@@ -265,8 +265,8 @@ func main() {
} }
if config.Channel.Enabled { if config.Channel.Enabled {
for _, c := range channels { for _, channelServer := range channelServers {
c.Shutdown() channelServer.Shutdown()
} }
} }

4
server/channelserver/handlers_register.go
View File

@@ -132,8 +132,8 @@ func (s *Session) notifyRavi() {
} }
} }
func (s *Server) getRaviSemaphore() *Semaphore { func (server *Server) getRaviSemaphore() *Semaphore {
for _, semaphore := range s.semaphore { for _, semaphore := range server.semaphore {
if strings.HasPrefix(semaphore.name, "hs_l0") && strings.HasSuffix(semaphore.name, "3") { if strings.HasPrefix(semaphore.name, "hs_l0") && strings.HasSuffix(semaphore.name, "3") {
return semaphore return semaphore
} }

83
server/channelserver/sys_broadcast.go Normal file
View File

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

294
server/channelserver/sys_channel_server.go
View File

@@ -3,17 +3,12 @@ package channelserver
import ( import (
"fmt" "fmt"
"net" "net"
"strings"
"sync" "sync"
"time" "time"
_config "erupe-ce/config" _config "erupe-ce/config"
"erupe-ce/network/binpacket"
"erupe-ce/network/mhfpacket"
"erupe-ce/server/discordbot" "erupe-ce/server/discordbot"
"erupe-ce/utils/byteframe"
"erupe-ce/utils/gametime" "erupe-ce/utils/gametime"
ps "erupe-ce/utils/pascalstring"
"github.com/jmoiron/sqlx" "github.com/jmoiron/sqlx"
"go.uber.org/zap" "go.uber.org/zap"
@@ -80,74 +75,22 @@ type Server struct {
questCacheTime map[int]time.Time 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. // NewServer creates a new Server type.
func NewServer(config *Config) *Server { 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, ID: config.ID,
logger: config.Logger, logger: config.Logger,
db: config.DB, db: config.DB,
@@ -156,7 +99,7 @@ func NewServer(config *Config) *Server {
deleteConns: make(chan net.Conn), deleteConns: make(chan net.Conn),
sessions: make(map[net.Conn]*Session), sessions: make(map[net.Conn]*Session),
objectIDs: make(map[*Session]uint16), objectIDs: make(map[*Session]uint16),
stages: make(map[string]*Stage), stages: stages,
userBinaryParts: make(map[userBinaryPartID][]byte), userBinaryParts: make(map[userBinaryPartID][]byte),
semaphore: make(map[string]*Semaphore), semaphore: make(map[string]*Semaphore),
semaphoreIndex: 7, semaphoreIndex: 7,
@@ -172,203 +115,94 @@ func NewServer(config *Config) *Server {
questCacheTime: make(map[int]time.Time), questCacheTime: make(map[int]time.Time),
} }
// Mezeporta server.i18n = getLangStrings(server)
s.stages["sl1Ns200p0a0u0"] = NewStage("sl1Ns200p0a0u0")
// Rasta bar stage return server
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
} }
// Start starts the server in a new goroutine. // 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.Port)) l, err := net.Listen("tcp", fmt.Sprintf(":%d", server.Port))
if err != nil { if err != nil {
return err return err
} }
s.listener = l server.listener = l
go s.acceptClients() go server.acceptClients()
go s.manageSessions() go server.manageSessions()
// Start the discord bot for chat integration. // Start the discord bot for chat integration.
if s.erupeConfig.Discord.Enabled && s.discordBot != nil { if server.erupeConfig.Discord.Enabled && server.discordBot != nil {
s.discordBot.Session.AddHandler(s.onDiscordMessage) server.discordBot.Session.AddHandler(server.onDiscordMessage)
s.discordBot.Session.AddHandler(s.onInteraction) server.discordBot.Session.AddHandler(server.onInteraction)
} }
return nil return nil
} }
// Shutdown tries to shut down the server gracefully. // Shutdown tries to shut down the server gracefully.
func (s *Server) Shutdown() { func (server *Server) Shutdown() {
s.Lock() server.Lock()
s.isShuttingDown = true server.isShuttingDown = true
s.Unlock() server.Unlock()
s.listener.Close() server.listener.Close()
close(s.acceptConns) close(server.acceptConns)
} }
func (s *Server) acceptClients() { func (server *Server) acceptClients() {
for { for {
conn, err := s.listener.Accept() conn, err := server.listener.Accept()
if err != nil { if err != nil {
s.Lock() server.Lock()
shutdown := s.isShuttingDown shutdown := server.isShuttingDown
s.Unlock() server.Unlock()
if shutdown { if shutdown {
break break
} else { } else {
s.logger.Warn("Error accepting client", zap.Error(err)) server.logger.Warn("Error accepting client", zap.Error(err))
continue continue
} }
} }
s.acceptConns <- conn server.acceptConns <- conn
} }
} }
func (s *Server) manageSessions() { func (server *Server) manageSessions() {
for { for {
select { select {
case newConn := <-s.acceptConns: case newConn := <-server.acceptConns:
// Gracefully handle acceptConns channel closing. // Gracefully handle acceptConns channel closing.
if newConn == nil { if newConn == nil {
s.Lock() server.Lock()
shutdown := s.isShuttingDown shutdown := server.isShuttingDown
s.Unlock() server.Unlock()
if shutdown { if shutdown {
return return
} }
} }
session := NewSession(s, newConn) session := NewSession(server, newConn)
s.Lock() server.Lock()
s.sessions[newConn] = session server.sessions[newConn] = session
s.Unlock() server.Unlock()
session.Start() session.Start()
case delConn := <-s.deleteConns: case delConn := <-server.deleteConns:
s.Lock() server.Lock()
delete(s.sessions, delConn) delete(server.sessions, delConn)
s.Unlock() server.Unlock()
} }
} }
} }
// BroadcastMHF queues a MHFPacket to be sent to all sessions. func (server *Server) FindSessionByCharID(charID uint32) *Session {
func (s *Server) BroadcastMHF(pkt mhfpacket.MHFPacket, ignoredSession *Session) { for _, c := range server.Channels {
// 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 {
for _, session := range c.sessions { for _, session := range c.sessions {
if session.charID == charID { if session.charID == charID {
return session return session
@@ -378,15 +212,15 @@ func (s *Server) FindSessionByCharID(charID uint32) *Session {
return nil return nil
} }
func (s *Server) DisconnectUser(uid uint32) { func (server *Server) DisconnectUser(uid uint32) {
var cid uint32 var cid uint32
var cids []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() { for rows.Next() {
rows.Scan(&cid) rows.Scan(&cid)
cids = append(cids, cid) cids = append(cids, cid)
} }
for _, c := range s.Channels { for _, c := range server.Channels {
for _, session := range c.sessions { for _, session := range c.sessions {
for _, cid := range cids { for _, cid := range cids {
if session.charID == cid { if session.charID == cid {
@@ -398,10 +232,10 @@ func (s *Server) DisconnectUser(uid uint32) {
} }
} }
func (s *Server) FindObjectByChar(charID uint32) *Object { func (server *Server) FindObjectByChar(charID uint32) *Object {
s.stagesLock.RLock() server.stagesLock.RLock()
defer s.stagesLock.RUnlock() defer server.stagesLock.RUnlock()
for _, stage := range s.stages { for _, stage := range server.stages {
stage.RLock() stage.RLock()
for objId := range stage.objects { for objId := range stage.objects {
obj := stage.objects[objId] obj := stage.objects[objId]
@@ -416,8 +250,8 @@ func (s *Server) FindObjectByChar(charID uint32) *Object {
return nil return nil
} }
func (s *Server) HasSemaphore(ses *Session) bool { func (server *Server) HasSemaphore(ses *Session) bool {
for _, semaphore := range s.semaphore { for _, semaphore := range server.semaphore {
if semaphore.host == ses { if semaphore.host == ses {
return true return true
} }
@@ -425,7 +259,7 @@ func (s *Server) HasSemaphore(ses *Session) bool {
return false return false
} }
func (s *Server) Season() uint8 { func (server *Server) Season() uint8 {
sid := int64(((s.ID & 0xFF00) - 4096) / 256) sid := int64(((server.ID & 0xFF00) - 4096) / 256)
return uint8(((gametime.TimeAdjusted().Unix() / 86400) + sid) % 3) return uint8(((gametime.TimeAdjusted().Unix() / 86400) + sid) % 3)
} }

43
server/channelserver/handlers_discord.go → server/channelserver/sys_discord.go
View File

@@ -2,11 +2,12 @@ package channelserver
import ( import (
"fmt" "fmt"
"github.com/bwmarrin/discordgo"
"golang.org/x/crypto/bcrypt"
"sort" "sort"
"strings" "strings"
"unicode" "unicode"
"github.com/bwmarrin/discordgo"
"golang.org/x/crypto/bcrypt"
) )
type Player struct { type Player struct {
@@ -14,11 +15,11 @@ type Player struct {
QuestID int QuestID int
} }
func getPlayerSlice(s *Server) []Player { func getPlayerSlice(server *Server) []Player {
var p []Player var p []Player
var questIndex int var questIndex int
for _, channel := range s.Channels { for _, channel := range server.Channels {
for _, stage := range channel.stages { for _, stage := range channel.stages {
if len(stage.clients) == 0 { if len(stage.clients) == 0 {
continue continue
@@ -39,7 +40,7 @@ func getPlayerSlice(s *Server) []Player {
return p return p
} }
func getCharacterList(s *Server) string { func getCharacterList(server *Server) string {
questEmojis := []string{ questEmojis := []string{
":person_in_lotus_position:", ":person_in_lotus_position:",
":white_circle:", ":white_circle:",
@@ -53,7 +54,7 @@ func getCharacterList(s *Server) string {
":black_circle:", ":black_circle:",
} }
playerSlice := getPlayerSlice(s) playerSlice := getPlayerSlice(server)
sort.SliceStable(playerSlice, func(i, j int) bool { sort.SliceStable(playerSlice, func(i, j int) bool {
return playerSlice[i].QuestID < playerSlice[j].QuestID return playerSlice[i].QuestID < playerSlice[j].QuestID
@@ -68,11 +69,11 @@ func getCharacterList(s *Server) string {
} }
// onInteraction handles slash commands // 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 { switch i.Interaction.ApplicationCommandData().Name {
case "link": case "link":
var temp string 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 { if err == nil {
ds.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{ ds.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
Type: discordgo.InteractionResponseChannelMessageWithSource, Type: discordgo.InteractionResponseChannelMessageWithSource,
@@ -92,7 +93,7 @@ func (s *Server) onInteraction(ds *discordgo.Session, i *discordgo.InteractionCr
} }
case "password": case "password":
password, _ := bcrypt.GenerateFromPassword([]byte(i.ApplicationCommandData().Options[0].StringValue()), 10) 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 { if err == nil {
ds.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{ ds.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
Type: discordgo.InteractionResponseChannelMessageWithSource, 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. // 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. // 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 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++ { for i := 0; i < 8-len(m.Author.Username); i++ {
paddedName += " " paddedName += " "
} }
message := s.discordBot.NormalizeDiscordMessage(fmt.Sprintf("[D] %s > %s", paddedName, m.Content)) message := server.discordBot.NormalizeDiscordMessage(fmt.Sprintf("[D] %s > %s", paddedName, m.Content))
if len(message) > s.erupeConfig.Discord.RelayChannel.MaxMessageLength { if len(message) > server.erupeConfig.Discord.RelayChannel.MaxMessageLength {
return return
} }
@@ -144,6 +145,20 @@ func (s *Server) onDiscordMessage(ds *discordgo.Session, m *discordgo.MessageCre
messages = append(messages, message[i:end]) messages = append(messages, message[i:end])
} }
for i := range messages { 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)
} }
} }

4
server/channelserver/sys_language.go
View File

@@ -101,9 +101,9 @@ type i18n struct {
} }
} }
func getLangStrings(s *Server) i18n { func getLangStrings(server *Server) i18n {
var i i18n var i i18n
switch s.erupeConfig.Language { switch server.erupeConfig.Language {
case "jp": case "jp":
i.language = "日本語" i.language = "日本語"
i.cafe.reset = "%d/%dにリセット" i.cafe.reset = "%d/%dにリセット"

71
server/channelserver/sys_ravi.go Normal file
View File

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

53
server/entranceserver/entrance_server.go
View File

@@ -8,8 +8,9 @@ import (
"strings" "strings"
"sync" "sync"
"erupe-ce/config" _config "erupe-ce/config"
"erupe-ce/network" "erupe-ce/network"
"github.com/jmoiron/sqlx" "github.com/jmoiron/sqlx"
"go.uber.org/zap" "go.uber.org/zap"
) )
@@ -33,50 +34,50 @@ type Config struct {
// NewServer creates a new Server type. // NewServer creates a new Server type.
func NewServer(config *Config) *Server { func NewServer(config *Config) *Server {
s := &Server{ server := &Server{
logger: config.Logger, logger: config.Logger,
erupeConfig: config.ErupeConfig, erupeConfig: config.ErupeConfig,
db: config.DB, db: config.DB,
} }
return s return server
} }
// Start starts the server in a new goroutine. // 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 { if err != nil {
return err return err
} }
s.listener = l server.listener = l
go s.acceptClients() go server.acceptClients()
return nil return nil
} }
// Shutdown exits the server gracefully. // Shutdown exits the server gracefully.
func (s *Server) Shutdown() { func (server *Server) Shutdown() {
s.logger.Debug("Shutting down...") server.logger.Debug("Shutting down...")
s.Lock() server.Lock()
s.isShuttingDown = true server.isShuttingDown = true
s.Unlock() server.Unlock()
// This will cause the acceptor goroutine to error and exit gracefully. // 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. // acceptClients handles accepting new clients in a loop.
func (s *Server) acceptClients() { func (server *Server) acceptClients() {
for { for {
conn, err := s.listener.Accept() conn, err := server.listener.Accept()
if err != nil { if err != nil {
// Check if we are shutting down and exit gracefully if so. // Check if we are shutting down and exit gracefully if so.
s.Lock() server.Lock()
shutdown := s.isShuttingDown shutdown := server.isShuttingDown
s.Unlock() server.Unlock()
if shutdown { if shutdown {
break 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. // 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() defer conn.Close()
// Client initalizes the connection with a one-time buffer of 8 NULL bytes. // Client initalizes the connection with a one-time buffer of 8 NULL bytes.
nullInit := make([]byte, 8) nullInit := make([]byte, 8)
n, err := io.ReadFull(conn, nullInit) n, err := io.ReadFull(conn, nullInit)
if err != nil { 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 return
} else if n != len(nullInit) { } 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 return
} }
@@ -107,11 +108,11 @@ func (s *Server) handleEntranceServerConnection(conn net.Conn) {
cc := network.NewCryptConn(conn) cc := network.NewCryptConn(conn)
pkt, err := cc.ReadPacket() pkt, err := cc.ReadPacket()
if err != nil { if err != nil {
s.logger.Warn("Error reading packet", zap.Error(err)) server.logger.Warn("Error reading packet", zap.Error(err))
return 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)) 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" { if strings.Split(conn.RemoteAddr().String(), ":")[0] == "127.0.0.1" {
local = true local = true
} }
data := makeSv2Resp(s.erupeConfig, s, local) data := makeSv2Resp(server.erupeConfig, server, local)
if len(pkt) > 5 { if len(pkt) > 5 {
data = append(data, makeUsrResp(pkt, s)...) data = append(data, makeUsrResp(pkt, server)...)
} }
cc.SendPacket(data) cc.SendPacket(data)
// Close because we only need to send the response once. // Close because we only need to send the response once.

26
server/entranceserver/make_resp.go
View File

@@ -12,7 +12,7 @@ import (
"net" "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 serverInfos := config.Entrance.Entries
bf := byteframe.NewByteFrame() bf := byteframe.NewByteFrame()
@@ -42,22 +42,22 @@ func encodeServerInfo(config *_config.Config, s *Server, local bool) []byte {
bf.WriteUint16(uint16(len(si.Channels))) bf.WriteUint16(uint16(len(si.Channels)))
bf.WriteUint8(si.Type) bf.WriteUint8(si.Type)
bf.WriteUint8(uint8(((gametime.TimeAdjusted().Unix() / 86400) + int64(serverIdx)) % 3)) 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) bf.WriteUint8(si.Recommended)
} }
fullName := append(append(stringsupport.UTF8ToSJIS(si.Name), []byte{0x00}...), stringsupport.UTF8ToSJIS(si.Description)...) 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.WriteUint8(uint8(len(fullName)))
bf.WriteBytes(fullName) bf.WriteBytes(fullName)
} else { } else {
if s.erupeConfig.ClientID >= _config.G51 { if server.erupeConfig.ClientID >= _config.G51 {
bf.WriteUint8(0) // Ignored bf.WriteUint8(0) // Ignored
} }
bf.WriteBytes(stringsupport.PaddedString(string(fullName), 65, false)) bf.WriteBytes(stringsupport.PaddedString(string(fullName), 65, false))
} }
if s.erupeConfig.ClientID >= _config.GG { if server.erupeConfig.ClientID >= _config.GG {
bf.WriteUint32(si.AllowedClientFlags) 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(uint16(channelIdx | 16))
bf.WriteUint16(ci.MaxPlayers) bf.WriteUint16(ci.MaxPlayers)
var currentPlayers uint16 var currentPlayers uint16
s.db.QueryRow("SELECT current_players FROM servers WHERE server_id=$1", sid).Scan(&currentPlayers) server.db.QueryRow("SELECT current_players FROM servers WHERE server_id=$1", sid).Scan(&currentPlayers)
bf.WriteUint16(currentPlayers) bf.WriteUint16(currentPlayers)
bf.WriteUint16(0) bf.WriteUint16(0)
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(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() return bf.Data()
} }
@@ -108,7 +108,7 @@ func makeHeader(data []byte, respType string, entryCount uint16, key byte) []byt
return bf.Data() 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 serverInfos := config.Entrance.Entries
// Decrease by the number of MezFes Worlds // Decrease by the number of MezFes Worlds
var mf int 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)) 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() return bf.Data()
} }
func makeUsrResp(pkt []byte, s *Server) []byte { func makeUsrResp(pkt []byte, server *Server) []byte {
bf := byteframe.NewByteFrameFromBytes(pkt) bf := byteframe.NewByteFrameFromBytes(pkt)
_ = bf.ReadUint32() // ALL+ _ = bf.ReadUint32() // ALL+
_ = bf.ReadUint8() // 0x00 _ = bf.ReadUint8() // 0x00
@@ -153,7 +153,7 @@ func makeUsrResp(pkt []byte, s *Server) []byte {
for i := 0; i < int(userEntries); i++ { for i := 0; i < int(userEntries); i++ {
cid := bf.ReadUint32() cid := bf.ReadUint32()
var sid uint16 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 { if err != nil {
resp.WriteUint16(0) resp.WriteUint16(0)
} else { } else {
@@ -162,7 +162,7 @@ func makeUsrResp(pkt []byte, s *Server) []byte {
resp.WriteUint16(0) 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())) fmt.Printf("[Server] -> [Client]\nData [%d bytes]:\n%s\n", len(resp.Data()), hex.Dump(resp.Data()))
} }

90
server/signserver/dbutils.go
View File

@@ -12,9 +12,9 @@ import (
"golang.org/x/crypto/bcrypt" "golang.org/x/crypto/bcrypt"
) )
func (s *Server) newUserChara(uid uint32) error { func (server *Server) newUserChara(uid uint32) error {
var numNewChars int 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 { if err != nil {
return err return err
} }
@@ -24,7 +24,7 @@ func (s *Server) newUserChara(uid uint32) error {
return err return err
} }
_, err = s.db.Exec(` _, err = server.db.Exec(`
INSERT INTO characters ( INSERT INTO characters (
user_id, is_female, is_new_character, name, unk_desc_string, user_id, is_female, is_new_character, name, unk_desc_string,
hr, gr, weapon_type, last_login) hr, gr, weapon_type, last_login)
@@ -39,9 +39,9 @@ func (s *Server) newUserChara(uid uint32) error {
return nil 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 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 // Create salted hash of user password
passwordHash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost) 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 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 { if err != nil {
return 0, err return 0, err
} }
@@ -69,42 +69,42 @@ type character struct {
LastLogin uint32 `db:"last_login"` 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) 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 { if err != nil {
return nil, err return nil, err
} }
return characters, nil return characters, nil
} }
func (s *Server) getReturnExpiry(uid uint32) time.Time { func (server *Server) getReturnExpiry(uid uint32) time.Time {
var returnExpiry, lastLogin 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) { if time.Now().Add((time.Hour * 24) * -90).After(lastLogin) {
returnExpiry = time.Now().Add(time.Hour * 24 * 30) 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 { } 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 { if err != nil {
returnExpiry = time.Now() 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 return returnExpiry
} }
func (s *Server) getLastCID(uid uint32) uint32 { func (server *Server) getLastCID(uid uint32) uint32 {
var lastPlayed 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 return lastPlayed
} }
func (s *Server) getUserRights(uid uint32) uint32 { func (server *Server) getUserRights(uid uint32) uint32 {
var rights uint32 var rights uint32
if uid != 0 { 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) _, rights = mhfcourse.GetCourseStruct(rights)
} }
return rights return rights
@@ -116,11 +116,11 @@ type members struct {
Name string `db:"name"` Name string `db:"name"`
} }
func (s *Server) getFriendsForCharacters(chars []character) []members { func (server *Server) getFriendsForCharacters(chars []character) []members {
friends := make([]members, 0) friends := make([]members, 0)
for _, char := range chars { for _, char := range chars {
friendsCSV := "" 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, ",") friendsSlice := strings.Split(friendsCSV, ",")
friendQuery := "SELECT id, name FROM characters WHERE id=" friendQuery := "SELECT id, name FROM characters WHERE id="
for i := 0; i < len(friendsSlice); i++ { for i := 0; i < len(friendsSlice); i++ {
@@ -130,7 +130,7 @@ func (s *Server) getFriendsForCharacters(chars []character) []members {
} }
} }
charFriends := make([]members, 0) charFriends := make([]members, 0)
err = s.db.Select(&charFriends, friendQuery) err = server.db.Select(&charFriends, friendQuery)
if err != nil { if err != nil {
continue continue
} }
@@ -142,19 +142,19 @@ func (s *Server) getFriendsForCharacters(chars []character) []members {
return friends return friends
} }
func (s *Server) getGuildmatesForCharacters(chars []character) []members { func (server *Server) getGuildmatesForCharacters(chars []character) []members {
guildmates := make([]members, 0) guildmates := make([]members, 0)
for _, char := range chars { for _, char := range chars {
var inGuild int 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 { if inGuild > 0 {
var guildID int 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 { if err != nil {
continue continue
} }
charGuildmates := make([]members, 0) 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 { if err != nil {
continue continue
} }
@@ -167,16 +167,16 @@ func (s *Server) getGuildmatesForCharacters(chars []character) []members {
return guildmates return guildmates
} }
func (s *Server) deleteCharacter(cid int, token string, tokenID uint32) error { func (server *Server) deleteCharacter(cid int, token string, tokenID uint32) error {
if !s.validateToken(token, tokenID) { if !server.validateToken(token, tokenID) {
return errors.New("invalid token") return errors.New("invalid token")
} }
var isNew bool 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 { 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 { } 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 { if err != nil {
return err return err
@@ -185,9 +185,9 @@ func (s *Server) deleteCharacter(cid int, token string, tokenID uint32) error {
} }
// Unused // Unused
func (s *Server) checkToken(uid uint32) (bool, error) { func (server *Server) checkToken(uid uint32) (bool, error) {
var exists int 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 { if err != nil {
return false, err return false, err
} }
@@ -197,42 +197,42 @@ func (s *Server) checkToken(uid uint32) (bool, error) {
return false, nil 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) _token := token.Generate(16)
var tid uint32 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 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) _token := token.Generate(16)
var tid uint32 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 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` query := `SELECT count(*) FROM sign_sessions WHERE token = $1`
if tokenID > 0 { if tokenID > 0 {
query += ` AND id = $2` query += ` AND id = $2`
} }
var exists int 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 { if err != nil || exists == 0 {
return false return false
} }
return true 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 uid uint32
var passDB string 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 err != nil {
if errors.Is(err, sql.ErrNoRows) { if errors.Is(err, sql.ErrNoRows) {
s.logger.Info("User not found", zap.String("User", user)) server.logger.Info("User not found", zap.String("User", user))
if s.erupeConfig.AutoCreateAccount { if server.erupeConfig.AutoCreateAccount {
uid, err = s.registerDBAccount(user, pass) uid, err = server.registerDBAccount(user, pass)
if err == nil { if err == nil {
return uid, SIGN_SUCCESS return uid, SIGN_SUCCESS
} else { } else {
@@ -245,11 +245,11 @@ func (s *Server) validateLogin(user string, pass string) (uint32, RespID) {
} else { } else {
if bcrypt.CompareHashAndPassword([]byte(passDB), []byte(pass)) == nil { if bcrypt.CompareHashAndPassword([]byte(passDB), []byte(pass)) == nil {
var bans int 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 { if err == nil && bans > 0 {
return uid, SIGN_EELIMINATE 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 { if err == nil && bans > 0 {
return uid, SIGN_ESUSPEND return uid, SIGN_ESUSPEND
} }

45
server/signserver/sign_server.go
View File

@@ -6,8 +6,9 @@ import (
"net" "net"
"sync" "sync"
"erupe-ce/config" _config "erupe-ce/config"
"erupe-ce/network" "erupe-ce/network"
"github.com/jmoiron/sqlx" "github.com/jmoiron/sqlx"
"go.uber.org/zap" "go.uber.org/zap"
) )
@@ -41,38 +42,38 @@ func NewServer(config *Config) *Server {
} }
// Start starts the server in a new goroutine. // 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.Sign.Port)) l, err := net.Listen("tcp", fmt.Sprintf(":%d", server.erupeConfig.Sign.Port))
if err != nil { if err != nil {
return err return err
} }
s.listener = l server.listener = l
go s.acceptClients() go server.acceptClients()
return nil return nil
} }
// Shutdown exits the server gracefully. // Shutdown exits the server gracefully.
func (s *Server) Shutdown() { func (server *Server) Shutdown() {
s.logger.Debug("Shutting down...") server.logger.Debug("Shutting down...")
s.Lock() server.Lock()
s.isShuttingDown = true server.isShuttingDown = true
s.Unlock() server.Unlock()
// This will cause the acceptor goroutine to error and exit gracefully. // 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 { for {
conn, err := s.listener.Accept() conn, err := server.listener.Accept()
if err != nil { if err != nil {
// Check if we are shutting down and exit gracefully if so. // Check if we are shutting down and exit gracefully if so.
s.Lock() server.Lock()
shutdown := s.isShuttingDown shutdown := server.isShuttingDown
s.Unlock() server.Unlock()
if shutdown { if shutdown {
break break
@@ -81,26 +82,26 @@ func (s *Server) acceptClients() {
} }
} }
go s.handleConnection(conn) go server.handleConnection(conn)
} }
} }
func (s *Server) handleConnection(conn net.Conn) { func (server *Server) handleConnection(conn net.Conn) {
s.logger.Debug("New connection", zap.String("RemoteAddr", conn.RemoteAddr().String())) server.logger.Debug("New connection", zap.String("RemoteAddr", conn.RemoteAddr().String()))
defer conn.Close() defer conn.Close()
// Client initalizes the connection with a one-time buffer of 8 NULL bytes. // Client initalizes the connection with a one-time buffer of 8 NULL bytes.
nullInit := make([]byte, 8) nullInit := make([]byte, 8)
_, err := io.ReadFull(conn, nullInit) _, err := io.ReadFull(conn, nullInit)
if err != nil { if err != nil {
s.logger.Error("Error initializing connection", zap.Error(err)) server.logger.Error("Error initializing connection", zap.Error(err))
return return
} }
// Create a new session. // Create a new session.
session := &Session{ session := &Session{
logger: s.logger, logger: server.logger,
server: s, server: server,
rawConn: conn, rawConn: conn,
cryptConn: network.NewCryptConn(conn), cryptConn: network.NewCryptConn(conn),
} }